From 52b5f222dbe4e1f9b7dc678971f5663f03637529 Mon Sep 17 00:00:00 2001 From: Karl Burtram Date: Sat, 8 Oct 2016 19:18:26 +0000 Subject: [PATCH 01/18] Merge dev to master for 0.0.7 release (#86) * Disable failing test while investigating * Made connection errors more user-friendly (#57) * Bug/negativeOneRowsAffected strings file fix (#61) * Adding changes to sr.strings files * Fixing bug by changing valid filename check to fail on whitespace (#55) Fixing a bug from the unit tests on OSX/Unix where attempting to create a file with a name that's all whitespace succeeds when it should fail. This was passing in Windows because File.Open throws an ArgumentException when an all whitespace name is provided. In Unix systems, File.Open does not throw, causing the test to fail. Solution is to check for whitespace in the sanity check. * Format Cell Values (#62) * WIP for ability to localize cell values * Changing how DateTimeOffsets are stored, getting unit tests going * Reworking BufferFileStreamWriter to use dictionary approach * Plumbing the DbCellValue type the rest of the way through * Removing unused components to simplify contract * Cleanup and making sure byte[] appears in parity with SSMS * CR comments, small tweaks for optimizing LINQ * Feature/batch line info (#56) * inital pipe of line numbers and getting text from workspace services * tests compile * Fixed bug regarding tests using connections on mac * updated tests * fixed workspace service and fixed tests * integrated feedback * Remove deleted file with whitespace name * Feature/autocomp options (#63) * Enable IntelliSense settings * Fix up some bugs in the IntelliSense settings. * Code cleans for PR * Fix a couple exceptions that are breaks query execute and intellisense. * Add useLowerCase flag and settings tests * Remove task.wait from test to avoid break on build machine. (#67) This is to fix test breaks so I'll merge now. Please let me know if there are comments on this commit. * Do not use ReliableCommand in the query execution service (#66) * Do not use ReliableCommand in the query execution service. * Fixing the logic to remove InfoMessage handlers from ReliableSqlConnection * Adding test to query UDT * Bump SMO to 140.1.6 to pick up perf fixes (#69) * Enable Quick Info hover tooltips (#65) Pushing to include in tomorrow's partner release build. Please send me any feedback and I'll address in the next Intellisense PR. * Added grouping between system/user dbs when listing (#70) * Feature/timestamp messages (#68) * added support for timestamps * fixed tests * Moved message class to own file; added 'z' to end of date strings * added default time constructor * removed unnecessary z * added time string format info in comment * changed from utc time to using local time * Feature/save selection (#64) * Save selection * Add tests * Change filename in test * Code cleanup * Refactor handler * Code cleanup * Modify tests to have query selection * Change variable declaration * Bump SMO to 14.0.7 to pick Batchparser updates (#72) ...bumping versions. No review needed. * Lingering File Handles (#71) Fixing a bug where in various situations, the files used for temporary storage of query results would be leftover. In particular, the following changes were made: * When the dispose query request is submitted, the corresponding query is now disposed in addition from being removed from the list of active queries * When a query is cancelled, it is disposed after it is cancelled * If a query already exists for a given ownerURI, the existing query is disposed before creating a new query * All queries are disposed when the query execution service is disposed (ie, at shutdown of the service) A unit test to verify the action of the dispose method for a ResultSet was added. * Ensuring queries are disposed Adding logic to dispose any queries when: * URI that already has a query executes another query * A request to dispose a query is submitted * A request to cancel a query is submitted * Small tweaks for cleanup of query execution service * Add IntelliSense binding queue (#73) * Initial code for binding queue * Fix-up some of the timeout wait code * Add some initial test code * Add missing test file * Update the binding queue tests * Add more test coverage and refactor a bit. Disable reliabile connection until we can fix it..it's holding an open data reader connection. * A few more test updates * Initial integrate queue with language service. * Hook up the connected binding queue into al binding calls. * Cleanup comments and remove dead code * More missing comments * Fix build break. Reenable ReliabileConnection. * Revert all changes to SqlConnectionFactory * Resolve merge conflicts * Cleanup some more of the timeouts and sync code * Address code review feedback * Address more code review feedback * Feature/connect cancel (#74) * Implemented connection cancellation * Made connect requests return immediately and created a separate connection complete notification * Fix spelling * Fix sorting * Add separate lock for cancellation source map * Fix an issue with queue deadlocks causing test failures (#77) * Fixed issue where connecting could take very long and cancellation would not work (#78) * Fixed issue where connecting could take very long and cancellation would not work * Addressing feedback * Remove warning suppression * Adding unlimited timeout for query execution (#76) Adding explicitly setting the timeout for command execution to unlimited. We can change this to be user configurable at a later time * Support 'for XML and for JSON' queries (#75) * Set isXMl and isJson for 'for xml/json' resultSets * Change string comparison * Modify if-else * VSTS 8499785. Close SqlToolsService after VS Code exits. (#80) VSTS 8499785. Close SqlToolsService after VS Code exits. * Remove extra level of tasks in binding queue (#79) * Remove extra layer of tasks in binding queue * Change order of assigning result to avoid race condition * Add timeout log for the metadata lock event * Fix test cases --- .gitignore | 5 + nuget.config | 1 + .../Connection/ConnectionService.cs | 201 ++++- .../Contracts/CancelConnectParams.cs | 19 + .../Contracts/CancelConnectRequest.cs | 19 + .../Connection/Contracts/ConnectResponse.cs | 33 - .../ConnectionCompleteNotification.cs | 61 ++ .../Connection/Contracts/ConnectionRequest.cs | 4 +- .../Hosting/ServiceHost.cs | 34 +- .../LanguageServices/AutoCompleteHelper.cs | 169 +++- .../LanguageServices/BindingQueue.cs | 259 ++++++ .../ConnectedBindingContext.cs | 208 +++++ .../LanguageServices/ConnectedBindingQueue.cs | 109 +++ .../LanguageServices/IBindingContext.cs | 81 ++ .../LanguageServices/LanguageService.cs | 500 +++++++---- .../LanguageServices/QueueItem.cs | 66 ++ .../LanguageServices/ScriptParseInfo.cs | 159 +--- .../Program.cs | 14 +- .../QueryExecution/Batch.cs | 53 +- .../QueryExecution/Contracts/BatchSummary.cs | 7 +- .../QueryExecution/Contracts/DbCellValue.cs | 23 + .../Contracts/DbColumnWrapper.cs | 7 +- .../Contracts/QueryExecuteRequest.cs | 19 +- .../QueryExecution/Contracts/ResultMessage.cs | 44 + .../Contracts/ResultSetSubset.cs | 2 +- .../Contracts/SaveResultsRequest.cs | 22 + .../DataStorage/FileStreamReadResult.cs | 28 +- .../DataStorage/FileStreamWrapper.cs | 2 +- .../DataStorage/IFileStreamReader.cs | 35 +- .../DataStorage/IFileStreamWriter.cs | 4 +- .../ServiceBufferFileStreamReader.cs | 782 +++++------------- .../ServiceBufferFileStreamWriter.cs | 477 ++++------- .../DataStorage/StorageDataReader.cs | 6 + .../QueryExecution/Query.cs | 27 +- .../QueryExecution/QueryExecutionService.cs | 148 +++- .../QueryExecution/ResultSet.cs | 44 +- .../QueryExecution/SaveResults.cs | 7 + .../SqlContext/HostDetails.cs | 10 +- .../SqlContext/IntelliSenseSettings.cs | 60 ++ .../SqlContext/ProfilePaths.cs | 108 --- .../SqlContext/SqlToolsContext.cs | 9 +- .../SqlContext/SqlToolsSettings.cs | 156 ++-- .../Utility/Logger.cs | 27 +- .../Workspace/Contracts/ScriptFile.cs | 12 +- .../Workspace/Workspace.cs | 5 +- .../Workspace/WorkspaceService.cs | 10 +- .../project.json | 3 +- src/Microsoft.SqlTools.ServiceLayer/sr.cs | 13 +- src/Microsoft.SqlTools.ServiceLayer/sr.resx | 6 +- .../sr.strings | 4 +- .../Connection/ConnectionServiceTests.cs | 275 +++++- .../LanguageServer/AutocompleteTests.cs | 139 ++++ .../LanguageServer/BindingQueueTests.cs | 187 +++++ .../LanguageServer/LanguageServiceTests.cs | 67 +- .../QueryExecution/CancelTests.cs | 38 +- .../QueryExecution/Common.cs | 37 +- ...erviceBufferFileStreamReaderWriterTests.cs | 45 +- .../QueryExecution/DisposeTests.cs | 74 +- .../QueryExecution/ExecuteTests.cs | 152 +++- .../QueryExecution/SaveResultsTests.cs | 176 +++- .../QueryExecution/SubsetTests.cs | 110 ++- .../SqlContext/SettingsTests.cs | 101 +++ .../Utility/TestObjects.cs | 15 +- .../Utility/TestUtils.cs | 19 + .../project.json | 2 +- 65 files changed, 3739 insertions(+), 1800 deletions(-) create mode 100644 src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/CancelConnectParams.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/CancelConnectRequest.cs delete mode 100644 src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectResponse.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionCompleteNotification.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/LanguageServices/BindingQueue.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingContext.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingQueue.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/LanguageServices/IBindingContext.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/LanguageServices/QueueItem.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbCellValue.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/ResultMessage.cs create mode 100644 src/Microsoft.SqlTools.ServiceLayer/SqlContext/IntelliSenseSettings.cs delete mode 100644 src/Microsoft.SqlTools.ServiceLayer/SqlContext/ProfilePaths.cs create mode 100644 test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/AutocompleteTests.cs create mode 100644 test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/BindingQueueTests.cs create mode 100644 test/Microsoft.SqlTools.ServiceLayer.Test/SqlContext/SettingsTests.cs diff --git a/.gitignore b/.gitignore index a52a0fe0..97e1cc41 100644 --- a/.gitignore +++ b/.gitignore @@ -14,6 +14,10 @@ project.lock.json *.userosscache *.sln.docstates *.exe +scratch.txt + +# mergetool conflict files +*.orig # Build results [Dd]ebug/ @@ -52,6 +56,7 @@ cross/rootfs/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* +test*json #NUNIT *.VisualState.xml diff --git a/nuget.config b/nuget.config index edd564a3..f5d41658 100644 --- a/nuget.config +++ b/nuget.config @@ -1,6 +1,7 @@ + diff --git a/src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs b/src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs index 6cdd62aa..36e86791 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs @@ -4,10 +4,12 @@ // using System; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Data.SqlClient; +using System.Threading; using System.Threading.Tasks; using Microsoft.SqlTools.ServiceLayer.Connection.Contracts; using Microsoft.SqlTools.ServiceLayer.Connection.ReliableConnection; @@ -47,6 +49,22 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection private Dictionary ownerToConnectionMap = new Dictionary(); + private ConcurrentDictionary ownerToCancellationTokenSourceMap = new ConcurrentDictionary(); + + private Object cancellationTokenSourceLock = new Object(); + + /// + /// Map from script URIs to ConnectionInfo objects + /// This is internal for testing access only + /// + internal Dictionary OwnerToConnectionMap + { + get + { + return this.ownerToConnectionMap; + } + } + /// /// Service host object for sending/receiving requests/events. /// Internal for testing purposes. @@ -119,21 +137,22 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection /// Open a connection with the specified connection details /// /// - public ConnectResponse Connect(ConnectParams connectionParams) + public async Task Connect(ConnectParams connectionParams) { // Validate parameters string paramValidationErrorMessage; if (connectionParams == null) { - return new ConnectResponse + return new ConnectionCompleteParams { Messages = SR.ConnectionServiceConnectErrorNullParams }; } if (!connectionParams.IsValid(out paramValidationErrorMessage)) { - return new ConnectResponse + return new ConnectionCompleteParams { + OwnerUri = connectionParams.OwnerUri, Messages = paramValidationErrorMessage }; } @@ -152,7 +171,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection connectionInfo = new ConnectionInfo(ConnectionFactory, connectionParams.OwnerUri, connectionParams.Connection); // try to connect - var response = new ConnectResponse(); + var response = new ConnectionCompleteParams(); + response.OwnerUri = connectionParams.OwnerUri; + CancellationTokenSource source = null; try { // build the connection string from the input parameters @@ -160,13 +181,75 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection // create a sql connection instance connectionInfo.SqlConnection = connectionInfo.Factory.CreateSqlConnection(connectionString); - connectionInfo.SqlConnection.Open(); + + // turning on MARS to avoid break in LanguageService with multiple editors + // we'll remove this once ConnectionService is refactored to not own the LanguageService connection + connectionInfo.ConnectionDetails.MultipleActiveResultSets = true; + + // Add a cancellation token source so that the connection OpenAsync() can be cancelled + using (source = new CancellationTokenSource()) + { + // Locking here to perform two operations as one atomic operation + lock (cancellationTokenSourceLock) + { + // If the URI is currently connecting from a different request, cancel it before we try to connect + CancellationTokenSource currentSource; + if (ownerToCancellationTokenSourceMap.TryGetValue(connectionParams.OwnerUri, out currentSource)) + { + currentSource.Cancel(); + } + ownerToCancellationTokenSourceMap[connectionParams.OwnerUri] = source; + } + + // Create a task to handle cancellation requests + var cancellationTask = Task.Run(() => + { + source.Token.WaitHandle.WaitOne(); + source.Token.ThrowIfCancellationRequested(); + }); + + var openTask = Task.Run(async () => { + await connectionInfo.SqlConnection.OpenAsync(source.Token); + }); + + // Open the connection + await Task.WhenAny(openTask, cancellationTask).Unwrap(); + source.Cancel(); + } } - catch(Exception ex) + catch (SqlException ex) { + response.ErrorNumber = ex.Number; + response.ErrorMessage = ex.Message; response.Messages = ex.ToString(); return response; } + catch (OperationCanceledException) + { + // OpenAsync was cancelled + response.Messages = SR.ConnectionServiceConnectionCanceled; + return response; + } + catch (Exception ex) + { + response.ErrorMessage = ex.Message; + response.Messages = ex.ToString(); + return response; + } + finally + { + // Remove our cancellation token from the map since we're no longer connecting + // Using a lock here to perform two operations as one atomic operation + lock (cancellationTokenSourceLock) + { + // Only remove the token from the map if it is the same one created by this request + CancellationTokenSource sourceValue; + if (ownerToCancellationTokenSourceMap.TryGetValue(connectionParams.OwnerUri, out sourceValue) && sourceValue == source) + { + ownerToCancellationTokenSourceMap.TryRemove(connectionParams.OwnerUri, out sourceValue); + } + } + } ownerToConnectionMap[connectionParams.OwnerUri] = connectionInfo; @@ -181,15 +264,15 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection }; // invoke callback notifications - foreach (var activity in this.onConnectionActivities) - { - activity(connectionInfo); - } + invokeOnConnectionActivities(connectionInfo); // try to get information about the connected SQL Server instance try { - ReliableConnectionHelper.ServerInfo serverInfo = ReliableConnectionHelper.GetServerVersion(connectionInfo.SqlConnection); + var reliableConnection = connectionInfo.SqlConnection as ReliableSqlConnection; + DbConnection connection = reliableConnection != null ? reliableConnection.GetUnderlyingConnection() : connectionInfo.SqlConnection; + + ReliableConnectionHelper.ServerInfo serverInfo = ReliableConnectionHelper.GetServerVersion(connection); response.ServerInfo = new Contracts.ServerInfo() { ServerMajorVersion = serverInfo.ServerMajorVersion, @@ -214,6 +297,37 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection return response; } + /// + /// Cancel a connection that is in the process of opening. + /// + public bool CancelConnect(CancelConnectParams cancelParams) + { + // Validate parameters + if (cancelParams == null || string.IsNullOrEmpty(cancelParams.OwnerUri)) + { + return false; + } + + // Cancel any current connection attempts for this URI + CancellationTokenSource source; + if (ownerToCancellationTokenSourceMap.TryGetValue(cancelParams.OwnerUri, out source)) + { + try + { + source.Cancel(); + return true; + } + catch + { + return false; + } + } + else + { + return false; + } + } + /// /// Close a connection with the specified connection details. /// @@ -225,6 +339,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection return false; } + // Cancel if we are in the middle of connecting + if (CancelConnect(new CancelConnectParams() { OwnerUri = disconnectParams.OwnerUri })) + { + return false; + } + // Lookup the connection owned by the URI ConnectionInfo info; if (!ownerToConnectionMap.TryGetValue(disconnectParams.OwnerUri, out info)) @@ -274,7 +394,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection connection.Open(); DbCommand command = connection.CreateCommand(); - command.CommandText = "SELECT name FROM sys.databases"; + command.CommandText = "SELECT name FROM sys.databases ORDER BY database_id ASC"; command.CommandTimeout = 15; command.CommandType = CommandType.Text; var reader = command.ExecuteReader(); @@ -299,6 +419,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection // Register request and event handlers with the Service Host serviceHost.SetRequestHandler(ConnectionRequest.Type, HandleConnectRequest); + serviceHost.SetRequestHandler(CancelConnectRequest.Type, HandleCancelConnectRequest); serviceHost.SetRequestHandler(DisconnectRequest.Type, HandleDisconnectRequest); serviceHost.SetRequestHandler(ListDatabasesRequest.Type, HandleListDatabasesRequest); @@ -331,14 +452,55 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection /// protected async Task HandleConnectRequest( ConnectParams connectParams, - RequestContext requestContext) + RequestContext requestContext) { Logger.Write(LogLevel.Verbose, "HandleConnectRequest"); try { - // open connection base on request details - ConnectResponse result = ConnectionService.Instance.Connect(connectParams); + RunConnectRequestHandlerTask(connectParams, requestContext); + await requestContext.SendResult(true); + } + catch + { + await requestContext.SendResult(false); + } + } + + private void RunConnectRequestHandlerTask(ConnectParams connectParams, RequestContext requestContext) + { + // create a task to connect asynchronously so that other requests are not blocked in the meantime + Task.Run(async () => + { + try + { + // open connection based on request details + ConnectionCompleteParams result = await ConnectionService.Instance.Connect(connectParams); + await ServiceHost.SendEvent(ConnectionCompleteNotification.Type, result); + } + catch (Exception ex) + { + ConnectionCompleteParams result = new ConnectionCompleteParams() + { + Messages = ex.ToString() + }; + await ServiceHost.SendEvent(ConnectionCompleteNotification.Type, result); + } + }); + } + + /// + /// Handle cancel connect requests + /// + protected async Task HandleCancelConnectRequest( + CancelConnectParams cancelParams, + RequestContext requestContext) + { + Logger.Write(LogLevel.Verbose, "HandleCancelConnectRequest"); + + try + { + bool result = ConnectionService.Instance.CancelConnect(cancelParams); await requestContext.SendResult(result); } catch(Exception ex) @@ -563,5 +725,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection } } } + + private void invokeOnConnectionActivities(ConnectionInfo connectionInfo) + { + foreach (var activity in this.onConnectionActivities) + { + // not awaiting here to allow handlers to run in the background + activity(connectionInfo); + } + } } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/CancelConnectParams.cs b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/CancelConnectParams.cs new file mode 100644 index 00000000..9f2efdb0 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/CancelConnectParams.cs @@ -0,0 +1,19 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts +{ + /// + /// Parameters for the Cancel Connect Request. + /// + public class CancelConnectParams + { + /// + /// A URI identifying the owner of the connection. This will most commonly be a file in the workspace + /// or a virtual file representing an object in a database. + /// + public string OwnerUri { get; set; } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/CancelConnectRequest.cs b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/CancelConnectRequest.cs new file mode 100644 index 00000000..a284f317 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/CancelConnectRequest.cs @@ -0,0 +1,19 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts; + +namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts +{ + /// + /// Cancel connect request mapping entry + /// + public class CancelConnectRequest + { + public static readonly + RequestType Type = + RequestType.Create("connection/cancelconnect"); + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectResponse.cs b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectResponse.cs deleted file mode 100644 index 9066efa8..00000000 --- a/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectResponse.cs +++ /dev/null @@ -1,33 +0,0 @@ -// -// Copyright (c) Microsoft. All rights reserved. -// Licensed under the MIT license. See LICENSE file in the project root for full license information. -// - -namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts -{ - /// - /// Message format for the connection result response - /// - public class ConnectResponse - { - /// - /// A GUID representing a unique connection ID - /// - public string ConnectionId { get; set; } - - /// - /// Gets or sets any connection error messages - /// - public string Messages { get; set; } - - /// - /// Information about the connected server. - /// - public ServerInfo ServerInfo { get; set; } - - /// - /// Gets or sets the actual Connection established, including Database Name - /// - public ConnectionSummary ConnectionSummary { get; set; } - } -} diff --git a/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionCompleteNotification.cs b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionCompleteNotification.cs new file mode 100644 index 00000000..50517a52 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionCompleteNotification.cs @@ -0,0 +1,61 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts; + +namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts +{ + /// + /// Parameters to be sent back with a connection complete event + /// + public class ConnectionCompleteParams + { + /// + /// A URI identifying the owner of the connection. This will most commonly be a file in the workspace + /// or a virtual file representing an object in a database. + /// + public string OwnerUri { get; set; } + + /// + /// A GUID representing a unique connection ID + /// + public string ConnectionId { get; set; } + + /// + /// Gets or sets any detailed connection error messages. + /// + public string Messages { get; set; } + + /// + /// Error message returned from the engine for a connection failure reason, if any. + /// + public string ErrorMessage { get; set; } + + /// + /// Error number returned from the engine for connection failure reason, if any. + /// + public int ErrorNumber { get; set; } + + /// + /// Information about the connected server. + /// + public ServerInfo ServerInfo { get; set; } + + /// + /// Gets or sets the actual Connection established, including Database Name + /// + public ConnectionSummary ConnectionSummary { get; set; } + } + + /// + /// ConnectionComplete notification mapping entry + /// + public class ConnectionCompleteNotification + { + public static readonly + EventType Type = + EventType.Create("connection/complete"); + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionRequest.cs b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionRequest.cs index 50251e12..74320bdd 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionRequest.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionRequest.cs @@ -13,7 +13,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts public class ConnectionRequest { public static readonly - RequestType Type = - RequestType.Create("connection/connect"); + RequestType Type = + RequestType.Create("connection/connect"); } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs b/src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs index 326cf5ed..92b097aa 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs @@ -4,13 +4,13 @@ // using System; -using System.Linq; -using System.Threading.Tasks; using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Threading.Tasks; using Microsoft.SqlTools.ServiceLayer.Hosting.Contracts; using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol; using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Channel; -using System.Reflection; using Microsoft.SqlTools.ServiceLayer.Utility; namespace Microsoft.SqlTools.ServiceLayer.Hosting @@ -22,6 +22,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting /// public sealed class ServiceHost : ServiceHostBase { + /// + /// This timeout limits the amount of time that shutdown tasks can take to complete + /// prior to the process shutting down. + /// + private const int ShutdownTimeoutInSeconds = 120; + #region Singleton Instance Code /// @@ -63,8 +69,18 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting #region Member Variables + /// + /// Delegate definition for the host shutdown event + /// + /// + /// public delegate Task ShutdownCallback(object shutdownParams, RequestContext shutdownRequestContext); + /// + /// Delegate definition for the host initialization event + /// + /// + /// public delegate Task InitializeCallback(InitializeRequest startupParams, RequestContext requestContext); private readonly List shutdownCallbacks; @@ -108,7 +124,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting // Call all the shutdown methods provided by the service components Task[] shutdownTasks = shutdownCallbacks.Select(t => t(shutdownParams, requestContext)).ToArray(); - await Task.WhenAll(shutdownTasks); + TimeSpan shutdownTimeout = TimeSpan.FromSeconds(ShutdownTimeoutInSeconds); + // shut down once all tasks are completed, or after the timeout expires, whichever comes first. + await Task.WhenAny(Task.WhenAll(shutdownTasks), Task.Delay(shutdownTimeout)).ContinueWith(t => Environment.Exit(0)); } /// @@ -119,8 +137,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting /// private async Task HandleInitializeRequest(InitializeRequest initializeParams, RequestContext requestContext) { - Logger.Write(LogLevel.Verbose, "HandleInitializationRequest"); - // Call all tasks that registered on the initialize request var initializeTasks = initializeCallbacks.Select(t => t(initializeParams, requestContext)); await Task.WhenAll(initializeTasks); @@ -136,7 +152,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting TextDocumentSync = TextDocumentSyncKind.Incremental, DefinitionProvider = true, ReferencesProvider = true, - DocumentHighlightProvider = true, + DocumentHighlightProvider = true, + HoverProvider = true, CompletionProvider = new CompletionOptions { ResolveProvider = true, @@ -144,7 +161,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting }, SignatureHelpProvider = new SignatureHelpOptions { - TriggerCharacters = new string[] { " " } // TODO: Other characters here? + TriggerCharacters = new string[] { " ", "," } } } }); @@ -157,7 +174,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting object versionRequestParams, RequestContext requestContext) { - Logger.Write(LogLevel.Verbose, "HandleVersionRequest"); await requestContext.SendResult(serviceVersion.ToString()); } diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteHelper.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteHelper.cs index ffc9811c..4eef4915 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteHelper.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteHelper.cs @@ -21,6 +21,10 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices /// public static class AutoCompleteHelper { + private const int PrepopulateBindTimeout = 60000; + + private static WorkspaceService workspaceServiceInstance; + private static readonly string[] DefaultCompletionText = new string[] { "absolute", @@ -421,16 +425,44 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices "zone" }; + /// + /// Gets or sets the current workspace service instance + /// Setter for internal testing purposes only + /// + internal static WorkspaceService WorkspaceServiceInstance + { + get + { + if (AutoCompleteHelper.workspaceServiceInstance == null) + { + AutoCompleteHelper.workspaceServiceInstance = WorkspaceService.Instance; + } + return AutoCompleteHelper.workspaceServiceInstance; + } + set + { + AutoCompleteHelper.workspaceServiceInstance = value; + } + } + + /// + /// Get the default completion list from hard-coded list + /// + /// + /// + /// + /// internal static CompletionItem[] GetDefaultCompletionItems( int row, int startColumn, - int endColumn) + int endColumn, + bool useLowerCase) { var completionItems = new CompletionItem[DefaultCompletionText.Length]; for (int i = 0; i < DefaultCompletionText.Length; ++i) { completionItems[i] = CreateDefaultCompletionItem( - DefaultCompletionText[i].ToUpper(), + useLowerCase ? DefaultCompletionText[i].ToLower() : DefaultCompletionText[i].ToUpper(), row, startColumn, endColumn); @@ -438,6 +470,13 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices return completionItems; } + /// + /// Create a completion item from the default item text + /// + /// + /// + /// + /// private static CompletionItem CreateDefaultCompletionItem( string label, int row, @@ -523,11 +562,14 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices /// /// /// - internal static void PrepopulateCommonMetadata(ConnectionInfo info, ScriptParseInfo scriptInfo) + internal static void PrepopulateCommonMetadata( + ConnectionInfo info, + ScriptParseInfo scriptInfo, + ConnectedBindingQueue bindingQueue) { if (scriptInfo.IsConnected) { - var scriptFile = WorkspaceService.Instance.Workspace.GetFile(info.OwnerUri); + var scriptFile = AutoCompleteHelper.WorkspaceServiceInstance.Workspace.GetFile(info.OwnerUri); LanguageService.Instance.ParseAndBind(scriptFile, info); if (scriptInfo.BuildingMetadataEvent.WaitOne(LanguageService.OnConnectionWaitTimeout)) @@ -536,44 +578,53 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices { scriptInfo.BuildingMetadataEvent.Reset(); - // parse a simple statement that returns common metadata - ParseResult parseResult = Parser.Parse( - "select ", - scriptInfo.ParseOptions); + QueueItem queueItem = bindingQueue.QueueBindingOperation( + key: scriptInfo.ConnectionKey, + bindingTimeout: AutoCompleteHelper.PrepopulateBindTimeout, + bindOperation: (bindingContext, cancelToken) => + { + // parse a simple statement that returns common metadata + ParseResult parseResult = Parser.Parse( + "select ", + bindingContext.ParseOptions); - List parseResults = new List(); - parseResults.Add(parseResult); - scriptInfo.Binder.Bind( - parseResults, - info.ConnectionDetails.DatabaseName, - BindMode.Batch); + List parseResults = new List(); + parseResults.Add(parseResult); + bindingContext.Binder.Bind( + parseResults, + info.ConnectionDetails.DatabaseName, + BindMode.Batch); - // get the completion list from SQL Parser - var suggestions = Resolver.FindCompletions( - parseResult, 1, 8, - scriptInfo.MetadataDisplayInfoProvider); + // get the completion list from SQL Parser + var suggestions = Resolver.FindCompletions( + parseResult, 1, 8, + bindingContext.MetadataDisplayInfoProvider); - // this forces lazy evaluation of the suggestion metadata - AutoCompleteHelper.ConvertDeclarationsToCompletionItems(suggestions, 1, 8, 8); + // this forces lazy evaluation of the suggestion metadata + AutoCompleteHelper.ConvertDeclarationsToCompletionItems(suggestions, 1, 8, 8); - parseResult = Parser.Parse( - "exec ", - scriptInfo.ParseOptions); + parseResult = Parser.Parse( + "exec ", + bindingContext.ParseOptions); - parseResults = new List(); - parseResults.Add(parseResult); - scriptInfo.Binder.Bind( - parseResults, - info.ConnectionDetails.DatabaseName, - BindMode.Batch); + parseResults = new List(); + parseResults.Add(parseResult); + bindingContext.Binder.Bind( + parseResults, + info.ConnectionDetails.DatabaseName, + BindMode.Batch); - // get the completion list from SQL Parser - suggestions = Resolver.FindCompletions( - parseResult, 1, 6, - scriptInfo.MetadataDisplayInfoProvider); + // get the completion list from SQL Parser + suggestions = Resolver.FindCompletions( + parseResult, 1, 6, + bindingContext.MetadataDisplayInfoProvider); - // this forces lazy evaluation of the suggestion metadata - AutoCompleteHelper.ConvertDeclarationsToCompletionItems(suggestions, 1, 6, 6); + // this forces lazy evaluation of the suggestion metadata + AutoCompleteHelper.ConvertDeclarationsToCompletionItems(suggestions, 1, 6, 6); + return null; + }); + + queueItem.ItemProcessed.WaitOne(); } catch { @@ -585,5 +636,53 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices } } } + + + /// + /// Converts a SQL Parser QuickInfo object into a VS Code Hover object + /// + /// + /// + /// + /// + internal static Hover ConvertQuickInfoToHover( + Babel.CodeObjectQuickInfo quickInfo, + int row, + int startColumn, + int endColumn) + { + // convert from the parser format to the VS Code wire format + var markedStrings = new MarkedString[1]; + if (quickInfo != null) + { + markedStrings[0] = new MarkedString() + { + Language = "SQL", + Value = quickInfo.Text + }; + + return new Hover() + { + Contents = markedStrings, + Range = new Range + { + Start = new Position + { + Line = row, + Character = startColumn + }, + End = new Position + { + Line = row, + Character = endColumn + } + } + }; + } + else + { + return null; + } + } } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/BindingQueue.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/BindingQueue.cs new file mode 100644 index 00000000..2b165dc8 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/BindingQueue.cs @@ -0,0 +1,259 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.SqlTools.ServiceLayer.Utility; + +namespace Microsoft.SqlTools.ServiceLayer.LanguageServices +{ + /// + /// Main class for the Binding Queue + /// + public class BindingQueue where T : IBindingContext, new() + { + private CancellationTokenSource processQueueCancelToken = new CancellationTokenSource(); + + private ManualResetEvent itemQueuedEvent = new ManualResetEvent(initialState: false); + + private object bindingQueueLock = new object(); + + private LinkedList bindingQueue = new LinkedList(); + + private object bindingContextLock = new object(); + + private Task queueProcessorTask; + + /// + /// Map from context keys to binding context instances + /// Internal for testing purposes only + /// + internal Dictionary BindingContextMap { get; set; } + + /// + /// Constructor for a binding queue instance + /// + public BindingQueue() + { + this.BindingContextMap = new Dictionary(); + + this.queueProcessorTask = StartQueueProcessor(); + } + + /// + /// Stops the binding queue by sending cancellation request + /// + /// + public bool StopQueueProcessor(int timeout) + { + this.processQueueCancelToken.Cancel(); + return this.queueProcessorTask.Wait(timeout); + } + + /// + /// Queue a binding request item + /// + public QueueItem QueueBindingOperation( + string key, + Func bindOperation, + Func timeoutOperation = null, + int? bindingTimeout = null) + { + // don't add null operations to the binding queue + if (bindOperation == null) + { + return null; + } + + QueueItem queueItem = new QueueItem() + { + Key = key, + BindOperation = bindOperation, + TimeoutOperation = timeoutOperation, + BindingTimeout = bindingTimeout + }; + + lock (this.bindingQueueLock) + { + this.bindingQueue.AddLast(queueItem); + } + + this.itemQueuedEvent.Set(); + + return queueItem; + } + + /// + /// Gets or creates a binding context for the provided context key + /// + /// + protected IBindingContext GetOrCreateBindingContext(string key) + { + // use a default binding context for disconnected requests + if (string.IsNullOrWhiteSpace(key)) + { + key = "disconnected_binding_context"; + } + + lock (this.bindingContextLock) + { + if (!this.BindingContextMap.ContainsKey(key)) + { + this.BindingContextMap.Add(key, new T()); + } + + return this.BindingContextMap[key]; + } + } + + private bool HasPendingQueueItems + { + get + { + lock (this.bindingQueueLock) + { + return this.bindingQueue.Count > 0; + } + } + } + + /// + /// Gets the next pending queue item + /// + private QueueItem GetNextQueueItem() + { + lock (this.bindingQueueLock) + { + if (this.bindingQueue.Count == 0) + { + return null; + } + + QueueItem queueItem = this.bindingQueue.First.Value; + this.bindingQueue.RemoveFirst(); + return queueItem; + } + } + + /// + /// Starts the queue processing thread + /// + private Task StartQueueProcessor() + { + return Task.Factory.StartNew( + ProcessQueue, + this.processQueueCancelToken.Token, + TaskCreationOptions.LongRunning, + TaskScheduler.Default); + } + + /// + /// The core queue processing method + /// + /// + private void ProcessQueue() + { + CancellationToken token = this.processQueueCancelToken.Token; + WaitHandle[] waitHandles = new WaitHandle[2] + { + this.itemQueuedEvent, + token.WaitHandle + }; + + while (true) + { + // wait for with an item to be queued or the a cancellation request + WaitHandle.WaitAny(waitHandles); + if (token.IsCancellationRequested) + { + break; + } + + try + { + // dispatch all pending queue items + while (this.HasPendingQueueItems) + { + QueueItem queueItem = GetNextQueueItem(); + if (queueItem == null) + { + continue; + } + + IBindingContext bindingContext = GetOrCreateBindingContext(queueItem.Key); + if (bindingContext == null) + { + queueItem.ItemProcessed.Set(); + continue; + } + + try + { + // prefer the queue item binding item, otherwise use the context default timeout + int bindTimeout = queueItem.BindingTimeout ?? bindingContext.BindingTimeout; + + // handle the case a previous binding operation is still running + if (!bindingContext.BindingLocked.WaitOne(bindTimeout)) + { + queueItem.Result = queueItem.TimeoutOperation(bindingContext); + queueItem.ItemProcessed.Set(); + continue; + } + + // execute the binding operation + object result = null; + CancellationTokenSource cancelToken = new CancellationTokenSource(); + var bindTask = Task.Run(() => + { + result = queueItem.BindOperation( + bindingContext, + cancelToken.Token); + }); + + // check if the binding tasks completed within the binding timeout + if (bindTask.Wait(bindTimeout)) + { + queueItem.Result = result; + } + else + { + // if the task didn't complete then call the timeout callback + if (queueItem.TimeoutOperation != null) + { + cancelToken.Cancel(); + queueItem.Result = queueItem.TimeoutOperation(bindingContext); + } + } + } + catch (Exception ex) + { + // catch and log any exceptions raised in the binding calls + // set item processed to avoid deadlocks + Logger.Write(LogLevel.Error, "Binding queue threw exception " + ex.ToString()); + } + finally + { + bindingContext.BindingLocked.Set(); + queueItem.ItemProcessed.Set(); + } + + // if a queue processing cancellation was requested then exit the loop + if (token.IsCancellationRequested) + { + break; + } + } + } + finally + { + // reset the item queued event since we've processed all the pending items + this.itemQueuedEvent.Reset(); + } + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingContext.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingContext.cs new file mode 100644 index 00000000..8851abe1 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingContext.cs @@ -0,0 +1,208 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Threading; +using Microsoft.SqlServer.Management.Common; +using Microsoft.SqlServer.Management.SmoMetadataProvider; +using Microsoft.SqlServer.Management.SqlParser.Binder; +using Microsoft.SqlServer.Management.SqlParser.Common; +using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; +using Microsoft.SqlServer.Management.SqlParser.Parser; + +namespace Microsoft.SqlTools.ServiceLayer.LanguageServices +{ + /// + /// Class for the binding context for connected sessions + /// + public class ConnectedBindingContext : IBindingContext + { + private ParseOptions parseOptions; + + private ServerConnection serverConnection; + + /// + /// Connected binding context constructor + /// + public ConnectedBindingContext() + { + this.BindingLocked = new ManualResetEvent(initialState: true); + this.BindingTimeout = ConnectedBindingQueue.DefaultBindingTimeout; + this.MetadataDisplayInfoProvider = new MetadataDisplayInfoProvider(); + } + + /// + /// Gets or sets a flag indicating if the binder is connected + /// + public bool IsConnected { get; set; } + + /// + /// Gets or sets the binding server connection + /// + public ServerConnection ServerConnection + { + get + { + return this.serverConnection; + } + set + { + this.serverConnection = value; + + // reset the parse options so the get recreated for the current connection + this.parseOptions = null; + } + } + + /// + /// Gets or sets the metadata display info provider + /// + public MetadataDisplayInfoProvider MetadataDisplayInfoProvider { get; set; } + + /// + /// Gets or sets the SMO metadata provider + /// + public SmoMetadataProvider SmoMetadataProvider { get; set; } + + /// + /// Gets or sets the binder + /// + public IBinder Binder { get; set; } + + /// + /// Gets or sets an event to signal if a binding operation is in progress + /// + public ManualResetEvent BindingLocked { get; set; } + + /// + /// Gets or sets the binding operation timeout in milliseconds + /// + public int BindingTimeout { get; set; } + + /// + /// Gets the Language Service ServerVersion + /// + public ServerVersion ServerVersion + { + get + { + return this.ServerConnection != null + ? this.ServerConnection.ServerVersion + : null; + } + } + + /// + /// Gets the current DataEngineType + /// + public DatabaseEngineType DatabaseEngineType + { + get + { + return this.ServerConnection != null + ? this.ServerConnection.DatabaseEngineType + : DatabaseEngineType.Standalone; + } + } + + /// + /// Gets the current connections TransactSqlVersion + /// + public TransactSqlVersion TransactSqlVersion + { + get + { + return this.IsConnected + ? GetTransactSqlVersion(this.ServerVersion) + : TransactSqlVersion.Current; + } + } + + /// + /// Gets the current DatabaseCompatibilityLevel + /// + public DatabaseCompatibilityLevel DatabaseCompatibilityLevel + { + get + { + return this.IsConnected + ? GetDatabaseCompatibilityLevel(this.ServerVersion) + : DatabaseCompatibilityLevel.Current; + } + } + + /// + /// Gets the current ParseOptions + /// + public ParseOptions ParseOptions + { + get + { + if (this.parseOptions == null) + { + this.parseOptions = new ParseOptions( + batchSeparator: LanguageService.DefaultBatchSeperator, + isQuotedIdentifierSet: true, + compatibilityLevel: DatabaseCompatibilityLevel, + transactSqlVersion: TransactSqlVersion); + } + return this.parseOptions; + } + } + + + /// + /// Gets the database compatibility level from a server version + /// + /// + private static DatabaseCompatibilityLevel GetDatabaseCompatibilityLevel(ServerVersion serverVersion) + { + int versionMajor = Math.Max(serverVersion.Major, 8); + + switch (versionMajor) + { + case 8: + return DatabaseCompatibilityLevel.Version80; + case 9: + return DatabaseCompatibilityLevel.Version90; + case 10: + return DatabaseCompatibilityLevel.Version100; + case 11: + return DatabaseCompatibilityLevel.Version110; + case 12: + return DatabaseCompatibilityLevel.Version120; + case 13: + return DatabaseCompatibilityLevel.Version130; + default: + return DatabaseCompatibilityLevel.Current; + } + } + + /// + /// Gets the transaction sql version from a server version + /// + /// + private static TransactSqlVersion GetTransactSqlVersion(ServerVersion serverVersion) + { + int versionMajor = Math.Max(serverVersion.Major, 9); + + switch (versionMajor) + { + case 9: + case 10: + // In case of 10.0 we still use Version 10.5 as it is the closest available. + return TransactSqlVersion.Version105; + case 11: + return TransactSqlVersion.Version110; + case 12: + return TransactSqlVersion.Version120; + case 13: + return TransactSqlVersion.Version130; + default: + return TransactSqlVersion.Current; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingQueue.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingQueue.cs new file mode 100644 index 00000000..c99f0cc6 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingQueue.cs @@ -0,0 +1,109 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Data.SqlClient; +using Microsoft.SqlServer.Management.Common; +using Microsoft.SqlServer.Management.SmoMetadataProvider; +using Microsoft.SqlServer.Management.SqlParser.Binder; +using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; +using Microsoft.SqlTools.ServiceLayer.Connection; +using Microsoft.SqlTools.ServiceLayer.Connection.Contracts; +using Microsoft.SqlTools.ServiceLayer.SqlContext; +using Microsoft.SqlTools.ServiceLayer.Workspace; + +namespace Microsoft.SqlTools.ServiceLayer.LanguageServices +{ + /// + /// ConnectedBindingQueue class for processing online binding requests + /// + public class ConnectedBindingQueue : BindingQueue + { + internal const int DefaultBindingTimeout = 60000; + + internal const int DefaultMinimumConnectionTimeout = 30; + + /// + /// Gets the current settings + /// + internal SqlToolsSettings CurrentSettings + { + get { return WorkspaceService.Instance.CurrentSettings; } + } + + /// + /// Generate a unique key based on the ConnectionInfo object + /// + /// + private string GetConnectionContextKey(ConnectionInfo connInfo) + { + ConnectionDetails details = connInfo.ConnectionDetails; + return string.Format("{0}_{1}_{2}_{3}", + details.ServerName ?? "NULL", + details.DatabaseName ?? "NULL", + details.UserName ?? "NULL", + details.AuthenticationType ?? "NULL" + ); + } + + /// + /// Use a ConnectionInfo item to create a connected binding context + /// + /// + public virtual string AddConnectionContext(ConnectionInfo connInfo) + { + if (connInfo == null) + { + return string.Empty; + } + + // lookup the current binding context + string connectionKey = GetConnectionContextKey(connInfo); + IBindingContext bindingContext = this.GetOrCreateBindingContext(connectionKey); + + try + { + // increase the connection timeout to at least 30 seconds and and build connection string + // enable PersistSecurityInfo to handle issues in SMO where the connection context is lost in reconnections + int? originalTimeout = connInfo.ConnectionDetails.ConnectTimeout; + bool? originalPersistSecurityInfo = connInfo.ConnectionDetails.PersistSecurityInfo; + connInfo.ConnectionDetails.ConnectTimeout = Math.Max(DefaultMinimumConnectionTimeout, originalTimeout ?? 0); + connInfo.ConnectionDetails.PersistSecurityInfo = true; + string connectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails); + connInfo.ConnectionDetails.ConnectTimeout = originalTimeout; + connInfo.ConnectionDetails.PersistSecurityInfo = originalPersistSecurityInfo; + + // open a dedicated binding server connection + SqlConnection sqlConn = new SqlConnection(connectionString); + if (sqlConn != null) + { + sqlConn.Open(); + + // populate the binding context to work with the SMO metadata provider + ServerConnection serverConn = new ServerConnection(sqlConn); + bindingContext.SmoMetadataProvider = SmoMetadataProvider.CreateConnectedProvider(serverConn); + bindingContext.MetadataDisplayInfoProvider = new MetadataDisplayInfoProvider(); + bindingContext.MetadataDisplayInfoProvider.BuiltInCasing = + this.CurrentSettings.SqlTools.IntelliSense.LowerCaseSuggestions.Value + ? CasingStyle.Lowercase : CasingStyle.Uppercase; + bindingContext.Binder = BinderProvider.CreateBinder(bindingContext.SmoMetadataProvider); + bindingContext.ServerConnection = serverConn; + bindingContext.BindingTimeout = ConnectedBindingQueue.DefaultBindingTimeout; + bindingContext.IsConnected = true; + } + } + catch (Exception) + { + bindingContext.IsConnected = false; + } + finally + { + bindingContext.BindingLocked.Set(); + } + + return connectionKey; + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/IBindingContext.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/IBindingContext.cs new file mode 100644 index 00000000..c83a28d7 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/IBindingContext.cs @@ -0,0 +1,81 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.Threading; +using Microsoft.SqlServer.Management.Common; +using Microsoft.SqlServer.Management.SmoMetadataProvider; +using Microsoft.SqlServer.Management.SqlParser.Binder; +using Microsoft.SqlServer.Management.SqlParser.Common; +using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; +using Microsoft.SqlServer.Management.SqlParser.Parser; + +namespace Microsoft.SqlTools.ServiceLayer.LanguageServices +{ + /// + /// The context used for binding requests + /// + public interface IBindingContext + { + /// + /// Gets or sets a flag indicating if the context is connected + /// + bool IsConnected { get; set; } + + /// + /// Gets or sets the binding server connection + /// + ServerConnection ServerConnection { get; set; } + + /// + /// Gets or sets the metadata display info provider + /// + MetadataDisplayInfoProvider MetadataDisplayInfoProvider { get; set; } + + /// + /// Gets or sets the SMO metadata provider + /// + SmoMetadataProvider SmoMetadataProvider { get; set; } + + /// + /// Gets or sets the binder + /// + IBinder Binder { get; set; } + + /// + /// Gets or sets an event to signal if a binding operation is in progress + /// + ManualResetEvent BindingLocked { get; set; } + + /// + /// Gets or sets the binding operation timeout in milliseconds + /// + int BindingTimeout { get; set; } + + /// + /// Gets or sets the current connection parse options + /// + ParseOptions ParseOptions { get; } + + /// + /// Gets or sets the current connection server version + /// + ServerVersion ServerVersion { get; } + + /// + /// Gets or sets the database engine type + /// + DatabaseEngineType DatabaseEngineType { get; } + + /// + /// Gets or sets the T-SQL version + /// + TransactSqlVersion TransactSqlVersion { get; } + + /// + /// Gets or sets the database compatibility level + /// + DatabaseCompatibilityLevel DatabaseCompatibilityLevel { get; } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs index cc834adc..889ad882 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs @@ -11,13 +11,11 @@ using System.Threading.Tasks; using Microsoft.SqlServer.Management.Common; using Microsoft.SqlServer.Management.SqlParser; using Microsoft.SqlServer.Management.SqlParser.Binder; +using Microsoft.SqlServer.Management.SqlParser.Common; using Microsoft.SqlServer.Management.SqlParser.Intellisense; -using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; using Microsoft.SqlServer.Management.SqlParser.Parser; -using Microsoft.SqlServer.Management.SmoMetadataProvider; using Microsoft.SqlTools.ServiceLayer.Connection; using Microsoft.SqlTools.ServiceLayer.Connection.Contracts; -using Microsoft.SqlTools.ServiceLayer.Connection.ReliableConnection; using Microsoft.SqlTools.ServiceLayer.Hosting; using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol; using Microsoft.SqlTools.ServiceLayer.LanguageServices.Contracts; @@ -39,31 +37,54 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices internal const int DiagnosticParseDelay = 750; - internal const int FindCompletionsTimeout = 3000; + internal const int HoverTimeout = 3000; + + internal const int BindingTimeout = 3000; internal const int FindCompletionStartTimeout = 50; internal const int OnConnectionWaitTimeout = 300000; + private static ConnectionService connectionService = null; + + private static WorkspaceService workspaceServiceInstance; + private object parseMapLock = new object(); private ScriptParseInfo currentCompletionParseInfo; - internal bool ShouldEnableAutocomplete() - { - return true; - } + private ConnectedBindingQueue bindingQueue = new ConnectedBindingQueue(); - private ConnectionService connectionService = null; + private ParseOptions defaultParseOptions = new ParseOptions( + batchSeparator: LanguageService.DefaultBatchSeperator, + isQuotedIdentifierSet: true, + compatibilityLevel: DatabaseCompatibilityLevel.Current, + transactSqlVersion: TransactSqlVersion.Current); + + /// + /// Gets or sets the binding queue instance + /// Internal for testing purposes only + /// + internal ConnectedBindingQueue BindingQueue + { + get + { + return this.bindingQueue; + } + set + { + this.bindingQueue = value; + } + } /// /// Internal for testing purposes only /// - internal ConnectionService ConnectionServiceInstance + internal static ConnectionService ConnectionServiceInstance { get { - if(connectionService == null) + if (connectionService == null) { connectionService = ConnectionService.Instance; } @@ -83,6 +104,9 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices private Lazy> scriptParseInfoMap = new Lazy>(() => new Dictionary()); + /// + /// Gets a mapping dictionary for SQL file URIs to ScriptParseInfo objects + /// internal Dictionary ScriptParseInfoMap { get @@ -91,11 +115,22 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices } } + /// + /// Gets the singleton instance object + /// public static LanguageService Instance { get { return instance.Value; } } + private ParseOptions DefaultParseOptions + { + get + { + return this.defaultParseOptions; + } + } + /// /// Default, parameterless constructor. /// @@ -109,14 +144,40 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices private static CancellationTokenSource ExistingRequestCancellation { get; set; } + /// + /// Gets the current settings + /// internal SqlToolsSettings CurrentSettings { get { return WorkspaceService.Instance.CurrentSettings; } } + /// + /// Gets or sets the current workspace service instance + /// Setter for internal testing purposes only + /// + internal static WorkspaceService WorkspaceServiceInstance + { + get + { + if (LanguageService.workspaceServiceInstance == null) + { + LanguageService.workspaceServiceInstance = WorkspaceService.Instance; + } + return LanguageService.workspaceServiceInstance; + } + set + { + LanguageService.workspaceServiceInstance = value; + } + } + + /// + /// Gets the current workspace instance + /// internal Workspace.Workspace CurrentWorkspace { - get { return WorkspaceService.Instance.Workspace; } + get { return LanguageService.WorkspaceServiceInstance.Workspace; } } /// @@ -181,23 +242,31 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices /// /// /// - private static async Task HandleCompletionRequest( + internal static async Task HandleCompletionRequest( TextDocumentPosition textDocumentPosition, RequestContext requestContext) { - // get the current list of completion items and return to client - var scriptFile = WorkspaceService.Instance.Workspace.GetFile( - textDocumentPosition.TextDocument.Uri); + // check if Intellisense suggestions are enabled + if (!WorkspaceService.Instance.CurrentSettings.IsSuggestionsEnabled) + { + await Task.FromResult(true); + } + else + { + // get the current list of completion items and return to client + var scriptFile = LanguageService.WorkspaceServiceInstance.Workspace.GetFile( + textDocumentPosition.TextDocument.Uri); - ConnectionInfo connInfo; - ConnectionService.Instance.TryFindConnection( - scriptFile.ClientFilePath, - out connInfo); + ConnectionInfo connInfo; + LanguageService.ConnectionServiceInstance.TryFindConnection( + scriptFile.ClientFilePath, + out connInfo); - var completionItems = Instance.GetCompletionItems( - textDocumentPosition, scriptFile, connInfo); + var completionItems = Instance.GetCompletionItems( + textDocumentPosition, scriptFile, connInfo); - await requestContext.SendResult(completionItems); + await requestContext.SendResult(completionItems); + } } /// @@ -211,8 +280,16 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices CompletionItem completionItem, RequestContext requestContext) { - completionItem = LanguageService.Instance.ResolveCompletionItem(completionItem); - await requestContext.SendResult(completionItem); + // check if Intellisense suggestions are enabled + if (!WorkspaceService.Instance.CurrentSettings.IsSuggestionsEnabled) + { + await Task.FromResult(true); + } + else + { + completionItem = LanguageService.Instance.ResolveCompletionItem(completionItem); + await requestContext.SendResult(completionItem); + } } private static async Task HandleDefinitionRequest( @@ -246,8 +323,21 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices private static async Task HandleHoverRequest( TextDocumentPosition textDocumentPosition, RequestContext requestContext) - { - await Task.FromResult(true); + { + // check if Quick Info hover tooltips are enabled + if (WorkspaceService.Instance.CurrentSettings.IsQuickInfoEnabled) + { + var scriptFile = WorkspaceService.Instance.Workspace.GetFile( + textDocumentPosition.TextDocument.Uri); + + var hover = LanguageService.Instance.GetHoverItem(textDocumentPosition, scriptFile); + if (hover != null) + { + await requestContext.SendResult(hover); + } + } + + await requestContext.SendResult(new Hover()); } #endregion @@ -264,7 +354,9 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices ScriptFile scriptFile, EventContext eventContext) { - if (!IsPreviewWindow(scriptFile)) + // if not in the preview window and diagnostics are enabled then run diagnostics + if (!IsPreviewWindow(scriptFile) + && WorkspaceService.Instance.CurrentSettings.IsDiagnositicsEnabled) { await RunScriptDiagnostics( new ScriptFile[] { scriptFile }, @@ -278,13 +370,15 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices /// Handles text document change events /// /// - /// - /// + /// public async Task HandleDidChangeTextDocumentNotification(ScriptFile[] changedFiles, EventContext eventContext) { - await this.RunScriptDiagnostics( - changedFiles.ToArray(), - eventContext); + if (WorkspaceService.Instance.CurrentSettings.IsDiagnositicsEnabled) + { + await this.RunScriptDiagnostics( + changedFiles.ToArray(), + eventContext); + } await Task.FromResult(true); } @@ -300,13 +394,18 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices SqlToolsSettings oldSettings, EventContext eventContext) { - // If script analysis settings have changed we need to clear & possibly update the current diagnostic records. - bool oldScriptAnalysisEnabled = oldSettings.ScriptAnalysis.Enable.HasValue; - if ((oldScriptAnalysisEnabled != newSettings.ScriptAnalysis.Enable)) + bool oldEnableIntelliSense = oldSettings.SqlTools.EnableIntellisense; + bool? oldEnableDiagnostics = oldSettings.SqlTools.IntelliSense.EnableDiagnostics; + + // update the current settings to reflect any changes + CurrentSettings.Update(newSettings); + + // if script analysis settings have changed we need to clear the current diagnostic markers + if (oldEnableIntelliSense != newSettings.SqlTools.EnableIntellisense + || oldEnableDiagnostics != newSettings.SqlTools.IntelliSense.EnableDiagnostics) { - // If the user just turned off script analysis or changed the settings path, send a diagnostics - // event to clear the analysis markers that they already have. - if (!newSettings.ScriptAnalysis.Enable.Value) + // if the user just turned off diagnostics then send an event to clear the error markers + if (!newSettings.IsDiagnositicsEnabled) { ScriptFileMarker[] emptyAnalysisDiagnostics = new ScriptFileMarker[0]; @@ -315,15 +414,12 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices await DiagnosticsHelper.PublishScriptDiagnostics(scriptFile, emptyAnalysisDiagnostics, eventContext); } } + // otherwise rerun diagnostic analysis on all opened SQL files else { await this.RunScriptDiagnostics(CurrentWorkspace.GetOpenedFiles(), eventContext); } } - - // Update the settings in the current - CurrentSettings.EnableProfileLoading = newSettings.EnableProfileLoading; - CurrentSettings.ScriptAnalysis.Update(newSettings.ScriptAnalysis, CurrentWorkspace.WorkspacePath); } #endregion @@ -350,52 +446,85 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices /// /// /// - /// + /// The ParseResult instance returned from SQL Parser public ParseResult ParseAndBind(ScriptFile scriptFile, ConnectionInfo connInfo) { // get or create the current parse info object ScriptParseInfo parseInfo = GetScriptParseInfo(scriptFile.ClientFilePath, createIfNotExists: true); - if (parseInfo.BuildingMetadataEvent.WaitOne(LanguageService.FindCompletionsTimeout)) + if (parseInfo.BuildingMetadataEvent.WaitOne(LanguageService.BindingTimeout)) { try { parseInfo.BuildingMetadataEvent.Reset(); - // parse current SQL file contents to retrieve a list of errors - ParseResult parseResult = Parser.IncrementalParse( - scriptFile.Contents, - parseInfo.ParseResult, - parseInfo.ParseOptions); - - parseInfo.ParseResult = parseResult; - - if (connInfo != null && parseInfo.IsConnected) + if (connInfo == null || !parseInfo.IsConnected) { - try - { - List parseResults = new List(); - parseResults.Add(parseResult); - parseInfo.Binder.Bind( - parseResults, - connInfo.ConnectionDetails.DatabaseName, - BindMode.Batch); - } - catch (ConnectionException) - { - Logger.Write(LogLevel.Error, "Hit connection exception while binding - disposing binder object..."); - } - catch (SqlParserInternalBinderError) - { - Logger.Write(LogLevel.Error, "Hit connection exception while binding - disposing binder object..."); - } + // parse current SQL file contents to retrieve a list of errors + ParseResult parseResult = Parser.IncrementalParse( + scriptFile.Contents, + parseInfo.ParseResult, + this.DefaultParseOptions); + + parseInfo.ParseResult = parseResult; } + else + { + QueueItem queueItem = this.BindingQueue.QueueBindingOperation( + key: parseInfo.ConnectionKey, + bindingTimeout: LanguageService.BindingTimeout, + bindOperation: (bindingContext, cancelToken) => + { + try + { + ParseResult parseResult = Parser.IncrementalParse( + scriptFile.Contents, + parseInfo.ParseResult, + bindingContext.ParseOptions); + + parseInfo.ParseResult = parseResult; + + List parseResults = new List(); + parseResults.Add(parseResult); + bindingContext.Binder.Bind( + parseResults, + connInfo.ConnectionDetails.DatabaseName, + BindMode.Batch); + } + catch (ConnectionException) + { + Logger.Write(LogLevel.Error, "Hit connection exception while binding - disposing binder object..."); + } + catch (SqlParserInternalBinderError) + { + Logger.Write(LogLevel.Error, "Hit connection exception while binding - disposing binder object..."); + } + catch (Exception ex) + { + Logger.Write(LogLevel.Error, "Unknown exception during parsing " + ex.ToString()); + } + + return null; + }); + + queueItem.ItemProcessed.WaitOne(); + } + } + catch (Exception ex) + { + // reset the parse result to do a full parse next time + parseInfo.ParseResult = null; + Logger.Write(LogLevel.Error, "Unknown exception during parsing " + ex.ToString()); } finally { parseInfo.BuildingMetadataEvent.Set(); } } + else + { + Logger.Write(LogLevel.Warning, "Binding metadata lock timeout in ParseAndBind"); + } return parseInfo.ParseResult; } @@ -406,42 +535,32 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices /// public async Task UpdateLanguageServiceOnConnection(ConnectionInfo info) { - await Task.Run( () => + await Task.Run(() => { - if (ShouldEnableAutocomplete()) + ScriptParseInfo scriptInfo = GetScriptParseInfo(info.OwnerUri, createIfNotExists: true); + if (scriptInfo.BuildingMetadataEvent.WaitOne(LanguageService.OnConnectionWaitTimeout)) { - ScriptParseInfo scriptInfo = GetScriptParseInfo(info.OwnerUri, createIfNotExists: true); - if (scriptInfo.BuildingMetadataEvent.WaitOne(LanguageService.OnConnectionWaitTimeout)) + try { - try - { - scriptInfo.BuildingMetadataEvent.Reset(); - var sqlConn = info.SqlConnection as ReliableSqlConnection; - if (sqlConn != null) - { - ServerConnection serverConn = new ServerConnection(sqlConn.GetUnderlyingConnection()); - scriptInfo.MetadataDisplayInfoProvider = new MetadataDisplayInfoProvider(); - scriptInfo.MetadataProvider = SmoMetadataProvider.CreateConnectedProvider(serverConn); - scriptInfo.Binder = BinderProvider.CreateBinder(scriptInfo.MetadataProvider); - scriptInfo.ServerConnection = new ServerConnection(sqlConn.GetUnderlyingConnection()); - scriptInfo.IsConnected = true; - } - } - catch (Exception) - { - scriptInfo.IsConnected = false; - } - finally - { - // Set Metadata Build event to Signal state. - // (Tell Language Service that I am ready with Metadata Provider Object) - scriptInfo.BuildingMetadataEvent.Set(); - } + scriptInfo.BuildingMetadataEvent.Reset(); + scriptInfo.ConnectionKey = this.BindingQueue.AddConnectionContext(info); + scriptInfo.IsConnected = true; + } + catch (Exception ex) + { + Logger.Write(LogLevel.Error, "Unknown error in OnConnection " + ex.ToString()); + scriptInfo.IsConnected = false; + } + finally + { + // Set Metadata Build event to Signal state. + // (Tell Language Service that I am ready with Metadata Provider Object) + scriptInfo.BuildingMetadataEvent.Set(); + } + } - // populate SMO metadata provider with most common info - AutoCompleteHelper.PrepopulateCommonMetadata(info, scriptInfo); - } + AutoCompleteHelper.PrepopulateCommonMetadata(info, scriptInfo, this.BindingQueue); }); } @@ -469,22 +588,88 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices /// internal CompletionItem ResolveCompletionItem(CompletionItem completionItem) { - var scriptParseInfo = LanguageService.Instance.currentCompletionParseInfo; - if (scriptParseInfo != null && scriptParseInfo.CurrentSuggestions != null) + try { - foreach (var suggestion in scriptParseInfo.CurrentSuggestions) + var scriptParseInfo = LanguageService.Instance.currentCompletionParseInfo; + if (scriptParseInfo != null && scriptParseInfo.CurrentSuggestions != null) { - if (string.Equals(suggestion.Title, completionItem.Label)) + foreach (var suggestion in scriptParseInfo.CurrentSuggestions) { - completionItem.Detail = suggestion.DatabaseQualifiedName; - completionItem.Documentation = suggestion.Description; - break; + if (string.Equals(suggestion.Title, completionItem.Label)) + { + completionItem.Detail = suggestion.DatabaseQualifiedName; + completionItem.Documentation = suggestion.Description; + break; + } } } } + catch (Exception ex) + { + // if any exceptions are raised looking up extended completion metadata + // then just return the original completion item + Logger.Write(LogLevel.Error, "Exeception in ResolveCompletionItem " + ex.ToString()); + } + return completionItem; } + /// + /// Get quick info hover tooltips for the current position + /// + /// + /// + internal Hover GetHoverItem(TextDocumentPosition textDocumentPosition, ScriptFile scriptFile) + { + int startLine = textDocumentPosition.Position.Line; + int startColumn = TextUtilities.PositionOfPrevDelimeter( + scriptFile.Contents, + textDocumentPosition.Position.Line, + textDocumentPosition.Position.Character); + int endColumn = textDocumentPosition.Position.Character; + + ScriptParseInfo scriptParseInfo = GetScriptParseInfo(textDocumentPosition.TextDocument.Uri); + if (scriptParseInfo != null && scriptParseInfo.ParseResult != null) + { + if (scriptParseInfo.BuildingMetadataEvent.WaitOne(LanguageService.FindCompletionStartTimeout)) + { + scriptParseInfo.BuildingMetadataEvent.Reset(); + try + { + QueueItem queueItem = this.BindingQueue.QueueBindingOperation( + key: scriptParseInfo.ConnectionKey, + bindingTimeout: LanguageService.HoverTimeout, + bindOperation: (bindingContext, cancelToken) => + { + // get the current quick info text + Babel.CodeObjectQuickInfo quickInfo = Resolver.GetQuickInfo( + scriptParseInfo.ParseResult, + startLine + 1, + endColumn + 1, + bindingContext.MetadataDisplayInfoProvider); + + // convert from the parser format to the VS Code wire format + return AutoCompleteHelper.ConvertQuickInfoToHover( + quickInfo, + startLine, + startColumn, + endColumn); + }); + + queueItem.ItemProcessed.WaitOne(); + return queueItem.GetResultAsT(); + } + finally + { + scriptParseInfo.BuildingMetadataEvent.Set(); + } + } + } + + // return null if there isn't a tooltip for the current location + return null; + } + /// /// Return the completion item list for the current text position. /// This method does not await cache builds since it expects to return quickly @@ -502,6 +687,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices textDocumentPosition.Position.Line, textDocumentPosition.Position.Character); int endColumn = textDocumentPosition.Position.Character; + bool useLowerCaseSuggestions = this.CurrentSettings.SqlTools.IntelliSense.LowerCaseSuggestions.Value; this.currentCompletionParseInfo = null; @@ -510,7 +696,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices ScriptParseInfo scriptParseInfo = GetScriptParseInfo(textDocumentPosition.TextDocument.Uri); if (connInfo == null || scriptParseInfo == null) { - return AutoCompleteHelper.GetDefaultCompletionItems(startLine, startColumn, endColumn); + return AutoCompleteHelper.GetDefaultCompletionItems(startLine, startColumn, endColumn, useLowerCaseSuggestions); } // reparse and bind the SQL statement if needed @@ -521,49 +707,60 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices if (scriptParseInfo.ParseResult == null) { - return AutoCompleteHelper.GetDefaultCompletionItems(startLine, startColumn, endColumn); + return AutoCompleteHelper.GetDefaultCompletionItems(startLine, startColumn, endColumn, useLowerCaseSuggestions); } if (scriptParseInfo.IsConnected && scriptParseInfo.BuildingMetadataEvent.WaitOne(LanguageService.FindCompletionStartTimeout)) { - scriptParseInfo.BuildingMetadataEvent.Reset(); - Task findCompletionsTask = Task.Run(() => { - try + scriptParseInfo.BuildingMetadataEvent.Reset(); + + QueueItem queueItem = this.BindingQueue.QueueBindingOperation( + key: scriptParseInfo.ConnectionKey, + bindingTimeout: LanguageService.BindingTimeout, + bindOperation: (bindingContext, cancelToken) => { - // get the completion list from SQL Parser - scriptParseInfo.CurrentSuggestions = Resolver.FindCompletions( - scriptParseInfo.ParseResult, - textDocumentPosition.Position.Line + 1, - textDocumentPosition.Position.Character + 1, - scriptParseInfo.MetadataDisplayInfoProvider); + CompletionItem[] completions = null; + try + { + // get the completion list from SQL Parser + scriptParseInfo.CurrentSuggestions = Resolver.FindCompletions( + scriptParseInfo.ParseResult, + textDocumentPosition.Position.Line + 1, + textDocumentPosition.Position.Character + 1, + bindingContext.MetadataDisplayInfoProvider); - // cache the current script parse info object to resolve completions later - this.currentCompletionParseInfo = scriptParseInfo; + // cache the current script parse info object to resolve completions later + this.currentCompletionParseInfo = scriptParseInfo; - // convert the suggestion list to the VS Code format - return AutoCompleteHelper.ConvertDeclarationsToCompletionItems( - scriptParseInfo.CurrentSuggestions, - startLine, - startColumn, - endColumn); - } - finally + // convert the suggestion list to the VS Code format + completions = AutoCompleteHelper.ConvertDeclarationsToCompletionItems( + scriptParseInfo.CurrentSuggestions, + startLine, + startColumn, + endColumn); + } + finally + { + scriptParseInfo.BuildingMetadataEvent.Set(); + } + + return completions; + }, + timeoutOperation: (bindingContext) => { - scriptParseInfo.BuildingMetadataEvent.Set(); - } - }); - - findCompletionsTask.Wait(LanguageService.FindCompletionsTimeout); - if (findCompletionsTask.IsCompleted - && findCompletionsTask.Result != null - && findCompletionsTask.Result.Length > 0) + return AutoCompleteHelper.GetDefaultCompletionItems(startLine, startColumn, endColumn, useLowerCaseSuggestions); + }); + + queueItem.ItemProcessed.WaitOne(); + var completionItems = queueItem.GetResultAsT(); + if (completionItems != null && completionItems.Length > 0) { - return findCompletionsTask.Result; + return completionItems; } } - return AutoCompleteHelper.GetDefaultCompletionItems(startLine, startColumn, endColumn); + return AutoCompleteHelper.GetDefaultCompletionItems(startLine, startColumn, endColumn, useLowerCaseSuggestions); } #endregion @@ -614,7 +811,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices /// private Task RunScriptDiagnostics(ScriptFile[] filesToAnalyze, EventContext eventContext) { - if (!CurrentSettings.ScriptAnalysis.Enable.Value) + if (!CurrentSettings.IsDiagnositicsEnabled) { // If the user has disabled script analysis, skip it entirely return Task.FromResult(true); @@ -710,7 +907,12 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices #endregion - private void AddOrUpdateScriptParseInfo(string uri, ScriptParseInfo scriptInfo) + /// + /// Adds a new or updates an existing script parse info instance in local cache + /// + /// + /// + internal void AddOrUpdateScriptParseInfo(string uri, ScriptParseInfo scriptInfo) { lock (this.parseMapLock) { @@ -726,7 +928,13 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices } } - private ScriptParseInfo GetScriptParseInfo(string uri, bool createIfNotExists = false) + /// + /// Gets a script parse info object for a file from the local cache + /// Internal for testing purposes only + /// + /// + /// Creates a new instance if one doesn't exist + internal ScriptParseInfo GetScriptParseInfo(string uri, bool createIfNotExists = false) { lock (this.parseMapLock) { @@ -736,6 +944,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices } else if (createIfNotExists) { + // create a new script parse info object and initialize with the current settings ScriptParseInfo scriptInfo = new ScriptParseInfo(); this.ScriptParseInfoMap.Add(uri, scriptInfo); return scriptInfo; @@ -752,10 +961,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices lock (this.parseMapLock) { if (this.ScriptParseInfoMap.ContainsKey(uri)) - { - var scriptInfo = this.ScriptParseInfoMap[uri]; - scriptInfo.ServerConnection.Disconnect(); - scriptInfo.ServerConnection = null; + { return this.ScriptParseInfoMap.Remove(uri); } else diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/QueueItem.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/QueueItem.cs new file mode 100644 index 00000000..adf5fa18 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/QueueItem.cs @@ -0,0 +1,66 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Microsoft.SqlTools.ServiceLayer.LanguageServices +{ + /// + /// Class that stores the state of a binding queue request item + /// + public class QueueItem + { + /// + /// QueueItem constructor + /// + public QueueItem() + { + this.ItemProcessed = new ManualResetEvent(initialState: false); + } + + /// + /// Gets or sets the queue item key + /// + public string Key { get; set; } + + /// + /// Gets or sets the bind operation callback method + /// + public Func BindOperation { get; set; } + + /// + /// Gets or sets the timeout operation to call if the bind operation doesn't finish within timeout period + /// + public Func TimeoutOperation { get; set; } + + /// + /// Gets or sets an event to signal when this queue item has been processed + /// + public ManualResetEvent ItemProcessed { get; set; } + + /// + /// Gets or sets the result of the queued task + /// + public object Result { get; set; } + + /// + /// Gets or sets the binding operation timeout in milliseconds + /// + public int? BindingTimeout { get; set; } + + /// + /// Converts the result of the execution to type T + /// + public T GetResultAsT() where T : class + { + //var task = this.ResultsTask; + return (this.Result != null) + ? this.Result as T + : null; + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ScriptParseInfo.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ScriptParseInfo.cs index 7dca96ab..2c56d497 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ScriptParseInfo.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ScriptParseInfo.cs @@ -3,15 +3,9 @@ // Licensed under the MIT license. See LICENSE file in the project root for full license information. // -using System; using System.Collections.Generic; using System.Threading; -using Microsoft.SqlServer.Management.Common; -using Microsoft.SqlServer.Management.SmoMetadataProvider; -using Microsoft.SqlServer.Management.SqlParser.Binder; -using Microsoft.SqlServer.Management.SqlParser.Common; using Microsoft.SqlServer.Management.SqlParser.Intellisense; -using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; using Microsoft.SqlServer.Management.SqlParser.Parser; namespace Microsoft.SqlTools.ServiceLayer.LanguageServices @@ -23,10 +17,6 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices { private ManualResetEvent buildingMetadataEvent = new ManualResetEvent(initialState: true); - private ParseOptions parseOptions = new ParseOptions(); - - private ServerConnection serverConnection; - /// /// Event which tells if MetadataProvider is built fully or not /// @@ -41,163 +31,18 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices public bool IsConnected { get; set; } /// - /// Gets or sets the LanguageService SMO ServerConnection + /// Gets or sets the binding queue connection context key /// - public ServerConnection ServerConnection - { - get - { - return this.serverConnection; - } - set - { - this.serverConnection = value; - this.parseOptions = new ParseOptions( - batchSeparator: LanguageService.DefaultBatchSeperator, - isQuotedIdentifierSet: true, - compatibilityLevel: DatabaseCompatibilityLevel, - transactSqlVersion: TransactSqlVersion); - } - } - - /// - /// Gets the Language Service ServerVersion - /// - public ServerVersion ServerVersion - { - get - { - return this.ServerConnection != null - ? this.ServerConnection.ServerVersion - : null; - } - } - - /// - /// Gets the current DataEngineType - /// - public DatabaseEngineType DatabaseEngineType - { - get - { - return this.ServerConnection != null - ? this.ServerConnection.DatabaseEngineType - : DatabaseEngineType.Standalone; - } - } - - /// - /// Gets the current connections TransactSqlVersion - /// - public TransactSqlVersion TransactSqlVersion - { - get - { - return this.IsConnected - ? GetTransactSqlVersion(this.ServerVersion) - : TransactSqlVersion.Current; - } - } - - /// - /// Gets the current DatabaseCompatibilityLevel - /// - public DatabaseCompatibilityLevel DatabaseCompatibilityLevel - { - get - { - return this.IsConnected - ? GetDatabaseCompatibilityLevel(this.ServerVersion) - : DatabaseCompatibilityLevel.Current; - } - } - - /// - /// Gets the current ParseOptions - /// - public ParseOptions ParseOptions - { - get - { - return this.parseOptions; - } - } - - /// - /// Gets or sets the SMO binder for schema-aware intellisense - /// - public IBinder Binder { get; set; } + public string ConnectionKey { get; set; } /// /// Gets or sets the previous SQL parse result /// public ParseResult ParseResult { get; set; } - - /// - /// Gets or set the SMO metadata provider that's bound to the current connection - /// - public SmoMetadataProvider MetadataProvider { get; set; } - - /// - /// Gets or sets the SMO metadata display info provider - /// - public MetadataDisplayInfoProvider MetadataDisplayInfoProvider { get; set; } /// /// Gets or sets the current autocomplete suggestion list /// public IEnumerable CurrentSuggestions { get; set; } - - /// - /// Gets the database compatibility level from a server version - /// - /// - private static DatabaseCompatibilityLevel GetDatabaseCompatibilityLevel(ServerVersion serverVersion) - { - int versionMajor = Math.Max(serverVersion.Major, 8); - - switch (versionMajor) - { - case 8: - return DatabaseCompatibilityLevel.Version80; - case 9: - return DatabaseCompatibilityLevel.Version90; - case 10: - return DatabaseCompatibilityLevel.Version100; - case 11: - return DatabaseCompatibilityLevel.Version110; - case 12: - return DatabaseCompatibilityLevel.Version120; - case 13: - return DatabaseCompatibilityLevel.Version130; - default: - return DatabaseCompatibilityLevel.Current; - } - } - - /// - /// Gets the transaction sql version from a server version - /// - /// - private static TransactSqlVersion GetTransactSqlVersion(ServerVersion serverVersion) - { - int versionMajor = Math.Max(serverVersion.Major, 9); - - switch (versionMajor) - { - case 9: - case 10: - // In case of 10.0 we still use Version 10.5 as it is the closest available. - return TransactSqlVersion.Version105; - case 11: - return TransactSqlVersion.Version110; - case 12: - return TransactSqlVersion.Version120; - case 13: - return TransactSqlVersion.Version130; - default: - return TransactSqlVersion.Current; - } - } } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/Program.cs b/src/Microsoft.SqlTools.ServiceLayer/Program.cs index 3e5a8655..35a659fe 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Program.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Program.cs @@ -16,26 +16,22 @@ namespace Microsoft.SqlTools.ServiceLayer /// /// Main application class for SQL Tools API Service Host executable /// - class Program + internal class Program { /// /// Main entry point into the SQL Tools API Service Host /// - static void Main(string[] args) + internal static void Main(string[] args) { // turn on Verbose logging during early development // we need to switch to Normal when preparing for public preview Logger.Initialize(minimumLogLevel: LogLevel.Verbose); Logger.Write(LogLevel.Normal, "Starting SQL Tools Service Host"); - const string hostName = "SQL Tools Service Host"; - const string hostProfileId = "SQLToolsService"; - Version hostVersion = new Version(1,0); - // set up the host details and profile paths - var hostDetails = new HostDetails(hostName, hostProfileId, hostVersion); - var profilePaths = new ProfilePaths(hostProfileId, "baseAllUsersPath", "baseCurrentUserPath"); - SqlToolsContext sqlToolsContext = new SqlToolsContext(hostDetails, profilePaths); + var hostDetails = new HostDetails(version: new Version(1,0)); + + SqlToolsContext sqlToolsContext = new SqlToolsContext(hostDetails); // Grab the instance of the service host ServiceHost serviceHost = ServiceHost.Instance; diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs index acdd70a9..51a35a7d 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs @@ -6,6 +6,7 @@ using System; using System.Collections.Generic; using System.Data; using System.Data.Common; +using System.Diagnostics; using System.Data.SqlClient; using System.Linq; using System.Threading; @@ -37,7 +38,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// /// Internal representation of the messages so we can modify internally /// - private readonly List resultMessages; + private readonly List resultMessages; /// /// Internal representation of the result sets so we can modify internally @@ -46,7 +47,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution #endregion - internal Batch(string batchText, int startLine, IFileStreamFactory outputFileFactory) + internal Batch(string batchText, int startLine, int startColumn, int endLine, int endColumn, IFileStreamFactory outputFileFactory) { // Sanity check for input Validate.IsNotNullOrEmptyString(nameof(batchText), batchText); @@ -54,10 +55,10 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution // Initialize the internal state BatchText = batchText; - StartLine = startLine - 1; // -1 to make sure that the line number of the batch is 0-indexed, since SqlParser gives 1-indexed line numbers + Selection = new SelectionData(startLine, startColumn, endLine, endColumn); HasExecuted = false; resultSets = new List(); - resultMessages = new List(); + resultMessages = new List(); this.outputFileFactory = outputFileFactory; } @@ -81,7 +82,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// /// Messages that have come back from the server /// - public IEnumerable ResultMessages + public IEnumerable ResultMessages { get { return resultMessages; } } @@ -111,9 +112,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution } /// - /// The 0-indexed line number that this batch started on + /// The range from the file that is this batch /// - internal int StartLine { get; set; } + internal SelectionData Selection { get; set; } #endregion @@ -134,19 +135,30 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution try { + DbCommand command = null; + // Register the message listener to *this instance* of the batch // Note: This is being done to associate messages with batches ReliableSqlConnection sqlConn = conn as ReliableSqlConnection; if (sqlConn != null) { sqlConn.GetUnderlyingConnection().InfoMessage += StoreDbMessage; + command = sqlConn.GetUnderlyingConnection().CreateCommand(); + } + else + { + command = conn.CreateCommand(); } + // Make sure we aren't using a ReliableCommad since we do not want automatic retry + Debug.Assert(!(command is ReliableSqlConnection.ReliableSqlCommand), "ReliableSqlCommand command should not be used to execute queries"); + // Create a command that we'll use for executing the query - using (DbCommand command = conn.CreateCommand()) + using (command) { command.CommandText = BatchText; command.CommandType = CommandType.Text; + command.CommandTimeout = 0; // Execute the command to get back a reader using (DbDataReader reader = await command.ExecuteReaderAsync(cancellationToken)) @@ -157,9 +169,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution if (!reader.HasRows && reader.FieldCount == 0) { // Create a message with the number of affected rows -- IF the query affects rows - resultMessages.Add(reader.RecordsAffected >= 0 - ? SR.QueryServiceAffectedRows(reader.RecordsAffected) - : SR.QueryServiceCompletedSuccessfully); + resultMessages.Add(new ResultMessage(reader.RecordsAffected >= 0 + ? SR.QueryServiceAffectedRows(reader.RecordsAffected) + : SR.QueryServiceCompletedSuccessfully)); continue; } @@ -172,7 +184,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution resultSets.Add(resultSet); // Add a message for the number of rows the query returned - resultMessages.Add(SR.QueryServiceAffectedRows(resultSet.RowCount)); + resultMessages.Add(new ResultMessage(SR.QueryServiceAffectedRows(resultSet.RowCount))); } while (await reader.NextResultAsync(cancellationToken)); } } @@ -190,10 +202,10 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution finally { // Remove the message event handler from the connection - SqlConnection sqlConn = conn as SqlConnection; + ReliableSqlConnection sqlConn = conn as ReliableSqlConnection; if (sqlConn != null) { - sqlConn.InfoMessage -= StoreDbMessage; + sqlConn.GetUnderlyingConnection().InfoMessage -= StoreDbMessage; } // Mark that we have executed @@ -233,7 +245,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// Arguments from the event private void StoreDbMessage(object sender, SqlInfoMessageEventArgs args) { - resultMessages.Add(args.Message); + resultMessages.Add(new ResultMessage(args.Message)); } /// @@ -253,16 +265,17 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution SqlError sqlError = error as SqlError; if (sqlError != null) { - int lineNumber = sqlError.LineNumber + StartLine; - string message = SR.QueryServiceErrorFormat(sqlError.Number, sqlError.Class, sqlError.State, - lineNumber, Environment.NewLine, sqlError.Message); - resultMessages.Add(message); + int lineNumber = sqlError.LineNumber + Selection.StartLine; + string message = string.Format("Msg {0}, Level {1}, State {2}, Line {3}{4}{5}", + sqlError.Number, sqlError.Class, sqlError.State, lineNumber, + Environment.NewLine, sqlError.Message); + resultMessages.Add(new ResultMessage(message)); } } } else { - resultMessages.Add(dbe.Message); + resultMessages.Add(new ResultMessage(dbe.Message)); } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/BatchSummary.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/BatchSummary.cs index 73d1d4c8..7e1b2837 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/BatchSummary.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/BatchSummary.cs @@ -20,10 +20,15 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts /// public int Id { get; set; } + /// + /// The selection from the file for this batch + /// + public SelectionData Selection { get; set; } + /// /// Any messages that came back from the server during execution of the batch /// - public string[] Messages { get; set; } + public ResultMessage[] Messages { get; set; } /// /// The summaries of the result sets inside the batch diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbCellValue.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbCellValue.cs new file mode 100644 index 00000000..6eabb4d3 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbCellValue.cs @@ -0,0 +1,23 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts +{ + /// + /// Class used for internally passing results from a cell around. + /// + public class DbCellValue + { + /// + /// Display value for the cell, suitable to be passed back to the client + /// + public string DisplayValue { get; set; } + + /// + /// The raw object for the cell, for use internally + /// + internal object RawObject { get; set; } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbColumnWrapper.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbColumnWrapper.cs index 7574a7de..9e387f8c 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbColumnWrapper.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbColumnWrapper.cs @@ -182,7 +182,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts /// /// Whether or not the column is XML /// - public bool IsXml { get; private set; } + public bool IsXml { get; set; } + + /// + /// Whether or not the column is JSON + /// + public bool IsJson { get; set; } #endregion diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/QueryExecuteRequest.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/QueryExecuteRequest.cs index cac98c1a..6079bf51 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/QueryExecuteRequest.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/QueryExecuteRequest.cs @@ -7,15 +7,30 @@ using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts; namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts { + /// + /// Container class for a selection range from file + /// + public class SelectionData { + public int StartLine { get; set; } + public int StartColumn { get; set; } + public int EndLine { get; set; } + public int EndColumn { get; set; } + public SelectionData(int startLine, int startColumn, int endLine, int endColumn) { + StartLine = startLine; + StartColumn = startColumn; + EndLine = endLine; + EndColumn = endColumn; + } + } /// /// Parameters for the query execute request /// public class QueryExecuteParams { /// - /// The text of the query to execute + /// The selection from the document /// - public string QueryText { get; set; } + public SelectionData QuerySelection { get; set; } /// /// URI for the editor that is asking for the query execute diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/ResultMessage.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/ResultMessage.cs new file mode 100644 index 00000000..27e6713b --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/ResultMessage.cs @@ -0,0 +1,44 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; + +namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts +{ + /// + /// Result message object with timestamp and actual message + /// + public class ResultMessage + { + /// + /// Timestamp of the message + /// Stored in UTC ISO 8601 format; should be localized before displaying to any user + /// + public string Time { get; set; } + + /// + /// Message contents + /// + public string Message { get; set; } + + /// + /// Full constructor + /// + public ResultMessage(string timeStamp, string message) + { + Time = timeStamp; + Message = message; + } + + /// + /// Constructor with default "Now" time + /// + public ResultMessage(string message) + { + Time = DateTime.Now.ToString("o"); + Message = message; + } + } +} \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/ResultSetSubset.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/ResultSetSubset.cs index 8e2b49a9..62308824 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/ResultSetSubset.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/ResultSetSubset.cs @@ -19,6 +19,6 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts /// /// 2D array of the cell values requested from result set /// - public object[][] Rows { get; set; } + public string[][] Rows { get; set; } } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/SaveResultsRequest.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/SaveResultsRequest.cs index 721d13c9..1cf2390e 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/SaveResultsRequest.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/SaveResultsRequest.cs @@ -32,6 +32,28 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts /// URI for the editor that called save results /// public string OwnerUri { get; set; } + + /// + /// Start index of the selected rows (inclusive) + /// + public int? RowStartIndex { get; set; } + + /// + /// End index of the selected rows (inclusive) + /// + public int? RowEndIndex { get; set; } + + /// + /// Start index of the selected columns (inclusive) + /// + /// + public int? ColumnStartIndex { get; set; } + + /// + /// End index of the selected columns (inclusive) + /// + /// + public int? ColumnEndIndex { get; set; } } /// diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/FileStreamReadResult.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/FileStreamReadResult.cs index 61ee62e0..0939c9d4 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/FileStreamReadResult.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/FileStreamReadResult.cs @@ -3,25 +3,16 @@ // Licensed under the MIT license. See LICENSE file in the project root for full license information. // +using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; + namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage { /// /// Represents a value returned from a read from a file stream. This is used to eliminate ref /// parameters used in the read methods. /// - /// The type of the value that was read - public struct FileStreamReadResult + public struct FileStreamReadResult { - /// - /// Whether or not the value of the field is null - /// - public bool IsNull { get; set; } - - /// - /// The value of the field. If is true, this will be set to default(T) - /// - public T Value { get; set; } - /// /// The total length in bytes of the value, (including the bytes used to store the length /// of the value) @@ -34,17 +25,20 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// public int TotalLength { get; set; } + /// + /// Value of the cell + /// + public DbCellValue Value { get; set; } + /// /// Constructs a new FileStreamReadResult /// - /// The value of the result - /// The number of bytes for the used to store the value's length and value - /// Whether or not the value is null - public FileStreamReadResult(T value, int totalLength, bool isNull) + /// The value of the result, ready for consumption by a client + /// The number of bytes for the used to store the value's length and values + public FileStreamReadResult(DbCellValue value, int totalLength) { Value = value; TotalLength = totalLength; - IsNull = isNull; } } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/FileStreamWrapper.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/FileStreamWrapper.cs index b8737cb9..74297a42 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/FileStreamWrapper.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/FileStreamWrapper.cs @@ -53,7 +53,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage { // Sanity check for valid buffer length, fileName, and accessMethod Validate.IsGreaterThan(nameof(bufferLength), bufferLength, 0); - Validate.IsNotNullOrEmptyString(nameof(fileName), fileName); + Validate.IsNotNullOrWhitespaceString(nameof(fileName), fileName); if (accessMethod == FileAccess.Write) { throw new ArgumentException(SR.QueryServiceFileWrapperWriteOnly, nameof(fileName)); diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/IFileStreamReader.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/IFileStreamReader.cs index ea5584f1..cfbe4fa1 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/IFileStreamReader.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/IFileStreamReader.cs @@ -5,7 +5,6 @@ using System; using System.Collections.Generic; -using System.Data.SqlTypes; using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage @@ -15,21 +14,23 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// public interface IFileStreamReader : IDisposable { - object[] ReadRow(long offset, IEnumerable columns); - FileStreamReadResult ReadInt16(long i64Offset); - FileStreamReadResult ReadInt32(long i64Offset); - FileStreamReadResult ReadInt64(long i64Offset); - FileStreamReadResult ReadByte(long i64Offset); - FileStreamReadResult ReadChar(long i64Offset); - FileStreamReadResult ReadBoolean(long i64Offset); - FileStreamReadResult ReadSingle(long i64Offset); - FileStreamReadResult ReadDouble(long i64Offset); - FileStreamReadResult ReadSqlDecimal(long i64Offset); - FileStreamReadResult ReadDecimal(long i64Offset); - FileStreamReadResult ReadDateTime(long i64Offset); - FileStreamReadResult ReadTimeSpan(long i64Offset); - FileStreamReadResult ReadString(long i64Offset); - FileStreamReadResult ReadBytes(long i64Offset); - FileStreamReadResult ReadDateTimeOffset(long i64Offset); + IList ReadRow(long offset, IEnumerable columns); + FileStreamReadResult ReadInt16(long i64Offset); + FileStreamReadResult ReadInt32(long i64Offset); + FileStreamReadResult ReadInt64(long i64Offset); + FileStreamReadResult ReadByte(long i64Offset); + FileStreamReadResult ReadChar(long i64Offset); + FileStreamReadResult ReadBoolean(long i64Offset); + FileStreamReadResult ReadSingle(long i64Offset); + FileStreamReadResult ReadDouble(long i64Offset); + FileStreamReadResult ReadSqlDecimal(long i64Offset); + FileStreamReadResult ReadDecimal(long i64Offset); + FileStreamReadResult ReadDateTime(long i64Offset); + FileStreamReadResult ReadTimeSpan(long i64Offset); + FileStreamReadResult ReadString(long i64Offset); + FileStreamReadResult ReadBytes(long i64Offset); + FileStreamReadResult ReadDateTimeOffset(long i64Offset); + FileStreamReadResult ReadGuid(long offset); + FileStreamReadResult ReadMoney(long offset); } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/IFileStreamWriter.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/IFileStreamWriter.cs index 968701ed..7cfffee8 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/IFileStreamWriter.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/IFileStreamWriter.cs @@ -29,7 +29,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage int WriteDateTimeOffset(DateTimeOffset dtoVal); int WriteTimeSpan(TimeSpan val); int WriteString(string val); - int WriteBytes(byte[] bytes, int length); + int WriteBytes(byte[] bytes); + int WriteGuid(Guid val); + int WriteMoney(SqlMoney val); void FlushBuffer(); } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamReader.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamReader.cs index 9772744f..8547999b 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamReader.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamReader.cs @@ -6,7 +6,6 @@ using System; using System.Collections.Generic; using System.Data.SqlTypes; -using System.Diagnostics; using System.IO; using System.Text; using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; @@ -26,6 +25,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage private readonly IFileStreamWrapper fileStream; + private Dictionary> readMethods; + #endregion /// @@ -41,6 +42,40 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage // Create internal buffer buffer = new byte[DefaultBufferSize]; + + // Create the methods that will be used to read back + readMethods = new Dictionary> + { + {typeof(string), ReadString}, + {typeof(short), ReadInt16}, + {typeof(int), ReadInt32}, + {typeof(long), ReadInt64}, + {typeof(byte), ReadByte}, + {typeof(char), ReadChar}, + {typeof(bool), ReadBoolean}, + {typeof(double), ReadDouble}, + {typeof(float), ReadSingle}, + {typeof(decimal), ReadDecimal}, + {typeof(DateTime), ReadDateTime}, + {typeof(DateTimeOffset), ReadDateTimeOffset}, + {typeof(TimeSpan), ReadTimeSpan}, + {typeof(byte[]), ReadBytes}, + + {typeof(SqlString), ReadString}, + {typeof(SqlInt16), ReadInt16}, + {typeof(SqlInt32), ReadInt32}, + {typeof(SqlInt64), ReadInt64}, + {typeof(SqlByte), ReadByte}, + {typeof(SqlBoolean), ReadBoolean}, + {typeof(SqlDouble), ReadDouble}, + {typeof(SqlSingle), ReadSingle}, + {typeof(SqlDecimal), ReadSqlDecimal}, + {typeof(SqlDateTime), ReadDateTime}, + {typeof(SqlBytes), ReadBytes}, + {typeof(SqlBinary), ReadBytes}, + {typeof(SqlGuid), ReadGuid}, + {typeof(SqlMoney), ReadMoney}, + }; } #region IFileStreamStorage Implementation @@ -50,12 +85,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file where the row starts /// The columns that were encoded - /// The objects from the row - public object[] ReadRow(long fileOffset, IEnumerable columns) + /// The objects from the row, ready for output to the client + public IList ReadRow(long fileOffset, IEnumerable columns) { // Initialize for the loop long currentFileOffset = fileOffset; - List results = new List(); + List results = new List(); // Iterate over the columns foreach (DbColumnWrapper column in columns) @@ -65,22 +100,23 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage if (column.IsSqlVariant) { // For SQL Variant columns, the type is written first in string format - FileStreamReadResult sqlVariantTypeResult = ReadString(currentFileOffset); + FileStreamReadResult sqlVariantTypeResult = ReadString(currentFileOffset); currentFileOffset += sqlVariantTypeResult.TotalLength; + string sqlVariantType = (string)sqlVariantTypeResult.Value.RawObject; // If the typename is null, then the whole value is null - if (sqlVariantTypeResult.IsNull) + if (sqlVariantTypeResult.Value == null || string.IsNullOrEmpty(sqlVariantType)) { - results.Add(null); + results.Add(sqlVariantTypeResult.Value); continue; } // The typename is stored in the string - colType = Type.GetType(sqlVariantTypeResult.Value); + colType = Type.GetType(sqlVariantType); // Workaround .NET bug, see sqlbu# 440643 and vswhidbey# 599834 // TODO: Is this workaround necessary for .NET Core? - if (colType == null && sqlVariantTypeResult.Value == @"System.Data.SqlTypes.SqlSingle") + if (colType == null && sqlVariantType == "System.Data.SqlTypes.SqlSingle") { colType = typeof(SqlSingle); } @@ -90,380 +126,19 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage colType = column.DataType; } - if (colType == typeof(string)) - { - // String - most frequently used data type - FileStreamReadResult result = ReadString(currentFileOffset); - currentFileOffset += result.TotalLength; - results.Add(result.IsNull ? null : result.Value); - } - else if (colType == typeof(SqlString)) - { - // SqlString - FileStreamReadResult result = ReadString(currentFileOffset); - currentFileOffset += result.TotalLength; - results.Add(result.IsNull ? null : (SqlString) result.Value); - } - else if (colType == typeof(short)) - { - // Int16 - FileStreamReadResult result = ReadInt16(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlInt16)) - { - // SqlInt16 - FileStreamReadResult result = ReadInt16(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add((SqlInt16)result.Value); - } - } - else if (colType == typeof(int)) - { - // Int32 - FileStreamReadResult result = ReadInt32(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlInt32)) - { - // SqlInt32 - FileStreamReadResult result = ReadInt32(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add((SqlInt32)result.Value); - } - } - else if (colType == typeof(long)) - { - // Int64 - FileStreamReadResult result = ReadInt64(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlInt64)) - { - // SqlInt64 - FileStreamReadResult result = ReadInt64(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add((SqlInt64)result.Value); - } - } - else if (colType == typeof(byte)) - { - // byte - FileStreamReadResult result = ReadByte(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlByte)) - { - // SqlByte - FileStreamReadResult result = ReadByte(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add((SqlByte)result.Value); - } - } - else if (colType == typeof(char)) - { - // Char - FileStreamReadResult result = ReadChar(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(bool)) - { - // Bool - FileStreamReadResult result = ReadBoolean(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlBoolean)) - { - // SqlBoolean - FileStreamReadResult result = ReadBoolean(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add((SqlBoolean)result.Value); - } - } - else if (colType == typeof(double)) - { - // double - FileStreamReadResult result = ReadDouble(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlDouble)) - { - // SqlByte - FileStreamReadResult result = ReadDouble(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add((SqlDouble)result.Value); - } - } - else if (colType == typeof(float)) - { - // float - FileStreamReadResult result = ReadSingle(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlSingle)) - { - // SqlSingle - FileStreamReadResult result = ReadSingle(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add((SqlSingle)result.Value); - } - } - else if (colType == typeof(decimal)) - { - // Decimal - FileStreamReadResult result = ReadDecimal(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlDecimal)) - { - // SqlDecimal - FileStreamReadResult result = ReadSqlDecimal(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(DateTime)) - { - // DateTime - FileStreamReadResult result = ReadDateTime(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlDateTime)) - { - // SqlDateTime - FileStreamReadResult result = ReadDateTime(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add((SqlDateTime)result.Value); - } - } - else if (colType == typeof(DateTimeOffset)) - { - // DateTimeOffset - FileStreamReadResult result = ReadDateTimeOffset(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(TimeSpan)) - { - // TimeSpan - FileStreamReadResult result = ReadTimeSpan(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(byte[])) - { - // Byte Array - FileStreamReadResult result = ReadBytes(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull || (column.IsUdt && result.Value.Length == 0)) - { - results.Add(null); - } - else - { - results.Add(result.Value); - } - } - else if (colType == typeof(SqlBytes)) - { - // SqlBytes - FileStreamReadResult result = ReadBytes(currentFileOffset); - currentFileOffset += result.TotalLength; - results.Add(result.IsNull ? null : new SqlBytes(result.Value)); - } - else if (colType == typeof(SqlBinary)) - { - // SqlBinary - FileStreamReadResult result = ReadBytes(currentFileOffset); - currentFileOffset += result.TotalLength; - results.Add(result.IsNull ? null : new SqlBinary(result.Value)); - } - else if (colType == typeof(SqlGuid)) - { - // SqlGuid - FileStreamReadResult result = ReadBytes(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(new SqlGuid(result.Value)); - } - } - else if (colType == typeof(SqlMoney)) - { - // SqlMoney - FileStreamReadResult result = ReadDecimal(currentFileOffset); - currentFileOffset += result.TotalLength; - if (result.IsNull) - { - results.Add(null); - } - else - { - results.Add(new SqlMoney(result.Value)); - } - } - else + // Use the right read function for the type to read the data from the file + Func readFunc; + if(!readMethods.TryGetValue(colType, out readFunc)) { // Treat everything else as a string - FileStreamReadResult result = ReadString(currentFileOffset); - currentFileOffset += result.TotalLength; - results.Add(result.IsNull ? null : result.Value); - } + readFunc = ReadString; + } + FileStreamReadResult result = readFunc(currentFileOffset); + currentFileOffset += result.TotalLength; + results.Add(result.Value); } - return results.ToArray(); + return results; } /// @@ -471,21 +146,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the short from /// A short - public FileStreamReadResult ReadInt16(long fileOffset) + public FileStreamReadResult ReadInt16(long fileOffset) { - - LengthResult length = ReadLength(fileOffset); - Debug.Assert(length.ValueLength == 0 || length.ValueLength == 2, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - short val = default(short); - if (!isNull) - { - fileStream.ReadData(buffer, length.ValueLength); - val = BitConverter.ToInt16(buffer, 0); - } - - return new FileStreamReadResult(val, length.TotalLength, isNull); + return ReadCellHelper(fileOffset, length => BitConverter.ToInt16(buffer, 0)); } /// @@ -493,19 +156,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the int from /// An int - public FileStreamReadResult ReadInt32(long fileOffset) + public FileStreamReadResult ReadInt32(long fileOffset) { - LengthResult length = ReadLength(fileOffset); - Debug.Assert(length.ValueLength == 0 || length.ValueLength == 4, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - int val = default(int); - if (!isNull) - { - fileStream.ReadData(buffer, length.ValueLength); - val = BitConverter.ToInt32(buffer, 0); - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + return ReadCellHelper(fileOffset, length => BitConverter.ToInt32(buffer, 0)); } /// @@ -513,19 +166,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the long from /// A long - public FileStreamReadResult ReadInt64(long fileOffset) + public FileStreamReadResult ReadInt64(long fileOffset) { - LengthResult length = ReadLength(fileOffset); - Debug.Assert(length.ValueLength == 0 || length.ValueLength == 8, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - long val = default(long); - if (!isNull) - { - fileStream.ReadData(buffer, length.ValueLength); - val = BitConverter.ToInt64(buffer, 0); - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + return ReadCellHelper(fileOffset, length => BitConverter.ToInt64(buffer, 0)); } /// @@ -533,19 +176,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the byte from /// A byte - public FileStreamReadResult ReadByte(long fileOffset) + public FileStreamReadResult ReadByte(long fileOffset) { - LengthResult length = ReadLength(fileOffset); - Debug.Assert(length.ValueLength == 0 || length.ValueLength == 1, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - byte val = default(byte); - if (!isNull) - { - fileStream.ReadData(buffer, length.ValueLength); - val = buffer[0]; - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + return ReadCellHelper(fileOffset, length => buffer[0]); } /// @@ -553,19 +186,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the char from /// A char - public FileStreamReadResult ReadChar(long fileOffset) + public FileStreamReadResult ReadChar(long fileOffset) { - LengthResult length = ReadLength(fileOffset); - Debug.Assert(length.ValueLength == 0 || length.ValueLength == 2, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - char val = default(char); - if (!isNull) - { - fileStream.ReadData(buffer, length.ValueLength); - val = BitConverter.ToChar(buffer, 0); - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + return ReadCellHelper(fileOffset, length => BitConverter.ToChar(buffer, 0)); } /// @@ -573,19 +196,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the bool from /// A bool - public FileStreamReadResult ReadBoolean(long fileOffset) + public FileStreamReadResult ReadBoolean(long fileOffset) { - LengthResult length = ReadLength(fileOffset); - Debug.Assert(length.ValueLength == 0 || length.ValueLength == 1, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - bool val = default(bool); - if (!isNull) - { - fileStream.ReadData(buffer, length.ValueLength); - val = buffer[0] == 0x01; - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + return ReadCellHelper(fileOffset, length => buffer[0] == 0x1); } /// @@ -593,19 +206,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the single from /// A single - public FileStreamReadResult ReadSingle(long fileOffset) + public FileStreamReadResult ReadSingle(long fileOffset) { - LengthResult length = ReadLength(fileOffset); - Debug.Assert(length.ValueLength == 0 || length.ValueLength == 4, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - float val = default(float); - if (!isNull) - { - fileStream.ReadData(buffer, length.ValueLength); - val = BitConverter.ToSingle(buffer, 0); - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + return ReadCellHelper(fileOffset, length => BitConverter.ToSingle(buffer, 0)); } /// @@ -613,19 +216,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the double from /// A double - public FileStreamReadResult ReadDouble(long fileOffset) + public FileStreamReadResult ReadDouble(long fileOffset) { - LengthResult length = ReadLength(fileOffset); - Debug.Assert(length.ValueLength == 0 || length.ValueLength == 8, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - double val = default(double); - if (!isNull) - { - fileStream.ReadData(buffer, length.ValueLength); - val = BitConverter.ToDouble(buffer, 0); - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + return ReadCellHelper(fileOffset, length => BitConverter.ToDouble(buffer, 0)); } /// @@ -633,23 +226,14 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the SqlDecimal from /// A SqlDecimal - public FileStreamReadResult ReadSqlDecimal(long offset) + public FileStreamReadResult ReadSqlDecimal(long offset) { - LengthResult length = ReadLength(offset); - Debug.Assert(length.ValueLength == 0 || (length.ValueLength - 3)%4 == 0, - string.Format("Invalid data length: {0}", length.ValueLength)); - - bool isNull = length.ValueLength == 0; - SqlDecimal val = default(SqlDecimal); - if (!isNull) + return ReadCellHelper(offset, length => { - fileStream.ReadData(buffer, length.ValueLength); - - int[] arrInt32 = new int[(length.ValueLength - 3)/4]; - Buffer.BlockCopy(buffer, 3, arrInt32, 0, length.ValueLength - 3); - val = new SqlDecimal(buffer[0], buffer[1], 1 == buffer[2], arrInt32); - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + int[] arrInt32 = new int[(length - 3) / 4]; + Buffer.BlockCopy(buffer, 3, arrInt32, 0, length - 3); + return new SqlDecimal(buffer[0], buffer[1], buffer[2] == 1, arrInt32); + }); } /// @@ -657,22 +241,14 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the decimal from /// A decimal - public FileStreamReadResult ReadDecimal(long offset) + public FileStreamReadResult ReadDecimal(long offset) { - LengthResult length = ReadLength(offset); - Debug.Assert(length.ValueLength%4 == 0, "Invalid data length"); - - bool isNull = length.ValueLength == 0; - decimal val = default(decimal); - if (!isNull) + return ReadCellHelper(offset, length => { - fileStream.ReadData(buffer, length.ValueLength); - - int[] arrInt32 = new int[length.ValueLength/4]; - Buffer.BlockCopy(buffer, 0, arrInt32, 0, length.ValueLength); - val = new decimal(arrInt32); - } - return new FileStreamReadResult(val, length.TotalLength, isNull); + int[] arrInt32 = new int[length / 4]; + Buffer.BlockCopy(buffer, 0, arrInt32, 0, length); + return new decimal(arrInt32); + }); } /// @@ -680,15 +256,13 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the DateTime from /// A DateTime - public FileStreamReadResult ReadDateTime(long offset) + public FileStreamReadResult ReadDateTime(long offset) { - FileStreamReadResult ticks = ReadInt64(offset); - DateTime val = default(DateTime); - if (!ticks.IsNull) + return ReadCellHelper(offset, length => { - val = new DateTime(ticks.Value); - } - return new FileStreamReadResult(val, ticks.TotalLength, ticks.IsNull); + long ticks = BitConverter.ToInt64(buffer, 0); + return new DateTime(ticks); + }); } /// @@ -696,27 +270,15 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the DateTimeOffset from /// A DateTimeOffset - public FileStreamReadResult ReadDateTimeOffset(long offset) + public FileStreamReadResult ReadDateTimeOffset(long offset) { // DateTimeOffset is represented by DateTime.Ticks followed by TimeSpan.Ticks // both as Int64 values - - // read the DateTime ticks - DateTimeOffset val = default(DateTimeOffset); - FileStreamReadResult dateTimeTicks = ReadInt64(offset); - int totalLength = dateTimeTicks.TotalLength; - if (dateTimeTicks.TotalLength > 0 && !dateTimeTicks.IsNull) - { - // read the TimeSpan ticks - FileStreamReadResult timeSpanTicks = ReadInt64(offset + dateTimeTicks.TotalLength); - Debug.Assert(!timeSpanTicks.IsNull, "TimeSpan ticks cannot be null if DateTime ticks are not null!"); - - totalLength += timeSpanTicks.TotalLength; - - // build the DateTimeOffset - val = new DateTimeOffset(new DateTime(dateTimeTicks.Value), new TimeSpan(timeSpanTicks.Value)); - } - return new FileStreamReadResult(val, totalLength, dateTimeTicks.IsNull); + return ReadCellHelper(offset, length => { + long dtTicks = BitConverter.ToInt64(buffer, 0); + long dtOffset = BitConverter.ToInt64(buffer, 8); + return new DateTimeOffset(new DateTime(dtTicks), new TimeSpan(dtOffset)); + }); } /// @@ -724,15 +286,13 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the TimeSpan from /// A TimeSpan - public FileStreamReadResult ReadTimeSpan(long offset) + public FileStreamReadResult ReadTimeSpan(long offset) { - FileStreamReadResult timeSpanTicks = ReadInt64(offset); - TimeSpan val = default(TimeSpan); - if (!timeSpanTicks.IsNull) + return ReadCellHelper(offset, length => { - val = new TimeSpan(timeSpanTicks.Value); - } - return new FileStreamReadResult(val, timeSpanTicks.TotalLength, timeSpanTicks.IsNull); + long ticks = BitConverter.ToInt64(buffer, 0); + return new TimeSpan(ticks); + }); } /// @@ -740,24 +300,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the string from /// A string - public FileStreamReadResult ReadString(long offset) + public FileStreamReadResult ReadString(long offset) { - LengthResult fieldLength = ReadLength(offset); - Debug.Assert(fieldLength.ValueLength%2 == 0, "Invalid data length"); - - if (fieldLength.ValueLength == 0) // there is no data - { - // If the total length is 5 (5 bytes for length, 0 for value), then the string is empty - // Otherwise, the string is null - bool isNull = fieldLength.TotalLength != 5; - return new FileStreamReadResult(isNull ? null : string.Empty, - fieldLength.TotalLength, isNull); - } - - // positive length - AssureBufferLength(fieldLength.ValueLength); - fileStream.ReadData(buffer, fieldLength.ValueLength); - return new FileStreamReadResult(Encoding.Unicode.GetString(buffer, 0, fieldLength.ValueLength), fieldLength.TotalLength, false); + return ReadCellHelper(offset, length => + length > 0 + ? Encoding.Unicode.GetString(buffer, 0, length) + : string.Empty, totalLength => totalLength == 1); } /// @@ -765,23 +313,54 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// /// Offset into the file to read the bytes from /// A byte array - public FileStreamReadResult ReadBytes(long offset) + public FileStreamReadResult ReadBytes(long offset) { - LengthResult fieldLength = ReadLength(offset); - - if (fieldLength.ValueLength == 0) + return ReadCellHelper(offset, length => { - // If the total length is 5 (5 bytes for length, 0 for value), then the byte array is 0x - // Otherwise, the byte array is null - bool isNull = fieldLength.TotalLength != 5; - return new FileStreamReadResult(isNull ? null : new byte[0], - fieldLength.TotalLength, isNull); - } + byte[] output = new byte[length]; + Buffer.BlockCopy(buffer, 0, output, 0, length); + return output; + }, totalLength => totalLength == 1, + bytes => + { + StringBuilder sb = new StringBuilder("0x"); + foreach (byte b in bytes) + { + sb.AppendFormat("{0:X2}", b); + } + return sb.ToString(); + }); + } - // positive length - byte[] val = new byte[fieldLength.ValueLength]; - fileStream.ReadData(val, fieldLength.ValueLength); - return new FileStreamReadResult(val, fieldLength.TotalLength, false); + /// + /// Reads the bytes that make up a GUID at the offset provided + /// + /// Offset into the file to read the bytes from + /// A guid type object + public FileStreamReadResult ReadGuid(long offset) + { + return ReadCellHelper(offset, length => + { + byte[] output = new byte[length]; + Buffer.BlockCopy(buffer, 0, output, 0, length); + return new SqlGuid(output); + }, totalLength => totalLength == 1); + } + + /// + /// Reads a SqlMoney type from the offset provided + /// into a + /// + /// + /// A sql money type object + public FileStreamReadResult ReadMoney(long offset) + { + return ReadCellHelper(offset, length => + { + int[] arrInt32 = new int[length / 4]; + Buffer.BlockCopy(buffer, 0, arrInt32, 0, length); + return new SqlMoney(new decimal(arrInt32)); + }); } /// @@ -813,6 +392,58 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage #endregion + #region Private Helpers + + /// + /// Creates a new buffer that is of the specified length if the buffer is not already + /// at least as long as specified. + /// + /// The minimum buffer size + private void AssureBufferLength(int newBufferLength) + { + if (buffer.Length < newBufferLength) + { + buffer = new byte[newBufferLength]; + } + } + + /// + /// Reads the value of a cell from the file wrapper, checks to see if it null using + /// , and converts it to the proper output type using + /// . + /// + /// Offset into the file to read from + /// Function to use to convert the buffer to the target type + /// + /// If provided, this function will be used to determine if the value is null + /// + /// Optional function to use to convert the object to a string. + /// The expected type of the cell. Used to keep the code honest + /// The object, a display value, and the length of the value + its length + private FileStreamReadResult ReadCellHelper(long offset, Func convertFunc, Func isNullFunc = null, Func toStringFunc = null) + { + LengthResult length = ReadLength(offset); + DbCellValue result = new DbCellValue(); + + if (isNullFunc == null ? length.ValueLength == 0 : isNullFunc(length.TotalLength)) + { + result.RawObject = null; + result.DisplayValue = null; + } + else + { + AssureBufferLength(length.ValueLength); + fileStream.ReadData(buffer, length.ValueLength); + T resultObject = convertFunc(length.ValueLength); + result.RawObject = resultObject; + result.DisplayValue = toStringFunc == null ? result.RawObject.ToString() : toStringFunc(resultObject); + } + + return new FileStreamReadResult(result, length.TotalLength); + } + + #endregion + /// /// Internal struct used for representing the length of a field from the file /// @@ -837,19 +468,6 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage } } - /// - /// Creates a new buffer that is of the specified length if the buffer is not already - /// at least as long as specified. - /// - /// The minimum buffer size - private void AssureBufferLength(int newBufferLength) - { - if (buffer.Length < newBufferLength) - { - buffer = new byte[newBufferLength]; - } - } - #region IDisposable Implementation private bool disposed; diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamWriter.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamWriter.cs index dfc36487..2e4360d2 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamWriter.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamWriter.cs @@ -4,10 +4,10 @@ // using System; +using System.Collections.Generic; using System.Data.SqlTypes; using System.Diagnostics; using System.IO; -using System.Linq; using System.Text; using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; using Microsoft.SqlTools.ServiceLayer.Utility; @@ -19,14 +19,14 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// public class ServiceBufferFileStreamWriter : IFileStreamWriter { - #region Properties + private const int DefaultBufferLength = 8192; - public const int DefaultBufferLength = 8192; - - private int MaxCharsToStore { get; set; } - private int MaxXmlCharsToStore { get; set; } + #region Member Variables + + private readonly IFileStreamWrapper fileStream; + private readonly int maxCharsToStore; + private readonly int maxXmlCharsToStore; - private IFileStreamWrapper FileStream { get; set; } private byte[] byteBuffer; private readonly short[] shortBuffer; private readonly int[] intBuffer; @@ -35,6 +35,11 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage private readonly double[] doubleBuffer; private readonly float[] floatBuffer; + /// + /// Functions to use for writing various types to a file + /// + private readonly Dictionary> writeMethods; + #endregion /// @@ -47,8 +52,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage public ServiceBufferFileStreamWriter(IFileStreamWrapper fileWrapper, string fileName, int maxCharsToStore, int maxXmlCharsToStore) { // open file for reading/writing - FileStream = fileWrapper; - FileStream.Init(fileName, DefaultBufferLength, FileAccess.ReadWrite); + fileStream = fileWrapper; + fileStream.Init(fileName, DefaultBufferLength, FileAccess.ReadWrite); // create internal buffer byteBuffer = new byte[DefaultBufferLength]; @@ -63,8 +68,42 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage floatBuffer = new float[1]; // Store max chars to store - MaxCharsToStore = maxCharsToStore; - MaxXmlCharsToStore = maxXmlCharsToStore; + this.maxCharsToStore = maxCharsToStore; + this.maxXmlCharsToStore = maxXmlCharsToStore; + + // Define what methods to use to write a type to the file + writeMethods = new Dictionary> + { + {typeof(string), val => WriteString((string) val)}, + {typeof(short), val => WriteInt16((short) val)}, + {typeof(int), val => WriteInt32((int) val)}, + {typeof(long), val => WriteInt64((long) val)}, + {typeof(byte), val => WriteByte((byte) val)}, + {typeof(char), val => WriteChar((char) val)}, + {typeof(bool), val => WriteBoolean((bool) val)}, + {typeof(double), val => WriteDouble((double) val) }, + {typeof(float), val => WriteSingle((float) val) }, + {typeof(decimal), val => WriteDecimal((decimal) val) }, + {typeof(DateTime), val => WriteDateTime((DateTime) val) }, + {typeof(DateTimeOffset), val => WriteDateTimeOffset((DateTimeOffset) val) }, + {typeof(TimeSpan), val => WriteTimeSpan((TimeSpan) val) }, + {typeof(byte[]), val => WriteBytes((byte[]) val)}, + + {typeof(SqlString), val => WriteNullable((SqlString) val, obj => WriteString((string) obj))}, + {typeof(SqlInt16), val => WriteNullable((SqlInt16) val, obj => WriteInt16((short) obj))}, + {typeof(SqlInt32), val => WriteNullable((SqlInt32) val, obj => WriteInt32((int) obj))}, + {typeof(SqlInt64), val => WriteNullable((SqlInt64) val, obj => WriteInt64((long) obj)) }, + {typeof(SqlByte), val => WriteNullable((SqlByte) val, obj => WriteByte((byte) obj)) }, + {typeof(SqlBoolean), val => WriteNullable((SqlBoolean) val, obj => WriteBoolean((bool) obj)) }, + {typeof(SqlDouble), val => WriteNullable((SqlDouble) val, obj => WriteDouble((double) obj)) }, + {typeof(SqlSingle), val => WriteNullable((SqlSingle) val, obj => WriteSingle((float) obj)) }, + {typeof(SqlDecimal), val => WriteNullable((SqlDecimal) val, obj => WriteSqlDecimal((SqlDecimal) obj)) }, + {typeof(SqlDateTime), val => WriteNullable((SqlDateTime) val, obj => WriteDateTime((DateTime) obj)) }, + {typeof(SqlBytes), val => WriteNullable((SqlBytes) val, obj => WriteBytes((byte[]) obj)) }, + {typeof(SqlBinary), val => WriteNullable((SqlBinary) val, obj => WriteBytes((byte[]) obj)) }, + {typeof(SqlGuid), val => WriteNullable((SqlGuid) val, obj => WriteGuid((Guid) obj)) }, + {typeof(SqlMoney), val => WriteNullable((SqlMoney) val, obj => WriteMoney((SqlMoney) obj)) } + }; } #region IFileStreamWriter Implementation @@ -76,22 +115,20 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// Number of bytes used to write the row public int WriteRow(StorageDataReader reader) { - // Determine if we have any long fields - bool hasLongFields = reader.Columns.Any(column => column.IsLong); - + // Read the values in from the db object[] values = new object[reader.Columns.Length]; - int rowBytes = 0; - if (!hasLongFields) + if (!reader.HasLongColumns) { // get all record values in one shot if there are no extra long fields reader.GetValues(values); } // Loop over all the columns and write the values to the temp file + int rowBytes = 0; for (int i = 0; i < reader.Columns.Length; i++) { DbColumnWrapper ci = reader.Columns[i]; - if (hasLongFields) + if (reader.HasLongColumns) { if (reader.IsDBNull(i)) { @@ -111,18 +148,18 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage // this is a long field if (ci.IsBytes) { - values[i] = reader.GetBytesWithMaxCapacity(i, MaxCharsToStore); + values[i] = reader.GetBytesWithMaxCapacity(i, maxCharsToStore); } else if (ci.IsChars) { - Debug.Assert(MaxCharsToStore > 0); + Debug.Assert(maxCharsToStore > 0); values[i] = reader.GetCharsWithMaxCapacity(i, - ci.IsXml ? MaxXmlCharsToStore : MaxCharsToStore); + ci.IsXml ? maxXmlCharsToStore : maxCharsToStore); } else if (ci.IsXml) { - Debug.Assert(MaxXmlCharsToStore > 0); - values[i] = reader.GetXmlWithMaxCapacity(i, MaxXmlCharsToStore); + Debug.Assert(maxXmlCharsToStore > 0); + values[i] = reader.GetXmlWithMaxCapacity(i, maxXmlCharsToStore); } else { @@ -133,8 +170,10 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage } } - Type tVal = values[i].GetType(); // get true type of the object + // Get true type of the object + Type tVal = values[i].GetType(); + // Write the object to a file if (tVal == typeof(DBNull)) { rowBytes += WriteNull(); @@ -148,272 +187,15 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage rowBytes += WriteString(val); } - if (tVal == typeof(string)) + // Use the appropriate writing method for the type + Func writeMethod; + if (writeMethods.TryGetValue(tVal, out writeMethod)) { - // String - most frequently used data type - string val = (string)values[i]; - rowBytes += WriteString(val); - } - else if (tVal == typeof(SqlString)) - { - // SqlString - SqlString val = (SqlString)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteString(val.Value); - } - } - else if (tVal == typeof(short)) - { - // Int16 - short val = (short)values[i]; - rowBytes += WriteInt16(val); - } - else if (tVal == typeof(SqlInt16)) - { - // SqlInt16 - SqlInt16 val = (SqlInt16)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteInt16(val.Value); - } - } - else if (tVal == typeof(int)) - { - // Int32 - int val = (int)values[i]; - rowBytes += WriteInt32(val); - } - else if (tVal == typeof(SqlInt32)) - { - // SqlInt32 - SqlInt32 val = (SqlInt32)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteInt32(val.Value); - } - } - else if (tVal == typeof(long)) - { - // Int64 - long val = (long)values[i]; - rowBytes += WriteInt64(val); - } - else if (tVal == typeof(SqlInt64)) - { - // SqlInt64 - SqlInt64 val = (SqlInt64)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteInt64(val.Value); - } - } - else if (tVal == typeof(byte)) - { - // Byte - byte val = (byte)values[i]; - rowBytes += WriteByte(val); - } - else if (tVal == typeof(SqlByte)) - { - // SqlByte - SqlByte val = (SqlByte)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteByte(val.Value); - } - } - else if (tVal == typeof(char)) - { - // Char - char val = (char)values[i]; - rowBytes += WriteChar(val); - } - else if (tVal == typeof(bool)) - { - // Boolean - bool val = (bool)values[i]; - rowBytes += WriteBoolean(val); - } - else if (tVal == typeof(SqlBoolean)) - { - // SqlBoolean - SqlBoolean val = (SqlBoolean)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteBoolean(val.Value); - } - } - else if (tVal == typeof(double)) - { - // Double - double val = (double)values[i]; - rowBytes += WriteDouble(val); - } - else if (tVal == typeof(SqlDouble)) - { - // SqlDouble - SqlDouble val = (SqlDouble)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteDouble(val.Value); - } - } - else if (tVal == typeof(SqlSingle)) - { - // SqlSingle - SqlSingle val = (SqlSingle)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteSingle(val.Value); - } - } - else if (tVal == typeof(decimal)) - { - // Decimal - decimal val = (decimal)values[i]; - rowBytes += WriteDecimal(val); - } - else if (tVal == typeof(SqlDecimal)) - { - // SqlDecimal - SqlDecimal val = (SqlDecimal)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteSqlDecimal(val); - } - } - else if (tVal == typeof(DateTime)) - { - // DateTime - DateTime val = (DateTime)values[i]; - rowBytes += WriteDateTime(val); - } - else if (tVal == typeof(DateTimeOffset)) - { - // DateTimeOffset - DateTimeOffset val = (DateTimeOffset)values[i]; - rowBytes += WriteDateTimeOffset(val); - } - else if (tVal == typeof(SqlDateTime)) - { - // SqlDateTime - SqlDateTime val = (SqlDateTime)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteDateTime(val.Value); - } - } - else if (tVal == typeof(TimeSpan)) - { - // TimeSpan - TimeSpan val = (TimeSpan)values[i]; - rowBytes += WriteTimeSpan(val); - } - else if (tVal == typeof(byte[])) - { - // Bytes - byte[] val = (byte[])values[i]; - rowBytes += WriteBytes(val, val.Length); - } - else if (tVal == typeof(SqlBytes)) - { - // SqlBytes - SqlBytes val = (SqlBytes)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteBytes(val.Value, val.Value.Length); - } - } - else if (tVal == typeof(SqlBinary)) - { - // SqlBinary - SqlBinary val = (SqlBinary)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteBytes(val.Value, val.Value.Length); - } - } - else if (tVal == typeof(SqlGuid)) - { - // SqlGuid - SqlGuid val = (SqlGuid)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - byte[] bytesVal = val.ToByteArray(); - rowBytes += WriteBytes(bytesVal, bytesVal.Length); - } - } - else if (tVal == typeof(SqlMoney)) - { - // SqlMoney - SqlMoney val = (SqlMoney)values[i]; - if (val.IsNull) - { - rowBytes += WriteNull(); - } - else - { - rowBytes += WriteDecimal(val.Value); - } + rowBytes += writeMethod(values[i]); } else { - // treat everything else as string - string val = values[i].ToString(); - rowBytes += WriteString(val); + rowBytes += WriteString(values[i].ToString()); } } } @@ -430,7 +212,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage public int WriteNull() { byteBuffer[0] = 0x00; - return FileStream.WriteData(byteBuffer, 1); + return fileStream.WriteData(byteBuffer, 1); } /// @@ -442,7 +224,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage byteBuffer[0] = 0x02; // length shortBuffer[0] = val; Buffer.BlockCopy(shortBuffer, 0, byteBuffer, 1, 2); - return FileStream.WriteData(byteBuffer, 3); + return fileStream.WriteData(byteBuffer, 3); } /// @@ -454,7 +236,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage byteBuffer[0] = 0x04; // length intBuffer[0] = val; Buffer.BlockCopy(intBuffer, 0, byteBuffer, 1, 4); - return FileStream.WriteData(byteBuffer, 5); + return fileStream.WriteData(byteBuffer, 5); } /// @@ -466,7 +248,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage byteBuffer[0] = 0x08; // length longBuffer[0] = val; Buffer.BlockCopy(longBuffer, 0, byteBuffer, 1, 8); - return FileStream.WriteData(byteBuffer, 9); + return fileStream.WriteData(byteBuffer, 9); } /// @@ -478,7 +260,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage byteBuffer[0] = 0x02; // length charBuffer[0] = val; Buffer.BlockCopy(charBuffer, 0, byteBuffer, 1, 2); - return FileStream.WriteData(byteBuffer, 3); + return fileStream.WriteData(byteBuffer, 3); } /// @@ -489,7 +271,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage { byteBuffer[0] = 0x01; // length byteBuffer[1] = (byte) (val ? 0x01 : 0x00); - return FileStream.WriteData(byteBuffer, 2); + return fileStream.WriteData(byteBuffer, 2); } /// @@ -500,7 +282,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage { byteBuffer[0] = 0x01; // length byteBuffer[1] = val; - return FileStream.WriteData(byteBuffer, 2); + return fileStream.WriteData(byteBuffer, 2); } /// @@ -512,7 +294,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage byteBuffer[0] = 0x04; // length floatBuffer[0] = val; Buffer.BlockCopy(floatBuffer, 0, byteBuffer, 1, 4); - return FileStream.WriteData(byteBuffer, 5); + return fileStream.WriteData(byteBuffer, 5); } /// @@ -524,7 +306,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage byteBuffer[0] = 0x08; // length doubleBuffer[0] = val; Buffer.BlockCopy(doubleBuffer, 0, byteBuffer, 1, 8); - return FileStream.WriteData(byteBuffer, 9); + return fileStream.WriteData(byteBuffer, 9); } /// @@ -548,7 +330,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage // data value Buffer.BlockCopy(arrInt32, 0, byteBuffer, 3, iLen - 3); - iTotalLen += FileStream.WriteData(byteBuffer, iLen); + iTotalLen += fileStream.WriteData(byteBuffer, iLen); return iTotalLen; // len+data } @@ -564,7 +346,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage int iTotalLen = WriteLength(iLen); // length Buffer.BlockCopy(arrInt32, 0, byteBuffer, 0, iLen); - iTotalLen += FileStream.WriteData(byteBuffer, iLen); + iTotalLen += fileStream.WriteData(byteBuffer, iLen); return iTotalLen; // len+data } @@ -584,9 +366,15 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// Number of bytes used to store the DateTimeOffset public int WriteDateTimeOffset(DateTimeOffset dtoVal) { - // DateTimeOffset gets written as a DateTime + TimeOffset - // both represented as 'Ticks' written as Int64's - return WriteInt64(dtoVal.Ticks) + WriteInt64(dtoVal.Offset.Ticks); + // Write the length, which is the 2*sizeof(long) + byteBuffer[0] = 0x10; // length (16) + + // Write the two longs, the datetime and the offset + long[] longBufferOffset = new long[2]; + longBufferOffset[0] = dtoVal.Ticks; + longBufferOffset[1] = dtoVal.Offset.Ticks; + Buffer.BlockCopy(longBufferOffset, 0, byteBuffer, 1, 16); + return fileStream.WriteData(byteBuffer, 17); } /// @@ -618,7 +406,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage byteBuffer[3] = 0x00; byteBuffer[4] = 0x00; - iTotalLen = FileStream.WriteData(byteBuffer, 5); + iTotalLen = fileStream.WriteData(byteBuffer, 5); } else { @@ -627,7 +415,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage // convert char array into byte array and write it out iTotalLen = WriteLength(bytes.Length); - iTotalLen += FileStream.WriteData(bytes, bytes.Length); + iTotalLen += fileStream.WriteData(bytes, bytes.Length); } return iTotalLen; // len+data } @@ -636,32 +424,76 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// Writes a byte[] to the file /// /// Number of bytes used to store the byte[] - public int WriteBytes(byte[] bytesVal, int iLen) + public int WriteBytes(byte[] bytesVal) { Validate.IsNotNull(nameof(bytesVal), bytesVal); int iTotalLen; - if (0 == iLen) // special case of 0 length byte array "0x" + if (bytesVal.Length == 0) // special case of 0 length byte array "0x" { - iLen = 5; - - AssureBufferLength(iLen); + AssureBufferLength(5); byteBuffer[0] = 0xFF; byteBuffer[1] = 0x00; byteBuffer[2] = 0x00; byteBuffer[3] = 0x00; byteBuffer[4] = 0x00; - iTotalLen = FileStream.WriteData(byteBuffer, iLen); + iTotalLen = fileStream.WriteData(byteBuffer, 5); } else { - iTotalLen = WriteLength(iLen); - iTotalLen += FileStream.WriteData(bytesVal, iLen); + iTotalLen = WriteLength(bytesVal.Length); + iTotalLen += fileStream.WriteData(bytesVal, bytesVal.Length); } return iTotalLen; // len+data } + /// + /// Stores a GUID value to the file by treating it as a byte array + /// + /// The GUID to write to the file + /// Number of bytes written to the file + public int WriteGuid(Guid val) + { + byte[] guidBytes = val.ToByteArray(); + return WriteBytes(guidBytes); + } + + /// + /// Stores a SqlMoney value to the file by treating it as a decimal + /// + /// The SqlMoney value to write to the file + /// Number of bytes written to the file + public int WriteMoney(SqlMoney val) + { + return WriteDecimal(val.Value); + } + + /// + /// Flushes the internal buffer to the file stream + /// + public void FlushBuffer() + { + fileStream.Flush(); + } + + #endregion + + #region Private Helpers + + /// + /// Creates a new buffer that is of the specified length if the buffer is not already + /// at least as long as specified. + /// + /// The minimum buffer size + private void AssureBufferLength(int newBufferLength) + { + if (newBufferLength > byteBuffer.Length) + { + byteBuffer = new byte[byteBuffer.Length]; + } + } + /// /// Writes the length of the field using the appropriate number of bytes (ie, 1 if the /// length is <255, 5 if the length is >=255) @@ -675,7 +507,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage int iTmp = iLen & 0x000000FF; byteBuffer[0] = Convert.ToByte(iTmp); - return FileStream.WriteData(byteBuffer, 1); + return fileStream.WriteData(byteBuffer, 1); } // The length won't fit in 1 byte, so we need to use 1 byte to signify that the length // is a full 4 bytes. @@ -684,27 +516,24 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage // convert int32 into array of bytes intBuffer[0] = iLen; Buffer.BlockCopy(intBuffer, 0, byteBuffer, 1, 4); - return FileStream.WriteData(byteBuffer, 5); + return fileStream.WriteData(byteBuffer, 5); } /// - /// Flushes the internal buffer to the file stream + /// Writes a Nullable type (generally a Sql* type) to the file. The function provided by + /// is used to write to the file if + /// is not null. is used if is null. /// - public void FlushBuffer() + /// The value to write to the file + /// The function to use if val is not null + /// Number of bytes used to write value to the file + private int WriteNullable(INullable val, Func valueWriteFunc) { - FileStream.Flush(); + return val.IsNull ? WriteNull() : valueWriteFunc(val); } #endregion - private void AssureBufferLength(int newBufferLength) - { - if (newBufferLength > byteBuffer.Length) - { - byteBuffer = new byte[byteBuffer.Length]; - } - } - #region IDisposable Implementation private bool disposed; @@ -724,8 +553,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage if (disposing) { - FileStream.Flush(); - FileStream.Dispose(); + fileStream.Flush(); + fileStream.Dispose(); } disposed = true; diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/StorageDataReader.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/StorageDataReader.cs index 1e45d437..cc5d1443 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/StorageDataReader.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/StorageDataReader.cs @@ -57,6 +57,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage // Read the columns into a set of wrappers Columns = DbDataReader.GetColumnSchema().Select(column => new DbColumnWrapper(column)).ToArray(); + HasLongColumns = Columns.Any(column => column.IsLong); } #region Properties @@ -71,6 +72,11 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage /// public DbDataReader DbDataReader { get; private set; } + /// + /// Whether or not any of the columns of this reader are 'long', such as nvarchar(max) + /// + public bool HasLongColumns { get; private set; } + #endregion #region DbDataReader Methods diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Query.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Query.cs index c4f49b2a..cf2df73c 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Query.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Query.cs @@ -86,7 +86,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution }); // NOTE: We only want to process batches that have statements (ie, ignore comments and empty lines) Batches = parseResult.Script.Batches.Where(b => b.Statements.Count > 0) - .Select(b => new Batch(b.Sql, b.StartLocation.LineNumber, outputFileFactory)).ToArray(); + .Select(b => new Batch(b.Sql, + b.StartLocation.LineNumber - 1, + b.StartLocation.ColumnNumber - 1, + b.EndLocation.LineNumber - 1, + b.EndLocation.ColumnNumber - 1, + outputFileFactory)).ToArray(); } #region Properties @@ -113,7 +118,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution Id = index, HasError = batch.HasError, Messages = batch.ResultMessages.ToArray(), - ResultSetSummaries = batch.ResultSummaries + ResultSetSummaries = batch.ResultSummaries, + Selection = batch.Selection }).ToArray(); } } @@ -189,10 +195,21 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution sqlConn.GetUnderlyingConnection().InfoMessage += OnInfoMessage; } - // We need these to execute synchronously, otherwise the user will be very unhappy - foreach (Batch b in Batches) + try { - await b.Execute(conn, cancellationSource.Token); + // We need these to execute synchronously, otherwise the user will be very unhappy + foreach (Batch b in Batches) + { + await b.Execute(conn, cancellationSource.Token); + } + } + finally + { + if (sqlConn != null) + { + // Subscribe to database informational messages + sqlConn.GetUnderlyingConnection().InfoMessage -= OnInfoMessage; + } } // TODO: Close connection after eliminating using statement for above TODO diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs index 5d4e1ad5..d0ff8d1a 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs @@ -13,7 +13,9 @@ using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol; using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; using Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage; using Microsoft.SqlTools.ServiceLayer.SqlContext; +using Microsoft.SqlTools.ServiceLayer.Utility; using Microsoft.SqlTools.ServiceLayer.Workspace; +using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts; using Newtonsoft.Json; namespace Microsoft.SqlTools.ServiceLayer.QueryExecution @@ -38,11 +40,13 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution private QueryExecutionService() { ConnectionService = ConnectionService.Instance; + WorkspaceService = WorkspaceService.Instance; } - internal QueryExecutionService(ConnectionService connService) + internal QueryExecutionService(ConnectionService connService, WorkspaceService workspaceService) { ConnectionService = connService; + WorkspaceService = workspaceService; } #endregion @@ -78,6 +82,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// private ConnectionService ConnectionService { get; set; } + private WorkspaceService WorkspaceService { get; set; } + /// /// Internal storage of active queries, lazily constructed as a threadsafe dictionary /// @@ -111,7 +117,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution }); // Register a handler for when the configuration changes - WorkspaceService.Instance.RegisterConfigChangeCallback((oldSettings, newSettings, eventContext) => + WorkspaceService.RegisterConfigChangeCallback((oldSettings, newSettings, eventContext) => { Settings.QueryExecutionSettings.Update(newSettings.QueryExecutionSettings); return Task.FromResult(0); @@ -202,6 +208,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution return; } + // Cleanup the query + result.Dispose(); + // Success await requestContext.SendResult(new QueryDisposeResult { @@ -232,6 +241,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution // Cancel the query result.Cancel(); + result.Dispose(); // Attempt to dispose the query if (!ActiveQueries.TryRemove(cancelParams.OwnerUri, out result)) @@ -263,7 +273,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// /// Process request to save a resultSet to a file in CSV format /// - public async Task HandleSaveResultsAsCsvRequest( SaveResultsAsCsvRequestParams saveParams, + public async Task HandleSaveResultsAsCsvRequest(SaveResultsAsCsvRequestParams saveParams, RequestContext requestContext) { // retrieve query for OwnerUri @@ -283,17 +293,40 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution // get the requested resultSet from query Batch selectedBatch = result.Batches[saveParams.BatchIndex]; ResultSet selectedResultSet = (selectedBatch.ResultSets.ToList())[saveParams.ResultSetIndex]; - if (saveParams.IncludeHeaders) - { - // write column names to csv - await csvFile.WriteLineAsync( string.Join( ",", selectedResultSet.Columns.Select( column => SaveResults.EncodeCsvField(column.ColumnName) ?? string.Empty))); + int columnCount = 0; + int rowCount = 0; + int columnStartIndex = 0; + int rowStartIndex = 0; + + // set column, row counts depending on whether save request is for entire result set or a subset + if (SaveResults.isSaveSelection(saveParams)) + { + columnCount = saveParams.ColumnEndIndex.Value - saveParams.ColumnStartIndex.Value + 1; + rowCount = saveParams.RowEndIndex.Value - saveParams.RowStartIndex.Value + 1; + columnStartIndex = saveParams.ColumnStartIndex.Value; + rowStartIndex =saveParams.RowStartIndex.Value; + } + else + { + columnCount = selectedResultSet.Columns.Length; + rowCount = (int)selectedResultSet.RowCount; } - // write rows to csv - foreach (var row in selectedResultSet.Rows) + // write column names if include headers option is chosen + if (saveParams.IncludeHeaders) { - await csvFile.WriteLineAsync( string.Join( ",", row.Select( field => SaveResults.EncodeCsvField((field != null) ? field.ToString(): string.Empty)))); + await csvFile.WriteLineAsync( string.Join( ",", selectedResultSet.Columns.Skip(columnStartIndex).Take(columnCount).Select( column => + SaveResults.EncodeCsvField(column.ColumnName) ?? string.Empty))); } + + // retrieve rows and write as csv + ResultSetSubset resultSubset = await result.GetSubset(saveParams.BatchIndex, saveParams.ResultSetIndex, rowStartIndex, rowCount); + foreach (var row in resultSubset.Rows) + { + await csvFile.WriteLineAsync( string.Join( ",", row.Skip(columnStartIndex).Take(columnCount).Select( field => + SaveResults.EncodeCsvField((field != null) ? field.ToString(): "NULL")))); + } + } // Successfully wrote file, send success result @@ -313,7 +346,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// /// Process request to save a resultSet to a file in JSON format /// - public async Task HandleSaveResultsAsJsonRequest( SaveResultsAsJsonRequestParams saveParams, + public async Task HandleSaveResultsAsJsonRequest(SaveResultsAsJsonRequestParams saveParams, RequestContext requestContext) { // retrieve query for OwnerUri @@ -333,26 +366,49 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution { jsonWriter.Formatting = Formatting.Indented; jsonWriter.WriteStartArray(); - + // get the requested resultSet from query Batch selectedBatch = result.Batches[saveParams.BatchIndex]; - ResultSet selectedResultSet = (selectedBatch.ResultSets.ToList())[saveParams.ResultSetIndex]; + ResultSet selectedResultSet = selectedBatch.ResultSets.ToList()[saveParams.ResultSetIndex]; + int rowCount = 0; + int rowStartIndex = 0; + int columnStartIndex = 0; + int columnEndIndex = 0; - // write each row to JSON - foreach (var row in selectedResultSet.Rows) + // set column, row counts depending on whether save request is for entire result set or a subset + if (SaveResults.isSaveSelection(saveParams)) + { + + rowCount = saveParams.RowEndIndex.Value - saveParams.RowStartIndex.Value + 1; + rowStartIndex = saveParams.RowStartIndex.Value; + columnStartIndex = saveParams.ColumnStartIndex.Value; + columnEndIndex = saveParams.ColumnEndIndex.Value + 1 ; // include the last column + } + else + { + rowCount = (int)selectedResultSet.RowCount; + columnEndIndex = selectedResultSet.Columns.Length; + } + + // retrieve rows and write as json + ResultSetSubset resultSubset = await result.GetSubset(saveParams.BatchIndex, saveParams.ResultSetIndex, rowStartIndex, rowCount); + foreach (var row in resultSubset.Rows) { jsonWriter.WriteStartObject(); - foreach (var field in row.Select((value,i) => new {value, i})) + for (int i = columnStartIndex ; i < columnEndIndex; i++) { - jsonWriter.WritePropertyName(selectedResultSet.Columns[field.i].ColumnName); - if (field.value != null) - { - jsonWriter.WriteValue(field.value); - } - else + //get column name + DbColumnWrapper col = selectedResultSet.Columns[i]; + string val = row[i]?.ToString(); + jsonWriter.WritePropertyName(col.ColumnName); + if (val == null) { jsonWriter.WriteNull(); - } + } + else + { + jsonWriter.WriteValue(val); + } } jsonWriter.WriteEndObject(); } @@ -371,6 +427,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution await requestContext.SendError(ex.Message); } } + #endregion #region Private Helpers @@ -394,14 +451,41 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution Query oldQuery; if (ActiveQueries.TryGetValue(executeParams.OwnerUri, out oldQuery) && oldQuery.HasExecuted) { + oldQuery.Dispose(); ActiveQueries.TryRemove(executeParams.OwnerUri, out oldQuery); } // Retrieve the current settings for executing the query with - QueryExecutionSettings settings = WorkspaceService.Instance.CurrentSettings.QueryExecutionSettings; + QueryExecutionSettings settings = WorkspaceService.CurrentSettings.QueryExecutionSettings; + // Get query text from the workspace. + ScriptFile queryFile = WorkspaceService.Workspace.GetFile(executeParams.OwnerUri); + + string queryText; + + if (executeParams.QuerySelection != null) + { + string[] queryTextArray = queryFile.GetLinesInRange( + new BufferRange( + new BufferPosition( + executeParams.QuerySelection.StartLine + 1, + executeParams.QuerySelection.StartColumn + 1 + ), + new BufferPosition( + executeParams.QuerySelection.EndLine + 1, + executeParams.QuerySelection.EndColumn + 1 + ) + ) + ); + queryText = queryTextArray.Aggregate((a, b) => a + '\r' + '\n' + b); + } + else + { + queryText = queryFile.Contents; + } + // If we can't add the query now, it's assumed the query is in progress - Query newQuery = new Query(executeParams.QueryText, connectionInfo, settings, BufferFileFactory); + Query newQuery = new Query(queryText, connectionInfo, settings, BufferFileFactory); if (!ActiveQueries.TryAdd(executeParams.OwnerUri, newQuery)) { await requestContext.SendResult(new QueryExecuteResult @@ -469,8 +553,22 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution { foreach (var query in ActiveQueries) { + if (!query.Value.HasExecuted) + { + try + { + query.Value.Cancel(); + } + catch (Exception e) + { + // We don't particularly care if we fail to cancel during shutdown + string message = string.Format("Failed to cancel query {0} during query service disposal: {1}", query.Key, e); + Logger.Write(LogLevel.Warning, message); + } + } query.Value.Dispose(); } + ActiveQueries.Clear(); } disposed = true; diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/ResultSet.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/ResultSet.cs index b4dd411d..ad392cf7 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/ResultSet.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/ResultSet.cs @@ -24,6 +24,11 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution // xml is a special case so number of chars to store is usually greater than for other long types private const int DefaultMaxXmlCharsToStore = 2097152; // 2 MB - QE default + // Column names of 'for xml' and 'for json' queries + private const string NameOfForXMLColumn = "XML_F52E2B61-18A1-11d1-B105-00805F49916B"; + private const string NameOfForJSONColumn = "JSON_F52E2B61-18A1-11d1-B105-00805F49916B"; + + #endregion #region Member Variables @@ -112,9 +117,13 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// /// The rows of this result set /// - public IEnumerable Rows + public IEnumerable Rows { - get { return FileOffsets.Select(offset => fileStreamReader.ReadRow(offset, Columns)); } + get + { + return FileOffsets.Select( + offset => fileStreamReader.ReadRow(offset, Columns).Select(cell => cell.DisplayValue).ToArray()); + } } #endregion @@ -151,7 +160,9 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution IEnumerable rowOffsets = FileOffsets.Skip(startRow).Take(rowCount); // Iterate over the rows we need and process them into output - object[][] rows = rowOffsets.Select(rowOffset => fileStreamReader.ReadRow(rowOffset, Columns)).ToArray(); + string[][] rows = rowOffsets.Select(rowOffset => + fileStreamReader.ReadRow(rowOffset, Columns).Select(cell => cell.DisplayValue).ToArray()) + .ToArray(); // Retrieve the subset of the results as per the request return new ResultSetSubset @@ -186,6 +197,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution currentFileOffset += fileWriter.WriteRow(DataReader); } } + // Check if resultset is 'for xml/json'. If it is, set isJson/isXml value in column metadata + SingleColumnXmlJsonResultSet(); // Mark that result has been read hasBeenRead = true; @@ -219,5 +232,30 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution } #endregion + + #region Private Helper Methods + + /// + /// If the result set represented by this class corresponds to a single XML + /// column that contains results of "for xml" query, set isXml = true + /// If the result set represented by this class corresponds to a single JSON + /// column that contains results of "for json" query, set isJson = true + /// + private void SingleColumnXmlJsonResultSet() { + + if (Columns?.Length == 1) + { + if (Columns[0].ColumnName.Equals(NameOfForXMLColumn, StringComparison.Ordinal)) + { + Columns[0].IsXml = true; + } + else if (Columns[0].ColumnName.Equals(NameOfForJSONColumn, StringComparison.Ordinal)) + { + Columns[0].IsJson = true; + } + } + } + + #endregion } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SaveResults.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SaveResults.cs index f63f253f..9188d5b0 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SaveResults.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SaveResults.cs @@ -4,6 +4,7 @@ // using System; using System.Text; +using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; namespace Microsoft.SqlTools.ServiceLayer.QueryExecution { @@ -79,6 +80,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution return ret; } + + internal static bool isSaveSelection(SaveResultsRequestParams saveParams) + { + return (saveParams.ColumnStartIndex != null && saveParams.ColumnEndIndex != null + && saveParams.RowEndIndex != null && saveParams.RowEndIndex != null); + } } } \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/HostDetails.cs b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/HostDetails.cs index 1b78faa4..9a2b6e3d 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/HostDetails.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/HostDetails.cs @@ -19,13 +19,13 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext /// The default host name for SqlTools Editor Services. Used /// if no host name is specified by the host application. /// - public const string DefaultHostName = "SqlTools Editor Services Host"; + public const string DefaultHostName = "SqlTools Service Host"; /// /// The default host ID for SqlTools Editor Services. Used /// for the host-specific profile path if no host ID is specified. /// - public const string DefaultHostProfileId = "Microsoft.SqlToolsEditorServices"; + public const string DefaultHostProfileId = "Microsoft.SqlToolsServiceHost"; /// /// The default host version for SqlTools Editor Services. If @@ -78,9 +78,9 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext /// /// The host application's version. public HostDetails( - string name, - string profileId, - Version version) + string name = null, + string profileId = null, + Version version = null) { this.Name = name ?? DefaultHostName; this.ProfileId = profileId ?? DefaultHostProfileId; diff --git a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/IntelliSenseSettings.cs b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/IntelliSenseSettings.cs new file mode 100644 index 00000000..f46d3556 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/IntelliSenseSettings.cs @@ -0,0 +1,60 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.SqlContext +{ + /// + /// Class for serialization and deserialization of IntelliSense settings + /// + public class IntelliSenseSettings + { + /// + /// Initialize the IntelliSense settings defaults + /// + public IntelliSenseSettings() + { + this.EnableSuggestions = true; + this.LowerCaseSuggestions = false; + this.EnableDiagnostics = true; + this.EnableQuickInfo = true; + } + + /// + /// Gets or sets a flag determining if suggestions are enabled + /// + /// + public bool? EnableSuggestions { get; set; } + + /// + /// Gets or sets a flag determining if built-in suggestions should be lowercase + /// + public bool? LowerCaseSuggestions { get; set; } + + /// + /// Gets or sets a flag determining if diagnostics are enabled + /// + public bool? EnableDiagnostics { get; set; } + + /// + /// Gets or sets a flag determining if quick info is enabled + /// + public bool? EnableQuickInfo { get; set; } + + /// + /// Update the Intellisense settings + /// + /// + public void Update(IntelliSenseSettings settings) + { + if (settings != null) + { + this.EnableSuggestions = settings.EnableSuggestions; + this.LowerCaseSuggestions = settings.LowerCaseSuggestions; + this.EnableDiagnostics = settings.EnableDiagnostics; + this.EnableQuickInfo = settings.EnableQuickInfo; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/ProfilePaths.cs b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/ProfilePaths.cs deleted file mode 100644 index f841970d..00000000 --- a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/ProfilePaths.cs +++ /dev/null @@ -1,108 +0,0 @@ -// -// Copyright (c) Microsoft. All rights reserved. -// Licensed under the MIT license. See LICENSE file in the project root for full license information. -// - -using System.Collections.Generic; -using System.IO; -using System.Linq; - -namespace Microsoft.SqlTools.ServiceLayer.SqlContext -{ - /// - /// Provides profile path resolution behavior relative to the name - /// of a particular SqlTools host. - /// - public class ProfilePaths - { - #region Constants - - /// - /// The file name for the "all hosts" profile. Also used as the - /// suffix for the host-specific profile filenames. - /// - public const string AllHostsProfileName = "profile.ps1"; - - #endregion - - #region Properties - - /// - /// Gets the profile path for all users, all hosts. - /// - public string AllUsersAllHosts { get; private set; } - - /// - /// Gets the profile path for all users, current host. - /// - public string AllUsersCurrentHost { get; private set; } - - /// - /// Gets the profile path for the current user, all hosts. - /// - public string CurrentUserAllHosts { get; private set; } - - /// - /// Gets the profile path for the current user and host. - /// - public string CurrentUserCurrentHost { get; private set; } - - #endregion - - #region Public Methods - - /// - /// Creates a new instance of the ProfilePaths class. - /// - /// - /// The identifier of the host used in the host-specific X_profile.ps1 filename. - /// - /// The base path to use for constructing AllUsers profile paths. - /// The base path to use for constructing CurrentUser profile paths. - public ProfilePaths( - string hostProfileId, - string baseAllUsersPath, - string baseCurrentUserPath) - { - this.Initialize(hostProfileId, baseAllUsersPath, baseCurrentUserPath); - } - - private void Initialize( - string hostProfileId, - string baseAllUsersPath, - string baseCurrentUserPath) - { - string currentHostProfileName = - string.Format( - "{0}_{1}", - hostProfileId, - AllHostsProfileName); - - this.AllUsersCurrentHost = Path.Combine(baseAllUsersPath, currentHostProfileName); - this.CurrentUserCurrentHost = Path.Combine(baseCurrentUserPath, currentHostProfileName); - this.AllUsersAllHosts = Path.Combine(baseAllUsersPath, AllHostsProfileName); - this.CurrentUserAllHosts = Path.Combine(baseCurrentUserPath, AllHostsProfileName); - } - - /// - /// Gets the list of profile paths that exist on the filesystem. - /// - /// An IEnumerable of profile path strings to be loaded. - public IEnumerable GetLoadableProfilePaths() - { - var profilePaths = - new string[] - { - this.AllUsersAllHosts, - this.AllUsersCurrentHost, - this.CurrentUserAllHosts, - this.CurrentUserCurrentHost - }; - - return profilePaths.Where(p => File.Exists(p)); - } - - #endregion - } -} - diff --git a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsContext.cs b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsContext.cs index d110f28c..baf602f4 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsContext.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsContext.cs @@ -20,9 +20,14 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext get; private set; } - public SqlToolsContext(HostDetails hostDetails, ProfilePaths profilePaths) + /// + /// Initalizes the SQL Tools context instance + /// + /// + public SqlToolsContext(HostDetails hostDetails) { - + this.SqlToolsVersion = hostDetails.Version; } } } + diff --git a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsSettings.cs b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsSettings.cs index ccf3f3fe..cfa438c0 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsSettings.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsSettings.cs @@ -1,5 +1,7 @@ -using System.IO; -using Microsoft.SqlTools.ServiceLayer.Utility; +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// namespace Microsoft.SqlTools.ServiceLayer.SqlContext { @@ -8,76 +10,114 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext /// public class SqlToolsSettings { - public SqlToolsSettings() - { - this.ScriptAnalysis = new ScriptAnalysisSettings(); - this.QueryExecutionSettings = new QueryExecutionSettings(); - } + private SqlToolsSettingsValues sqlTools = null; - public bool EnableProfileLoading { get; set; } - - public ScriptAnalysisSettings ScriptAnalysis { get; set; } - - public void Update(SqlToolsSettings settings, string workspaceRootPath) - { - if (settings != null) + /// + /// Gets or sets the underlying settings value object + /// + public SqlToolsSettingsValues SqlTools + { + get { - this.EnableProfileLoading = settings.EnableProfileLoading; - this.ScriptAnalysis.Update(settings.ScriptAnalysis, workspaceRootPath); + if (this.sqlTools == null) + { + this.sqlTools = new SqlToolsSettingsValues(); + } + return this.sqlTools; + } + set + { + this.sqlTools = value; } } - public QueryExecutionSettings QueryExecutionSettings { get; set; } + /// + /// Query excution settings forwarding property + /// + public QueryExecutionSettings QueryExecutionSettings + { + get { return this.SqlTools.QueryExecutionSettings; } + } + + /// + /// Updates the extension settings + /// + /// + public void Update(SqlToolsSettings settings) + { + if (settings != null) + { + this.SqlTools.EnableIntellisense = settings.SqlTools.EnableIntellisense; + this.SqlTools.IntelliSense.Update(settings.SqlTools.IntelliSense); + } + } + + /// + /// Gets a flag determining if diagnostics are enabled + /// + public bool IsDiagnositicsEnabled + { + get + { + return this.SqlTools.EnableIntellisense + && this.SqlTools.IntelliSense.EnableDiagnostics.Value; + } + } + + /// + /// Gets a flag determining if suggestons are enabled + /// + public bool IsSuggestionsEnabled + { + get + { + return this.SqlTools.EnableIntellisense + && this.SqlTools.IntelliSense.EnableSuggestions.Value; + } + } + + /// + /// Gets a flag determining if quick info is enabled + /// + public bool IsQuickInfoEnabled + { + get + { + return this.SqlTools.EnableIntellisense + && this.SqlTools.IntelliSense.EnableQuickInfo.Value; + } + } } /// - /// Sub class for serialization and deserialization of script analysis settings + /// Class that is used to serialize and deserialize SQL Tools settings /// - public class ScriptAnalysisSettings + public class SqlToolsSettingsValues { - public bool? Enable { get; set; } - - public string SettingsPath { get; set; } - - public ScriptAnalysisSettings() + /// + /// Initializes the Sql Tools settings values + /// + public SqlToolsSettingsValues() { - this.Enable = true; + this.EnableIntellisense = true; + this.IntelliSense = new IntelliSenseSettings(); + this.QueryExecutionSettings = new QueryExecutionSettings(); } - public void Update(ScriptAnalysisSettings settings, string workspaceRootPath) - { - if (settings != null) - { - this.Enable = settings.Enable; + /// + /// Gets or sets a flag determining if IntelliSense is enabled + /// + /// + public bool EnableIntellisense { get; set; } - string settingsPath = settings.SettingsPath; + /// + /// Gets or sets the detailed IntelliSense settings + /// + public IntelliSenseSettings IntelliSense { get; set; } - if (string.IsNullOrWhiteSpace(settingsPath)) - { - settingsPath = null; - } - else if (!Path.IsPathRooted(settingsPath)) - { - if (string.IsNullOrEmpty(workspaceRootPath)) - { - // The workspace root path could be an empty string - // when the user has opened a SqlTools script file - // without opening an entire folder (workspace) first. - // In this case we should just log an error and let - // the specified settings path go through even though - // it will fail to load. - Logger.Write( - LogLevel.Error, - "Could not resolve Script Analyzer settings path due to null or empty workspaceRootPath."); - } - else - { - settingsPath = Path.GetFullPath(Path.Combine(workspaceRootPath, settingsPath)); - } - } - - this.SettingsPath = settingsPath; - } - } + /// + /// Gets or sets the query execution settings + /// + public QueryExecutionSettings QueryExecutionSettings { get; set; } } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/Utility/Logger.cs b/src/Microsoft.SqlTools.ServiceLayer/Utility/Logger.cs index 5c4adae4..4f1a27a3 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Utility/Logger.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Utility/Logger.cs @@ -45,6 +45,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Utility { private static LogWriter logWriter; + private static bool isEnabled; + + private static bool isInitialized = false; + /// /// Initializes the Logger for the current session. /// @@ -56,8 +60,19 @@ namespace Microsoft.SqlTools.ServiceLayer.Utility /// public static void Initialize( string logFilePath = "sqltools", - LogLevel minimumLogLevel = LogLevel.Normal) + LogLevel minimumLogLevel = LogLevel.Normal, + bool isEnabled = true) { + Logger.isEnabled = isEnabled; + + // return if the logger is not enabled or already initialized + if (!Logger.isEnabled || Logger.isInitialized) + { + return; + } + + Logger.isInitialized = true; + // get a unique number to prevent conflicts of two process launching at the same time int uniqueId; try @@ -89,6 +104,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Utility minimumLogLevel, fullFileName, true); + + Logger.Write(LogLevel.Normal, "Initializing SQL Tools Service Host logger"); } /// @@ -116,7 +133,13 @@ namespace Microsoft.SqlTools.ServiceLayer.Utility [CallerMemberName] string callerName = null, [CallerFilePath] string callerSourceFile = null, [CallerLineNumber] int callerLineNumber = 0) - { + { + // return if the logger is not enabled or not initialized + if (!Logger.isEnabled || !Logger.isInitialized) + { + return; + } + if (logWriter != null) { logWriter.Write( diff --git a/src/Microsoft.SqlTools.ServiceLayer/Workspace/Contracts/ScriptFile.cs b/src/Microsoft.SqlTools.ServiceLayer/Workspace/Contracts/ScriptFile.cs index 43f064e6..279f9b7f 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Workspace/Contracts/ScriptFile.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Workspace/Contracts/ScriptFile.cs @@ -36,8 +36,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace.Contracts /// /// Gets or sets the path which the editor client uses to identify this file. /// Setter for testing purposes only + /// virtual to allow mocking. /// - public string ClientFilePath { get; internal set; } + public virtual string ClientFilePath { get; internal set; } /// /// Gets or sets a boolean that determines whether @@ -56,7 +57,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace.Contracts /// Gets or sets a string containing the full contents of the file. /// Setter for testing purposes only /// - public string Contents + public virtual string Contents { get { @@ -109,7 +110,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace.Contracts /// /// Add a default constructor for testing /// - internal ScriptFile() + public ScriptFile() { ClientFilePath = "test.sql"; } @@ -171,11 +172,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace.Contracts } /// - /// Gets a range of lines from the file's contents. + /// Gets a range of lines from the file's contents. Virtual method to allow for + /// mocking. /// /// The buffer range from which lines will be extracted. /// An array of strings from the specified range of the file. - public string[] GetLinesInRange(BufferRange bufferRange) + public virtual string[] GetLinesInRange(BufferRange bufferRange) { this.ValidatePosition(bufferRange.Start); this.ValidatePosition(bufferRange.End); diff --git a/src/Microsoft.SqlTools.ServiceLayer/Workspace/Workspace.cs b/src/Microsoft.SqlTools.ServiceLayer/Workspace/Workspace.cs index 80fe6a9f..1c798a5d 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Workspace/Workspace.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Workspace/Workspace.cs @@ -50,7 +50,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace /// /// Gets an open file in the workspace. If the file isn't open but - /// exists on the filesystem, load and return it. + /// exists on the filesystem, load and return it. Virtual method to + /// allow for mocking /// /// The file path at which the script resides. /// @@ -59,7 +60,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace /// /// contains a null or empty string. /// - public ScriptFile GetFile(string filePath) + public virtual ScriptFile GetFile(string filePath) { Validate.IsNotNullOrWhitespaceString("filePath", filePath); diff --git a/src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs b/src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs index c1fe5080..40dc1574 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs @@ -28,7 +28,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace #region Singleton Instance Implementation - private static readonly Lazy> instance = new Lazy>(() => new WorkspaceService()); + private static Lazy> instance = new Lazy>(() => new WorkspaceService()); public static WorkspaceService Instance { @@ -52,8 +52,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace #region Properties - public Workspace Workspace { get; private set; } + /// + /// Workspace object for the service. Virtual to allow for mocking + /// + public virtual Workspace Workspace { get; private set; } + /// + /// Current settings for the workspace + /// public TConfig CurrentSettings { get; internal set; } /// diff --git a/src/Microsoft.SqlTools.ServiceLayer/project.json b/src/Microsoft.SqlTools.ServiceLayer/project.json index 2718de69..aa33787e 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/project.json +++ b/src/Microsoft.SqlTools.ServiceLayer/project.json @@ -7,10 +7,9 @@ }, "dependencies": { "Newtonsoft.Json": "9.0.1", - "Microsoft.SqlServer.SqlParser": "140.1.5", "System.Data.Common": "4.1.0", "System.Data.SqlClient": "4.1.0", - "Microsoft.SqlServer.Smo": "140.1.5", + "Microsoft.SqlServer.Smo": "140.1.8", "System.Security.SecureString": "4.0.0", "System.Collections.Specialized": "4.0.1", "System.ComponentModel.TypeConverter": "4.1.0", diff --git a/src/Microsoft.SqlTools.ServiceLayer/sr.cs b/src/Microsoft.SqlTools.ServiceLayer/sr.cs index 213c3d55..811ab975 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/sr.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/sr.cs @@ -45,6 +45,14 @@ namespace Microsoft.SqlTools.ServiceLayer } } + public static string ConnectionServiceConnectionCanceled + { + get + { + return Keys.GetString(Keys.ConnectionServiceConnectionCanceled); + } + } + public static string ConnectionParamsValidateNullOwnerUri { get @@ -368,7 +376,7 @@ namespace Microsoft.SqlTools.ServiceLayer [System.Runtime.CompilerServices.CompilerGeneratedAttribute()] public class Keys { - static ResourceManager resourceManager = new ResourceManager("Microsoft.SqlTools.ServiceLayer.SR", typeof(SR).GetTypeInfo().Assembly); + static ResourceManager resourceManager = new ResourceManager(typeof(SR)); static CultureInfo _culture = null; @@ -388,6 +396,9 @@ namespace Microsoft.SqlTools.ServiceLayer public const string ConnectionServiceConnStringInvalidIntent = "ConnectionServiceConnStringInvalidIntent"; + public const string ConnectionServiceConnectionCanceled = "ConnectionServiceConnectionCanceled"; + + public const string ConnectionParamsValidateNullOwnerUri = "ConnectionParamsValidateNullOwnerUri"; diff --git a/src/Microsoft.SqlTools.ServiceLayer/sr.resx b/src/Microsoft.SqlTools.ServiceLayer/sr.resx index c83b9a1c..63d7e71b 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/sr.resx +++ b/src/Microsoft.SqlTools.ServiceLayer/sr.resx @@ -140,6 +140,10 @@ . Parameters: 0 - intent (string) + + Connection canceled + + OwnerUri cannot be null or empty @@ -240,7 +244,7 @@ ({0} row(s) affected) . - Parameters: 0 - rows (int) + Parameters: 0 - rows (long) Command(s) copleted successfully. diff --git a/src/Microsoft.SqlTools.ServiceLayer/sr.strings b/src/Microsoft.SqlTools.ServiceLayer/sr.strings index 444e0af8..a74a54d9 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/sr.strings +++ b/src/Microsoft.SqlTools.ServiceLayer/sr.strings @@ -33,6 +33,8 @@ ConnectionServiceConnStringInvalidAuthType(string authType) = Invalid value '{0} ConnectionServiceConnStringInvalidIntent(string intent) = Invalid value '{0}' for ApplicationIntent. Valid values are 'ReadWrite' and 'ReadOnly'. +ConnectionServiceConnectionCanceled = Connection canceled + ###### ### Connection Params Validation Errors @@ -103,7 +105,7 @@ QueryServiceFileWrapperReadOnly = This FileStreamWrapper cannot be used for writ ### Query Request -QueryServiceAffectedRows(int rows) = ({0} row(s) affected) +QueryServiceAffectedRows(long rows) = ({0} row(s) affected) QueryServiceCompletedSuccessfully = Command(s) copleted successfully. diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/Connection/ConnectionServiceTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/Connection/ConnectionServiceTests.cs index 82b5aca3..8205cf21 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/Connection/ConnectionServiceTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/Connection/ConnectionServiceTests.cs @@ -8,6 +8,7 @@ using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Reflection; +using System.Threading; using System.Threading.Tasks; using Microsoft.SqlTools.ServiceLayer.Connection; using Microsoft.SqlTools.ServiceLayer.Connection.Contracts; @@ -52,6 +53,214 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection return connectionMock.Object; } + [Fact] + public void CanCancelConnectRequest() + { + var testFile = "file:///my/test/file.sql"; + + // Given a connection that times out and responds to cancellation + var mockConnection = new Mock { CallBase = true }; + CancellationToken token; + bool ready = false; + mockConnection.Setup(x => x.OpenAsync(Moq.It.IsAny())) + .Callback(t => + { + // Pass the token to the return handler and signal the main thread to cancel + token = t; + ready = true; + }) + .Returns(() => + { + if (TestUtils.WaitFor(() => token.IsCancellationRequested)) + { + throw new OperationCanceledException(); + } + else + { + return Task.FromResult(true); + } + }); + + var mockFactory = new Mock(); + mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny())) + .Returns(mockConnection.Object); + + + var connectionService = new ConnectionService(mockFactory.Object); + + // Connect the connection asynchronously in a background thread + var connectionDetails = TestObjects.GetTestConnectionDetails(); + var connectTask = Task.Run(async () => + { + return await connectionService + .Connect(new ConnectParams() + { + OwnerUri = testFile, + Connection = connectionDetails + }); + }); + + // Wait for the connection to call OpenAsync() + Assert.True(TestUtils.WaitFor(() => ready)); + + // Send a cancellation request + var cancelResult = connectionService + .CancelConnect(new CancelConnectParams() + { + OwnerUri = testFile + }); + + // Wait for the connection task to finish + connectTask.Wait(); + + // Verify that the connection was cancelled (no connection was created) + Assert.Null(connectTask.Result.ConnectionId); + + // Verify that the cancel succeeded + Assert.True(cancelResult); + } + + [Fact] + public async void CanCancelConnectRequestByConnecting() + { + var testFile = "file:///my/test/file.sql"; + + // Given a connection that times out and responds to cancellation + var mockConnection = new Mock { CallBase = true }; + CancellationToken token; + bool ready = false; + mockConnection.Setup(x => x.OpenAsync(Moq.It.IsAny())) + .Callback(t => + { + // Pass the token to the return handler and signal the main thread to cancel + token = t; + ready = true; + }) + .Returns(() => + { + if (TestUtils.WaitFor(() => token.IsCancellationRequested)) + { + throw new OperationCanceledException(); + } + else + { + return Task.FromResult(true); + } + }); + + // Given a second connection that succeeds + var mockConnection2 = new Mock { CallBase = true }; + mockConnection2.Setup(x => x.OpenAsync(Moq.It.IsAny())) + .Returns(() => Task.Run(() => {})); + + var mockFactory = new Mock(); + mockFactory.SetupSequence(factory => factory.CreateSqlConnection(It.IsAny())) + .Returns(mockConnection.Object) + .Returns(mockConnection2.Object); + + + var connectionService = new ConnectionService(mockFactory.Object); + + // Connect the first connection asynchronously in a background thread + var connectionDetails = TestObjects.GetTestConnectionDetails(); + var connectTask = Task.Run(async () => + { + return await connectionService + .Connect(new ConnectParams() + { + OwnerUri = testFile, + Connection = connectionDetails + }); + }); + + // Wait for the connection to call OpenAsync() + Assert.True(TestUtils.WaitFor(() => ready)); + + // Send a cancellation by trying to connect again + var connectResult = await connectionService + .Connect(new ConnectParams() + { + OwnerUri = testFile, + Connection = connectionDetails + }); + + // Wait for the first connection task to finish + connectTask.Wait(); + + // Verify that the first connection was cancelled (no connection was created) + Assert.Null(connectTask.Result.ConnectionId); + + // Verify that the second connection succeeded + Assert.NotEmpty(connectResult.ConnectionId); + } + + [Fact] + public void CanCancelConnectRequestByDisconnecting() + { + var testFile = "file:///my/test/file.sql"; + + // Given a connection that times out and responds to cancellation + var mockConnection = new Mock { CallBase = true }; + CancellationToken token; + bool ready = false; + mockConnection.Setup(x => x.OpenAsync(Moq.It.IsAny())) + .Callback(t => + { + // Pass the token to the return handler and signal the main thread to cancel + token = t; + ready = true; + }) + .Returns(() => + { + if (TestUtils.WaitFor(() => token.IsCancellationRequested)) + { + throw new OperationCanceledException(); + } + else + { + return Task.FromResult(true); + } + }); + + var mockFactory = new Mock(); + mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny())) + .Returns(mockConnection.Object); + + + var connectionService = new ConnectionService(mockFactory.Object); + + // Connect the first connection asynchronously in a background thread + var connectionDetails = TestObjects.GetTestConnectionDetails(); + var connectTask = Task.Run(async () => + { + return await connectionService + .Connect(new ConnectParams() + { + OwnerUri = testFile, + Connection = connectionDetails + }); + }); + + // Wait for the connection to call OpenAsync() + Assert.True(TestUtils.WaitFor(() => ready)); + + // Send a cancellation by trying to disconnect + var disconnectResult = connectionService + .Disconnect(new DisconnectParams() + { + OwnerUri = testFile + }); + + // Wait for the first connection task to finish + connectTask.Wait(); + + // Verify that the first connection was cancelled (no connection was created) + Assert.Null(connectTask.Result.ConnectionId); + + // Verify that the disconnect failed (since it caused a cancellation) + Assert.False(disconnectResult); + } + /// /// Verify that we can connect to the default database when no database name is /// provided as a parameter. @@ -59,12 +268,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection [Theory] [InlineDataAttribute(null)] [InlineDataAttribute("")] - public void CanConnectWithEmptyDatabaseName(string databaseName) + public async void CanConnectWithEmptyDatabaseName(string databaseName) { // Connect var connectionDetails = TestObjects.GetTestConnectionDetails(); connectionDetails.DatabaseName = databaseName; - var connectionResult = + var connectionResult = await TestObjects.GetTestConnectionService() .Connect(new ConnectParams() { @@ -83,7 +292,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection [Theory] [InlineDataAttribute("master")] [InlineDataAttribute("nonMasterDb")] - public void ConnectToDefaultDatabaseRespondsWithActualDbName(string expectedDbName) + public async void ConnectToDefaultDatabaseRespondsWithActualDbName(string expectedDbName) { // Given connecting with empty database name will return the expected DB name var connectionMock = new Mock { CallBase = true }; @@ -99,7 +308,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection var connectionDetails = TestObjects.GetTestConnectionDetails(); connectionDetails.DatabaseName = string.Empty; - var connectionResult = + var connectionResult = await connectionService .Connect(new ConnectParams() { @@ -118,14 +327,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// connection, we disconnect first before connecting. /// [Fact] - public void ConnectingWhenConnectionExistCausesDisconnectThenConnect() + public async void ConnectingWhenConnectionExistCausesDisconnectThenConnect() { bool callbackInvoked = false; // first connect string ownerUri = "file://my/sample/file.sql"; var connectionService = TestObjects.GetTestConnectionService(); - var connectionResult = + var connectionResult = await connectionService .Connect(new ConnectParams() { @@ -146,7 +355,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection ); // send annother connect request - connectionResult = + connectionResult = await connectionService .Connect(new ConnectParams() { @@ -165,7 +374,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Verify that when connecting with invalid credentials, an error is thrown. /// [Fact] - public void ConnectingWithInvalidCredentialsYieldsErrorMessage() + public async void ConnectingWithInvalidCredentialsYieldsErrorMessage() { var testConnectionDetails = TestObjects.GetTestConnectionDetails(); var invalidConnectionDetails = new ConnectionDetails(); @@ -175,7 +384,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection invalidConnectionDetails.Password = "invalidPassword"; // Connect to test db with invalid credentials - var connectionResult = + var connectionResult = await TestObjects.GetTestConnectionService() .Connect(new ConnectParams() { @@ -204,10 +413,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection [InlineData("Integrated", "file://my/sample/file.sql", null, "test", "sa", "123456")] [InlineData("Integrated", "", "my-server", "test", "sa", "123456")] [InlineData("Integrated", "file://my/sample/file.sql", "", "test", "sa", "123456")] - public void ConnectingWithInvalidParametersYieldsErrorMessage(string authType, string ownerUri, string server, string database, string userName, string password) + public async void ConnectingWithInvalidParametersYieldsErrorMessage(string authType, string ownerUri, string server, string database, string userName, string password) { // Connect with invalid parameters - var connectionResult = + var connectionResult = await TestObjects.GetTestConnectionService() .Connect(new ConnectParams() { @@ -238,10 +447,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection [InlineData("sa", "")] [InlineData(null, "12345678")] [InlineData("", "12345678")] - public void ConnectingWithNoUsernameOrPasswordWorksForIntegratedAuth(string userName, string password) + public async void ConnectingWithNoUsernameOrPasswordWorksForIntegratedAuth(string userName, string password) { // Connect - var connectionResult = + var connectionResult = await TestObjects.GetTestConnectionService() .Connect(new ConnectParams() { @@ -263,10 +472,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Verify that when connecting with a null parameters object, an error is thrown. /// [Fact] - public void ConnectingWithNullParametersObjectYieldsErrorMessage() + public async void ConnectingWithNullParametersObjectYieldsErrorMessage() { // Connect with null parameters - var connectionResult = + var connectionResult = await TestObjects.GetTestConnectionService() .Connect(null); @@ -330,7 +539,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Verify that a connection changed event is fired when the database context changes. /// [Fact] - public void ConnectionChangedEventIsFiredWhenDatabaseContextChanges() + public async void ConnectionChangedEventIsFiredWhenDatabaseContextChanges() { var serviceHostMock = new Mock(); @@ -339,7 +548,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection // Set up an initial connection string ownerUri = "file://my/sample/file.sql"; - var connectionResult = + var connectionResult = await connectionService .Connect(new ConnectParams() { @@ -364,11 +573,11 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Verify that the SQL parser correctly detects errors in text /// [Fact] - public void ConnectToDatabaseTest() + public async void ConnectToDatabaseTest() { // connect to a database instance string ownerUri = "file://my/sample/file.sql"; - var connectionResult = + var connectionResult = await TestObjects.GetTestConnectionService() .Connect(new ConnectParams() { @@ -384,12 +593,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Verify that we can disconnect from an active connection succesfully /// [Fact] - public void DisconnectFromDatabaseTest() + public async void DisconnectFromDatabaseTest() { // first connect string ownerUri = "file://my/sample/file.sql"; var connectionService = TestObjects.GetTestConnectionService(); - var connectionResult = + var connectionResult = await connectionService .Connect(new ConnectParams() { @@ -414,14 +623,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Test that when a disconnect is performed, the callback event is fired /// [Fact] - public void DisconnectFiresCallbackEvent() + public async void DisconnectFiresCallbackEvent() { bool callbackInvoked = false; // first connect string ownerUri = "file://my/sample/file.sql"; var connectionService = TestObjects.GetTestConnectionService(); - var connectionResult = + var connectionResult = await connectionService .Connect(new ConnectParams() { @@ -458,12 +667,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Test that disconnecting an active connection removes the Owner URI -> ConnectionInfo mapping /// [Fact] - public void DisconnectRemovesOwnerMapping() + public async void DisconnectRemovesOwnerMapping() { // first connect string ownerUri = "file://my/sample/file.sql"; var connectionService = TestObjects.GetTestConnectionService(); - var connectionResult = + var connectionResult = await connectionService .Connect(new ConnectParams() { @@ -498,12 +707,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection [InlineDataAttribute(null)] [InlineDataAttribute("")] - public void DisconnectValidatesParameters(string disconnectUri) + public async void DisconnectValidatesParameters(string disconnectUri) { // first connect string ownerUri = "file://my/sample/file.sql"; var connectionService = TestObjects.GetTestConnectionService(); - var connectionResult = + var connectionResult = await connectionService .Connect(new ConnectParams() { @@ -530,7 +739,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Verifies the the list databases operation lists database names for the server used by a connection. /// [Fact] - public void ListDatabasesOnServerForCurrentConnectionReturnsDatabaseNames() + public async void ListDatabasesOnServerForCurrentConnectionReturnsDatabaseNames() { // Result set for the query of database names Dictionary[] data = @@ -550,7 +759,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection // connect to a database instance string ownerUri = "file://my/sample/file.sql"; - var connectionResult = + var connectionResult = await connectionService .Connect(new ConnectParams() { @@ -579,7 +788,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Verify that the SQL parser correctly detects errors in text /// [Fact] - public void OnConnectionCallbackHandlerTest() + public async void OnConnectionCallbackHandlerTest() { bool callbackInvoked = false; @@ -593,7 +802,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection ); // connect to a database instance - var connectionResult = connectionService.Connect(TestObjects.GetTestConnectionParams()); + var connectionResult = await connectionService.Connect(TestObjects.GetTestConnectionParams()); // verify that a valid connection id was returned Assert.True(callbackInvoked); @@ -603,14 +812,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection /// Verify when a connection is created that the URI -> Connection mapping is created in the connection service. /// [Fact] - public void TestConnectRequestRegistersOwner() + public async void TestConnectRequestRegistersOwner() { // Given a request to connect to a database var service = TestObjects.GetTestConnectionService(); var connectParams = TestObjects.GetTestConnectionParams(); // connect to a database instance - var connectionResult = service.Connect(connectParams); + var connectionResult = await service.Connect(connectParams); // verify that a valid connection id was returned Assert.NotNull(connectionResult.ConnectionId); diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/AutocompleteTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/AutocompleteTests.cs new file mode 100644 index 00000000..a44f8994 --- /dev/null +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/AutocompleteTests.cs @@ -0,0 +1,139 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.Collections.Generic; +using System.Threading.Tasks; +using Microsoft.SqlServer.Management.SqlParser.Binder; +using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; +using Microsoft.SqlServer.Management.SqlParser.Parser; +using Microsoft.SqlTools.ServiceLayer.Connection; +using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol; +using Microsoft.SqlTools.ServiceLayer.LanguageServices; +using Microsoft.SqlTools.ServiceLayer.LanguageServices.Contracts; +using Microsoft.SqlTools.ServiceLayer.SqlContext; +using Microsoft.SqlTools.ServiceLayer.Test.QueryExecution; +using Microsoft.SqlTools.ServiceLayer.Workspace; +using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts; +using Microsoft.SqlTools.Test.Utility; +using Moq; +using Xunit; + +namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices +{ + /// + /// Tests for the language service autocomplete component + /// + public class AutocompleteTests + { + private const int TaskTimeout = 60000; + + private readonly string testScriptUri = TestObjects.ScriptUri; + + private readonly string testConnectionKey = "testdbcontextkey"; + + private Mock bindingQueue; + + private Mock> workspaceService; + + private Mock> requestContext; + + private Mock binder; + + private TextDocumentPosition textDocument; + + private void InitializeTestObjects() + { + // initial cursor position in the script file + textDocument = new TextDocumentPosition + { + TextDocument = new TextDocumentIdentifier {Uri = this.testScriptUri}, + Position = new Position + { + Line = 0, + Character = 0 + } + }; + + // default settings are stored in the workspace service + WorkspaceService.Instance.CurrentSettings = new SqlToolsSettings(); + + // set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + fileMock.SetupGet(file => file.ClientFilePath).Returns(this.testScriptUri); + + // set up workspace mock + workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); + + // setup binding queue mock + bindingQueue = new Mock(); + bindingQueue.Setup(q => q.AddConnectionContext(It.IsAny())) + .Returns(this.testConnectionKey); + + // inject mock instances into the Language Service + LanguageService.WorkspaceServiceInstance = workspaceService.Object; + LanguageService.ConnectionServiceInstance = TestObjects.GetTestConnectionService(); + ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo(); + LanguageService.ConnectionServiceInstance.OwnerToConnectionMap.Add(this.testScriptUri, connectionInfo); + LanguageService.Instance.BindingQueue = bindingQueue.Object; + + // setup the mock for SendResult + requestContext = new Mock>(); + requestContext.Setup(rc => rc.SendResult(It.IsAny())) + .Returns(Task.FromResult(0)); + + // setup the IBinder mock + binder = new Mock(); + binder.Setup(b => b.Bind( + It.IsAny>(), + It.IsAny(), + It.IsAny())); + + var testScriptParseInfo = new ScriptParseInfo(); + LanguageService.Instance.AddOrUpdateScriptParseInfo(this.testScriptUri, testScriptParseInfo); + testScriptParseInfo.IsConnected = true; + testScriptParseInfo.ConnectionKey = LanguageService.Instance.BindingQueue.AddConnectionContext(connectionInfo); + + // setup the binding context object + ConnectedBindingContext bindingContext = new ConnectedBindingContext(); + bindingContext.Binder = binder.Object; + bindingContext.MetadataDisplayInfoProvider = new MetadataDisplayInfoProvider(); + LanguageService.Instance.BindingQueue.BindingContextMap.Add(testScriptParseInfo.ConnectionKey, bindingContext); + } + + /// + /// Tests the primary completion list event handler + /// + [Fact] + public void GetCompletionsHandlerTest() + { + InitializeTestObjects(); + + // request the completion list + Task handleCompletion = LanguageService.HandleCompletionRequest(textDocument, requestContext.Object); + handleCompletion.Wait(TaskTimeout); + + // verify that send result was called with a completion array + requestContext.Verify(m => m.SendResult(It.IsAny()), Times.Once()); + } + + /// + /// Test the service initialization code path and verify nothing throws + /// + [Fact] + public async void UpdateLanguageServiceOnConnection() + { + InitializeTestObjects(); + + AutoCompleteHelper.WorkspaceServiceInstance = workspaceService.Object; + + ConnectionInfo connInfo = TestObjects.GetTestConnectionInfo(); + + await LanguageService.Instance.UpdateLanguageServiceOnConnection(connInfo); + } + } +} diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/BindingQueueTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/BindingQueueTests.cs new file mode 100644 index 00000000..63181f67 --- /dev/null +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/BindingQueueTests.cs @@ -0,0 +1,187 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.Threading; +using System.Threading.Tasks; +using Microsoft.SqlServer.Management.Common; +using Microsoft.SqlServer.Management.SmoMetadataProvider; +using Microsoft.SqlServer.Management.SqlParser.Binder; +using Microsoft.SqlServer.Management.SqlParser.Common; +using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; +using Microsoft.SqlServer.Management.SqlParser.Parser; +using Microsoft.SqlTools.ServiceLayer.LanguageServices; +using Microsoft.SqlTools.ServiceLayer.LanguageServices.Contracts; +using Xunit; + +namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices +{ + + /// + /// Test class for the test binding context + /// + public class TestBindingContext : IBindingContext + { + public TestBindingContext() + { + this.BindingLocked = new ManualResetEvent(initialState: true); + this.BindingTimeout = 3000; + } + + public bool IsConnected { get; set; } + + public ServerConnection ServerConnection { get; set; } + + public MetadataDisplayInfoProvider MetadataDisplayInfoProvider { get; set; } + + public SmoMetadataProvider SmoMetadataProvider { get; set; } + + public IBinder Binder { get; set; } + + public ManualResetEvent BindingLocked { get; set; } + + public int BindingTimeout { get; set; } + + public ParseOptions ParseOptions { get; } + + public ServerVersion ServerVersion { get; } + + public DatabaseEngineType DatabaseEngineType { get; } + + public TransactSqlVersion TransactSqlVersion { get; } + + public DatabaseCompatibilityLevel DatabaseCompatibilityLevel { get; } + } + + /// + /// Tests for the Binding Queue + /// + public class BindingQueueTests + { + private int bindCallCount = 0; + + private int timeoutCallCount = 0; + + private int bindCallbackDelay = 0; + + private bool isCancelationRequested = false; + + private IBindingContext bindingContext = null; + + private BindingQueue bindingQueue = null; + + private void InitializeTestSettings() + { + this.bindCallCount = 0; + this.timeoutCallCount = 0; + this.bindCallbackDelay = 10; + this.isCancelationRequested = false; + this.bindingContext = GetMockBindingContext(); + this.bindingQueue = new BindingQueue(); + } + + private IBindingContext GetMockBindingContext() + { + return new TestBindingContext(); + } + + /// + /// Test bind operation callback + /// + private object TestBindOperation( + IBindingContext bindContext, + CancellationToken cancelToken) + { + cancelToken.WaitHandle.WaitOne(this.bindCallbackDelay); + this.isCancelationRequested = cancelToken.IsCancellationRequested; + if (!this.isCancelationRequested) + { + ++this.bindCallCount; + } + return new CompletionItem[0]; + } + + /// + /// Test callback for the bind timeout operation + /// + private object TestTimeoutOperation( + IBindingContext bindingContext) + { + ++this.timeoutCallCount; + return new CompletionItem[0]; + } + + /// + /// Queues a single task + /// + [Fact] + public void QueueOneBindingOperationTest() + { + InitializeTestSettings(); + + this.bindingQueue.QueueBindingOperation( + key: "testkey", + bindOperation: TestBindOperation, + timeoutOperation: TestTimeoutOperation); + + Thread.Sleep(1000); + + this.bindingQueue.StopQueueProcessor(15000); + + Assert.True(this.bindCallCount == 1); + Assert.True(this.timeoutCallCount == 0); + Assert.False(this.isCancelationRequested); + } + + /// + /// Queue a 100 short tasks + /// + [Fact] + public void Queue100BindingOperationTest() + { + InitializeTestSettings(); + + for (int i = 0; i < 100; ++i) + { + this.bindingQueue.QueueBindingOperation( + key: "testkey", + bindOperation: TestBindOperation, + timeoutOperation: TestTimeoutOperation); + } + + Thread.Sleep(2000); + + this.bindingQueue.StopQueueProcessor(15000); + + Assert.True(this.bindCallCount == 100); + Assert.True(this.timeoutCallCount == 0); + Assert.False(this.isCancelationRequested); + } + + /// + /// Queue an task with a long operation causing a timeout + /// + [Fact] + public void QueueWithTimeout() + { + InitializeTestSettings(); + + this.bindCallbackDelay = 1000; + + this.bindingQueue.QueueBindingOperation( + key: "testkey", + bindingTimeout: bindCallbackDelay / 2, + bindOperation: TestBindOperation, + timeoutOperation: TestTimeoutOperation); + + Thread.Sleep(this.bindCallbackDelay + 100); + + this.bindingQueue.StopQueueProcessor(15000); + + Assert.True(this.bindCallCount == 0); + Assert.True(this.timeoutCallCount == 1); + Assert.True(this.isCancelationRequested); + } + } +} diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/LanguageServiceTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/LanguageServiceTests.cs index 34f7e405..9ce596e5 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/LanguageServiceTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/LanguageServiceTests.cs @@ -7,18 +7,8 @@ using System; using System.Collections.Generic; using System.Data; using System.Data.Common; -using System.Data.SqlClient; using System.IO; using System.Reflection; -using System.Threading.Tasks; -using Microsoft.SqlServer.Management.Common; -using Microsoft.SqlServer.Management.Smo; -using Microsoft.SqlServer.Management.SmoMetadataProvider; -using Microsoft.SqlServer.Management.SqlParser; -using Microsoft.SqlServer.Management.SqlParser.Binder; -using Microsoft.SqlServer.Management.SqlParser.Intellisense; -using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; -using Microsoft.SqlServer.Management.SqlParser.Parser; using Microsoft.SqlTools.ServiceLayer.Connection; using Microsoft.SqlTools.ServiceLayer.Connection.Contracts; using Microsoft.SqlTools.ServiceLayer.Credentials; @@ -43,6 +33,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices { #region "Diagnostics tests" + /// /// Verify that the latest SqlParser (2016 as of this writing) is used by default /// @@ -154,61 +145,29 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices #region "General Language Service tests" - /// - /// Check that autocomplete is enabled by default - /// - [Fact] - public void CheckAutocompleteEnabledByDefault() - { - // get test service - LanguageService service = TestObjects.GetTestLanguageService(); - Assert.True(service.ShouldEnableAutocomplete()); - } - /// /// Test the service initialization code path and verify nothing throws /// - [Fact] + // Test is causing failures in build lab..investigating to reenable + //[Fact] public void ServiceInitiailzation() { InitializeTestServices(); Assert.True(LanguageService.Instance.Context != null); - Assert.True(LanguageService.Instance.ConnectionServiceInstance != null); + Assert.True(LanguageService.ConnectionServiceInstance != null); Assert.True(LanguageService.Instance.CurrentSettings != null); Assert.True(LanguageService.Instance.CurrentWorkspace != null); - LanguageService.Instance.ConnectionServiceInstance = null; - Assert.True(LanguageService.Instance.ConnectionServiceInstance == null); + LanguageService.ConnectionServiceInstance = null; + Assert.True(LanguageService.ConnectionServiceInstance == null); } - - /// - /// Test the service initialization code path and verify nothing throws - /// - [Fact] - public void UpdateLanguageServiceOnConnection() - { - string ownerUri = "file://my/sample/file.sql"; - var connectionService = TestObjects.GetTestConnectionService(); - var connectionResult = - connectionService - .Connect(new ConnectParams() - { - OwnerUri = ownerUri, - Connection = TestObjects.GetTestConnectionDetails() - }); - - ConnectionInfo connInfo = null; - connectionService.TryFindConnection(ownerUri, out connInfo); - - var task = LanguageService.Instance.UpdateLanguageServiceOnConnection(connInfo); - task.Wait(); - } /// /// Test the service initialization code path and verify nothing throws /// - [Fact] + // Test is causing failures in build lab..investigating to reenable + //[Fact] public void PrepopulateCommonMetadata() { InitializeTestServices(); @@ -232,7 +191,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices ScriptParseInfo scriptInfo = new ScriptParseInfo(); scriptInfo.IsConnected = true; - AutoCompleteHelper.PrepopulateCommonMetadata(connInfo, scriptInfo); + AutoCompleteHelper.PrepopulateCommonMetadata(connInfo, scriptInfo, null); } private string GetTestSqlFile() @@ -259,8 +218,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices // set up the host details and profile paths var hostDetails = new HostDetails(hostName, hostProfileId, hostVersion); - var profilePaths = new ProfilePaths(hostProfileId, "baseAllUsersPath", "baseCurrentUserPath"); - SqlToolsContext sqlToolsContext = new SqlToolsContext(hostDetails, profilePaths); + SqlToolsContext sqlToolsContext = new SqlToolsContext(hostDetails); // Grab the instance of the service host Hosting.ServiceHost serviceHost = Hosting.ServiceHost.Instance; @@ -281,9 +239,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices private Hosting.ServiceHost GetTestServiceHost() { // set up the host details and profile paths - var hostDetails = new HostDetails("Test Service Host", "SQLToolsService", new Version(1,0)); - var profilePaths = new ProfilePaths("SQLToolsService", "baseAllUsersPath", "baseCurrentUserPath"); - SqlToolsContext context = new SqlToolsContext(hostDetails, profilePaths); + var hostDetails = new HostDetails("Test Service Host", "SQLToolsService", new Version(1,0)); + SqlToolsContext context = new SqlToolsContext(hostDetails); // Grab the instance of the service host Hosting.ServiceHost host = Hosting.ServiceHost.Instance; diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/CancelTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/CancelTests.cs index 7e0e5a4d..d27fe156 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/CancelTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/CancelTests.cs @@ -7,7 +7,10 @@ using System; using System.Threading.Tasks; using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol; using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; +using Microsoft.SqlTools.ServiceLayer.SqlContext; using Microsoft.SqlTools.ServiceLayer.Test.Utility; +using Microsoft.SqlTools.ServiceLayer.Workspace; +using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts; using Moq; using Xunit; @@ -16,12 +19,21 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution public class CancelTests { [Fact] - public void CancelInProgressQueryTest() + public async void CancelInProgressQueryTest() { + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.Setup(file => file.GetLinesInRange(It.IsAny())) + .Returns(new string[] { Common.StandardQuery }); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); + // If: // ... I request a query (doesn't matter what kind) and execute it - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams { QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.GetSubSectionDocument(), OwnerUri = Common.OwnerUri }; var executeRequest = RequestContextMocks.SetupRequestContextMock(null, QueryExecuteCompleteEvent.Type, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); @@ -43,12 +55,20 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void CancelExecutedQueryTest() + public async void CancelExecutedQueryTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // If: // ... I request a query (doesn't matter what kind) and wait for execution - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams {QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri}; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams {QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri}; var executeRequest = RequestContextMocks.SetupRequestContextMock(null, QueryExecuteCompleteEvent.Type, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); @@ -69,11 +89,13 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void CancelNonExistantTest() + public async void CancelNonExistantTest() { + + var workspaceService = new Mock>(); // If: // ... I request to cancel a query that doesn't exist - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), false); + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), false, workspaceService.Object); var cancelParams = new QueryCancelParams {OwnerUri = "Doesn't Exist"}; QueryCancelResult result = null; var cancelRequest = GetQueryCancelResultContextMock(qcr => result = qcr, null); diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/Common.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/Common.cs index c7a00c09..c3f6df75 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/Common.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/Common.cs @@ -10,6 +10,7 @@ using System.Data.Common; using System.IO; using System.Data.SqlClient; using System.Threading; +using System.Threading.Tasks; using Microsoft.SqlTools.ServiceLayer.Connection; using Microsoft.SqlTools.ServiceLayer.Connection.Contracts; using Microsoft.SqlServer.Management.Common; @@ -18,9 +19,11 @@ using Microsoft.SqlServer.Management.SqlParser.Binder; using Microsoft.SqlServer.Management.SqlParser.MetadataProvider; using Microsoft.SqlTools.ServiceLayer.LanguageServices; using Microsoft.SqlTools.ServiceLayer.QueryExecution; +using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; using Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage; using Microsoft.SqlTools.ServiceLayer.SqlContext; using Microsoft.SqlTools.ServiceLayer.Test.Utility; +using Microsoft.SqlTools.ServiceLayer.Workspace; using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts; using Moq; using Moq.Protected; @@ -29,12 +32,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution { public class Common { + public const SelectionData WholeDocument = null; + public const string StandardQuery = "SELECT * FROM sys.objects"; public const string InvalidQuery = "SELECT *** FROM sys.objects"; public const string NoOpQuery = "-- No ops here, just us chickens."; + public const string UdtQuery = "SELECT hierarchyid::Parse('/')"; + public const string OwnerUri = "testFile"; public const int StandardRows = 5; @@ -72,9 +79,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution return output; } + public static SelectionData GetSubSectionDocument() + { + return new SelectionData(0, 0, 2, 2); + } + public static Batch GetBasicExecutedBatch() { - Batch batch = new Batch(StandardQuery, 1, GetFileStreamFactory()); + Batch batch = new Batch(StandardQuery, 0, 0, 2, 2, GetFileStreamFactory()); batch.Execute(CreateTestConnection(new[] {StandardTestData}, false), CancellationToken.None).Wait(); return batch; } @@ -184,6 +196,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution connectionMock.Protected() .Setup("CreateDbCommand") .Returns(CreateTestCommand(data, throwOnRead)); + connectionMock.Setup(dbc => dbc.Open()) + .Callback(() => connectionMock.SetupGet(dbc => dbc.State).Returns(ConnectionState.Open)); + connectionMock.Setup(dbc => dbc.Close()) + .Callback(() => connectionMock.SetupGet(dbc => dbc.State).Returns(ConnectionState.Closed)); return connectionMock.Object; } @@ -232,19 +248,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution }; connInfo = Common.CreateTestConnectionInfo(null, false); - - var srvConn = GetServerConnection(connInfo); - var displayInfoProvider = new MetadataDisplayInfoProvider(); - var metadataProvider = SmoMetadataProvider.CreateConnectedProvider(srvConn); - var binder = BinderProvider.CreateBinder(metadataProvider); - LanguageService.Instance.ScriptParseInfoMap.Add(textDocument.TextDocument.Uri, - new ScriptParseInfo - { - Binder = binder, - MetadataProvider = metadataProvider, - MetadataDisplayInfoProvider = displayInfoProvider - }); + LanguageService.Instance.ScriptParseInfoMap.Add(textDocument.TextDocument.Uri, new ScriptParseInfo()); scriptFile = new ScriptFile {ClientFilePath = textDocument.TextDocument.Uri}; @@ -268,18 +273,18 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution }; } - public static QueryExecutionService GetPrimedExecutionService(ISqlConnectionFactory factory, bool isConnected) + public static async Task GetPrimedExecutionService(ISqlConnectionFactory factory, bool isConnected, WorkspaceService workspaceService) { var connectionService = new ConnectionService(factory); if (isConnected) { - connectionService.Connect(new ConnectParams + await connectionService.Connect(new ConnectParams { Connection = GetTestConnectionDetails(), OwnerUri = OwnerUri }); } - return new QueryExecutionService(connectionService) {BufferFileStreamFactory = GetFileStreamFactory()}; + return new QueryExecutionService(connectionService, workspaceService) {BufferFileStreamFactory = GetFileStreamFactory()}; } #endregion diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/DataStorage/ServiceBufferFileStreamReaderWriterTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/DataStorage/ServiceBufferFileStreamReaderWriterTests.cs index b10a7f92..87076204 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/DataStorage/ServiceBufferFileStreamReaderWriterTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/DataStorage/ServiceBufferFileStreamReaderWriterTests.cs @@ -14,7 +14,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution.DataStorage { public class ReaderWriterPairTest { - private static void VerifyReadWrite(int valueLength, T value, Func writeFunc, Func> readFunc) + private static void VerifyReadWrite(int valueLength, T value, Func writeFunc, Func readFunc) { // Setup: Create a mock file stream wrapper Common.InMemoryWrapper mockWrapper = new Common.InMemoryWrapper(); @@ -29,16 +29,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution.DataStorage } // ... And read the type T back - FileStreamReadResult outValue; + FileStreamReadResult outValue; using (ServiceBufferFileStreamReader reader = new ServiceBufferFileStreamReader(mockWrapper, "abc")) { outValue = readFunc(reader); } // Then: - Assert.Equal(value, outValue.Value); + Assert.Equal(value, outValue.Value.RawObject); Assert.Equal(valueLength, outValue.TotalLength); - Assert.False(outValue.IsNull); + Assert.NotNull(outValue.Value); } finally { @@ -200,7 +200,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution.DataStorage }; foreach (DateTimeOffset value in testValues) { - VerifyReadWrite((sizeof(long) + 1)*2, value, (writer, val) => writer.WriteDateTimeOffset(val), reader => reader.ReadDateTimeOffset(0)); + VerifyReadWrite(sizeof(long)*2 + 1, value, (writer, val) => writer.WriteDateTimeOffset(val), reader => reader.ReadDateTimeOffset(0)); } } @@ -267,7 +267,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution.DataStorage { // Then: // ... I should get an argument null exception - Assert.Throws(() => writer.WriteBytes(null, 0)); + Assert.Throws(() => writer.WriteBytes(null)); } } @@ -289,7 +289,38 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution.DataStorage byte[] value = sb.ToArray(); int lengthLength = length == 0 || length > 255 ? 5 : 1; int valueLength = sizeof(byte)*length + lengthLength; - VerifyReadWrite(valueLength, value, (writer, val) => writer.WriteBytes(value, length), reader => reader.ReadBytes(0)); + VerifyReadWrite(valueLength, value, (writer, val) => writer.WriteBytes(value), reader => reader.ReadBytes(0)); + } + + [Fact] + public void GuidTest() + { + // Setup: + // ... Create some test values + // NOTE: We are doing these here instead of InlineData because Guid type can't be written as constant expressions + Guid[] guids = + { + Guid.Empty, Guid.NewGuid(), Guid.NewGuid() + }; + foreach (Guid guid in guids) + { + VerifyReadWrite(guid.ToByteArray().Length + 1, new SqlGuid(guid), (writer, val) => writer.WriteGuid(guid), reader => reader.ReadGuid(0)); + } + } + + [Fact] + public void MoneyTest() + { + // Setup: Create some test values + // NOTE: We are doing these here instead of InlineData because SqlMoney can't be written as a constant expression + SqlMoney[] monies = + { + SqlMoney.Zero, SqlMoney.MinValue, SqlMoney.MaxValue, new SqlMoney(1.02) + }; + foreach (SqlMoney money in monies) + { + VerifyReadWrite(sizeof(decimal) + 1, money, (writer, val) => writer.WriteMoney(money), reader => reader.ReadMoney(0)); + } } } } diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/DisposeTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/DisposeTests.cs index 8c79296d..b3ff5efd 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/DisposeTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/DisposeTests.cs @@ -4,10 +4,16 @@ // using System; +using System.Data.Common; using System.Threading.Tasks; using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol; +using Microsoft.SqlTools.ServiceLayer.QueryExecution; using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; +using Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage; +using Microsoft.SqlTools.ServiceLayer.SqlContext; using Microsoft.SqlTools.ServiceLayer.Test.Utility; +using Microsoft.SqlTools.ServiceLayer.Workspace; +using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts; using Moq; using Xunit; @@ -16,19 +22,43 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution public class DisposeTests { [Fact] - public void DisposeExecutedQuery() + public void DisposeResultSet() { + // Setup: Mock file stream factory, mock db reader + var mockFileStreamFactory = new Mock(); + var mockDataReader = Common.CreateTestConnection(null, false).CreateCommand().ExecuteReaderAsync().Result; + + // If: I setup a single resultset and then dispose it + ResultSet rs = new ResultSet(mockDataReader, mockFileStreamFactory.Object); + rs.Dispose(); + + // Then: The file that was created should have been deleted + mockFileStreamFactory.Verify(fsf => fsf.DisposeFile(It.IsAny()), Times.Once); + } + + [Fact] + public async void DisposeExecutedQuery() + { + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns("doesn't matter"); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // If: // ... I request a query (doesn't matter what kind) - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams {QueryText = "Doesn'tMatter", OwnerUri = Common.OwnerUri}; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams {QuerySelection = null, OwnerUri = Common.OwnerUri}; var executeRequest = RequestContextMocks.SetupRequestContextMock(null, QueryExecuteCompleteEvent.Type, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); // ... And then I dispose of the query var disposeParams = new QueryDisposeParams {OwnerUri = Common.OwnerUri}; QueryDisposeResult result = null; - var disposeRequest = GetQueryDisposeResultContextMock(qdr => result = qdr, null); + var disposeRequest = GetQueryDisposeResultContextMock(qdr => { + result = qdr; + }, null); queryService.HandleDisposeRequest(disposeParams, disposeRequest.Object).Wait(); // Then: @@ -40,11 +70,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void QueryDisposeMissingQuery() + public async void QueryDisposeMissingQuery() { + var workspaceService = new Mock>(); // If: // ... I attempt to dispose a query that doesn't exist - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), false); + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), false, workspaceService.Object); var disposeParams = new QueryDisposeParams {OwnerUri = Common.OwnerUri}; QueryDisposeResult result = null; var disposeRequest = GetQueryDisposeResultContextMock(qdr => result = qdr, null); @@ -57,6 +88,37 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution Assert.NotEmpty(result.Messages); } + [Fact] + public async Task ServiceDispose() + { + // Setup: + // ... We need a workspace service that returns a file + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); + // ... We need a query service + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, + workspaceService.Object); + + // If: + // ... I execute some bogus query + var queryParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; + var requestContext = RequestContextMocks.Create(null); + await queryService.HandleExecuteRequest(queryParams, requestContext.Object); + + // ... And it sticks around as an active query + Assert.Equal(1, queryService.ActiveQueries.Count); + + // ... The query execution service is disposed, like when the service is shutdown + queryService.Dispose(); + + // Then: + // ... There should no longer be an active query + Assert.Empty(queryService.ActiveQueries); + } + #region Mocking private Mock> GetQueryDisposeResultContextMock( diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/ExecuteTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/ExecuteTests.cs index c81f5ee6..2484e233 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/ExecuteTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/ExecuteTests.cs @@ -3,6 +3,8 @@ // Licensed under the MIT license. See LICENSE file in the project root for full license information. // +//#define USE_LIVE_CONNECTION + using System; using System.Data.Common; using System.Linq; @@ -16,6 +18,8 @@ using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; using Microsoft.SqlTools.ServiceLayer.SqlContext; using Microsoft.SqlTools.ServiceLayer.Test.Utility; using Microsoft.SqlTools.ServiceLayer.Workspace; +using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts; +using Microsoft.SqlTools.Test.Utility; using Moq; using Xunit; @@ -29,7 +33,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution public void BatchCreationTest() { // If I create a new batch... - Batch batch = new Batch(Common.StandardQuery, 1, Common.GetFileStreamFactory()); + Batch batch = new Batch(Common.StandardQuery, 0, 0, 2, 2, Common.GetFileStreamFactory()); // Then: // ... The text of the batch should be stored @@ -45,14 +49,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution Assert.Empty(batch.ResultMessages); // ... The start line of the batch should be 0 - Assert.Equal(0, batch.StartLine); + Assert.Equal(0, batch.Selection.StartLine); } [Fact] public void BatchExecuteNoResultSets() { // If I execute a query that should get no result sets - Batch batch = new Batch(Common.StandardQuery, 1, Common.GetFileStreamFactory()); + Batch batch = new Batch(Common.StandardQuery, 0, 0, 2, 2, Common.GetFileStreamFactory()); batch.Execute(GetConnection(Common.CreateTestConnectionInfo(null, false)), CancellationToken.None).Wait(); // Then: @@ -70,7 +74,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution // ... There should be a message for how many rows were affected Assert.Equal(1, batch.ResultMessages.Count()); - Assert.Contains("1 ", batch.ResultMessages.First()); + Assert.Contains("1 ", batch.ResultMessages.First().Message); // NOTE: 1 is expected because this test simulates a 'update' statement where 1 row was affected. // The 1 in quotes is to make sure the 1 isn't part of a larger number } @@ -82,7 +86,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution ConnectionInfo ci = Common.CreateTestConnectionInfo(new[] { Common.StandardTestData }, false); // If I execute a query that should get one result set - Batch batch = new Batch(Common.StandardQuery, 1, Common.GetFileStreamFactory()); + Batch batch = new Batch(Common.StandardQuery, 0, 0, 2, 2, Common.GetFileStreamFactory()); batch.Execute(GetConnection(ci), CancellationToken.None).Wait(); // Then: @@ -104,7 +108,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution // ... There should be a message for how many rows were affected Assert.Equal(resultSets, batch.ResultMessages.Count()); - Assert.Contains(Common.StandardRows.ToString(), batch.ResultMessages.First()); + Assert.Contains(Common.StandardRows.ToString(), batch.ResultMessages.First().Message); } [Fact] @@ -115,7 +119,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution ConnectionInfo ci = Common.CreateTestConnectionInfo(dataset, false); // If I execute a query that should get two result sets - Batch batch = new Batch(Common.StandardQuery, 1, Common.GetFileStreamFactory()); + Batch batch = new Batch(Common.StandardQuery, 0, 0, 1, 1, Common.GetFileStreamFactory()); batch.Execute(GetConnection(ci), CancellationToken.None).Wait(); // Then: @@ -151,7 +155,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution Assert.Equal(resultSets, batch.ResultMessages.Count()); foreach (var rsm in batch.ResultMessages) { - Assert.Contains(Common.StandardRows.ToString(), rsm); + Assert.Contains(Common.StandardRows.ToString(), rsm.Message); } } @@ -161,7 +165,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution ConnectionInfo ci = Common.CreateTestConnectionInfo(null, true); // If I execute a batch that is invalid - Batch batch = new Batch(Common.StandardQuery, 1, Common.GetFileStreamFactory()); + Batch batch = new Batch(Common.StandardQuery, 0, 0, 2, 2, Common.GetFileStreamFactory()); batch.Execute(GetConnection(ci), CancellationToken.None).Wait(); // Then: @@ -183,7 +187,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution ConnectionInfo ci = Common.CreateTestConnectionInfo(new[] { Common.StandardTestData }, false); // If I execute a batch - Batch batch = new Batch(Common.StandardQuery, 1, Common.GetFileStreamFactory()); + Batch batch = new Batch(Common.StandardQuery, 0, 0, 2, 2, Common.GetFileStreamFactory()); batch.Execute(GetConnection(ci), CancellationToken.None).Wait(); // Then: @@ -213,7 +217,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution // ... I create a batch that has an empty query // Then: // ... It should throw an exception - Assert.Throws(() => new Batch(query, 1, Common.GetFileStreamFactory())); + Assert.Throws(() => new Batch(query, 0, 0, 2, 2, Common.GetFileStreamFactory())); } [Fact] @@ -223,7 +227,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution // ... I create a batch that has no file stream factory // Then: // ... It should throw an exception - Assert.Throws(() => new Batch("stuff", 1, null)); + Assert.Throws(() => new Batch("stuff", 0, 0, 2, 2, null)); } #endregion @@ -414,16 +418,23 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution #region Service Tests [Fact] - public void QueryExecuteValidNoResultsTest() + public async void QueryExecuteValidNoResultsTest() { // Given: // ... Default settings are stored in the workspace service WorkspaceService.Instance.CurrentSettings = new SqlToolsSettings(); + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // If: // ... I request to execute a valid query with no results - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var queryParams = new QueryExecuteParams { QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var queryParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; QueryExecuteResult result = null; QueryExecuteCompleteParams completeParams = null; @@ -450,12 +461,21 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void QueryExecuteValidResultsTest() + public async void QueryExecuteValidResultsTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // If: // ... I request to execute a valid query with results - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(new[] { Common.StandardTestData }, false), true); - var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QueryText = Common.StandardQuery }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(new[] { Common.StandardTestData }, false), true, + workspaceService.Object); + var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; QueryExecuteResult result = null; QueryExecuteCompleteParams completeParams = null; @@ -483,12 +503,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void QueryExecuteUnconnectedUriTest() + public async void QueryExecuteUnconnectedUriTest() { + + var workspaceService = new Mock>(); // If: // ... I request to execute a query using a file URI that isn't connected - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), false); - var queryParams = new QueryExecuteParams { OwnerUri = "notConnected", QueryText = Common.StandardQuery }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), false, workspaceService.Object); + var queryParams = new QueryExecuteParams { OwnerUri = "notConnected", QuerySelection = Common.WholeDocument }; QueryExecuteResult result = null; var requestContext = RequestContextMocks.SetupRequestContextMock(qer => result = qer, QueryExecuteCompleteEvent.Type, null, null); @@ -506,12 +528,21 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void QueryExecuteInProgressTest() + public async void QueryExecuteInProgressTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); + // If: // ... I request to execute a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QueryText = Common.StandardQuery }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; // Note, we don't care about the results of the first request var firstRequestContext = RequestContextMocks.SetupRequestContextMock(null, QueryExecuteCompleteEvent.Type, null, null); @@ -535,12 +566,21 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void QueryExecuteCompletedTest() + public async void QueryExecuteCompletedTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); + // If: // ... I request to execute a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QueryText = Common.StandardQuery }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; // Note, we don't care about the results of the first request var firstRequestContext = RequestContextMocks.SetupRequestContextMock(null, QueryExecuteCompleteEvent.Type, null, null); @@ -565,14 +605,21 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Theory] - [InlineData("")] [InlineData(null)] - public void QueryExecuteMissingQueryTest(string query) + public async void QueryExecuteMissingSelectionTest(SelectionData selection) { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(""); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // If: // ... I request to execute a query with a missing query string - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QueryText = query }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = selection }; QueryExecuteResult result = null; var requestContext = @@ -592,12 +639,19 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void QueryExecuteInvalidQueryTest() + public async void QueryExecuteInvalidQueryTest() { + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // If: // ... I request to execute a query that is invalid - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, true), true); - var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QueryText = Common.StandardQuery }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, true), true, workspaceService.Object); + var queryParams = new QueryExecuteParams { OwnerUri = Common.OwnerUri, QuerySelection = Common.WholeDocument }; QueryExecuteResult result = null; QueryExecuteCompleteParams complete = null; @@ -616,7 +670,35 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution Assert.NotEmpty(complete.BatchSummaries[0].Messages); } - #endregion +#if USE_LIVE_CONNECTION + [Fact] + public void QueryUdtShouldNotRetry() + { + // If: + // ... I create a query with a udt column in the result set + ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo(); + Query query = new Query(Common.UdtQuery, connectionInfo, new QueryExecutionSettings(), Common.GetFileStreamFactory()); + + // If: + // ... I then execute the query + DateTime startTime = DateTime.Now; + query.Execute().Wait(); + + // Then: + // ... The query should complete within 2 seconds since retry logic should not kick in + Assert.True(DateTime.Now.Subtract(startTime) < TimeSpan.FromSeconds(2), "Query completed slower than expected, did retry logic execute?"); + + // Then: + // ... There should be an error on the batch + Assert.True(query.HasExecuted); + Assert.NotEmpty(query.BatchSummaries); + Assert.Equal(1, query.BatchSummaries.Length); + Assert.True(query.BatchSummaries[0].HasError); + Assert.NotEmpty(query.BatchSummaries[0].Messages); + } +#endif + +#endregion private void VerifyQueryExecuteCallCount(Mock> mock, Times sendResultCalls, Times sendEventCalls, Times sendErrorCalls) { diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SaveResultsTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SaveResultsTests.cs index 99e77f5d..e3c38ab5 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SaveResultsTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SaveResultsTests.cs @@ -9,6 +9,9 @@ using System.Runtime.InteropServices; using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol; using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts; using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; +using Microsoft.SqlTools.ServiceLayer.SqlContext; +using Microsoft.SqlTools.ServiceLayer.Workspace; +using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts; using Moq; using Xunit; @@ -23,11 +26,19 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution /// Test save results to a file as CSV with correct parameters /// [Fact] - public void SaveResultsAsCsvSuccessTest() + public async void SaveResultsAsCsvSuccessTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // Execute a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams { QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; var executeRequest = GetQueryExecuteResultContextMock(null, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); @@ -57,15 +68,75 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } } + /// + /// Test save results to a file as CSV with a selection of cells and correct parameters + /// + [Fact] + public async void SaveResultsAsCsvWithSelectionSuccessTest() + { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); + + // Execute a query + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument , OwnerUri = Common.OwnerUri }; + var executeRequest = GetQueryExecuteResultContextMock(null, null, null); + queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); + + // Request to save the results as csv with correct parameters + var saveParams = new SaveResultsAsCsvRequestParams + { + OwnerUri = Common.OwnerUri, + ResultSetIndex = 0, + BatchIndex = 0, + FilePath = "testwrite_2.csv", + IncludeHeaders = true, + RowStartIndex = 0, + RowEndIndex = 0, + ColumnStartIndex = 0, + ColumnEndIndex = 0 + }; + SaveResultRequestResult result = null; + var saveRequest = GetSaveResultsContextMock(qcr => result = qcr, null); + queryService.ActiveQueries[Common.OwnerUri].Batches[0] = Common.GetBasicExecutedBatch(); + queryService.HandleSaveResultsAsCsvRequest(saveParams, saveRequest.Object).Wait(); + + // Expect to see a file successfully created in filepath and a success message + Assert.Null(result.Messages); + Assert.True(File.Exists(saveParams.FilePath)); + VerifySaveResultsCallCount(saveRequest, Times.Once(), Times.Never()); + + // Delete temp file after test + if (File.Exists(saveParams.FilePath)) + { + File.Delete(saveParams.FilePath); + } + } + /// /// Test handling exception in saving results to CSV file /// [Fact] - public void SaveResultsAsCsvExceptionTest() + public async void SaveResultsAsCsvExceptionTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); + // Execute a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams { QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; var executeRequest = GetQueryExecuteResultContextMock(null, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); @@ -93,11 +164,13 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution /// Test saving results to CSV file when the requested result set is no longer active /// [Fact] - public void SaveResultsAsCsvQueryNotFoundTest() + public async void SaveResultsAsCsvQueryNotFoundTest() { + + var workspaceService = new Mock>(); // Execute a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams { QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; var executeRequest = GetQueryExecuteResultContextMock(null, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); @@ -123,11 +196,19 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution /// Test save results to a file as JSON with correct parameters /// [Fact] - public void SaveResultsAsJsonSuccessTest() + public async void SaveResultsAsJsonSuccessTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // Execute a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams { QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; var executeRequest = GetQueryExecuteResultContextMock(null, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); @@ -137,13 +218,62 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution OwnerUri = Common.OwnerUri, ResultSetIndex = 0, BatchIndex = 0, - FilePath = "testwrite_4.json" + FilePath = "testwrite_4.json" }; SaveResultRequestResult result = null; var saveRequest = GetSaveResultsContextMock(qcr => result = qcr, null); queryService.ActiveQueries[Common.OwnerUri].Batches[0] = Common.GetBasicExecutedBatch(); queryService.HandleSaveResultsAsJsonRequest(saveParams, saveRequest.Object).Wait(); + + // Expect to see a file successfully created in filepath and a success message + Assert.Null(result.Messages); + Assert.True(File.Exists(saveParams.FilePath)); + VerifySaveResultsCallCount(saveRequest, Times.Once(), Times.Never()); + // Delete temp file after test + if (File.Exists(saveParams.FilePath)) + { + File.Delete(saveParams.FilePath); + } + } + + /// + /// Test save results to a file as JSON with a selection of cells and correct parameters + /// + [Fact] + public async void SaveResultsAsJsonWithSelectionSuccessTest() + { + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); + + // Execute a query + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument , OwnerUri = Common.OwnerUri }; + var executeRequest = GetQueryExecuteResultContextMock(null, null, null); + queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); + + // Request to save the results as json with correct parameters + var saveParams = new SaveResultsAsJsonRequestParams + { + OwnerUri = Common.OwnerUri, + ResultSetIndex = 0, + BatchIndex = 0, + FilePath = "testwrite_5.json", + RowStartIndex = 0, + RowEndIndex = 0, + ColumnStartIndex = 0, + ColumnEndIndex = 0 + }; + SaveResultRequestResult result = null; + var saveRequest = GetSaveResultsContextMock(qcr => result = qcr, null); + queryService.ActiveQueries[Common.OwnerUri].Batches[0] = Common.GetBasicExecutedBatch(); + queryService.HandleSaveResultsAsJsonRequest(saveParams, saveRequest.Object).Wait(); + // Expect to see a file successfully created in filepath and a success message Assert.Null(result.Messages); Assert.True(File.Exists(saveParams.FilePath)); @@ -160,11 +290,18 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution /// Test handling exception in saving results to JSON file /// [Fact] - public void SaveResultsAsJsonExceptionTest() + public async void SaveResultsAsJsonExceptionTest() { + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // Execute a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams { QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; var executeRequest = GetQueryExecuteResultContextMock(null, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); @@ -192,11 +329,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution /// Test saving results to JSON file when the requested result set is no longer active /// [Fact] - public void SaveResultsAsJsonQueryNotFoundTest() + public async void SaveResultsAsJsonQueryNotFoundTest() { + var workspaceService = new Mock>(); // Execute a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams { QueryText = Common.StandardQuery, OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = Common.WholeDocument, OwnerUri = Common.OwnerUri }; var executeRequest = GetQueryExecuteResultContextMock(null, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SubsetTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SubsetTests.cs index 1a50dd55..7b57971b 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SubsetTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SubsetTests.cs @@ -4,12 +4,15 @@ // using System; +using System.Linq; using System.Threading.Tasks; using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol; using Microsoft.SqlTools.ServiceLayer.QueryExecution; using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts; using Microsoft.SqlTools.ServiceLayer.SqlContext; using Microsoft.SqlTools.ServiceLayer.Test.Utility; +using Microsoft.SqlTools.ServiceLayer.Workspace; +using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts; using Moq; using Xunit; @@ -17,6 +20,48 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution { public class SubsetTests { + #region ResultSet Class Tests + + [Theory] + [InlineData(0,2)] + [InlineData(0,20)] + [InlineData(1,2)] + public void ResultSetValidTest(int startRow, int rowCount) + { + // Setup: + // ... I have a batch that has been executed + Batch b = Common.GetBasicExecutedBatch(); + + // If: + // ... I have a result set and I ask for a subset with valid arguments + ResultSet rs = b.ResultSets.First(); + ResultSetSubset subset = rs.GetSubset(startRow, rowCount).Result; + + // Then: + // ... I should get the requested number of rows back + Assert.Equal(Math.Min(rowCount, Common.StandardTestData.Length), subset.RowCount); + Assert.Equal(Math.Min(rowCount, Common.StandardTestData.Length), subset.Rows.Length); + } + + [Theory] + [InlineData(-1, 2)] // Invalid start index, too low + [InlineData(10, 2)] // Invalid start index, too high + [InlineData(0, -1)] // Invalid row count, too low + [InlineData(0, 0)] // Invalid row count, zero + public void ResultSetInvalidParmsTest(int rowStartIndex, int rowCount) + { + // If: + // I have an executed batch with a resultset in it and request invalid result set from it + Batch b = Common.GetBasicExecutedBatch(); + ResultSet rs = b.ResultSets.First(); + + // Then: + // ... It should throw an exception + Assert.ThrowsAsync(() => rs.GetSubset(rowStartIndex, rowCount)).Wait(); + } + + #endregion + #region Batch Class Tests [Theory] @@ -37,13 +82,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Theory] - [InlineData(-1, 0, 2)] // Invalid result set, too low - [InlineData(2, 0, 2)] // Invalid result set, too high - [InlineData(0, -1, 2)] // Invalid start index, too low - [InlineData(0, 10, 2)] // Invalid start index, too high - [InlineData(0, 0, -1)] // Invalid row count, too low - [InlineData(0, 0, 0)] // Invalid row count, zero - public void BatchSubsetInvalidParamsTest(int resultSetIndex, int rowStartInex, int rowCount) + [InlineData(-1)] // Invalid result set, too low + [InlineData(2)] // Invalid result set, too high + public void BatchSubsetInvalidParamsTest(int resultSetIndex) { // If I have an executed batch Batch b = Common.GetBasicExecutedBatch(); @@ -51,7 +92,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution // ... And I ask for a subset with an invalid result set index // Then: // ... It should throw an exception - Assert.ThrowsAsync(() => b.GetSubset(resultSetIndex, rowStartInex, rowCount)).Wait(); + Assert.ThrowsAsync(() => b.GetSubset(resultSetIndex, 0, 2)).Wait(); } #endregion @@ -91,11 +132,20 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution [Fact] public async Task SubsetServiceValidTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // If: // ... I have a query that has results (doesn't matter what) - var queryService =Common.GetPrimedExecutionService( - Common.CreateMockFactory(new[] {Common.StandardTestData}, false), true); - var executeParams = new QueryExecuteParams {QueryText = "Doesn'tMatter", OwnerUri = Common.OwnerUri}; + var queryService = await Common.GetPrimedExecutionService( + Common.CreateMockFactory(new[] {Common.StandardTestData}, false), true, + workspaceService.Object); + var executeParams = new QueryExecuteParams {QuerySelection = null, OwnerUri = Common.OwnerUri}; var executeRequest = RequestContextMocks.SetupRequestContextMock(null, QueryExecuteCompleteEvent.Type, null, null); await queryService.HandleExecuteRequest(executeParams, executeRequest.Object); @@ -115,11 +165,13 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void SubsetServiceMissingQueryTest() + public async void SubsetServiceMissingQueryTest() { + + var workspaceService = new Mock>(); // If: // ... I ask for a set of results for a file that hasn't executed a query - var queryService = Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true); + var queryService = await Common.GetPrimedExecutionService(Common.CreateMockFactory(null, false), true, workspaceService.Object); var subsetParams = new QueryExecuteSubsetParams { OwnerUri = Common.OwnerUri, RowsCount = 1, ResultSetIndex = 0, RowsStartIndex = 0 }; QueryExecuteSubsetResult result = null; var subsetRequest = GetQuerySubsetResultContextMock(qesr => result = qesr, null); @@ -135,13 +187,22 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void SubsetServiceUnexecutedQueryTest() + public async void SubsetServiceUnexecutedQueryTest() { + + // Set up file for returning the query + var fileMock = new Mock(); + fileMock.SetupGet(file => file.Contents).Returns(Common.StandardQuery); + // Set up workspace mock + var workspaceService = new Mock>(); + workspaceService.Setup(service => service.Workspace.GetFile(It.IsAny())) + .Returns(fileMock.Object); // If: // ... I have a query that hasn't finished executing (doesn't matter what) - var queryService = Common.GetPrimedExecutionService( - Common.CreateMockFactory(new[] { Common.StandardTestData }, false), true); - var executeParams = new QueryExecuteParams { QueryText = "Doesn'tMatter", OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService( + Common.CreateMockFactory(new[] { Common.StandardTestData }, false), true, + workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = null, OwnerUri = Common.OwnerUri }; var executeRequest = RequestContextMocks.SetupRequestContextMock(null, QueryExecuteCompleteEvent.Type, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); queryService.ActiveQueries[Common.OwnerUri].HasExecuted = false; @@ -162,13 +223,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution } [Fact] - public void SubsetServiceOutOfRangeSubsetTest() + public async void SubsetServiceOutOfRangeSubsetTest() { + + var workspaceService = new Mock>(); // If: // ... I have a query that doesn't have any result sets - var queryService = Common.GetPrimedExecutionService( - Common.CreateMockFactory(null, false), true); - var executeParams = new QueryExecuteParams { QueryText = "Doesn'tMatter", OwnerUri = Common.OwnerUri }; + var queryService = await Common.GetPrimedExecutionService( + Common.CreateMockFactory(null, false), true, + workspaceService.Object); + var executeParams = new QueryExecuteParams { QuerySelection = null, OwnerUri = Common.OwnerUri }; var executeRequest = RequestContextMocks.SetupRequestContextMock(null, QueryExecuteCompleteEvent.Type, null, null); queryService.HandleExecuteRequest(executeParams, executeRequest.Object).Wait(); @@ -191,7 +255,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution #region Mocking - private Mock> GetQuerySubsetResultContextMock( + private static Mock> GetQuerySubsetResultContextMock( Action resultCallback, Action errorCallback) { @@ -218,7 +282,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution return requestContext; } - private void VerifyQuerySubsetCallCount(Mock> mock, Times sendResultCalls, + private static void VerifyQuerySubsetCallCount(Mock> mock, Times sendResultCalls, Times sendErrorCalls) { mock.Verify(rc => rc.SendResult(It.IsAny()), sendResultCalls); diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/SqlContext/SettingsTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/SqlContext/SettingsTests.cs new file mode 100644 index 00000000..fba65a29 --- /dev/null +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/SqlContext/SettingsTests.cs @@ -0,0 +1,101 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using Microsoft.SqlTools.ServiceLayer.SqlContext; +using Xunit; + +namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices +{ + /// + /// Tests for the SqlContext settins + /// + public class SettingsTests + { + /// + /// Validate that the Language Service default settings are as expected + /// + [Fact] + public void ValidateLanguageServiceDefaults() + { + var sqlToolsSettings = new SqlToolsSettings(); + Assert.True(sqlToolsSettings.IsDiagnositicsEnabled); + Assert.True(sqlToolsSettings.IsSuggestionsEnabled); + Assert.True(sqlToolsSettings.SqlTools.EnableIntellisense); + Assert.True(sqlToolsSettings.SqlTools.IntelliSense.EnableDiagnostics); + Assert.True(sqlToolsSettings.SqlTools.IntelliSense.EnableSuggestions); + Assert.True(sqlToolsSettings.SqlTools.IntelliSense.EnableQuickInfo); + Assert.False(sqlToolsSettings.SqlTools.IntelliSense.LowerCaseSuggestions); + } + + /// + /// Validate that the IsDiagnositicsEnabled flag behavior + /// + [Fact] + public void ValidateIsDiagnosticsEnabled() + { + var sqlToolsSettings = new SqlToolsSettings(); + + // diagnostics is enabled if IntelliSense and Diagnostics flags are set + sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableDiagnostics = true; + Assert.True(sqlToolsSettings.IsDiagnositicsEnabled); + + // diagnostics is disabled if either IntelliSense and Diagnostics flags is not set + sqlToolsSettings.SqlTools.EnableIntellisense = false; + sqlToolsSettings.SqlTools.IntelliSense.EnableDiagnostics = true; + Assert.False(sqlToolsSettings.IsDiagnositicsEnabled); + + sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableDiagnostics = false; + Assert.False(sqlToolsSettings.IsDiagnositicsEnabled); + } + + /// + /// Validate that the IsSuggestionsEnabled flag behavior + /// + [Fact] + public void ValidateIsSuggestionsEnabled() + { + var sqlToolsSettings = new SqlToolsSettings(); + + // suggestions is enabled if IntelliSense and Suggestions flags are set + sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableSuggestions = true; + Assert.True(sqlToolsSettings.IsSuggestionsEnabled); + + // suggestions is disabled if either IntelliSense and Suggestions flags is not set + sqlToolsSettings.SqlTools.EnableIntellisense = false; + sqlToolsSettings.SqlTools.IntelliSense.EnableSuggestions = true; + Assert.False(sqlToolsSettings.IsSuggestionsEnabled); + + sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableSuggestions = false; + Assert.False(sqlToolsSettings.IsSuggestionsEnabled); + } + + /// + /// Validate that the IsQuickInfoEnabled flag behavior + /// + [Fact] + public void ValidateIsQuickInfoEnabled() + { + var sqlToolsSettings = new SqlToolsSettings(); + + // quick info is enabled if IntelliSense and quick info flags are set + sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableQuickInfo = true; + Assert.True(sqlToolsSettings.IsQuickInfoEnabled); + + // quick info is disabled if either IntelliSense and quick info flags is not set + sqlToolsSettings.SqlTools.EnableIntellisense = false; + sqlToolsSettings.SqlTools.IntelliSense.EnableQuickInfo = true; + Assert.False(sqlToolsSettings.IsQuickInfoEnabled); + + sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableQuickInfo = false; + Assert.False(sqlToolsSettings.IsQuickInfoEnabled); + } + } +} diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestObjects.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestObjects.cs index 82ffffd0..67e48786 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestObjects.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestObjects.cs @@ -21,6 +21,8 @@ namespace Microsoft.SqlTools.Test.Utility /// public class TestObjects { + public const string ScriptUri = "file://some/file.sql"; + /// /// Creates a test connection service /// @@ -35,11 +37,22 @@ namespace Microsoft.SqlTools.Test.Utility #endif } + /// + /// Creates a test connection info instance. + /// + public static ConnectionInfo GetTestConnectionInfo() + { + return new ConnectionInfo( + GetTestSqlConnectionFactory(), + ScriptUri, + GetTestConnectionDetails()); + } + public static ConnectParams GetTestConnectionParams() { return new ConnectParams() { - OwnerUri = "file://some/file.sql", + OwnerUri = ScriptUri, Connection = GetTestConnectionDetails() }; } diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestUtils.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestUtils.cs index 9a5f8ce1..b2d52180 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestUtils.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestUtils.cs @@ -1,5 +1,6 @@ using System; using System.Runtime.InteropServices; +using System.Threading; namespace Microsoft.SqlTools.ServiceLayer.Test.Utility { @@ -21,5 +22,23 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Utility test(); } } + + /// + /// Wait for a condition to be true for a limited amount of time. + /// + /// Function that returns a boolean on a condition + /// Number of milliseconds to wait between test intervals. + /// Number of test intervals to perform before giving up. + /// True if the condition was met before the test interval limit. + public static bool WaitFor(Func condition, int intervalMilliseconds = 10, int intervalCount = 200) + { + int count = 0; + while (count++ < intervalCount && !condition.Invoke()) + { + Thread.Sleep(intervalMilliseconds); + } + + return (count < intervalCount); + } } } diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/project.json b/test/Microsoft.SqlTools.ServiceLayer.Test/project.json index 4e5318f5..ae6e3ea6 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/project.json +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/project.json @@ -9,7 +9,7 @@ "System.Runtime.Serialization.Primitives": "4.1.1", "System.Data.Common": "4.1.0", "System.Data.SqlClient": "4.1.0", - "Microsoft.SqlServer.Smo": "140.1.5", + "Microsoft.SqlServer.Smo": "140.1.8", "System.Security.SecureString": "4.0.0", "System.Collections.Specialized": "4.0.1", "System.ComponentModel.TypeConverter": "4.1.0", From ea77bfa88528857d2b3141c67b38c848d7460cf2 Mon Sep 17 00:00:00 2001 From: Karl Burtram Date: Tue, 25 Oct 2016 17:21:37 +0000 Subject: [PATCH 02/18] Suggestion list cleanups (#115) * Add additional autocomplete words * Add another word to default completion list * Add colorization keywords and fix minor bugs. --- src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs | 2 +- .../LanguageServices/AutoCompleteHelper.cs | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs b/src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs index 36875ab6..f217e0d3 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Hosting/ServiceHost.cs @@ -157,7 +157,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting CompletionProvider = new CompletionOptions { ResolveProvider = true, - TriggerCharacters = new string[] { ".", "-", ":", "\\", "," } + TriggerCharacters = new string[] { ".", "-", ":", "\\" } }, SignatureHelpProvider = new SignatureHelpOptions { diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteHelper.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteHelper.cs index 74aeccce..40d2b608 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteHelper.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteHelper.cs @@ -30,7 +30,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices private static WorkspaceService workspaceServiceInstance; - private static Regex ValidSqlNameRegex = new Regex(@"^[\p{L}_][\p{L}\p{N}@$#_]{0,127}$"); + private static Regex ValidSqlNameRegex = new Regex(@"^[\p{L}_@][\p{L}\p{N}@$#_]{0,127}$"); private static CompletionItem[] emptyCompletionList = new CompletionItem[0]; @@ -103,6 +103,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices "end-exec", "exec", "execute", + "exists", "exit", "external", "fast_forward", @@ -177,6 +178,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices "nonclustered", "none", "norecompute", + "not", "now", "null", "numeric", @@ -193,6 +195,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices "or", "order", "out", + "outer", "output", "over", "owner", From 017b00437a2289e7c2b09a522244de491a1b9af8 Mon Sep 17 00:00:00 2001 From: Leila Lali Date: Tue, 25 Oct 2016 17:09:42 -0700 Subject: [PATCH 03/18] changing the setting namespace (#116) --- .../LanguageServices/LanguageService.cs | 8 +++--- .../SqlContext/IntelliSenseSettings.cs | 13 +++++++-- .../SqlContext/SqlToolsSettings.cs | 21 ++++++-------- .../SqlContext/SettingsTests.cs | 28 +++++++++---------- 4 files changed, 37 insertions(+), 33 deletions(-) diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs index dba3d0aa..10ac39cc 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs @@ -392,15 +392,15 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices SqlToolsSettings oldSettings, EventContext eventContext) { - bool oldEnableIntelliSense = oldSettings.SqlTools.EnableIntellisense; - bool? oldEnableDiagnostics = oldSettings.SqlTools.IntelliSense.EnableDiagnostics; + bool oldEnableIntelliSense = oldSettings.SqlTools.IntelliSense.EnableIntellisense; + bool? oldEnableDiagnostics = oldSettings.SqlTools.IntelliSense.EnableErrorChecking; // update the current settings to reflect any changes CurrentSettings.Update(newSettings); // if script analysis settings have changed we need to clear the current diagnostic markers - if (oldEnableIntelliSense != newSettings.SqlTools.EnableIntellisense - || oldEnableDiagnostics != newSettings.SqlTools.IntelliSense.EnableDiagnostics) + if (oldEnableIntelliSense != newSettings.SqlTools.IntelliSense.EnableIntellisense + || oldEnableDiagnostics != newSettings.SqlTools.IntelliSense.EnableErrorChecking) { // if the user just turned off diagnostics then send an event to clear the error markers if (!newSettings.IsDiagnositicsEnabled) diff --git a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/IntelliSenseSettings.cs b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/IntelliSenseSettings.cs index f46d3556..9d6caab3 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/IntelliSenseSettings.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/IntelliSenseSettings.cs @@ -15,12 +15,19 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext /// public IntelliSenseSettings() { + this.EnableIntellisense = true; this.EnableSuggestions = true; this.LowerCaseSuggestions = false; - this.EnableDiagnostics = true; + this.EnableErrorChecking = true; this.EnableQuickInfo = true; } + /// + /// Gets or sets a flag determining if IntelliSense is enabled + /// + /// + public bool EnableIntellisense { get; set; } + /// /// Gets or sets a flag determining if suggestions are enabled /// @@ -35,7 +42,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext /// /// Gets or sets a flag determining if diagnostics are enabled /// - public bool? EnableDiagnostics { get; set; } + public bool? EnableErrorChecking { get; set; } /// /// Gets or sets a flag determining if quick info is enabled @@ -52,7 +59,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext { this.EnableSuggestions = settings.EnableSuggestions; this.LowerCaseSuggestions = settings.LowerCaseSuggestions; - this.EnableDiagnostics = settings.EnableDiagnostics; + this.EnableErrorChecking = settings.EnableErrorChecking; this.EnableQuickInfo = settings.EnableQuickInfo; } } diff --git a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsSettings.cs b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsSettings.cs index cfa438c0..37c35ebf 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsSettings.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/SqlContext/SqlToolsSettings.cs @@ -3,6 +3,8 @@ // Licensed under the MIT license. See LICENSE file in the project root for full license information. // +using Newtonsoft.Json; + namespace Microsoft.SqlTools.ServiceLayer.SqlContext { /// @@ -15,6 +17,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext /// /// Gets or sets the underlying settings value object /// + [JsonProperty("mssql")] public SqlToolsSettingsValues SqlTools { get @@ -47,7 +50,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext { if (settings != null) { - this.SqlTools.EnableIntellisense = settings.SqlTools.EnableIntellisense; + this.SqlTools.IntelliSense.EnableIntellisense = settings.SqlTools.IntelliSense.EnableIntellisense; this.SqlTools.IntelliSense.Update(settings.SqlTools.IntelliSense); } } @@ -59,8 +62,8 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext { get { - return this.SqlTools.EnableIntellisense - && this.SqlTools.IntelliSense.EnableDiagnostics.Value; + return this.SqlTools.IntelliSense.EnableIntellisense + && this.SqlTools.IntelliSense.EnableErrorChecking.Value; } } @@ -71,7 +74,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext { get { - return this.SqlTools.EnableIntellisense + return this.SqlTools.IntelliSense.EnableIntellisense && this.SqlTools.IntelliSense.EnableSuggestions.Value; } } @@ -83,7 +86,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext { get { - return this.SqlTools.EnableIntellisense + return this.SqlTools.IntelliSense.EnableIntellisense && this.SqlTools.IntelliSense.EnableQuickInfo.Value; } } @@ -99,17 +102,11 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlContext /// public SqlToolsSettingsValues() { - this.EnableIntellisense = true; + this.IntelliSense = new IntelliSenseSettings(); this.QueryExecutionSettings = new QueryExecutionSettings(); } - /// - /// Gets or sets a flag determining if IntelliSense is enabled - /// - /// - public bool EnableIntellisense { get; set; } - /// /// Gets or sets the detailed IntelliSense settings /// diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/SqlContext/SettingsTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/SqlContext/SettingsTests.cs index fba65a29..e06764de 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/SqlContext/SettingsTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/SqlContext/SettingsTests.cs @@ -22,8 +22,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices var sqlToolsSettings = new SqlToolsSettings(); Assert.True(sqlToolsSettings.IsDiagnositicsEnabled); Assert.True(sqlToolsSettings.IsSuggestionsEnabled); - Assert.True(sqlToolsSettings.SqlTools.EnableIntellisense); - Assert.True(sqlToolsSettings.SqlTools.IntelliSense.EnableDiagnostics); + Assert.True(sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense); + Assert.True(sqlToolsSettings.SqlTools.IntelliSense.EnableErrorChecking); Assert.True(sqlToolsSettings.SqlTools.IntelliSense.EnableSuggestions); Assert.True(sqlToolsSettings.SqlTools.IntelliSense.EnableQuickInfo); Assert.False(sqlToolsSettings.SqlTools.IntelliSense.LowerCaseSuggestions); @@ -38,17 +38,17 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices var sqlToolsSettings = new SqlToolsSettings(); // diagnostics is enabled if IntelliSense and Diagnostics flags are set - sqlToolsSettings.SqlTools.EnableIntellisense = true; - sqlToolsSettings.SqlTools.IntelliSense.EnableDiagnostics = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableErrorChecking = true; Assert.True(sqlToolsSettings.IsDiagnositicsEnabled); // diagnostics is disabled if either IntelliSense and Diagnostics flags is not set - sqlToolsSettings.SqlTools.EnableIntellisense = false; - sqlToolsSettings.SqlTools.IntelliSense.EnableDiagnostics = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = false; + sqlToolsSettings.SqlTools.IntelliSense.EnableErrorChecking = true; Assert.False(sqlToolsSettings.IsDiagnositicsEnabled); - sqlToolsSettings.SqlTools.EnableIntellisense = true; - sqlToolsSettings.SqlTools.IntelliSense.EnableDiagnostics = false; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableErrorChecking = false; Assert.False(sqlToolsSettings.IsDiagnositicsEnabled); } @@ -61,16 +61,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices var sqlToolsSettings = new SqlToolsSettings(); // suggestions is enabled if IntelliSense and Suggestions flags are set - sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = true; sqlToolsSettings.SqlTools.IntelliSense.EnableSuggestions = true; Assert.True(sqlToolsSettings.IsSuggestionsEnabled); // suggestions is disabled if either IntelliSense and Suggestions flags is not set - sqlToolsSettings.SqlTools.EnableIntellisense = false; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = false; sqlToolsSettings.SqlTools.IntelliSense.EnableSuggestions = true; Assert.False(sqlToolsSettings.IsSuggestionsEnabled); - sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = true; sqlToolsSettings.SqlTools.IntelliSense.EnableSuggestions = false; Assert.False(sqlToolsSettings.IsSuggestionsEnabled); } @@ -84,16 +84,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices var sqlToolsSettings = new SqlToolsSettings(); // quick info is enabled if IntelliSense and quick info flags are set - sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = true; sqlToolsSettings.SqlTools.IntelliSense.EnableQuickInfo = true; Assert.True(sqlToolsSettings.IsQuickInfoEnabled); // quick info is disabled if either IntelliSense and quick info flags is not set - sqlToolsSettings.SqlTools.EnableIntellisense = false; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = false; sqlToolsSettings.SqlTools.IntelliSense.EnableQuickInfo = true; Assert.False(sqlToolsSettings.IsQuickInfoEnabled); - sqlToolsSettings.SqlTools.EnableIntellisense = true; + sqlToolsSettings.SqlTools.IntelliSense.EnableIntellisense = true; sqlToolsSettings.SqlTools.IntelliSense.EnableQuickInfo = false; Assert.False(sqlToolsSettings.IsQuickInfoEnabled); } From 6df458dcfc7d02ea063ad2325047a6af6175881f Mon Sep 17 00:00:00 2001 From: Anthony Dresser Date: Fri, 28 Oct 2016 11:52:39 -0700 Subject: [PATCH 04/18] change time when the batch time is set (#118) --- src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs index 17901e6a..7b54484e 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Batch.cs @@ -38,7 +38,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// /// Local time when the execution starts, specifically when the object is created /// - private readonly DateTime executionStartTime; + private DateTime executionStartTime; /// /// Factory for creating readers/writers for the output of the batch @@ -65,7 +65,6 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution // Initialize the internal state BatchText = batchText; - executionStartTime = DateTime.Now; Selection = new SelectionData(startLine, startColumn, endLine, endColumn); HasExecuted = false; resultSets = new List(); @@ -198,6 +197,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution command.CommandText = BatchText; command.CommandType = CommandType.Text; command.CommandTimeout = 0; + executionStartTime = DateTime.Now; // Execute the command to get back a reader using (DbDataReader reader = await command.ExecuteReaderAsync(cancellationToken)) From a27c182a0f5fa9eec4c1fd27ce6c613534d79497 Mon Sep 17 00:00:00 2001 From: Sharon Ravindran Date: Fri, 28 Oct 2016 12:26:31 -0700 Subject: [PATCH 05/18] Refactor error messages (#122) --- .../QueryExecution/Contracts/SaveResultsRequest.cs | 11 +++++++++++ .../QueryExecution/QueryExecutionService.cs | 4 ++-- .../QueryExecution/SaveResults.cs | 2 +- .../QueryExecution/SaveResultsTests.cs | 8 ++++---- 4 files changed, 18 insertions(+), 7 deletions(-) diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/SaveResultsRequest.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/SaveResultsRequest.cs index 369fdb67..85f87b9d 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/SaveResultsRequest.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/SaveResultsRequest.cs @@ -84,6 +84,17 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts public string Messages { get; set; } } + /// + /// Error object for save result + /// + public class SaveResultRequestError + { + /// + /// Error message + /// + public string message { get; set; } + } + /// /// Request type to save results as CSV /// diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs index 9819504d..ea69514b 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs @@ -280,7 +280,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution SaveResults.AsyncSaveEventHandler errorHandler = async message => { selectedResultSet.RemoveSaveTask(saveParams.FilePath); - await requestContext.SendError(message); + await requestContext.SendError(new SaveResultRequestError { message = message }); }; saveAsCsv.SaveFailed += errorHandler; @@ -323,7 +323,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution SaveResults.AsyncSaveEventHandler errorHandler = async message => { selectedResultSet.RemoveSaveTask(saveParams.FilePath); - await requestContext.SendError(message); + await requestContext.SendError(new SaveResultRequestError { message = message }); }; saveAsJson.SaveFailed += errorHandler; diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SaveResults.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SaveResults.cs index 6fd3a505..713eb764 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SaveResults.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SaveResults.cs @@ -222,7 +222,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution } if (SaveFailed != null) { - await SaveFailed(ex.ToString()); + await SaveFailed(ex.Message); } } }); diff --git a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SaveResultsTests.cs b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SaveResultsTests.cs index 161e255b..470476c2 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SaveResultsTests.cs +++ b/test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SaveResultsTests.cs @@ -137,8 +137,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution FilePath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "G:\\test.csv" : "/test.csv" }; - string errMessage = null; - var saveRequest = GetSaveResultsContextMock( null, err => errMessage = (string) err); + SaveResultRequestError errMessage = null; + var saveRequest = GetSaveResultsContextMock( null, err => errMessage = (SaveResultRequestError) err); queryService.ActiveQueries[Common.OwnerUri].Batches[0] = Common.GetBasicExecutedBatch(); // Call save results and wait on the save task @@ -296,8 +296,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution }; - string errMessage = null; - var saveRequest = GetSaveResultsContextMock( null, err => errMessage = (string) err); + SaveResultRequestError errMessage = null; + var saveRequest = GetSaveResultsContextMock( null, err => errMessage = (SaveResultRequestError) err); queryService.ActiveQueries[Common.OwnerUri].Batches[0] = Common.GetBasicExecutedBatch(); // Call save results and wait on the save task From 6937e46c1b25e4fbca85f106f151f95cde5e1e79 Mon Sep 17 00:00:00 2001 From: Sharon Ravindran Date: Mon, 31 Oct 2016 11:25:51 -0700 Subject: [PATCH 06/18] Handle connection exceptions and add error callback (#126) --- .../QueryExecuteCompleteNotification.cs | 5 ++++ .../QueryExecution/Query.cs | 25 ++++++++++++++++++- .../QueryExecution/QueryExecutionService.cs | 12 +++++++++ 3 files changed, 41 insertions(+), 1 deletion(-) diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/QueryExecuteCompleteNotification.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/QueryExecuteCompleteNotification.cs index 90c8c7b3..8375235a 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/QueryExecuteCompleteNotification.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/QueryExecuteCompleteNotification.cs @@ -21,6 +21,11 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts /// Summaries of the result sets that were returned with the query /// public BatchSummary[] BatchSummaries { get; set; } + + /// + /// Error message, if any + /// + public string Message { get; set; } } public class QueryExecuteCompleteEvent diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Query.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Query.cs index 61b17543..d47fafca 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Query.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Query.cs @@ -102,6 +102,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// The query that completed public delegate Task QueryAsyncEventHandler(Query q); + /// + /// Delegate type for callback when a query connection fails + /// + /// The query that completed + public delegate Task QueryAsyncErrorEventHandler(string message); + /// /// Callback for when the query has completed successfully /// @@ -112,6 +118,11 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution /// public event QueryAsyncEventHandler QueryFailed; + /// + /// Callback for when the query connection has failed + /// + public event QueryAsyncErrorEventHandler QueryConnectionException; + /// /// The batches underneath this query /// @@ -241,7 +252,19 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution // TODO: Don't create a new connection every time, see TFS #834978 using (DbConnection conn = editorConnection.Factory.CreateSqlConnection(connectionString)) { - await conn.OpenAsync(); + try + { + await conn.OpenAsync(); + } + catch(Exception exception) + { + this.HasExecuted = true; + if (QueryConnectionException != null) + { + await QueryConnectionException(exception.Message); + } + return; + } ReliableSqlConnection sqlConn = conn as ReliableSqlConnection; if (sqlConn != null) diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs index ea69514b..c7614596 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs @@ -427,8 +427,20 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution await requestContext.SendEvent(QueryExecuteCompleteEvent.Type, eventParams); }; + Query.QueryAsyncErrorEventHandler errorCallback = async errorMessage => + { + // Send back the error message + QueryExecuteCompleteParams eventParams = new QueryExecuteCompleteParams + { + OwnerUri = executeParams.OwnerUri, + Message = errorMessage + }; + await requestContext.SendEvent(QueryExecuteCompleteEvent.Type, eventParams); + }; + query.QueryCompleted += callback; query.QueryFailed += callback; + query.QueryConnectionException += errorCallback; // Launch this as an asynchronous task query.Execute(); From 3c98d03cc8f7fbfb8bf63393b43b24ee557ea2fa Mon Sep 17 00:00:00 2001 From: Karl Burtram Date: Tue, 1 Nov 2016 11:09:55 -0700 Subject: [PATCH 07/18] Update nuget.config to pull private nuget packages from within the repro. (#132) --- .../Microsoft.SqlServer.Smo.140.1.10.nupkg | Bin 0 -> 3371244 bytes ...ta.SqlClient.4.4.0-sqltools-24613-04.nupkg | Bin 0 -> 2073001 bytes nuget.config | 4 ++-- .../project.json | 2 +- .../project.json | 2 +- 5 files changed, 4 insertions(+), 4 deletions(-) create mode 100644 bin/nuget/Microsoft.SqlServer.Smo.140.1.10.nupkg create mode 100644 bin/nuget/System.Data.SqlClient.4.4.0-sqltools-24613-04.nupkg diff --git a/bin/nuget/Microsoft.SqlServer.Smo.140.1.10.nupkg b/bin/nuget/Microsoft.SqlServer.Smo.140.1.10.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..4cb8cdda3d43146b0bef2cdcfb3ccc887e67678f GIT binary patch literal 3371244 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 {U|;vo5&l=Mqu(7Pr&vz8~f zr^t8N`TTPMpI$Gb)9N3f0Br4-E{)nJ6+g5+liMiG>qOghddEcT?+Yw5_6nzJ!q**@ z4ckXWGpE|?pTHOszi8Y-Gl|tzzo||jA?vuS&%gtgH2j92^SH+C+|B+qh~!b^1Lzu_l7Ga7?S8fOFp}}3 z2=hNitkZdX24I~0k6^`A7)4a&+C_cZ`hAp{n!`=oy{$Zk#&2XxISxC9$YF{`Gxje3 z3JQFd+i+fDhWw_x~DF)iz|4jN!x>|yDG z7`dq6^4RbK$a``3u|N&KfLG277%%+sKS4bi7sX(b15bv?{B7^Z*R}5E{?xqBy3`5$ zD`awSR40(cutPGf%heOqmfKDe5B*-?U_y3ssf2A+TMIi$cM&frD4RMHXnhcklX_<= ztR5W*$7nSB)iQS{qfPtNKUmF#l4;=tDpF4OlJ0uzAv4mgh;0R|S9(rVdJh-!tw;v< ze^$S&{wlngzg}$}+F2N-kMtR<=cujYJCcyrVH#uJFeB#ABIffmV*VodNTen1Gv6j! z{s*S}ct=~9IJeyiE$>btrjM%>mot52ndH;1rCmOInRmT_G7Wqat$c^dEX-aeoWqs* zUCK1-25@HEtNOMK{90pq!+$4U#8}=?F9No=mSdrpJCHW7d&61yv$CAm(Y$jn{K@OB zQA}_JCh+W`ys2+9^14k1F@oN_;SD)?W4k{=@mYKO>~#4qwc(^W=yLZ9rpx!J%robp zOY#3%y6jY2N0}$S;4;5YWqxIjGC%)< z%0!!X4^x?sTt3_Kps^WaR66cjuq=08wH?N_4@4a|eqDxT%9?VlsVG0hI@(S#t*0O@-j%{h`mwCl}*S zqsHB?mm~1@Hehzw#+ks}u2T?rPaCkH?>e;$)Y$b3gx1=j=B`aMi!E5YHY4=TcBsAU zv@TF**EwCF>0Re`fo67X=>pB}I-?6Tx9inip!r>|nn|!i&#rA;iRnZS4Z> z+qE5`_qIa|yUyzZE$%uWp?&Sp(yj}-lSiQP?` zsB^&=LVa#8f6*ll#kelZemKytvR?!WWV{>hlm)nUGLTLNa>+nG87O!$25zw&2h1>j z^uynF;@e4lyLvKUBm-tLkSxnh7Us5kcGTzvr9bGZ0@`;4ZM-`D`H&O@6rxYzX3p zz@5P`*90K49~|cIcswnD!7D5TK&0edSmYHdLBG4mt+1B2 z+Azw6g+bn}ls6SBZpB>$Eb>p?g>@{~lVu51$`B5)F*rLVu&9{%lqP!}PB(O8&!$?I<5EL`Ih8Uxplh^}DJ+i2^})=2_Rj zYDUCf;aZvG>>rnVv?k;}mkB9OoLID}(mvxr9;? z{fZnUUI~^0KnM)-GJ zA#58qmw&*Q!%Feroh~|Eo^=S5yGUuh$=G5aNcVrlP7p(!FYPTuZUsC*>>Tw`0|5^4-Y0l!bS)POGX+ zD5pKj@b>Y&UdYn_mSC7Kr+K9Mchb3iT!#uKcc$n{3g2^1UQRtGQ+pYT3qkmFYB7-c`wf3hRJN;dXqNpG8a_~}FjIKIr^Dc-9U{eLxB zIYxY)jF(#P#)H-3L*^B(_NNqb96J-J8k4V2$vY;M1}xc^pFn6DeQxirtHmn5H$O@( zlR73{B#BJe#@>!Rb+oJx=QUE*`Kl4=ToyXZw$bQ6x~Rs{{5l&Feki&CyAHcTpL`>Y zeEeI_svf-tCK%r6T$>W^9j_ID>%{LHWW*by^}PXgznJRA+~Qp^UO)Gk7Q?KmJ#_ah zQw%?YPqT|av4;$4CswCdsv~?~_U07bkljEN?ZbHQAl|#{d(!gL*n>{YEdRHLB1`)| ze(vm+pDa54HXaKbi+;2WiLOjiC)9bR~w^(|S87t&wu>l{aCaC<42qfV6>6 zxU$w$2>gxN$nvjWr4^52Lb5LYNgO+*6%~icGbu1Qoa|*dp*aP9HcbEShzD69|}6|MM7r#RI&k3Uk#^OBr5g8Aig9m7(huX3Jxm9 z#J3dW0|D|zt=;Fu!&St25iso2WHXs9ilwRo8-8_zwWAiSs69cjj2iyVK)o3<7J;{# zCn;pogWRW7#hdVm+@p5`6m|ndKG&zQ0fSrdeVpbWW+Js*3qHw5#J{7B38Ws448KNq z@e(UjU{%o3-541}F!~HGZzI+LP32LB<`@oe(EEWgi{z^Iba1vrz^bQa_N* zvq>DsRv8?xkO_Lx;uf9#_P80yk#RF^Nr!(TT2@H+r5TlPD2Pg$QOSCRT(DS!lWA_M z(MLbLe7H{dB`r3k;AYY2LN_$>UZFQw$a@{_}2!8}ddB&&@O6-G!rb`&{zVI7p(@&x`Avuy&X=0{rC|7zDV_BVj zEQ?vvTq6ecYBV&N9M=OluDJspdMy2gjJ4Hodd77R!)^e;6n^G6F%F9n!r2! zj7IM0dEnK>p%dHwXBb*P-Pb&cmzasaC}g>NmYMUH_L;LvAxFweuItRXy35QtAD@~g zu#{b`_vxJASbRe!G1TRpF>ubrv!kD8hv;~NJ3cuhe%fs)+Fk+n4m3n3W`wZmG0Ti_ z;3z^EeV%57!_{Zd3`xJ6akH{|o2wVrN8HS8)x&`3ftiqVdy+GuN6v&E$luczmz)Xt zzC4eGAqxgNVM6bT`sqE9z$C|*B%l2Jl+G7NwC&T0A+|z5VzrNz3x%>f^^u6ClY4^( z)uS`EBN!t7A4$^x2;Mf(yzvi0{A-r#uaNQ&ydRLdS{h9W7+hL;62J8RX1Q%3AA(j@ zptR{#FuNQG{1gKR>5C}v6AUcS2Pp6}4D{%g-a)pv@GWU?f%MIKm1D+Y+n~VNDnCOV z-~L7x-)CF;!20o28(l`vO3kFx=m|V1cS{6EajVb=8vJxv?09LJ;-ffMG?PsbU))9= z(+`mMaB7eapQ4b<5H3ZyqjAi?TbG;~KLQ6PWS&MdHi<@7 zwP_-+ChgdmNwAq2xFW&piCFw>Zj=wpkM(fEnZdy#md30(g%iz2Z_y(uJkGnqL?g_F zLsO`HFJDvIFa+HK=D6IKELUUG^a><&X$7z`p zgM&iVGM)Fr_bQR!zHb7te~xpZHcun3&55}lo^7C|g=I4$#3$ZV4r%i7N4xpOw z`%J2(i4uvG?^a?IAwK6U5w^8Q4Ww4i5gv-guYr5PMI1}qk|nP;NXY#0R8$-qx8g|Q z#aQ+KAT!ysW-?%uCo{=C#u_|C8<~Q( z#q>kd4GH?`N&4w?(GOW=HlYIRkk0h81^w&<{j8XN!W50;IyKzanSQY!vB#8^X{H~p zQBnt2-(AxU)T_OMbd+~*Gj?x-d40KfmQmGVwv!QQ2fqCEqIbaWR1S_m|9NZmR0@ho4xMeAk* zz(?c5>2NhJ@l9I<#Um8q;JnyTNxH3)8}>z%8xll0HIiT5!cvp>36az-;+MjESPBfO z-p{G_z>hHi%WZk`gP1@y`1gwb1!a%$=U!l)f8KdqyEY^;kZgwef=(jWmC= zl~^Nd{-~c(ZyXHl+pwt+ zM~|6pzN5x5;2&(pEIr4F%(C78NtZBjV@JNMprwhZy#-sHKuVzrqKGaoztjrxxdN=b zi)Ti;{D>?(mQuKOl59sf9d^TLa@TQb=46-~qU(E;T|Z((j?bT+rCch&WCL1CYCYePEP0Q-J2^{v z#Xa)-j?{@MReZlJ_5G#t`wVr#PX5Mmz7zJHUy{5|oxu4~KS)03+{dsFJeV3EkZJIv z9Bzv;)*9m3?n3^hd6AeXG(~Dh!`#Ep57u%CoTVzVE^W&i#V7JxB0mh!l|)`ll(FhZ z2_)8vu{AG2cr6}UnPB0J2rV9084IlekI?lXktWwhey+_EjVAQSl|e=XwnJcg$zZZ& zZX&=`+&d8IRIN=7Y)UOT0J;cuX@Tcco+VjdY^tYC??09C%)?NMTFmxodrL!*PY=c5N8A!Uh)%4zw|i6XQG`o!Xu!=R{T7JR4Wm z-63u64J-frKx`}Zb1+7KMQ_ZDnLd@UcplfRFKBJqsa)h5 zr0+p)p?nK=O1|uaWe|^S9f{7{*)36GW~@Qu@TPz_E)ySVRebm>$XazhIuq+PYR zV;mLESF41Wl{#jXQ*#_P)m_Y4R-%{eKASusRvJa}EShu3v@`#8P2oQTcv4|&gEf<~YaOYWZ=Q-4QWT7WAMO8Z>84@P=dj-t3`itQxv6IXoYH&8XdGGVj zC(&!S^U3=v7RDxSA70HM1&KE?r{KVoP>_oXSIjnAbpbDOeDTvg38OH z^0qqX5r)Cy*;6o9D!?)+A`1S{(jg_ZTHGz`E`Y(vmDf(NfMHo3>C}-IOmR$1fZ`5` zcYn#zB>H>!E|c__V5!8PoV|OS11F2~?A`Ul;e!vlwg=ow#kE~WI_Y*29&Pss8^sPv zlz)sY3|jOaL2FRX?$Mj*(w?dH2YDr(=)~Y+l#8A%F6Gb#uiL=-$;gL-&V?rE`IRZna%>V zevl9)YuDFGVqBIWh83>G6X!aVFE1}!d_y>6+I)yuRXPh{Ep~W6@|RBiDmi0^+hRWn zpVOBN+T`ko&W1CiPZi5d^Z5TUT0x&`(fQe-zuYfOudUHEcp9dG(6_%%DZERm3=&^q zDVt$=`**Pp(=uq&`Zbb0X9}gM9T3B1|8McQ7urr@kq~1(s{B(E`>fmym(8ek+5dX2^qjww zi0l3e9W`=iD%u6s-$KNv9k9~2(UFbW_*i5He)nkc86S_#uEibDUYylY+yQZM2ecPw zb+$pQecizhu38)MHpex^V~%7pxe&<((j^HHC0jOoGOa`=NSBRvVH&onHcw|A2WX*a^Jf3+)sdfb^LctL1gtfmoPW?-L=~kXSY*Ox!+1 z`V*HzdA}i>lEhJFwU}kB_9@~#z;Q22F#UKEuxXl$4$9*F=OSBfqNr$*q;#wTG5mO+ zVtYP{zuGjTRz;dokw59*(z}mB>rWF>vugZM+$RFJwd6{ot9) z4UKr1dvWqpEEM{5igbByM?uhbzSre9(iAa)sm98i@S!j!!H2@DRDV59bW9P4FlBYE zD8cl9K=%YEM>4Bi3SEulQ^MD-Mm|>P?Bh-LU|ePKjSJDUb1w$SyL@{0w#wp7<*~}* z)5y%EABWFP+&IG109-$BmcO-+>W=O&=r{PLuSDP%+$f6BMWa5?Nxk&J8}mo|_h z>(H7%KgvW-Nz%nVDmi3Gm&d4PX;%Sy5A|5l{|TjKIY5WCVM7?`U*Zoxo;$w#OeLnJPm}22nyCAfQU6JL zdem=~-m|9C+T!Q2)Qm|(!lEIuw}gL98VgneYb!?BT#nmdI%}85c!ZG8F6{hyv^Zg8 z-BwM1362F0a}{JE!Gf6iDP9{`H}$^=FYKjsDHFVg>1N(sI(STeW`kqwbL{e_EjbC< z?p(N~X3g^rjf^%f-t72GA!1WTL)SIfMr*2;x2p0R{e6@&w)3j2T{^RVhp@TC17!F{ zuD#YH=Zr=JHe*!>W!rFi;{@>bYIOezD=^U$c&4&QTx#THZRwFW(Qw9rGcc5qb1)rT z!m!HXp}a~r&jNlr!x!T$peQ|xI$T7dIw(c;Mo|aKsH;WP;wUPM!zd*}rivaqpvOv0 zYe0~UI>e?vH+e+%Zna-Ec|g=zwpb#TcR;ks!4Am80r8q8?P3B64@8pYRq^HfmM+vGT zfwrMm!xRBlzZjzJN{QR7Ya2Fds*K|j%T=$sIY4cM8U)dEDSgy`qgBb@`9boYTPOU| zst%Z93crp6g}CES7=2el)nU+I>3TW%we9)Dl@j0C$f2rA^eKcv7ZY%COnt`x)T%3adpxC z*6MX|>I=@}uI=BO${Vk$os!o}&0|%rlnUzAgEdhv=k>M$H-^GjZ-s18CU9jRS~V2T zj`iwR{i}gp=@DHiM!s3EYV|BIx>yT2UQ!KRPBK02N*yLy%fq81jlSl}4=< ze*v4)4(B!8q+wQHE8|2Tn&P)Dizi?SP_H^t#^o&nVyVrd2*LQn_XaQG9&WFpTgh4* z(D2t%Mz&Etvr!T9YyQW`2d8(elpUC_{hwmq-ef{^^mH_sU+)oPm+ob*G#ot+a1s6yDKuGJRXxq4 zZ{m}m)fDBA%!i8w-;)cz_|Z8rtZ6(C8k!!Y46^gc8Pf6#Y2hX|i+=Jo-`@@_H?4(o zKJrTBh<&H7>lq-GPMl3fu2XV)BNZ(%o_RgXnl+d-HqB|f?k0B4CAdE>KueI+-*EUb zxVc^CPMMAEWs`qK_5QNcnQTB zge0y}_2;zO0#`4f*wQuqBPp7BLAslJPV58aW>(cq+whMfVmhN66clBmp1aU1Ua&Hn+ z7o|~Oa!ie58Y1SvIOf1a42^#%-v$hL>wyGE<76!8!68xq1X?|Z{bN_s`|Kb~U-JyE zGM1Vojin|DgQ1uV7>bD`XtI{T35p~LqQ`8QphkZjuJaI-Tc;jv#QbGR@PQHdz!*&Q zK;zj=jlk0Mre^h~V0;uMH89%M1$V*JYUitTdXExlLQib<^XQ&q^EO-i$FSMp+1iY0qhv`8Cr1vT=zST<)bDcag^np~Ozq~=N1tBo9jE~45K9wrNtJBCEU1SHn(3kegx;(=huZGmej&uC7PUyX(U z;Pu{^fYDaAL()aBt!O9BOsr}WD_#RfUs!tVl#E;|+K6*d2bH^1^(P8bHIeYJ4jQyk zb!OML_Bu^B;eI{&`iG+curi&r;YvwT4P8 zycgOPS1vnoG3j891}mE0#w6zBFtUfhqt3I4|BH4vQ%3YowvMcTvWQhin1-y$9{ zt0$;}Cx{sWA+tCE%Ka0`DK-D4Vqnr@T9St~hMVKZU?x##rZ1)4uoy*V9{vqaL_xFa zrA?2MvHm2!ef%@ojuzZa#-jRbxO;CPHEw zG{KZK`%HPD;!S$frZlY1TK!R$M{ew1&bk@pRNKpu=g*$#s436UqWmv1J&%dT3bnf^ z7*Gw)+sCKajykliFXf-W1Ejy7hcJ3=c^3-iD>)%3vt)M?fB9)S=F6L4VtX6KSS)3N zOEfDn_Rf`KXr*Qi*EOr{*uSYfwql-cZq%$XEG8ah$BS;nP~C!P;M+#r}W>_6R5x#C%0uzSizsHO8rLIE`^oIslNzcoaL*Ltjm>+uU4xQ+O(mZ({d_^Sj68`}l1y zq<(TiFlXfpG^kM2e=FACQSVQyyAwABB2FP4dqQ6W#5d+@s(W5BDpt<|Fme?(%P4;^jvkBF94shjn(hB zVKCT+!k|PU--g0q_4>IApP+u8JISVfCmGv!5^vv0Ht##h@_i?vk@7{gGCcVR-rtU& z2I0vc;%8(+CiY{aYLgGA*w%$fKCjr$#-jl9-(-@aKbGQO58p#YH5v5Z2!8?;J1O z%=kwH=8uRpkEUWfBu7Mi#-o&D)Jq5R8KuN?DJ?uMB{YZVd7GgByRFoGdQ&^4xNi=xl)GGLZU+Z$QeD41%W>EB?+8o{Fe z2k<%-(`!?Bol0N&9_HOO(AnkY8to1sm zcDl}1*zarLIj9CkpP7=;v>Y>pW0vqAH~hBglK+T}&-@|IR{Inp&)xxP|JGLC^#P@X zdO_F2>_Wn*a`tmi@d)C17dx|fOiXb4ZTRnlGAE9(@L82mDruc}C3@CC4MKlAsu6C5 zJ{&&_S3F9`;}7xWU=TMBpRW-FV{;gkGiDQ}Rc{6zGFM2;z{+`=?Rbm-0p*8J0kHKcR0Be{ zGkb_=Xcy+|{>xF{L-Wr`NqvEZ0@u0fuU0khWR+Bks{5Ts=%7Y6e56*+iI`3^!hgWn zn0y%o^jb})W_T-s^`5|Zef&ZTVo$cHr|>7d7y&Q0*y7Jg7Crr4IBaN@%*u>b$u&%^ za^T)nwJgsS7XTgh(i->*%rt>nQ6X$%ldb5L`AxhtL)aunOYp$@f5F=|SfR9uF#ue$ z0}!trpmJyjhWroFlGaveIUP)h3~xeTI!^8UAnQ!5bRZ7{CRV_Ay}~d`RO?G5py=9n zM6w}~j4EHMigdGAu1#!?aD{Utg=SBl8MzkK065Q^=+zs{${j)8)nkMZ#>gxYU`D!- zOvG3}C{wPKDG8Bfs!TdNCZ@FoEr`@@CSG7NR#}x();t~!l>wUp<42cp6Z4+p6iF@EAV@I{6(Q4N*+si&dBvaC=O5K*Hx zi2<%}Vbg|Xc=En9DY0$h(X&}rJW5Xa7!j;{^lMSLU}~Ij5<{A6PGW!y#fLnL#-gX2 zS%r;mR^WfIT&p;fm?)U9E#i+p820>S!{$$4b2brefmkz|XwB6`tG$Ucxp8}G%1Ck1OjadIP#JVbrsG~A{hCxufA z_ha}0vIbhnoI2P+lc)<)t=Z20RLZ1dY@)fmF3*@ zLc!A9HSH!5c!HjaR-M@2YFWAXjjT5*eg8x>+zi=|}q1Zj+cjnMw0OJn)GyX)rU80kU&ag9yn7`tFPqxjm2t9WsQPSXYUdN~%7AUU6&yzzUX zMYr;@!O1I_>LFQJ=NI9qn1Kj5Ifjn>4Ec2+V~m^RFk%7?xsA1#$*WnqzeD2-^8<3 zG(V|XsOvunn25=4&FG|Z5+6i;_z{U$7V=#Ywcxz=emWrv5;=~S8}U-P5x2!BH|1Pg z3~kU|yVD-NM#yA80MpWdcEJwde~gxG>^|n_c8URKp_ z!r`|}vIj)8^GI4$@6fFqge!1VRDr#Y8y5K0+QTyD*; z=>S221J_KaV-*hE0pz3Y0iq_&Uf`OI!YT)3|b!s;L( z_@uCq(JWWTr)r2NJ~ad6a1_w7E9+(#jvZ-{#0cgA{P*GiA@Kij_9 zvEXdzG1J>Vtd#@36r^A*1t&vzg(d<=ibx8KKwwD51Q1v$V-|^_A|vx0Zi;ww8{N0w z4)r>-%}4KlJ|CkU3*9Tf)OI@dse&$e4K&t?E3;|Q1R@hDC7JwmT&UoT3~cn-ReEzN z_OwrVQZD{d_`Q|xA-zo7vYHJVmc6NbR*s=g_zgM)po-CF;A?qZb<*AtzU0gVx&!Gg zd*yfezV%2b^Dw^qPnMVo>Y4>5W*KTziD>OtlxL^C6_$+`!vSnGV=y3Ae$SL=)fdBW zn&?csK(T!f7+=E+{%48srDhsUW1I#gu<=&;bGQwd7AF$reGJbJDJgfVAKk;d1U;-0 zXak7smOgH>=rnKIu$R0B=JPGI4~i^94nViz#r03jD&4B&X66SbuV4Vz(Wg@Z{_V)A z$HnSg>^Gfodn5;Z3yK|LyhT+S+1IR&|Bz38owef_TA}u-iMkgicO4N! z<2L*e+Ev1_5+kBAB46MvR`?jsTH3%YGyE|=$0T{<$`qMZb>&HhRPTLbvn7+IBad~^7o8S|^wKLbRv_(1ixXA)8R%+z{&Y8bi0Y1CWJ*MiD*fZ5#q66t~vxoajqrZDoux~e1jf6z_7__BbaxMu_)r;|0 zyDbtSF@LVoI!?aVcwIB;_65sI_bL8)5IVEEO4alt>TZ1v^PQn;d|Bat73mql1^rei z=n)oewvhw?>q8E!A2=+l^TZUfRzGLG8T8kg$FY0Wg@Ay6CR!~EEqOWGx{K};?l;?g zpF{nt6#S`tWlPQUKPv7Y&t!_>>WxzHS6gK0{w$iOi2b0NH|nNQ+?#@(Wb!#xl^w%IeKh7Nm;C^4$i?dYsUzGM~XB7*T9~4=#0F)n?)_3v7J$Sg)Zl@VoXAhtnShy z<`kJ)-v2(i*JGD2KQ`GFO_{&wOnr=4`&!E>3VeS@)?pf0TCIBbSjV$u@t(F01P*Z6ZG$X#e=Atb%KT5yItn_ZFrK5Ctv$A+g z&6e@5UTPdfFU^oiMa?iow&cPw`5IP6<*jHFVK1!Z9zUzK+?dB&rQGv7>F-aAbh+t0 z1+iBSZjHaEwYI86>rEMX<6m{|iJl~CeLd5!HZo%q%O)sm6E9QVlq5EusYqZ??bA$Z zUZ%ZyYFSHct_#KZEvRMAWzo!{{no1{K|H2&oqG)$9T9S>T<8AMJ?`l!?i_Vu8!{F> zq75hO%vO4Eie$9%`097O70s*7(R9=F#B@8Vb^cXtv$A?e>yCDaDvl|5G*eOS|1We0 z@T4l@bU7zvHt2rzv9VLE3MG=(#l~C?^Fh0 z4E_;wX(b4iWr&=PN-js8C&6Ov4J2N7C(1TZ(auDn{ByKEX{PS~8XNe1u`bxki7A#F zwr+cEB3~X3u6fg6-Ikj`&yftSwEpjSe^Fll2i(@-_>3cY^jX^DiN7zJ-cT>{_*5O9 z60-Penn;u7H1!pBsZmok$c>u~-Z9Z)oY%wGeEl=W5fNb+Qtxc@p zU^gxiO1XCCw1u??OORz3blcUN8Fj$bZLY#DH3!skUKd?omMJCGqlE3Wgk%;R>0{b1 z;?c@$?+%~~9LZe0b`hL}2|b;*H)81|U@~TY1jj(@uw^sMjyVRC^f`GQMk{7dXjXV# ziXOC!vaXVa(>_&`^Qv|ru=E3}8NLB8Gty`bhyFHIQ?Tse8zE-+$x?MSKGT9s!Cn<- z+c3LWyqcI(shv6gCKPjAk2UM)0wB#s@6p!Qjkp-B_0);$Y1@E5d(n^>1-0-d!J1RZ zH=q`hJL3J?pLqVig^7U)%)Zp#5^R(6t?;dM7{{{lBt?H2iW$JGfT zTfRBDd%8!KJw|0eA#k-+%YTQ!O`Zi#xDZ(-UiW1GXz5^?Y!>1|4{Pe#WJ}HR7&K$$ zV?;0H)d#SR2``hd?&y2aV(Eca}^blM)ZDAKKs98I=|iyDVpkrT*Ci)3QEERuy? zX-OZgOJ>D|QzcNED?Q+(b9#x|W>K{)MsEkp)B@3A^~#-=^b-k_aKcjfjr1C+XG9=5 z%jOHw;zGQElyG$Z)aeAfhsUSS4R{jQa{AYfl$<__=NoLI@6)NG`^5Y55mSnh_KF5EG3iZK(X80tkhjZap!oNn2 z%79@wNS;8#A40PFzm=;OilWHKdsg*JfL!>nNnU%npMY6X7Np3Y1jS~o5CuDnb`*gl{*cmxcGeomdJ6@*tm#EUU+R^CsX390mb7dka+aR8g z7BHvqniCVD>CLyHSxjMn*hTBUPez{D43cc}{RhOX+d_{B#e4(SO)+AhAk_Gi&?y&s z=gR2=&6h|YRBJTVUyd}n3#nLV5@_Kk(D3Ge<90tF6MUE~rPH_RFD1)}tGEfm4U)n> zae83CU6}gc@O{LU@7|WRX;_nUoz)B^qw&@ZM>(Pt$2Hpg6UhrKd-yBtD90Jk(VhJN zrUM*a7w=bA{z-}a2i*m~i)fADmP!9XaF8Bl7~8oO#>%61ksTp&8{}xxMEMQT3ELe0 zns5h3&C1Sbl^HApDp9K}n;T_`Mp=nQ3Dc!NfJT{JyaU*>O&2LE-p_54v!49d3?~LS zFuByjG)eiB7690IaSk4)L~l#VU3~pSj(whr9Q*9F625!}Bp+}9l(UI^@|>rzPaf4r z1FGphMcaWOGN;PEcRmT5@H>>YX}Eh^xmiery(ulMrg)u2Agm@FN!I_fB0x@aiuBe6 zovc-`Kf?gB4d7jb%Gw0CN7@7gBP+!?@LP?SiboY`mHOB8PgB@yFNIpGWIVx9v4bpC zr$rf;$#A}E{2oX3{0Y}7 zt#$yrO7@2=;WU}>6@EC$<4M=L(CZe*pffIkP~!6sMgma`NQA^)2DW!G%7xegJgp1f z@H&`6b(IJS?Leg!|8)F=l*|Zg!JKqRwS<4?SQmNaeQGq1a6axj3LgUa?;^>RHw25s z&v8By*qoa9Mw;%x{6l#D8Oi}VpZ_Yg8-ImLHC}5IAo9>><=`K`KS!qQTid&V`&*ZH z1J7&i>INQYUEd8nzxB>;;03J@bptPK-PsMisP$ksaK&l;xGOx}db%q-)A}94`#Ry- zmhyUl|63~tB>$tA)zSbECKd}>D zXkCc#&v(L$tt%0}qZ3|g?MC<)I^kYxs%yRF)~#LP{jEE?!soT_?+PDieZMPwe(Tw; z^jy&TJHl`8Ouw+DUkmViJK>93#cR9uZ>2TZHT~k&imvb_t(PJE%boD0txLP6U)Fk0 z*Ln|VeX(mf%Ujb3zo!#E*m|yOIS01>d~G+n`7QN2fZx>#Kd7|;;a}>6S6c^P*A1Vb zbppb_*bcuMmk(eM;M`d*`fDt@(}IAP*EvM%>^p@l3AX90EjkCCgzA$ObW=Mp`7(T~ z^lH6QfzW&oovK$BLudhqUaD7?KxiR{R_m3e&9qu^I2h=ar&HJYL45DmT`c z<6qiH@hR0Q9EU%=SxjIH=mqWMsr1wf|Kd3u;r=%)cDq>8&2TrqPvUsHkz+=T+zSo= zTz+Ile)4n2HS7M1qJBIT`tVSa&770Grm~vNUfeABz`U`hi%Lw1OqkOgnb7G- z2m_}`IuoQ+OMQYe`lTcnIfWZFvq!3e7Lm00Mij@V6HqvX`~ry=Xm!*7C1-ubjN&xW z+VH)IExXiivZvu*Hd}yKVy6KU&wj|8#R2%9co1d%FDBiNUN!JySVpECXe`w!o zA=w=wS(7gBsndy7?-K!qEEDXoNONjuJaaekycx4u&j>YktJjN3qmmM?ria&3U~?R( zwqVeTr-<~I-!}K4c4yzo7={#;#f^oWRTLnwCmbj@Q|c%+ypF^m ztVC>A7LOl{szuf%$bQuNt=s6=t}J1AWhwuv{xy(of#r>F#rCSzK@`tFiB+9!)KMLV z=coXiKxDsagl~+N{5~{hSHfH<} z691>*{|@o}75IOzMg|C!!4!YX|8O=?M(#w%VXFUHJQhx+$Yz+H2$IrB=E-j*QoS1> zdg9xE4<-3_5UO9&BNrVs)q5Js_Lrhb*83!s%J}jvP>v?OESYUNhEbL;aH=58majU8Z!uGX9 zwr7Csx>DVS`vH|w$CaZgHJ8};OeCcH7;CVD1j??~g)WM}wgQbgb}gDWxk0P;h#zik z;#H!L`db9QCq!H>44+BD_;6UdC6v~e5f3gt>oIUOUfHnc<8=qERa41lZ>54iN~i-6 zrMK!T`Rp4BbseETk>ED~Rr1+45$a+>9f+uCYg8qleKVoXAk;yKinT(0q0hdBP)9U* zO-1TjrT>*@sd4&|Z|fQKV0CL;wQnVsaZSN?c>%w*#uU0pvExkdIk?Gc2vR;+K)h8( zc}AFK-!Dn{dRK_CRS7Zne@d|r#lj?76Ds-a+bCzBM|S&gL?v63D*5c&5jA#(VjqI= zR4dE^(P!U5@J}lC!3b||ZC1%=-%0RUW0UN+VYnIVW~Ysv6gxUQ_~ni>C+@4@MG{bD zxQ5>E0x`dYAFf-czz^?j%*Gqu0eDHk_XxrF5b*vGe3pQp6N1kbaF}n%U1;+xD@nb$ ze$REy`YYB;u5;Gg=yuKeH3gHiUL$w6SwF?)xcFlEN!+4{1Ojo5ik6P>m6^0=M#QBb zQxo@dOr5kTKDo=Dm>Dg`G;vi(%bPL(W|5xP_%?|l1^^D`@s+2g#U2?i?s&J9BCbcV z@n%l~Ca8_@OX$8JV(6IAUh259^Q!`?`<8~(|#5KpGLP9FjOfs+AfbS|3L3z7U3 zT5E<-26$%mI)q7drjv#qlq#4pOZUL<6!^UdzlAdMp-H6=`V9p9=P1~+lJu<1VN`@y z!0&eWb>q+k?or6|7lk%BNon2%{az3F7t*7r0l*quuO$aIWqh8y13Y(!c@VJXQQ}z^ z;JGKjb5EED0c##6o^pWa-T=?NVIBmmd7OCunf7@$2YAr`BJm^#UJTG|3(%ndXKS7y zntKB@_XTL~Bbq0PW?g`0Sn_Gm|KgfQh-P_!=IeoYXkfn|^L;qc%?;3fBS7~JD(hoJ zGd@6bO@QVaqIrnR-|Exc5XckyY2P$C@G~UAE3!?+$@)rMnisqEt>|i7X~X3K%+|3K z-EBmBte_>HZjEU58rlniHk(!lK8rkr6*Lbb%?hGff;f8~Xjz^9+uIR$E8*r4Za(2? zEPM!YrxI=w;SL}i4TcXR?li*bggcOMG~_*kxYG&u2NQ7z5st>ZM-jK2a6cm4CkRKQ z=wpccG~u=p?qI^vnD98_DunwA;r1sS{!vT%P4t^ulW z5-5tJg;v5Bi(Z!K=8|-%n986w>HuxANN6IQll>TeUr|2X4>g|aH{tgmh+|mrjkVm*g_e6R)mVeQA~e{|sgUS>+ZVkx zsm5CJ=R!+8Xs_f3Vw@jJdaPEIw}j*EnLlu{v4f7TcEHREgjBRpOaRPknl7lLYfQUnL%x45`Z>__$)Sp~`@1Y*1x* zi3VlG8%YV{rqO@t;^@ zmGP2L8862|Dr1MQG9HUHRv9k~mGQM$W0moeP#G&@A(ioCUu7(cHC7of3ze~FY!@oy zd0%BDV}m8VJ-hqp?6OX&_Ml)x~6!NdtkpU2iNy3qOi4ZzT4+-5XzREM7pVOK7Zjp&OHjPbmL)={y0wr{{lXV2+?Yq9dJm*X>@e8EN{GQb z5v6uv$D$>|@Qm1#;LU-w`P!SnD{Hzj&OS<~GxD^j2#D|h7m;2LycWi)P^>#uH_~(e zi%4gNB9+}pC;S(Y{#p%18mNKqs{i-#t_{Vj2IBq9e-ZDVDmRxRnoDsb?N&qkSt5lN zkwTl;no4F}j^D$o!*T;rmYV`G^G)`NI`<|t?svS7& z*F7E)L_nWNO1pFVu>L{ZR%A@Kwzk@@gH#j~F7mgy2_B5?gQ|5582DpMsYU1P7&QO$ z;6;-^(ufqkhzLLVU!qVl<_x)hRqQ94c*X}7dv_d)_=`{?D`IVHP$EN=#L%D=?XuUg zM29LGI>4m{rGu5a3pYcBDQH#2-GuLB+E+lrGkyT0r;$taPi~~aPY@b>8S&uWXz`RP zE&T?nyR?y;+~3-owtwZ19n+8_H;KS+`omZUfx8L(Yk!25@m;jEQ1^JHq|tD3JP#L9 z!~RyxBl=AfZVWvxu?Bqrry?sa!UK*litG5u#7F7P-;i8UN=8;-Ea|wF&J+$e<3rof zpiyRX@cUnRy6A?Y@k$dk-||z!SH`8NX#GN`naM6pXUq&lcn?I_cVj_U>|bC$$C6XH zT=pv%H1VXl!tv?;{(LlVnt4guubcPh@jUTZn}*%S5HIjN17O~%)=K27X^N@ zn5&@$CYXYf@mpAZ(rw08i4EblOKhEKJpAyaK7NA2uL7k|T=?59;Gf1j{$$Zd;t`$s<4ke44 zu?q3)Sy~heFZ&I^uR~M`wpkziih=a7d8WW`D$+yVvEbv~qQ|N9%~X~Y)C<%?CsjfV zl`WUgO~~hV%jbIXx!!zkay~aHpX<)&y7Dla3eN?qKU|%#9a*Mi3 z@H`$71)3`b%|=19QP5oJ($Kk7d^BzfeV0l1x2W(ho{HF$(KNiQ!mefM^m~npZmdHMOH(?tsLVT(%rhbJ_lOH;yEL`V9nuCy#8o=6(RS zB3&y0Tl1i#&cgFKhP@DCPXgye3k?v^?VQy3d{reVxz7Fw+V6{j52NVp$0%|W z5jqi}6A?NQp;|6IUDtD&spQX01%G8`Ca)njg&N`tZior_Xl@EN@RTyN`joPg>%se-_F_aA zqug6RWHX>HxJihgl6!B_JT$P6AGvJtn;7u-1pMQL+bw?R?-W1uXT=Zw8R443O$j$H zT!RwN_D@2E)<&w!bVWT58lVewTN|n`&~6GJ2TZ9pS{kMMOt9FOcB6A#;(XAT0;5u! z9I%R*67vf2rBWU`2~ac9MwNG*=u6ZK>6L?0kG2wb{7dcP01*#8THph5^|VAptL0k# z1C(N5Mq`L85SZ5Rebl8o-Tm|q8Wme)V;D12&^c2HowG1m=PYzrWx`s>MC75R!V-LT(Y%Nltd0~d z9u*qDa25~T;{1*oG3ac8y9CHvKKy%XaM6*kMtERDBp-G0X0-BsRh<9Gb6ukS&5uF* z+H`&$pK6F{*@aZzxMJy+R(T62YMOP83r<-0ao9>n=n}ndMmFT~#`)3x!LnZ=l z2zbPdXnntie^b?{H7#PQ?R_v6d6DNHXt1qt0#PpMpXXi)(mVIl zh$F7!%U)!}TrfQrq!#hbIpY2I-#4u2;O}s$jP_$Yhp}1mQEU2uZeezHbb9+I>RNUY zhNJB1?Kk8Orj^@;n-y*syJb2?n++k`7J6gLdo`@5ak#y^Ji#MUOXvE_{yK%J(;vRcKEK& zpGbn?FK%@K!}wh>D0#Xob~5ICk(4=0()m0J_*Y2!9hZ zZ*}Rxf4fT${%uT;^_2ifp6W}tXur&_r$e-HZZ*9ts)-0(ux$Sifel))RMnnBwKoF| zVnu@$h`MP89_uz$u9d%HtzfL_$ZHoN`>txzW%^%adW4w9j`&ar(J&B;WHfnr>tM@|QIG9x{F3d-Lx z@(?Cb(&$!NoBFzhjPs4$k-a4STXAhn)u_+sbYkU}(LwrJ& zvcqhUt5Z0me?v`zrO%%r;z^1a_|UE8oe#Iq)g`v!f;;#nnpd1+2y5dQDHTgZa=M7b zoj347s93Ip>ul=5QkH$?@fv&NA*wox$+wdn8=DZ!}+N;$Moy_c+TuFuoGJMKe3QQmdF7txvXn1ZLy`whH0YN~wlyxb$slfw`sj+3V} zd^fB5G&x=|{*LCJCO?&CCUjVrhi$UwhhHnEQa%umX58?M{8KvHg$h<19s7*KqF=Us zd)&HT-U$*c7?OA%4*CnV;$l&dglKtjB73}S{~$(J;;Ye@F**!h!(fT+4-SJnjqcc9 zpo<%Kyh*0ZTX`NsyG+GqnRb=%`X6p80T?x5ak|W-(%-R8#`c6szuTS$wWsVKdo;LB z1CR_u0%abMQuC!r*v2!x2dvI8*v3E;O}RVRPA1l^L9c7Y(3aB~ZpR{o#Do5mQddKP=pxYDarXgJc=ypT8iAXmN=sM(X zm{;d|%Pn$layc&NCY3cg$Gm3)ZyWNqAa5L~b=m%kPUqfl1>9uBJIWmM?!H|RGToSXJ!t6E^ z+hzpi5Y!1E%=rY&c@L6JK{D~O7wS@Xi$u;HH+(S)ajrc4C31_ymymnP@R!M*H+(6% zC$AmGCtI!%f%7nMm8XKCSvDBrEjHA5WcQ-fYQ)10NTA19{+Z)mtw+k{3uaR4c!jDj{XjP=nn97 z^|x@*af5)jTwx5_L@Zv7;Mv|g;P<*jw)CU};RlLDIv;*_(ynmxzAxjRWmRS7qWyhx z*1nAj6wa~TW8mp?5Dg~CwUAqgXVMfHg}_*|r;zMFaL#ran;tH!JcQlV)J<*B0D|Pe z9!<4X&qTFx4yK8viCA`3;n*-3MZ2jEo`hQ$13!>HEKirm^R*An)9LaQJ{@F0Ltz1y z_G+dMkE#E|GmUeZ_xtaY6>RE>GcS|s^kmV$KH>JSeK{^?1+0$--wni8 zCB3wiXZbaaZmXRIc;Ey`urXaO>JjdVggJ}F$Knobe?#Y|7m8_EsM9tCzK6gk`!)MH z>QeR=aOe@ZbWHS@*w7!a{VA_e`i@YMuz$tPcpHpFX579eSd4Z`ZD8BKAO|15WM4pX z7HGX%?5An=8#>=&;z|wbIs##*C6&^`wcQQtY*rv5+`qSo`d}_!Iw8tQA4QU8(o9tT z2X`=%6&XqLCe~|tkPfg`b2kiou^a5 zJT;rmW{UD8o6VdYx8lGOKPf2H<)o_6m>LZWg+T#o0Z^7fOBrNOfxL@si4GwUy@i`hj&Jx9UJIYGP01y*M&(!S_U%+B%Sccdswtx70FdK_K&z|G&r>Gdl53q zLpZ&#HuJzd#1jCXPoC6t#63;T8CuUr@O@ILkLJ3;AtqIxE6M|%>(?B8-2x=Mk%mg3 z7=tsgqrY|wsW6TU4J(SVFEox#-}T57uNlT-nYcTO?V8ogS8%Ws1>ub1_M<*Xm&c=d zcdo5VKY2xJ=J$S7`b5QcNU!2vb0rC0OdCdzwi)ksqR*NpXYztb&}?>XZsff<5RqHf zr`gYPHUe?d9E;*qMulC(b8zVe?UISrO8uQ!fH_At(W7huUB>zVmvCbD_FEDe3!+;^ z=xVrm=k8oIuU+i$rULH&?N1KoAh&^EoaS0N4eFE{2%}_luGaa`&9Z$nCe%gbg|k6k@4|f( zFWa}!NPy_l;efsq(OKEv>Vb<N@n@oM@H&yO1lr%WE0i=E?lfBZ*F)hOaOCn~pI z#7|1(g*g$qw6};yGxqZ9qH&COQj9PGaCuef#%f-dRP8UjaiAsb2@%Z=Zm7Hm?PB$X z6R8eSKojpVQ;bUg^&Yfuf);G>?4qjK;p<{$5RA{wGUfS(>O40}+OPCU{Xee@E+70M zv-ARHNozQtB{XQqbu|@{pU9b<;?6;y1b6R1-o3WD8{(L;l{OeqR2n80_usNhSjmwu z8uX;WqO=+{)rIX#(h-ATX5{ie;I!|LF?>$Aasb~g)=E?5D)c+}6ewl83j8MoqY}!S zXgCZ%hbHMOEvGYmL*9KyY9P?>=4!QLY+P6Rr}&lM<#&gckQ}JGQjYuWvF$@P&G)G8 zySabNc4xH;DHyT$-v0se;pMKyZ;m@qRDPE4Q*u4iA_^M%w&+}jU7k|Ci|(@bg6O!s%p)a7@WfTQo2B5!o&AZphyyx83$zG;ikr z&+3rgLDTR(SNh8()}oa6TFx4nIpmVL&cSDsl6C_Dv(82Wb_ZbX&J74lSpiswb2q}` zxrqT_CvAb{l3f83INAB&ml0;5rB<%9#$xso&YcxbzWfhU_!Z= z^9n+ngW1f*owqoj6MX1u)OBbydSBl0$EBLA4&yRJjtt|H4nJBwi)NJY$ijD<_+20s zZzhtF#`*pI4Gx!fsO1=2ynnH;8Ll0Ml9`r+Vop*5#cOBYi|04pHJDp#W z&dHKd^Il6HwXa3g0H+AtUpR|5 zf62|_lN`^hjpAAE>};I+r{kEfhsnxE*G{b)y`0+P@q~++}BzFTrfz=p6V#gsS~b zF8iu4H>|>|8=>YpkAFGTNPn(FE2^;l(yA()>l_jWIMsj=XWgZN*ec8X;ys4=?>V<# z>epsXBlNbbb!y~?mwsTo5#=+EbXg#B?($yU)r-_Dqs(M`IOj}c3Xr(%prE3~C+C^(ZGIDog+E>?vI)l8np~OyWj9S(RHP>0U zHk6wO8q>bCwkkJsoy58jVE-`SylTLRbMLxf|C{4CA8AdA=X*;evCr2wd^f6e&yd|+ z5VB&0i6i$JWC8azaMUjQ4v3}{l{KO+q{vJnk-*&Z1$hXe*3^VNgzRiplHc7z8#6Ot zUP-h}w|VH7xbW?j>GDJs;tlxU=f?5_Ue4l`jZ#X^@>ggK6=pCi*%b9fVel8c~icah<&(xLGur;}()Uy!(_0Ip2VA73Hre64yWzkW)q0A(@p5=ZfLJ0o?wnE;}6%mgEp;G4*TcWJRgZT&^hLu zfjgWv*~FKN-q*>FeZWp8uLbZ*%Pf$CESo4THoGlK$G-7-vtZ}@g=ah5wX2QBRhdQG zOoyCG{;Rdb@%mQB1qSGtFg0KdQmpAC?K_Izp?m5Wn*C3lf0uO4ew!3EmU%>z@VvUIw9mR3P40Eh z!X0cS*TS~S7DM2#5lPx9j(QXnN%{-GPl6v_Q^QMvr6xY?f^@$H|DOcUu6}6OY~WAe z0hQwmXH1A^8lYRrWc0t>Be8jnuK6&Etaks~J^PxkDSFm^6$==OI~Sc6*E-5+4G)wR z7Hhdwd5V^6E$>q}3?udKS>`c>`oO){n|IUnPG0Y9@-77c&Ob)yfkI{j?H`N$gjG)7 zhh68M3lG4&v*-aB8q~rd9ULshP(lA7aG3)ze3K%hT9|LTO`)}Fbem!ns9kIp{Iysr zi(977%746!x&uTc#j2f-Ko(7RkZ{3*uH6UJw2u9>s0_}x3f!1$Kj)>YeDB1=*k0l4 z6iH;3&YX!#&2j@~7sVkb77YmqP3qC< zB8R%MFgjh0>WdOCg>F=S6>PE(*-&o$zvPQQbp~x9sj_2;tydI>(b+s=q*?;ZNG{ty z9=d#gha0`BK%PtbhVldViMAq;3^te%Qw<>Uxs+f``4;(uj0hw-s9|gtjLp7@{~#j*={iH0 z5qLfvDDPHt8AL|-V$iFqs~*}9MVGEENiw~uW6<}@lf_mOo_{SYb30~nq1!KuhuMF| z#z@VK zcdB?({ichx0Qslthy%!}E>e`=CGrRcBap{I4gPWWs#ONGW^iP?3GWuR)(ood8_1i4 z=B*ud$Codx1?I}jYk@uGqicZ^%KO#=CzcDfz)5AR7TC+jZD}n3dYwE@sk=t1Srrxc zZLlhudPu!_hGxIStB&9bq%ME8%D}ozNSDfDud`+C7kIC8C#b(%r#~6bT3J7k$qYt# zcfipu2fDP6vaAk2P|qhg+j;M^+aD3FY&PRX+~K4!;?`iq?e(H_89JSAVCeK``IzDR zYBJnKdOg?Tqq2};FW|EW-pgRlZf7#)Xk3u9UJB!!GSX!NInUOsy7A6zq?@v1(5LJ0 zU#HkbPI6J_IAom=teimIR3{3~+DS{%BDaUmnNo-@O!ALO=S?DG)%g+b?4US|jUw!5dXT*zIW zNED7la zX?JdCPlvOeJ)O=|?CBzvLGR5x$B=O(;`E}-WR5UL9gp6O*~p#=)K%$KnB&+pi8>#> z`*I0;da1k7%PuG~qpR`7lKf(Kqbf4|Yi`ir7~-3^LT3Z_3GCfuhJVXl<}CwnV!5wD zyoDN2p?AfgEisx>UTgeNiL8nDNidc|D}Mg`wc)-=@)oIC{Eu%XAl!bFwJ^fy-LJT; zizi7itNbJhgNO*QCAk|g7!~#>OM(g1fC>8ym*oXQxi{;bn2XmcnqPuE}bT{O0cJ=!*w9e)FkYw@p7s0shkbkTj zME`9ha}P@fxj2pLm}HSKKH^4Mk+T#*;1QTOljys61m+#L#`ApsGAngVle+o*r6L{f z>Yt&vYtmOry)wVWVTx$*C6UTXUMhw2u83=E_(pJklwtUsIWf|EBvr8t(f;6vARPX% zgdG>1rIF+i-R7V6YCT}F?4#zx$Wmtn$Ax6 zyL&fX?faIgw#X`;q%fj}I1cd>s%S-3IGlIH4XPHrL1p3%s#d%~l@a&Ca-Dd0tE=2B zcOWk5->#ZHPM#K(a|wQ5*~%XykCdahBRyTowdct%Z{&Gvx7gp2N2U_Rv>18h&9Q>! zya=i@#`oJl?~WzKwKxOl-LWYKT|zIdNITtv|bD`hpiVw%$keE5c9&t zVu)F=UJNnEtrtVg$i-ra5uP6U6i!3TTNjHV=I)Ed5OeZ+F~pp`UJNmpt`|eh7WVAs z+>4&o*fjoFqYmS{G%)1gGc?f1?yEi+ba&^MgMuL{7fO30C4)63!T6r3*e9I_x^!Rs zE`q8yrt-~Ap?H;fc=!Rg(r_0RZ(X5n%z@QD$EN~*1HYfZ4>!s2I@kc7 znNYW)5zbR+-z7GHkI|@G9}Yl%N0560ke?Cc5rRBIkZ%*@F@iiskZlBch#(IUj50lxFf7I|%oKIDYnB%lO$4%!dl*0c|a~FaUB!e*!~XoY&pY{q736ZOl}_^aKACq>r62^ z6pni#En+VO4YU+8q9|6-dJ6wvAd77ldF3|&hj;9=0L%`54D)2~8OQH)GmsK*8sh~f z#XijNzj31Vv;F9<2qM+NRv9m&D%xNgJWRR3WmE&eW85SZdoMo?7%T^(;#M+w_L7wq zD{-AcAwbV?(KD*hGX#33i=J79o+;3nVt&+8rpKKpK?&J+7&J;zPMp^PBHKM6(uzG* z;yco_-1ufy#YdroWIP+7jqF8Dd>V38gU*m>X2GDnv9(VD--`9nGE)N35bxeT?|6A| zf2^!B88sR_Dd0aX&<1;fJD1wPOPo`>96x+&#WrOn%)R7d653z|`YI=LL!J@$&L(0U zANS*^&Mn7rg%=0R zhnXfO_;gb)!4G^9#_qw;I$@xq6n74~5*qL}(SWm~v{2bM>YgW_1LfJD`z6v>GT1LQ z8rbQGwr(g!r44|iH1*f|-jVfSEVBJs!6;Upq5CoDfV1@JZ$J+A ziHfx;&;Jg@?`tr3UU`&6251af8~kn(HR#}v(DCgh>?d@>T+wG_vgSzh$D#eGwzAaD z?l%go6Sl4Ji6)n3<$07!NwYtXy+yMxGQ^teX;8uk0UaS?TBS3BO0EN9taQS^_`v6Y zK(BOxKcQ8AqvHM7kp(ahH7eamv>KKsMrEAL&$ij)!BcFHj(n0R5WHrZBy|y4p@re3 z$OU6A%y<+r=4u#^3NiMC8ILB$o*KrZLyQx`jK>h;gc` z(i*WRgQuiq3(WyouPna*36@idWlA-Rg)CDVv7AUOyVYUYtr5#&VzKM6*o|0DAeP7cD?{7rjUrp|;099#J_Gm=DM~M7VBHz=?opS>L_HqFl zJw=ZK1v%s`0c*9XOjXiBO7Y-FkTpNt7uJ1zEb_;i$a65&|r8CEqlfP27hUd~W2S@x0tjJ@+zztYL z;NEPX!0s)RT}oa0I4F!myg4IG1P|ivje}{;Gki#tzl|IUZYoktg1_=PjPNj;d352~ zg_NvR+R@J1LVy+8m5PZ_e72kby4*#c_LR2o810B+q?PU%ZMlrT{@Xts3^Tz7t44#X4i4!+{?;@-5JVgC)1n-ik4r$p%_)tfja&Ze~f3$wATSDdt* zp_160aS>PHG-fWISicO(wrIH{Sca%yhC<;3vsy4xn*A2d*oQD&JeA4F0_@?G9=5Sw z`7LrB>}8-h8yeTX3LEzb0%8-F+GJVNQ${M9irHU7+>ueTlIa0Adq9|@9xB{}g-dX< zRr!uYFUXimWfj?A;}0%}QbI^oxzNCSX!hl3J3(J}`dXA|wCt8PqEG>Aa3gvg{JYw- z-1b|^N~;B1192v76#wDLn^MY!S(Wi9AiNE%BGZqpbfnO(n~}}Mgkquv)y0WMO4|(X5*ghK*mN9LTJhT8;DO^eV=21>TUk~!d zn9L}@58wAJt%cA^dvjHMyD_2OFbds^;-~)JPj#Lq1oPAq&XeH&xqD`Ea!npG;XDYI zw`g4jYd7gIe#0K68@q}X8+e(d3?bUa8P8GxnYGPisV=UU7I^?VGIfv}q*GJ4e}<>T zN@%+iPfx`QySuR^quKsuL2VDcu4i+OigHFHbKVI5>lr4$z${Gr^}1 z&XUo_t^F~X%@0!qW@K<5im_vGw#;`(^~xL>zsoV+J284Rts&=hypOh0j)6cjN`@39 zvCrEqvGM7gSMaWe#(RdjN$!S@Jcet&D@oX}nMrz-*3{8Ot~@DZy8j6J=2R#%i?+Vl3j6wFicc^)p`c8pqh2jL!HW?qu4t zA%ioY_A!~!=!%0SK7?0!0w?lcB_xVeDJPUTYD9x{OIlMv%fPxDX2XTa0W@|hmV@C9Sb0>u`o>e?>ca_SV zcB!`Y$^+mn?Cz36&yo{HvBRjGtl}q9b}Mmew{vhE21!`j^sndfz3U&rB;zQufs=tw zBN_pVjaK_I*koR_qK=5BBDmge$}X&2-sBDJh^4~_ctM7m__Y{+arFX~6Y#{Zret?E z6`HKHZlz-b2ZK;p={P3}v(#a1_Jo-z8D`8r3MVT&4tD3$_Hy_KGt>RCT6*-79;J~t zuA8xJZ#sUpzq(2%3afV9RiBTwSt%h$sS6ArP5tX=NUz=QQ#>L*aW5zZXhx{VLdZ7v0rauuV*>O8AXozm#QrO4!TU)Gj%1SpEGG2GigHa#R-Vq8ZndhR}7qr zh!ssC4Ghf?_&s(V&Hg0KPm4(?DgZ%}v@L}m&tGnOWc(3@P0h1SGEI6$ zlcb|*96gL`##g@U;#k4!N>Py|8SL*8Iad7%>0{nSb_={~}bzq^eXX6=| zA7@FMWYQYRJ~mJ$9RuOdq!XERRdqo3GY3w`2hL1$bGj8)wWD#|Jh0Lk@L!AmHnXkN zEYya{Y6C%rY1UU8Z7jyH5-vf>c+QUf#Y}_l$OLsqTVW)uI|TDYA@?a6V+c#W2{N{S zSbGT0VnBPe?K+nBEt#|hrMw18S*q3%=4P|4y3ZovSFk#=rd9g58HHX2k(y}|5$w@s zx@`;4d>v?Jv|{_~rL^FIzOn@JGvi;Vf}w#1-j(Yq7PDHhSk;=t3@Mf{I-pogR4naQ zx&stTyMT3oVre%!Ky*9Ij(}om_Z16g9+XNJGJFc|6eP_^Ni(xB<503NZO9Y{AX$>y zai%3Sk0msZ#hPbeCEf|JNXyJT9pASgMPnMJ2@tQw@mgk<*TG2;PfS3=1PsyH_xTRg z3FPLhn45`an>`0d;SMjQ*2;C*VuqK6HowjLyG(4UD}lh8rnD7w5va5^5$88BPQ%Tt z8&#)^iMo~GN8Vcb8aC+`&J!YMUWxv;$~@?AGqL?Jy4?fOt#p|SXSnsXjIxC#61630 zMIDOtIa8KMlj95&uAG99cSW#2%)JTL&WyYc3#i0u? zOq-?&RCCt;3x|&8Ou7Yzj!(NoM`!KO(OE5qEoMt`hS|a;&6_Qv9b34*v4kyd30nd~ zNi*lbGUFdh)1Y2=KuLb!fT9;KFpB5nPQ%owY((u%Xqge}D8)2JWi`+j7ScC2V=$@X zzNTPbhU&K4>?U2E9%rS;7si=gX16)MavMM@hofMC&h9EC%<+)f@#c7QT;FSE7j(*Q zv#W9^b`+yzgA9@A6vnoDHGjOrIsINx$H(B@+~3#f9XT^54rs>kVK0@JDZD*9vOIvB zB2aN!cI#zJ(O2Np8T?h^f9dTJ37O8Q!^BVg8Ng(OncgL)bLuc9i75(9(Et;^%uy*) z_9_9U-33#czXO_TIjfjzfNws2tH}cK$XWH+BFq*+wn&&Q*5ujNz_aSd(wu?%>PdVu z6&9r=p=ejc^{J!Q;CQUCYyvIvQol7+n$DOSf4Q~~fY|Ara2vjjv=pfO-_)a(e%$3! z^~zz2NLQ86de%Z(x8X5-u^wHlQnwXLUXZA`qS4hxeQ9w|StHV6+RTAfdIxnWSsBKS zp28>OtO#p1tZ-ut?Uya?czKzl_M?!+qF(7NG_?n#ir@+zDI%m*QtD{_puq#7V7+qX z6Igo(;Yx2lgDMAm5L~x6(eB9sxXxS^8^gl#`CO<#SyHgyE*m)xOB&DG(3uOXF+h;~ zvXSEnVKD*&1j(nADfvEU(*`_vb3N{v^f_<)fxYCxYb3N{bAv%&?v=qU)xkq$FE|^I z7ait@f%l+l;%`Vn#E`mg!%@L@MD-L zXYBjkY#dn?^JrBB3*@RCf3k}7C^-=O(N(Bps?&PRjo?@xevvbGV~s_O!G%@PEDENu zxC*tTI%miE!SS;F04J>2+tG7^Od}B)Wf?p^n1dB{auBG1vz?6_g_#ZK8Sn+0_ey7M zV_i!n!5%W|v|Lqf_C-PKDz$`*ow-+ul!D+J9p|b*B80D>(v8jyACmHW&hLYH@+l!> zYzU!-PG`-gS{q6?;cj4n^ynrcy}co6SuW`c zpHynbJrf~@kZ7Y$xvfKK!(_RkpYMT+R4p6i_Y z71t=wO$^xR0Z1c_I8O$vy-u_Itzok`Q@$$VlI@#0_5;5fO77IJRwXyz`Kr%z3qu|V zLFPIyRmXCpQ{FGw)8~jz8!#!Px*2HyT2*>MfXLB#VT$v@6z_&9-VIYM-yEWNDGWI9 z>mk71VL;2(;e3PvFI5BBF3@W6l}4V24+rB3n;wbZS>8|l3W&``%hTmtYyaMkc8!Q7 z@67eR7yI7FeXp^_^B%FqZ+7fjpL2U2S2&HKu_&H4bw;*)kZ_;vJh!E$7b)CktDMv~ z>f6^6m3_oFLbZQU81O(fVAOg08y{rhO>i35hU$FZFyKrN@E|MDE!Wo3x{5!X2NSqa zcHRh(D=xVjq`Vy||K_w_7qo2`w8WNm`RduU!?UpYr=0zPyR*Jp@9l^LlOu*#ob#@$ zHx9T7sWs)f581Xjx7TI!hYv3I1J3K$efV0M>tsgVO8zzj7FGk6J2#HjY9WDou@P#O zV_aXqXXUWt{@$5=eW22+i;s&Ss5zB(zk)d?R*7Zt5Fv{SFN`NT=Um@#YQ_D@8Qld1 zMZMg4;riP05Neg9-LQ-DEO+*}p#kS|=j2AH`Od93RO{cfS5wbWOiQSIiv+LzmwzFKcmaR2K zyTK#BK3p^p;LP5Nxx68q%j;`$d3`9C!AKU?i)3+_z%53de2HSrbI-5BaUwjT9NCW;}3=AXw%!Uj~)a6Sf1vBDfVyJ((k2^R+)e3T4dsxFLo z&LxU*&b{QeIq#60bn-WWE8D*_=zx-+{l(77H(|l?BXQO6Ml!V|koHE5p|GbMI5y>` zU1)b+By85{ycykQ=LB+fH$}G+)S6N*cSdh+P)Xx6_FV2duiWf)o$aiX)LYzEcp3q3 zID6evtFcd%t7hRGtkwa`ou#)lNPe!f#!G}0?(@zwxA={=t3(3IeZKSFEnepDUW!+yKk+Y6nOK^pgMovdGprVJRjd^dE!nCdv2?i)y>YC zw*^wGUDmi{U;Qv-umZo0(|IP8&Rj>kJv1fW_x1);;-{HmM^sg>Xa z;Q`)?$=nk(ej1+l2%`BPOf>48cTb~CD?!3l&h7WqpB)GRd;OlUMr*w{)bZ!v8#JgJ z)|+#kRriKw#}9`AZ&d@tb*4QKD)Pw>G$`_X=i&#v?)DUOKl(tZv%D7u6dw!$J{<OtcO3C>SAZ#Dyocql3Y!( zIYhD3`gFYtT3$saSEE)nLXmz)8#9Yhzd!zPLsc25z_^O%>6(f$U8RpDvBH45at{}> z499`O6m@043ptV?8Fl43F63B($ZAZZ@f4Ols`F1sTP%Kfsy|bNR9;`qmF%1pWOaPNMiq5hgMW_{?Uf0QyZb?I-4J@(u*Xh zi7R-fJyylD$~o+@U2FlZaxUH#8WhW8A=MmvJOtQ33^=bEaJIAY@j4q++qv}j)#BWW zd9yL9`-z6ALmH#jHAX#J2PK;M&rehpXSp-}$%Zr1!|I^KhVDgAhBs%ohak(H-#3bR zu48>O)Y%q(vtePjG(s)*FHg$~KZb-KJaAo#pHg?=T-p8{!9AMp9H#`X3YE{x z%X?OD`l_`2rTi4Rr)4*ZeD)(Cf$~n-UGL&lw}iY1kIC9Ac-{U9@Y_$JsJeltG2lkC z1br0sl6a`tBv-B34>GZ+pJUj z;Q9CCF^_n%x~%CHXpmUK*#S*$*lZ;!p^!BmQ5#0(bVzIppSacnwrDR+ zS}%$FCM7h%rE`H|3WVYXo!^azye%w6BI=RZyh^T>R|%0YG=1SzhG^FGW>xO2ya{kY zq+8RAs?u5cwGWD@8uBb63%sHSD3r}33kgCp>c}j=6|dqM3F!p72Y}D!$#gO^8LfPd z?yDB|G$WPqK)<37SK{X@e4x9toHVuZ<&>%ATFR+H3*Im&ke&2`N=IuWbfvfS)L5Gt zp=$|g-PDWl6IXlng~r0Q7-d>jio+00XmKm%rFw8MRkSP{PB}vzElr5iJ2ly0v3#3Dp);#snE)QpXqQ4=3y zkjHx5$iLH|pr)E{vT?cFCe1yTKB9pCGHKzjT))z^&%RCM?~~DRJa-TGPQfq0JrVo+ zy3+?MB!ufukIVSNTe5JJ9Nmm}E{gj=-iT{zzb|P3I)^UwXr|g4seA^Hlty(t?2G+P z!^1NUUfqt#(UF@#Mn|LZD8y<-r{A1S=xMF+DcRIEV`2C^_BaSSPifLQqZ;@w$D@3v zX4pRhfk_mm2h!C!UES0)@DGB&+!|oX63Z0#Vi}aBZxh?hz`J5g@x0Cv&5A!0qz)Vl zXb_4XEe)=~8|X@DbZh=DeH^ZdzTtF!=+Mh*%gy4A? zT>hecKHm|Q={-2q&4NXj?Nx}9?IEo2p7-B>|H9>(eE|i4bTtHqF`%7}R#E6cY>6xb zE?~XE<4UfB29|uEqR5pIpg$3YnAvhss8Nfos+Hv;)ByWwoWKN5!uBp2bh=6=b989) z1+8d+2D=cm#`gYa__S<2s9#sI3sh@?&tNIcu|VaSo&9V~(iY?ui^yIXxf9Po*{iW{ zOxm%@+ecnblRz9bK8HH+BKWr&Nr|4u!t=#Uo7&}$8wTV1< z_gA&=!;7~@Q8x0el5T%V=yjRij4IPTz?~RHe-b*wV=;dI0c{8dQV|gs;~q&HM5b<~ z5^#(>Pna!i;&F5NC4^o{#Cd`6j|nGbvQ)0vmr$o=^dlZRA@i#OpOSp+JwYr5z7)Vd z9K=%K%Ym354Pq&9X#o3V5KDo}0@x>lSPHBOU>^@+DX=zxeK3fnz`6j|?+O3*+xuwu zZN@-trJ5xt^%RWb_T|W~RF%iR0=p4H01>PPdp#l^W<;>|>?>v00KZaI>GtW8`-+27 zm3Mmsay-b0V3F;OhZ z^dxc!j2g(RAh4JK=W1vJ=~HxOG@u=d-RxSLrLb?^=`@VG&n?|WM?39rVl3mCHGi+V zVo#V~rD{tXNvT2&fa0%gmdX5^Lev}+OhYlIQ$fY~#>2@5LnFyuF}ifFz)1YE zR!r)YQabY57O!3*fRk7&ffvUoE2g$Ft;;aDSH-2THMAJ=%qS({p+4y$G!aLs`WaRv?%nth*2xWJp^lW$|}Y4lq(&* zO0iR+v(en`Dp$+G%uuz6oa&3nJuD)e%GKh&XP1{JH+7f{uo*#DBL3#)x7DrMs{?(X zAZj=#S9_gbd@I8Ke+u>g2e|*=Bl`b6UjM(Rw*TK#-Tx_D7pp7w68&Ekh59{JnBVD< zgxLd~{z1RfqqkdhdR(i#C`;0*+~+&lWGD7{{Gxk5X!{nxo&-Obo=MpC@i*`VysNZ4 zuF$=)!W1)R#y6%DvYFuS+l&u*VgF66Kl^7O3*v@H+>Aj7exBq3Rct!>+7j85hvaLA zQLG6oDdNp@yeZjCalC0m#G6`w_KOLWuu$AT#7nl(N@T`w_vc-3zekXPfGoroI?$ zLM&c{#v{nLWRi8vZ@1i~JpZx2r0M5rk7OXHg(N;I0&y%_eCCpLM9szf)3ETkMiwvo zK=GRCy%jgq6fF5)A&wq=&pmBe>6SuXFT8nbG>QUTX3aeK*hE|?pw?j zR60M>iYe1@EA>Vx5cStkiKU}fx)q~s-Iz|xX1Y4s^m;RDe*>e9LbRHOlq1yVh&hxzn14dTkr)wQV(ejq|iEpw}L3q}R69=(TM%dhNPK zdhOGs*B)fOwoT}@ZJu7+R;$;xRqM3}gEBxsS70F z^qR387IhLRQ|WosV=t3jfMDQwUalU`yX2w!X*}Pc_bGZI>IH*?`*Wnsw)5bATX1mS z;tlT8LxZ~;vA)5WrWjtt`i9U*|16F4+Z&AZ_p@+pa0%*<^xJnO9Fe>?&cFB1>T!NK z$pfXaA;umkcq4fjt&)cy?m`|!jJ5JW86DlVJY0|RuzgqZa6iifr*cg|9ym{K>L?G} zt7g9L`yau)x4M;ljVBvwI6E<|M|w$;`V6h-{a;AZ^o*99FxA4R;bK}YR*q=7WWTQ2 zFUn-7grd`~2?&xaM|+VRZD%>UU&zt@o*dm@D@XTN%h7frM;ReUq6+HC5t1;wkR!29 z-q)S?XNMn*(hCRM*?E+m$Ju!ToeRH--RLC9%J5SdMz3q>7~|USzm7|>^Hel>2wBKb zF?pa9J%;tNvk7qzx;XLx;2{@49y%|RhJ2hs{TUh2u54CBlHa0u2WP4tbT=RZB2d`I z%tYDZu$Q`miD4=7o0Pyox2hN(=NQPy7f@qi^EWDiBY8C(PcX-?1;;BUB9Cit z_e?6&lU$~(Tq(r(`HjKfk)1Sc7*Vu^K8dv@(H5I622}nE|8}Z*3ozN?hpFbtK=K38 z8pF*DIs-vZ$u@2ebcv5Zxy+hpz%$z0LEDL=_6^X@R(u_=9?F%x(8aR!eaP=w^iBsg z8Fvb02s;J$424>bS`GYIPAV+;vDLZTC{*{<5a7q!<$k14)l%gtT*hUVQt`?-^(ZcI zOu(XXv>`NEr%maEW~^KTxh;VvjvFh`TbTpZU->7HPGKXOr5DCbo%W%V(V`aRP3XL^ zYx8Ak+Cwy*kQO_wPq}8cZCG@3L*x%qigbM8y_=TCA$DgysG;)deYKy6$uvrl&@vreqW+|ed=kiU{gf4-g~-H zwu(liP7X4Pnu%}*&@4_U1Dt-VG=Cwdp9Vs_KU^VuI95Crkt-80d9+8Aw4!7eXX*(V z{L+z1sk%KE2R(ey76ukIn#J#5natqD20dR`G|Wil68ual+~Q*XHX19W zG~u`R!~T+rkV(YSMKIKrVrogZ*0Mz(?9)+tr|leWx5T$<>W7+*imq0*(*guVO2N8G zsn*n_^8~~JO>_i7A_(~zLL&Cz#KBdnT8S|`SQl|@T0NzvBAJYh)|e80#Tt39UN2nl z)@wwv!2Jxq%`3{UjDoUIEvvGJyAKkT(727mW&2~OY|f#JA>+?O+DZ}TK*fk+ZFc(u zm$#~LS(wU9O-4#8^i7TXJ$@1cCc0S<5|xTp{*ITkqgLfTaM48HXSffS&QSwJ#q|=k zyEU!HR7(e-m6e&;?D%mg=HjNm1)%}URHw#Vg5vJb`%HCn#*Bavh>`(z`lw`AVE5=cvp%{rYpkBq^tfe#d#*xD*dnC zBxJ~tE(3Sa{SKI7b52vwW)tyxN>3T~3~V#(w?^?8qw;0!oQE0QN$0am2DY<$f4h~6 z^hK(1sYpt*_rhK})-4N#C1;ClseONh5=5pRRoGu1!oi~0r&O*m_!053 zX$ix7O3ARdf=@OS%7sEjvgbhhW1xW73l2RpwN)f>H;#N%fVeK+MJh^(0ci@`$5H8Z zk(E@3oV&Qlz$Xg*66XQGl#WgLPCiHC{Qc zd%4y**E;l2%4=&ay_R?P=3-K2Jii@t}- zn&TXAtvvx}l(Tu#0Qn$er1=xXBqGT}s!~ZHlx^Klgc#2E-&w#p1HZFy5Wllvz@)D7 zTtv)!WjY793hh8d2EP@-Tqu?AqA7W;GCPJQs=p0^lBrdmjY#yF4&7A>zc;-P@D5?0 zKx2UVW~E=2^ZcSXNbx)PF?S(px0sbE#56-THuD1pi2gHvAXP@S{4%8kY;y2;C4Cvq zm-(fK2YC8rH^=BW2{i^Q$zxno`}U!@?ojPdc=PBcI)2Tz_P@n*GmSn5=jkH(@VCUA z?rC>U_jFWz|MU629pbxFwhux**2O5rex5CQ5VTFHd_G2xrywrBYH&V;dYO_yy_^wF z8FGFIQrib&^Fgy75p&Pujo`ikwnx?IE^bN5nLHbX!e+X?3A(+dPdh+o<5E*+YdTpN z1l5Cq`M|k=sO_(`KhPW&|Q{< zJ8^DTB4pw@pUEr2$gMq*$5nSGO=YHg{7bp{RQq#OXX*;Nesq$HURD?VsTdt0f@S8Z zE}?^-#q!WIP^ompfP9s$xX3E|cbag)WuH%L(`RT7eIpXgb%7A$YEl0(9bTaKZWMbJ z&ESbeV-|_)#SGJEB8GDT!g=N_pAsWGoM`GVy9o1cFUJPQy(zpv*X{7nHtTG6Gl-pcy_E7_j8%XF%wO# zlX8@1*DEQH%l$ZhK6X$|9Bu?{B7$q^WQ%O7LB?OzNnDK4Sfia&d2WvOCwCuo{g+7- zZfCzEw<-2TSTl0vV3Lb7NUhz3b-r9QZ(JU{8N$ODU{HRp#dSLsIL;EXkM)P=pGIh1 zhGfM#qFdZTCr^_wjkpzj8A=KQx5-p}DZIZh1I_$X_65)FvUn#@hViJgOh@IUnQi!{ z3XMXz0;b>!KPa-VR_>7bStAj=(><5b%bd<5!%fD>EJso#hmcL8llhD6FL7O0u38 zW`AGfG3GaTG2tOJ>)}ygdbXvBZjsiE*fAx$u%)RD z%7|^y{|fZQL#eQeX5-+Pci+IFdRK`GYbCB|xNa>|mT?R`)1@hblCQXAR@?YZ{A`pA_kTCa7W==4n$7Wuo@Ju%GSTGO!R9o!3r zJ!eMKXNZIWMNs(|+w`QSI=$yXna`uTK0O{ODcbV9q-#@K^i*V_HeJ*7MX`dCio^^Z zCOR7J;f^h(d3o_zj0+e1(Ntu)JtQ^+`e02Tfof}p*}v+{!06AX=&j{_5mj5>mr6x~ z$!aNeA<$2cg2!Hkke!{737*&QAx$`1T8i`fW4vPE`5iigY;DMMS@Fy6>guw3ME_3; zd;%Bv=v@}L1^!i)ShxCA=o;0DHYl!G8_kd=ES65d^7^gXR^7-CR|oH@4n9&He5^Y7 zP*spBDS$n^I(V#i76rj=;J9<20qUugA5$w z&}t6-o}Ia()})pjrBR+>u8Zj{!RmCzdNg?F!cW4$o8Yy$Fo{l z#@Dnb5<=dL*I@7|UlQ5;?5tdl%0(^LCe!)oDY;IWU!NB9wFzP#lIx7QiD{ehyfn?| zy~I45XWJ!lhN@%HyeU%cSFMlo(*mv*2+JYATnGO_zk-p40>N4(q3}uU$LQlN>BiFm ze-Z6leFtZyX*Ihbl3f4;)Pj@-KM3Y!fLaR>;z6wi`4JUVnlhrGAZ*lfP+t?4%sA^dPI4@g_={$Vxae16qJs;c|`-!_tQh7n_lCWCC zev+4jZ9My*P4x0)yYuL`@w>tj`cUK_g@w6(EP;13_masYSGMvuWmP&t=K9L*z82ql z>&@PT-@@VgP{}?eoa_*l` z#+T0hlf?Mkxqn0%-#qsZ6XV0@{t04y{oFq_j8CBZCx!7HbhKaRh0Gl*0-;v_s5L%| zzN0M=%Iv_|s2gfS`+8o;@?XTmr_y%}214zAh2x{?JANDpb)q#pFVuzB?z~XI6DyP+41Q>Xu^)u1EGmK&Ip7i?YK1%n!MxGK&W@eX@Ss`9hE?6 zH#Di|g>2st_ULL5H-CI>&sYy4pZ)Y&7}W3_w42*W+%NKCA`$WzT{ z#A^14Ul)7Ci1PP{U*|pIjyUZRBTnq~T?BD`0q;D%Olxe;3Z<=a97N0|DK56SnDlta z)I&6SNhB^{gE73Y)L{fR`gGpttDKDckOuG7{bDR*@O3UV_+E_rO+%Irkb2KVGtrWC z7$+;ff7oBZ3ZCi0>@Rxtjgylviv3FeL%D2^1-1=jSO=4-ZoI8{N(8cM8Pm-FL*9G9 zNl~Q#!!^@AJ!w<#?9MJrSb{9=CV>@LP)Q;xMnFjh&^wVNg9~`-x(kY;;u1ta<%|dh z42bc}oOZzx`6}mzs%v0Bq za3r-qew6UeFJqr6u9}XdMHgQ}pVSIEcRaXf zov-uvdUAQE@)(Kpbd|wdMmmg^PdATr$f36?4gy zCK3Oa=8~_{bIG27zj7{_rq=OJJyK9LO)ZzlX=?c`nsN)^OX_hswM>N@56*o8`~Oj@ zY513>mcNoy%Lb}n%`2ZxxPpFgUYRW7NjsFt6W&9#2=au{Nyt2pCMsiR}c-!Dy^U7!tJg@8q_0B7Q<(XIJ zHHTdTdQP|xgxtj&lCBDfhil_TSk5Y^3wpk^`sc~n?#g-IUrtu#E{La1FZWT?%V-y7 znq8QwXFb!)U+L-P20guu#lzFf{q^)RS9B+#>UmLC9cH&yFGR4ND9&?gZrNMKOXKa# zE%%Xg%V;2KZkb{UI$vkZEthAY6GyFb&JNIXOrKk3`6Mf2Zn?4Dx#d1QW&Ea^TYghc zCGW20mNCJ|=*J%4&YWAuqy5^MTgC#Qx#f4%+;Rt{chB5%Jf1eUJV4GZXU_2|Z~1BU zL(lPkff?#eUr+t#co}MFj<+Xy<2hd3!>N0Etuc_?hOd=nyf7NqMNfr+_c>YXqH(DI z8azM3)3^(GX?+2wNpLmJ5W_ZCB|^BI26tFN6>W}#U^{dbiVizh(HQ|o7_SZVIN-() z&)S;1X{j_iB&==k2)$I=+V&E>w7!V5jLAe8V+*fJM1poCJ+=r5jc{zc84(>DJK*AJ z7!l)QAQ@XMB4gWrvWjZ^Y-3q%8HY2Ht0ar`DO_O_$6 zOP$tyzZ0d2Ch$#5thKiNmRMUE`w#X8#qJYG-+ur$EY2ltr({v0V*FyVA}uONTtytK z%MZIRnR{t1E(?i^*k&vVy!$O=-HtoHs?L-aNuIP7n9TNS%K|Z>M%cb9BI4P+-PJ%Om_jgdzEt%}BJs!&mb37J;n3JzD zCqEl=^3ySg)lT1ACxE;axK?Z4P=J(}i#73ZU5pb|Hn}co6=WA&O$V2|oGb)&K~A_R zmB9+*xLn9PnGK4BQ^UB$F?47c3Vr0>&@-YE?!iK(#aJvGb;sJG804+FoY%g8s+LJ@ z7?_OLRKrk^1a)Q)Vfo_1qzbxod{{ie+#5d9s@p&J}YasY%%pDEU1bUHL;? z`G-EL<%gVoaz_yI6RyVe-TEonVd@#ky(NW@DcJ>~pWa+jU}o*>`=yCys8EQ+J1YKscYlGNJ} z9)I5n$|+Gf@3gz99LwwU@rI${lR2G1kuN44&vT_%&S;|-vR>c#bJ~6lUkgem$wZ+N zOvz=V#iFXwwWA@f`~i=`kt0ToAlp&KiI%Rc`r7(PN-% zb2!i4h4(Q{eL~xum0kyU=Sp(7JlcmNx8a2F9e3f#O*jQUTX_o5GABNnRVyHZ<8Y&y z-#(`j@!ON#`j36ci#Y$kc`~i++#Nb`j~en=4f(-vG8u`cev9|cnw~u>rl$<+hNR<+ z)bj&69_Z!mpF_(bLdoC$44knNlFcyV%><;_43Wt6ZA#iMI@G%5w#qHH z_|uu#m1FDCPZS_+M#?kmj8LuR9L`0WR($B80U{}zQWPTmC?SN)DoLe-la{zTfKHoO zOJlPF%Yz#higcD@+ zZ68rAi71wfD2yjVMEwa0PwK>hr?_}B?{vnK?q=Cxp_0*Ms*jHIqQB>TEFLQf*LDe~ z{z^;3YD*$?ZwPG}iAAg=O%q$VUyeBPTMeGEc?rv5{3h^@mxk-*Zjvy8Hw5g}LH1|z zq{k{3^!YDMe#LM;%Mvex+)Jsib0GI+4#Lvn8UMUS+@&W!Okra3qXTgvOIei9kE>k} zO}$IHwz+QC%`O14Bt&#m{ohQK{<+tIX^=};S#=S6)l&?vfV=Piqz82@Ec(m2tF@0nTVFz zR=pKW&A`u7iC9S@ZY1)OiTuW4A!w%Z?EJNf0=r;fT?kLaDYOgteAQCBR8CMtLi}Kd zCtu(#;a%!0?9$4j`l_1#Wr>()keP_r^y#2ErOc@;*PH}%@?|8>oAlY+F2KWv%+z6V zx(vIZBsCwe@Qv3N2kkh4wH>pe6LSK%Z|{{z+DW}N5J=n`XcyVZ)Gm2Ql%4@#qwO zlX;}JsHN2F5Nj#(yt)@SLWsX1`j-`#?MPlBFo?6PiQVLp<_zD(Pu&yi- zZEOt)QIaUP;{$OTtNiDSojm9Y%t+Xdl3+~u!JsOc8Oim@jdGC*(eEmI^8H`UU&M|= zj?^@%ZSB@!+w`Ci&Sa>fiSimSDZ9`)f?l?l^wcKPlPm^!&ILkmO;>=Pk`bZUk;Ee*y1@>te<0p&H{X?2-+1Dktj6lzr)v#ASsfnfY4=j z#|AryV(o-;5?bhuSQv?lq}|aO62%JWNq6H4Ho190oAq!yO6wG~JJ~T;dgn5`b3;E& zEqHQH!F(#CNu-KF%-p|YDR%H!6X&;PcL)Pw?atXz*OapxsXomG>TVaii(7ZQaNSMV zUDCaYGO01Bt0hwJx**(QsH9@3^cF)U6hoz5*={j3l-MP;hoR0738oGqOpMly!1t(r zPbRvO@UA3$M=7bKD+upucV*$=$<7BxzMXI9Et@{%wjXxx1Q~mL33^Z3(LF!H-f4-a zl)K3S?jE$edkVOR9ZBp0Wg3AVeu*7r(B1`X8<@^$tP9=jU8Di@XeeL<=tc$ritYxb z-@{V`-L#^6+OEahZ1NzfXSz3GcazHP#>(xcm0LymuktFl3bI>eS83&T^C)+Ft!!lG zU{5}o=v4#V!Cq^lcCS^`xwm^k;9hpG2rk2YJ)H2g`*_&dup9V$MehLLFnTEb!gvWg zQ?!!&BB8I>F>s`EI1P&-bvy*GEm1r>=GIZgYes*A z@OzgIiOx~bnuaN5kPU?E$+d^uvD(q#&`{v|J%>)th}YDs z+yeAZMU~>IjKIPMBb4fZOKZ6!t`8@SG-Kn^_fho)&K&ZG9Xof1$bjocg{Z364NpdP z8yq4igN8pkrM3@bG{Vu>VE6rFY-aL96{elPZ2Cm_OPTT(oZO29wooi8E~D>fCVl6^ zH4$da2w7|E2g08M(_&K(S;jheNnU2a-{siB-?+}8*2v4p{n5j>I znGfAwwAM!a3R)Jb50{6A;z>tlWsw}g+vx|GBokIr9#pbhs4QXC0DSQoGata9aTdIM zii5`A1WSxm0tC~@#1184n1@A2^O|MqTpK(_p3Vu`9SAx&qy_{GKmpy$LOTN1M&r^vMG42m2Lu14HHYW~f6$9~M)$s}W*KR|yWi&NUrFnvMu`LL8YXmVQS| zY=J&f+-?U5deDx>!0$Ekj1Y`49@c9)aeZ5bd}?~&+@aHqMj+|ah%O5P*+OI}j zI;&z11iqH{#yKT1f}NV9%m~+OtXui&1*>u0VEN|4MQu$Q>oa7PhimQ1PEqRlPR4_! zP?7kBjE<@Z^}XDp?{LpR+}F{!8myAIrr0?OZ#*$rM|hf!l{y>>3&%e-lfdTOWFn9NnfX7-=iE~)EU3e(QSr>1*cdK51ZL}oOaalW#L9?Z!{D|o+ zj;kfmXUF;bW?4+F5eSJUL91NsU~@SxnT0Z3ir*PaTFPkAEDB@P+k<^9n@(rb#n{P8 zeGP6^L3Xo(%^fII1?~Y@47Na0a7hKGrZz6+AuuN8J(SpAx{=l>kW-QhYAJ5YpcOV{ zfR*e7m|2Ds4XUNZ*5*Y6LTF{t#6@7mwX)>P`b1IXm;t-w_2E}?Et=h&j zRZDHtwxIKGt)06ZJg-ydrh>1&f3-b(I$Aojt#yg`ufS((5{TN0op$0-k-tYDdaWSCGDLi?3$mQ zARl>GXUn_#*T}mrTi$iQM&8D3c^iL?ylb=NUHdP|8S-3v3ZpfB( z!!MO}Q?{&|eyOY*vt`}*OJ&`hE$ilADr(7=oC|%a= zD61w-*6qHs!qz<8&8PRpXQXLUcA7T*behVl7pDceEiDM2iSTr=wUXP^jyPY~9epck z?Mlnj2=H6FG0gVhCOzrg5vRRO<%;N_h>nWrtcVIlbW%hYCaQv!QBB1(71vaOriwIW zYpPgN2~CwS)f8;*!OeYTer29>C-QyNx80j`jk(8j8|wB8He-fKHO5*# z53MxZP-d9*36GPho$v@5Wb-j;F)7MgXUX+^f0T0~m8I0N=$ULC10L4(ENdN0zvZom z(Qk*=Y4lssI-PzywjN8rom!{RZ|Bxy=(kJjZ|S!(+B%tuSnJVD#9NPNBCmBk6Zx&b zVWOb*2qp?!CooaedK43O>v2pJw@zXr(K?lh66y%7TZlQPMa+6Erz6&oTOkFuq=UzF%YX+0yU~^CG73Ez; z(ccaRo_X`c6SRsMofG-nZt>ncu|dgqFQ4e+UOvGwR77M91#S#}cThZP)s{!1&Ug6H z_qBk$00`n3=8bUoAYDa4aXR0F*I9{>`%>lQTizFSH^njT-4vXn6_1zVm@p73LoAP2u zoF9YP_g6f@_gBc0z!NKU92;>)DhhFwsW^%;4tbG9dK?LkBZ}8GWnE_R1Yc&sacm!_ zFS9t1m#w1!T(*wx%9HxvA22$d8=DZk)#3wEWEZymYrSf7R7N31FP%p;Pi6--7v5I@!VydM0dfI8Hb z9{lW;g`b$nEB&zZHp0%k7(07O?ChnnvsX5D_DaW2O6g*A-f)SXGM9e$pr98H?zvA$ z9|Du4yD2++a8ej_BU(H6q#Xy(>E3(NZpw8}8uu&kp0ox6$dxl*^1mnT9~-$|Q*F>6Kp|{H4&y(GxUM{DmtOG^$sZ`maIbz%*#A@j_!4 z{A|8+LH0dqoUsy_dV3|nBA7!iSd>cL>V?IJ1bz`;xHAh9(?us%0we~EoRG+(^{&W# z+7+4LzyOIWm51>NiDQyDTUt_69yII{xh2w)Ixm60C3Xple#evceNR=QzC7PXAI$qr0QhZv3V6290)M(J8nUsk zAszcDSu4$XdrRz-S;^5~L|-gH!rzRb=OSMI+*29Nz`sBI+wrd-;oqu%JN}W}f>rI~ z-<{I#{{#3(@fWUA_@`c7>i=E*+qpBVTc|;bQg5#U{G%1K{`j{!C;kbsFemyh{qEsc0eQK0P8{sVILNVF=D|VJn(>8$LuU^@Qkn|aD120}F7^NF z(779rZQH>}%7MKGF!HqAL+5*P44u2lq~^v+5}#NDIN6eW=zLF(q4NO7$u-J@|IqoK z_7O1sT#T3D&nrF{cn|dfDZ(`|Cd@Ve0tVK#gMm_NHU?74=e3W4Uk9XN=fuDPjDZ}> z%}{5(5Wl3>=V+fdkSp z@E(bQBP0gOtmMEz^u-b+1`Y>ZRMuCN;V#_o;|ibojwf2LX^twJa2OusZ;rD1Mngf% zd75@ynWI_{gaoa_V=*m5&K-wDC+Iug2YD(mlfB~w7G6n4{!5Ke>O0UuLwTtwsRAQ) z7_G#_zx7e@>^#Lg(&^I}UZj>6B*(d7hyWM=R(7SOm5qH6rEDv;75fk2$Uc_D<~D4p zq3V|Njlg)~h-ln_)jaHc2e}*c1<|2~ax2Wq4_d{60?YXpw+Flkj-`ejrsVZZMCyB* zc7)>yMU$xrB%&Zx7mb3C>G<)cBCl~B1~Fw2PadRq?X@hg@pm%nj#fBIOSQalC-WM| z=Mbe+f>b!Ans&a@$m~cgSmmeu~hkX~ebmQbyfCOjL1tTAm=^W-1C| zs&p_N8RX_Vl%OMMTuTD&P(w+YhC1doF7!rRGoL)=dsJ9+tSk>drPS=BQt9Sh`z+6c zfrfPMj6w?2!+O*u7Y(sB4SDdNJ9o0pBqg#X<&!VpYvMWo3BCCFbLqG_)qcNZn1lb4gNd zM>B;N##;2ZA>W#ZT$4msTP8=IuW%FIO63tjX1!t3RlSzUv0^?B5$Y^LNG~}X6v*H( z4aij_xN!=Sh9}OLn;k<6w$!~5^`dYul^;`#fSUIJ-C0XXcMM!<8Z_M((A{qMQ7haB z^+qc+@lHD&5x*~yXA$=P-iAL013oRhXuE^j9y5y-Y<$$?^~!)gnJJqUY`nzd^-_1z z*UVxCYvvjAdSRiO^phV+9S)9B`in{TzGH@PRb$U!1S)!*z>0sJopHIR(y&9-YKO=I@zX{Dw|PuY1Ia;v@@cDVhQ|ip>sLugnO&Q#C?in zg~T=9SYfdfuFghOx9;GUlM-2h@pwjD|J_LrLc3sP?$V*Uoc=4z`Y#Dw_YiJ_ER3$L zs|{9wQ(u+bk{tnF*8>*C=bKAAmi5ahSy#<{C-ceDXyw`v}LXGZmz3l`-;g> z`mpbYD$6|wyrF~gPnVC(-HBz5UUh8xSn#2^1ITjELvJWiLFw8XC(ppf+H%iG_jn*) zzVvXnj|buvNDrHRJP@x?dbr2O1M!Nahx>gz5YLt#9`Nx%ykhBLi;oB5C8US@d^`}Z zM0&W(#{=<7$paovXr0P`v9H#^^&I+Ya>?;v*;gB^`)Y%;`)bI-PFgX2kVdS*vqAqz z=XrI+^StPUE?HCLcZ;|_oGV<{58T(zM;xfFMv@MC%PS7b6U^|~FL=RYz4*v7f{b-s zpG-PC;6cJQii}c|jMePRF z%_@k5i$$s&ID_!Ik=CKW#$6H7V$&HUeEs3~Y>p*TJE<&^>Hy3MtwZC&oLhm@@S#Ym zBmP=7U5YKI6OzzZDGocGfrOtf@RO=U+H$(WPu(lq3yQ5B$$j;?%XTQQCe9MOfrq@{ z-0tu*7t@Vu?P1`O{asK@PZXm#Rmkb(Cl*57aerJ?KzF$5~6l3?DK?p??BLK8A&6D zmfuo@3{g@kiFB@c z=R9>EOHD@FYNL31^BP=9j5{3$3Vr+pw8gZciNCSVNYks)Gz*RW`3N4&(R7-kS>2@> z59K5;)U*b@eax4?E9D=|${)qbKR_z~K&hKiDkr0uk*dt&L*`Rm^LVSpLCVKLGRVR5 z_W=2O$WN*FkaYD@)c7q`U$v2JL$agiTfz$v_~D%267s=yGCa-RZwY7Q`j)_J3h-OP zXqrP?@e|(?CVJ6!ChuTatl_p|1IHG$|Q*V-aBLT_kYJS6NZ7B)mVYl|bnfAsB;CtJfCmYRudXD81*?x4_X_B$) zY=tcn=ljWkRey;Bj1?Ecs2^tm!h(_(Yp z{&KENX2);M2zue*a-vLdEPZuUT)p#mDORLFad&qsu(*41cXwZ03lw*^#ogWAtt`de zWpS6HeR;mW_n*yXZcfh0+|NjEGBZAI-Bp}F;0a8?qI#VhO|W&|WHp-(-b8eIy&HG1 zDq$4rH-t)i@fA{tnkL*|B@l58xPOS+kgM2B??j%KG)wP1pOxsw^P-na#SdVu{%|A@ zVd%tU+=-x#L%AWA7^eR&H9JKkUk)eoP$Zs|UB~ilWly-F2)}O>z4Q5|q?atDawdzMC)4mTxsfiW*w;@`L zr<}!4jOT`I1x8=+c`%P{q$-`9N98dcCv`F<$Zj0j%Q2@E0Bcn#XCk8V0LNLKfOZxs z;Ox-UxWq(o0MNzoWlCnXHI?ZK(jWZ*!wcG-{?&@PCGp{uMeSm*`1n!E_xhh=)LvC7 z5+e4pG&Kq;%hG7C*kaJ(Xg2-ZDTX3Qep$6u%4`$aDXZD`2WnRIjK6);fWM`P^`ZAlm(ZgBX%JMk=V4iGe zXm;_sigP#6-+e9@e;AV6$6kW416S$hVb>ANuW2@;=ET2VF36&{Qcm`5-HGTp#DU%Y zc}Bd_$C<#vpiUvhC5!#w;W1&Y-2>SSCyZ}Na~}C8?g_(Sioi*wjg1*HG%fNpoJ^*P ztr7Z^~YLlRe!IVx;LiBak z6b?n8V(>a8kB?^}-P5CwmF!K9{8sr>stSj?j$MCi^{zNS zb9F9L+d|)6E=)Ou&p@`A1z#tdaNUXDGQ?sW&ZmKWXlera;HOtcwE^u6h*0I%!~M@C z9CNR-Ec0Wd_Qx}?TYjc^WsSkt#;CMX0i@}SAeQK1_8!$1Fb~`aF!W)kN^u?D((d|p zT`mXWyaJ+#As~uNGLONDwC^h+EQaTnw>n$p$n++lNVW0K zqdfW;N{7At_YbuQfr2X5HKmN`NOZt2qi6b5_!0YJlyf7hO~}^IyJOLM%CiJ4^>j)| z)0>O!`#$T^pLV;6GA&--^LW4^e@tZgv+mX-3WDHeb?4bN|FTeaOCST8(}HwKj2GTQ z>u2-9x6^x|jMzB;lsXObWO^j6Js{qndCoVO6d1E@hxbYrT>YIzQk>wRIlF$gDv?D>FxpeIZ_9z zqt6?AHqYn%%a_eEvwJB;qsgPxad$`8v~fR(v#pb)yg30Ywn)TN#uP3;fj zbLD+DgDn0`tkj8?LFJ6|&3gZHgKu0%Da(1&hy1fYaC?o*8#y9Ha_i3~s=0&QG)^7; z#65(^iIi^`Q{_p5V@<~!{UyCipNqKzRXPjjGZ<3@4T+{zEI$Zx7o0-vRJ5(14|0TE zATyBaW5!1qp?3JEBjeEABNNQ?yrXxdJvza#ziKMeYJZpE0CxnYxG!$@WPN(3~ zKYjqs-|^#U7Y8E%chO{jA<%-rB_>A3l6_BTuzS5VKdNgv1M{cZ_f0bbER8kNi3{J? za;7g1eTGLNz2i$D)%`1P&zx<(hSH#s+#!D_D&$rq^S40}X-g3jr*g&6(Qi9}gntv> zzi4Y-e@5i5d*b)J`gvDbw>gXZ8vygG)j5zCo@}b*C|Wqvrw)wU!L@-mB?Mo9qzP*o zP}B}^c@WF&ga-FZH$DMgNV^k`6QqGle^zj;FLVL$q*G|S(W05gD*#OEh6p<>3(N#H znVQbg0I(`Xy*%^$go!C_^r3j$hqIcfGGneXzWiN$azr)XXkWAvNnId;=xAEpAIcWTRNW1KYJ`pDPrr(H|KVPm2Ax7^N@O3>U%`G zV+@(GlA-;cX3Ng}tE{FeCRA)7W#&0{XTq}^I)1LM^H+u!4{;97os;><`V%pV4OvW} zki2Fp-d8V?N5r0!iQTI|FIRu%>hPOV`B(H}Q#RtZ`hy{xdwAQ+Nj}04j#qY*we>M6 zi$R@Ge|8^!ZAA!9i?q31ur?7cs?5=_gag>QT~mD8qN~a~j-y<|0#kSbh8=#R6xR$q zD`Bu~0MD zaESFbVR7Y_YI0aa;C(_Qwf%W1s{m}J2f%Sti{lN9)Fdsn|O>&RW(NE06lK%qAWfwx{PB6+j zW9lcQYYo9C(I*nm4~xtbO|32fTlN!dx<1`z5E6$CHr=3ZJt&I(1gpGHx4KNPt2t5) zQmv*pV4XrQMPxD>HIop3y%pW1ogG+L75Ub87AEscyoetq2V=(?;m>)E=P8!@3;}f0 zAZ+iaNXwlS=E~zOr)-w_%z%k4tM~vpbM+ytZ=M(&7vw^O#H>Qj`1}m!>Rp=TykPkq zfjkM)QW_13_4H99OS?W$GtcvrK&y?`J$n9bJP?7M#Vw2tp>o-US?utjO6|<6q{b;& zWtz*4Dzm|ktbUVfVAvQE_tS_780_3^7?lPEWo=^_(=tWZ@$+A*gF9FL_>oyQ@{J`S?rIO)uGbd=qxkgHWQvMy zTD>KUmwY6PTk$#^3unbSbXE8`J5um)6|qEZ{u-VQ@wArS8{Uw+5^G74Pz&h{*f|Qp zX}TU^g*VCeG-%ZvZC{6B4x*@pE+n%{>6xbRqLXbL>j${ zn&{jy+uFFUE~z{nM+r^nA!=p1V`KaE@Xv--zA|PZb7r>7?#avGDZy+@U&h~>wIJl; zBfL#dv0pm#kD1^XCIqhO;Rqkw1)UyE4WEFxRw|8BzxEw2!Y~Qdqc!A^VYemezg3+m zTmdA*=5FPq@_@sEoq5_Fge=o+*I2l|XLPc)@=dp`%iP|S zK~mN^yrzYAQ#^6nC_7HtDDyRA1Qjz=1XZLaVy)_yjuX?t++B6ZgI68R>ms{mfNe(B zTeZ1E^pZ+qHwzc!U^0%8T`_}1`x*Z0&A`r;T%*C^nm2vjmjecS^X0ZpG<^JP`PEhn zKH*l)q>w#%Y3c{2w z|CPO;ODvPsXeSMj@W|?6f;B=7e_9bX@ppT-3{ zcTeB}MIyQ1FF4vnX6 z=`YM`5f>e4Wf|4PZ;}J_Y_hk^MlYZJy8U7i8J8`$I_y5HpfG^CwVBQh-CJk3TSalC z+XG~Q0mXDy+!K$#J9~6eUUg@#Y+}q081}hg-MxG!7WKXIhbDnfu??Eeu+&Ac9A_VA zHhm?pOp;hwYoFfcn7)hpc%b#8V&k%Ax}~va0)rr;Nz3AJ)Olk2jWKm!0o|qdCrI|D z>U=s$e;yt=GuSn40pinHVSRdh%dfAoLRDr^xZV5TwRO-jPj(0jAWqHpu%&Nm#yfHF zcticPKgqOwmMML&j_PG1gO3bLE8Ycj@P3DuxIHkPx+?Rht0vd{hZc~M9d8^;8$LNN$i>{8WA;HxgO@Al9C*r3f1+k>efJLj1h9nY`LWj}Az99x>{>U9pfr&N zBaa!KA^Y1HahUU=sq9P#p2 zmY*XhA{3BW%5t?XWyz=!ybd$4z&0h9b0Co$F}n-1oJswPrFoOno?qb2l`VMUkK0b^ z(m)Svz~=P|&HLvaM5>b@T#Q55pG#KF_X(_T7B%_0rt6V$+GNLQ!1+# z&a$tAUozX57>~z?LAI$nxIBOgIj<>|6ooW-5w;~!h$38VaQ7BcD!>1YcBgnCUEZU7 zeri>-T)OlYM~DIWYgg`dqr|Rd)W~$I-K(9~8Wr))9^iZ15{KS249_?q#fFPw+%z((6h8YdR8AjQg}UPqc**2{#X1q-#ouI`BO*_Lck`t zPwt2*vKOsJsY2u9yiF6@phdRJ?tXX@>KntlVou#o&7*HI(OEKEe3#u>5r}_L(ETKi z8Bh;|GNqAn%ZSRZ^}N;k{eAYSaR?0WkL|8vgm@$nW+j5{ZbI%iP3E0acMCNFhDGPY zu{zU>kI6=wt-pne$cC3WOK$%in0*vQ=@>FTq%lpj%KvD`+Km#P40=z;eZFj4&JyK_fG+ ziNKLF^+OaX&g0qcF`xeO*A&v?UZ*-DDcV?{baU_evRwXAU~&jNhsOt~nAAU8Kb&&Z z;ez68ePui=>cjlw<2!S#y&MtIwT{Zyis9~He8#VD0y)O#Q=A?F&&|~XqlUo2RPGac zhkXkFote1TK%dPc4O%JV`T4n*Pas05Gb})R!{)M%+wU*T_r{IvI$O;al(_U(yU2i< z2xD3!-+=^X)A6oM@ju~Xm&heOt*F)i`~(SDz!tuud=`WnmT_O$+^gzl928UP znMa-EvoL#s(99@2i>G!DPDIpr&0e7%>R8juiYeq~tcguI{LwcJtFu~^>t1j_?u^FS zWjMp;Z|@yd0J(h!zM+f|4p%^KfWbd$Hwflnq860@Q+`d*oN0z{zSqqZ4Ie}2T!s}7fFY&^u=Y$c4^ z=-AaXuCi&a$zB%jc5GGrjA}2PxMR$fXz2{MOM@|Bv0rlI;%-B+>&#LAx$2Hnf3EVu z75`LDwX}uQ5%L`{aP~i9ffY)*{iA)uhPGX2RM9!}Y)dEYnmdlnS~ivaqmp$eUc_yq z{@uh*y)J}#f9QMeU1>w(XUe7(JUmY|jYgbgcmKL4dFJ!x-cO+pR;7B^J+dKUg_3M2 zG5gE%c*m=53+j?t9i_!}QBz)p#TVwQudcBMJcPR;o1Y|nO05DDz*Neu=EeC&3QHw-*Htfh`rawNJ>D(`v-AP%{I5Vt;AW|4+rncNw3d3UX!a^R7t4Xs5uTPN;I? zGZ*idXG62!Mt{KAiltebmF%GEXpaSg+Od9u1eu*kn?5p$dzfD(ae2ZLfDD2)||%eC2X1gwse z$IdA%2QWr3q0$36_HNua9m15X(qJvNEUtq zVc&==L_6orZnfC$S8omcihZ zX~q>_6-9riJ}=sWnQ}Y-X*S~f08t|7<(yp=l>M4PHb<>_Zx7e%SJT+u@3!4C-FTwk z>SxLJ`XBP%c~}0lSG90rYX+V-obyGk31Uu>xvf1i?_9b?_gc!l3drqUYOnnDNgXmw zYy^Y2C3hVqcSR+!kqZ@3Vt?dz;(TuX@h5kJ+1l?KWWTj*xcQ*JrBHwPk?5`Q2B*`0 z%Vgt$EybIn^PB=_0;|O@s{OoEu=?C5&NV>b)W3fI&7}Hec%{RT(Ji3c?qx)Fg9W_t zkdK2BW}mysApR0<6;maruF>Il0Qf|DX?dTbC>bS!zl5&92*w|jl zpVcwp`0WNqS8oAnR*$3OPpfL@=;@bMzwKQ)&o$d{7Dpf|Z;-O2233IwUna46@-In{ zhi{>o=9zYI1SPqU`^-X#V}YlTC4si+$}KQ z{=aY=Qq_Q_+JXuIMI$MwV=b1A_PI>P|E3++@a(V#yRd>lf2w@!v0T+2^)WyoJCQMpM2?9o)WB7l~8c7r~S*E)F&0c9gWXtOTCk9$4>#t1n&8^PhQ9gOFE> z={wu^PQGkkNNKl4omyUl^DdqAF|GdTd0q{X_~Ku(@<-v9^EM;(LfBtbA}_`fdK)UT zPeQgZ8pxj!Fa^_;wWLy@L$Z<4V#Ec?@>FgzaH6-KJc6#jWf<{)?oXdJI4a3@ULO4M zI4k&U@chsA?yXGVP9SZ^jkoY}i^KTO9the`{mC-_a`Zg^vK_g04$n{M`a=f*^DgfQ zk9=yx4P7;J{J%bTKr&wUweT~&uKjr*RBTc^53L%$8!*)WpK*!q&UxF$_n9_7D>kCE zese`=VyEUq^2yIOf)R);obTVi?QOw#aQ4qH%0yoLg=ze+ zJUFQhdg z&Fo{eb_<93N^F|>fA6J1qLz?&QX@A_!qR1iTI~b>34(@i;{g^u&-@Nb_Zh1H>Yq+- zJ$o|ApLa_kmGFP3HUE7lUAQ$&uN90d&7*@iEQxbs&-Ug2$1<%Mu(0WS@5N8nov^lC z%Rv(>00taZav$25_F6lB%$F0tIc9&>+B4GtjD0$Z0jw_HQf__#^3L|Kazpjrf86(b zap>=O>!iwO5A-m7OJMM6AI}*;S7PtVD|!$!nzDL}R%FS%xwyU!(U-;fFaL<~#|por z1jzDqC46)v1|imjf-D4K(@8vC%DY!E5rZH0d(im9et!$Qe+qCNA+dk)D4)=ub^hD< z4;iJE4dqnz?cJ1TeS}B;+uPL~5C0fR*cO8H{VR@BTTFh6%atiFiY4!p=eyy^PC!%G zpgnSvDqh&X41{oE2q6#ucN~;UE7Y(xT&q%cl*_yS@Uwk2Psp=Q?TovTQfe4HctMxn z3lm27-7Hi-OK*XDtUmUC?iy~G07S={(7}|jSJ)4p+>e{mOrndR7eWM4*RpphLn2KO8j*lv55FUFZ^itKnjLpAH^97@pUV z%h&hzGXFoX5mzA8X-H7+$V;R1vPY0L-5x8|FltclmFQKw!56_PNB=FHpfq+ERYH+5 zL$Hkh&uyEGqdOV@0VA>U!``3$a(EhaNF^De{r^)?X>2@ZEx{i|vp7rSmfy&%cRY~3 z?LDBe)3P0Wa2op<@iZ>s{{+bB>Kef6Sw3X+KLLX4EXDpu2^WC8a6RXWTrwYz$8PWP zy;sMi?*I4@EC4~UK{lAcmG76Hecq$m{y)tUST?j>9NqsPACTV@S^s*DY!{;kr+tjf zjOmx7f+P8;E0#F49X<49%=)2M!uy{oRe85kVw+vcC+Km4<)DIlZ_bfe25+NDB55Bue*U!zAdSsZ5&8#9YA~`a zt34(Mzbj8eGW~B-7_>!<#$sCZgAEPGjJ#kJ0FPGc0_AM%Bit38z%?waw@<*t2l=$C zhC*sU9r(Xj4?T1dI4Weh1;$aL=#?Eckww!c|L_kUvna7U|0lZj%fOt-(+DUIU@Y$VTo`=1zm5DC+}^i0@4 z9K2q*qz%=V02JzfpWJRqj??84$mKrl3vWR7klFv)7iu5y!s5rQY#IOA7Y@o#o&VXF zr68Ax@kzWS<&T|9`YV(14f4qT0eVuJt-L`_%=jb~^>lo?Z_&{He<)!84+Z1TeV)8_ zIbfh$x$Nlh{-)9N7VPY_><~t`vj*<;cPnv@SAZoI$}_Ab74>iXEPV#<*6PtV|B?2H zW}(ORpHX$kDV!ewbHMcmU+ z=!;0oewKnva$rdv)qzo}3a$r8G5XD#cVXo!ziVb!eR1$)rM_*7{rot)eR=I#F}kCI_B2Nc6}8%b#Q zW5KEpCX{>MKrbY{>nUoCc{hkIC1I`Hn}t--yqOCCWEYd7&;Bl8d}uj%_^)%W)WJER z!rLc>jXEBcRHU{LQQfsG?@xYwO){-wAEi5*8xdLsE%ivIh;=lA?zR{AUO~)#;m$-u z0JPD#_{&B0qjs$#-cO+UH)iRatP8Fo&`0cweBR#9s%KjfC9K$@R#geth8Qf&MAZBU zIaPTqbq54im4J1E&8mcw?|jiZ^0%zp=UzNb&b`&}JRSwgEZB{4H6yhEE4&$ztxb18p;JW4_20)y&U#OoP_Dk+KQ)Dz_-Lp6492W19x!~DSu(yhH26Jh? zTby9an{@=-RdDB4c0;Tm>vLJopMC9@AeL+28|F7}hkapv0<)xqfF)6LGu<8j4me74 zqKqcIgbqn9y(4+ANv=yf`|E2Bybn>2Ep|5W?7%a7?WvHqRVHz2XGbK}a#;>rN2GS8 zSSLrM?u=VjcMr!&p)aaj^%t6Q8?}oahS}9G3+Sq>$n*gXYVRlO6H+YfdUa2`>0Ld~ zCgWO_xZ?6(dBxbsOBwKQ=|1uF7tKYt&C%;e&yR;o?3)!SNOWlLs>H8i^G1z`z|#ij zx$4WoQ*!$SOEvJ({){EJbaWMtnfr>hOi6*z{F-A|b&!a=vFJxva(+VUkl2jOdZHWT zoAHQs)`b#q7#keVq&Zj4z7yx<>UrShB%UGZ?z~0gkN` z>ozI@AJy^J8~Q|zz)T!GbrPGaGgcX4seYqQpu$s1|f zz*xh&CwlfM_ zm|M_{j6M8Q855gIC$22fJr_xa=lfTL#fmW43W1abfoRb??yDmfiUriI%-S$lrGToMzAwB|pK4*X z|A-lJThhax1V+doE)nW5@&J{&t@n@i^Ot#{YsKrYw%_d>yPLTu+woP!Ard~AOCH%O zgbSn@NrhxIx9>svOzhqn2V3S&fZB4MY@H7NJmhYNX4jTI_B-nmY*)sFPUW_XvA-O& zf)1Sjppg7>oi?rr-wy?mQt~YM-7q{+3CeqpAfNME*95Y0$hGi1)OZ3=KZ%V+x1p4{9VqXI3xaO-nfwf!26Kkq4}t2YJ+h%^yv$f7jhPq5RNozEdZ?#soEEjH z^mRcx^pE76W!1bYKl#ew*-}&bbmE=4Q#nb>@aZwZqyz2-)jY~3r8GVa)C7bmL|}%8 zkvY>Z-=W}h7Tb6(qw0KTyqDyk2;NBj5f_#w z%0iPqD)c9}8Q&1=$d?apg~>$jym&X>sPajJ^Ho_Xw0!(7R@Bbc-i8iyr6Utg=#r7% zO*mFqnyv@z#aRQxs1SY24V=sOmUwqAM zvKjrkM!g%G{24y0mTb^hONl0E>-RkKvU?q*0pScQRF!Ed-&SU_=u=l564#!sJ@G$T zW)m~Vm;@$*dMWHm8T_ik`S(2Bhw(iZlTvJ9>qo!rfs6bBF4I4&J!owdbMNT<4vdHG zHoUfo(~yAxppQxEllRq}Y`~Sl%c8Nf@kQM`;?&$ay_3RykkA?bhMWJ=s8{6aYfjv4 zea-EQAb3s>g6a#3bIumJb0*&7{Wmr0RdxEB5O-@_bGzjS8tnv=Sn_c*Y117_Llk{Q zNsdF`=SQDfYi=zC!BXwu+!r1a2yehnQj?d%Y|kBnUlYMI0|`W?=5|RCtf~)j^aas$ zg14S|NG^B-Abb2^xA#pN)6KjhK$<^!5sf6~I2}N)}`zpSTn{{DU+||r`4Y5v^TzbK~ zeW`SYE4X$oV9RT+aD6N>%kj>r2yZ}0+DkNut-mA0%5l+(m-w7sXIATbBn+$ieL4N! z?gEWe@h^sZ$DSn)Zin%24f7?L1O%@?k9#(Tk|JTCFFg2k!`DLIL12SKU$MqDXy}g& zEACXkV9d`aR&8t4k;!x53StL1AA?z$?xksT-Ay&f8oVj|bV&Yo7GgH7C9oaR3Zx}t zZB{Yde^Z|0uu3<_2rk``J25g#O0#&?#VP-tMwN<Ynj@sD+%qZ;NCYJ2hIZ)uu38s#mWifP#yVz4m2kHF4*v`HzWxv~ z831rg1b?T#V|?2}p!pM{n?Fh2(AU2-%{Ubht6%~*_aeC{IEMFR*LSpGA+Bs8wd>O2 z+c3I!w&T~GNFnO%Uhb(m+;ugMUT$jae?^kCql3PLkILwywxc@9JSsQkeh))Uwdn3e zaXJsGvAy@s>xKa0gFPNu05N3G^QUVO9ANHR80*F=Hy)mDR7Nlso?*0HFgA>Kbo}F& zess`}lUD~2d+SVCINu?tUu|mcM#g0$8YStsedoz$sD5ltR&Zc zQwtUuHPqNOprQO_*o>Ut+x8wCmd^Gp+0D+=M_rsZj>2kIzZK1Fl?f9- zEHg)Ql=rOK6ArSVPR1@j&j6F^fYR}1vbz!4Q7AtAU{Sd%(3G|7)@g9f6;NG9#asLqr_zUBqi=SP#=umhMJJaeql6I=|PqiHCR4rXo<+a%G2IND0UQqEjEBT-xZ{^nb z^E`tydZvO}o?|&OX5@UKBVHxD)V4?U)W`T`zPz)8izRhClI${C=!x^+GG)QNT_v6Y zUh2yCyhBqI=_f1?9n!}}L!v*j%ga2>Dj1y)wCT_O49kB-e-p&oZDSwH<&m^$)dE33 ziQ3eK2ULo7xl*Xgu>DA#ak{4L+LF^yc@II0d4U;{cD`j3J#&GV6~v^}>>7;$ZW!5oQWK-OecZRAYkW3XicVWYT{d{5%au)%!85vI+K<6Q?_2caad)N@=rMsm zoANzqXl>dVZ-a+5<7Z3D{C}gA@pMRMRbjv2>Gdp_7;7nWZ`kxtqwdZE;d`n7r-r@db`HSE;z)9b}bSV{|*Q&7un5oSu|^I zJ5W8;Hp%-vBVCWiNFZliMEeSwG>yhxO7q%-QPBHJH;lINUUaq{L6Sm^q@Xt6jfCZP z28?{Z^O87!i7w!>*O+f+DOX7^13sNFMAFY_fJ)0Jn@%r;rx+zq`Zd)m4okE)DZlk3 z=~oVWNg1%E#gh2(S3|jtG^n}$!ni~-f-Q+>Q+fB-Fg*%c!j4uw!Igp! zdO3@~(TOUmB&Xb3HMah=#^Rl}xUxPky{@iy9;4m8GGaS#cX9mbGGFrINJw&sehF}e z(9)(Y9R`1w_wAv0;$FeNwDy=Q?{Xz_^i>hR9FA*du2)&{AbWszsZ4;#Mk3W zSJwBhAqCvBnA!BaX&moRk#LyahBW2$%7V8jl$I1k?WN#l^QXcDBL8OIsYZGOrl3>|M|uJuRrEnE$#7lQuX4 z{rW=!$?K~Fw;q>3&idMgFJeL`pPq&NA2;pZq$2RQ^K$(>T!>ako*lxza9-V%hT!(% zEm_}(zUzE?4%^6g32PBzvKY8MUQjjTsEJh5WkC5VU~)O^`an-DM@{Xzg@WX zdT9KRSUq?;7IcBn6VunbRJ*S6Ac}r=gTgjJtlt@*LFYp5$>?_ZNVK9xXO3 zD~_d5rHgYuPu70&o7k{hN?Y1K=nfGm8D%?UI&|C}1F-M&3gS_(Z3mS`06}55jLrr= z8wXv&gp(8y^WF8`oi15WU~LD;e#mQM5AtL8i=y5onq>pcybn~<)d-7PPt7+HIPyL( zYtBp_cvte%KD$t*tlp738@tEbwp7+FXbw zoQ8Hjr-QMD4E{29(fm5pGjpG?fa&DxH7IcLWm$7#dTm#1cl}@U(J*y`MWt|P(z34zOc8#oOKQ%F5!R@&B<~pOla7j z>0({=%u*OhbO=6?jgFCEh)${457gJ#SG}u@rn0^}Vc?f)htVb3FdBG=e5J5c-;c!7 zB}(>d$wWB_pt(SfdcBlk?Z7b6^eA=ShsMvSNgytwm-axKv1vl>G*oCX2iZ_=(ozFS zSL?gfu6T|cfG+|F@n9Zph*!Puo}{A$o8xqX*mt|y77kn+SOpk3TdGj*NMjd@cyK7- z?HTi3oHOnkC3Od|0_mfaPUVX089p!UL&)siG~waUEU#1}8xwdWc9HbcxXIvmc@=dw z>iSChgpp2%0fiw|I9Z>4w5;5G-o?h-saT_V_#Tx&LQwE*h)aK6yoo7SqBvcLmSQJMxa4|0qaKHkWiY2?2avEuLu&mxbX2M@V0tNfx z%YmgxTP%;y1$sP)BQQ8ojMoq%t8gzsUz3pV%-Vv(C#Mg-*oWATub|`N9g|2-vFPOO zu5z=-zeW>`gSer?$l>>0S2Ufe#UH4I)Muv``@SU#|LppmkPW0@hSqBo5YUa{x)PPM0YS{J0JfKc`5s5w2SBeT(k|4dOyn;pqBN zOjV8|=*0o2VFR3mE+>soN-t13+Ta)1x zzK-;L{)colzpcK_rJ*D9Z+41`%oZqj;Xi}(YqoL$5EyO=!zgmg{KIv^w|E}qsdlR8 z@6OCiptXWP+*Fsn$KNXw>))p0@^il>axnZ=aur7gKELW`mI?ee1&$>qDR zQ3Cp<3ZqQJKjpWk-zr{<-;Lm|j{L?@@5zBfu_<&DqJrpd=k2F4Yk-u_uy%dB)SV0J zQR$e0$rBQci)^u=mq%4lS31UMk2p(qRFGCL&!H^XsaN+y;Y1pSPb{F6Rzbjtbv}Yu&2ap<6wo=^f?-*8 zco+A^6uW$Lo<=VaQ|~x7&6WLeGge5Y=RI*-?>Ek%DXiBRo@N10p^5$t>-?k6O@93e ze-%zHe;#Gr$0u3vU#7_0tmRLLZiOgrCRJ>x=V(HLjk)dh-}X!ON-Z7ie2EX=TEI{l zk6!hAW796@5Vi4)0;*i>EIE)qXX*Erc%H%Umd18;&J}L$x!-i!kq8 z5eJIcVu0mv3mSxON}JFplIQWL4IJAo3Zg%UfR=rR+O=K)+z(XFsaD{`^f4*0-4uW& zRT0#aIfq?I3eL}L=ZfYj<`rNtfyaPQOaX-4F`XY4KnwNS zPg;AM(dF02nakr(mSd?2032CxesLu5o0F)KkfxhPJ~Lb_l)ph%-s`Ji3#$;x>9Nqt zw9v45{oJispVwdQLw?4Zco6q@OFuinc)O7ynI*6$LLWo|4>o$5`ZNMtFDHE?l%t$j z8>KG;BH^?&wG(il$AZ4F1UmEt*;Vm$C2h?mTgV0#L1pE<;LoPO&DUO1#O1Qpp zI>3F$*@O1vQf6w6iL^YdMx*QCAhP4pO2Q8aD){3Lz%%qd0u+zMOk(5BstmAn|AXlsd-UBeZHnJ`6Ffr^ZP#b!SnP~WTrFYU2{IC z6w7Np#;qjFtCGrBlM7z5%^>uq;Ylf&p-y4##m?e0UWXl$jxX2T+cCO4b|D20U76($ z%sMU}PKAZgDKC=FHPfa?vB%a;kBm62nk3?4|Qs7PeyBsxq9!lOz z^@`2P6n^+c42P^dR7YarQGH%eAIn^W-X{D3=VBz;@VTqr@002KwktB5GmL6R4R*Ui zkFIj7E&WF^QVr2@*85#239PRg^CccBz0;EHEMyjX;0=Y+e6`oj+>!oGG6b)1kE0gwH&5NVBfq8 zNH>fy5Nl9JR zRC~UPCN4SYCx4(0=!O2Z5vSstmh6t|n&@8{*53E#uZ1P>N>SMInNx|j>A6r#+ zm+pLtl}SfktmYrLo8FqmUTYyi18_t7I2D9Mt_cMWoB2%%gjFVMyo{vGnX%`;=OdsZ zjHS}(y1O*6<8K=5*U`F5>AW212!*IgnJG?o>LWYs(UKXJ0|;=@mQuZz4#U}>vB?ehFyxRvoR`T&{IOsfORifT|k^rvss5-bb#lwL106yDo}xS znYod^^usQ6<{C--?bF{^SvVaKKur5A1|QV|n{Ly3HdB)2?3*Uji>z*Y&xc>AVTn8C zK;xykP|-l>9o8@&#D{gi3?uQiLhZfAu-MbFO66wtnV!M@bOzY@|LdvJW(n&Eo4BqQIn|J9BYyJ zZy`7M^lr_K^R_jdC|+!ytWFotT>ne-oBettuuNgg_HscL$yLDd(WWcf!rc+0z{V?T zbYKcNi%6q=poBww>U+m^A}%XO^&ralt0Sl`(48PO!`MNBt~dl+e)u%CP>|W`&2Vi@ z#jiHQ(2@J3N`a}c)ImsvKCARForatr%j&q=YRiz7qPxn$%T#?@Qx&T+pq}e+x?(98 zW~7Eq4I(|>U*-_m-F}gA*Y@x_B;?r>r{di1I_{IDC1|g}VUb*s_Xrgt!1bfHBc%KF zyDf90OG`%+`YHdZvRs85l=2&eS&a`m8Q?EdR5FvchBE35hB*vR1vLZ7b4^WsmE)tc z+*i9AHD?x0chd>KB5!BCauwpq#F-m4qw|*e7+3U%wwyo)Pj^$vsAsqen0ZEf%>`9A zsi@TgbtXmg;18a@ZRYPuOUnMTDfZD%+WhC^${lN;DZk2{@vyDy-ObTWjC9_$epz<& zfK1pWifK)Dn;V_{ue%{2D}3bS-(xdG{70re1%Gb*KWuQ%~?FPb;9^Qf3g_6OI$DC4FB~g zI%Yh{WMt$fe>D1YowzDOc4!(jX?4HbWsVo8W&Ea805cv@q%0$AgnxAT-}<{_JZ=LG z$U?m;YBjjL!iZ8v3EeO&>}XcAUs)7Kl$&3qS)Kx3SazFXmI7CPMBhxzpj6mWsr0*J z+}X{5vjV3uq>D0B(H5P!>y0jZ4?3}@BWC{v*;4T4H@VI^raX^TreR;z1a!#I^S~qB z3Er8q1T=<5uKvrMU-MaxGkW}XCVjqeFIC>X$>8UrK!k^cv-h5LA=8bKBmey_u#D3i zUYuTzN?Bhhv63OrU8EbA!iG{S3J$&Hz;Pf}r(mSBKw}A0oh7LZ!6-Wqg&~rK=TTGT z^nOtFbS~Zo-^Z&1gq5s7=f+x8tTN1xRsD#M#jjolnxEXXGALa@`FnIpoKh#aT-q1o;A*vQVM#9{IVHn z@dG-GdR`JLn;jaLdlh2iOGV5U&$zOMrKbdmIH^XAN0yrtzWjI)gZb3TDTt=z! z%83P@GW^qnlMJpeKE&nfXzHCzHa9_aqo?8^#5{}4H@MRhOz`EW)#=PheBWTH*fdry7Q|7Z!KMAh#4h zSfiqc+I>0uS(e&Pd8SYY)%=S{nxO)F_oc41tXNedrk33OM=KIT^xquvX&;3M`uESq zt-=d93${IF8n6;S{BgVh)QrYDMWL>WW?0_~Lw}{mxMGkULXgC#L`j|-5xo&+|8~{u zox3V7NAeZCzv-)`z!x}d;kaR+{Iyp$&BG=e@?7@&$@$(EvM3d<5nwb=4lnTSfo zt>CLlXAmb>UYGHhdQd^ZYJUx;8sj|Ouc_cV#RMJbI>-16zAxIq7Q>H zIzjXpohYLwLG(J>sKH?LIz*3dL`fK(NJNRz!UWNh*Z24SbDz7{de*vkopsN1p1be4 zdoSpkj%`VvLbB+C0;vbpMQns|PAIW=@%gzr*i^@|zim7_Aj<)YY#N#7OcYZZujYbG zo;wv@yl$@Ep3Gy`a7nMurN}w~R}3+gnRJbkr846PL^JQ3mk$o6l52ODF8m!hC?c($ z-^imS>*d3h(}7(yN1S5U(^#c{Ci}%KpD>#@&3spxe}itG66fMVDslg?n_d+%2{ulk#uw5KMhXggN?fhz z)p7W}h;Cjn(oDD-Z2XkyKg``Ho3f1)L-og^wRk^pT5PbrTPAL%i-pdE8~Q$mvM0P+ z)QPwKcPyb_8h4v*fiHkriqU$ zp;8!qU~&&JBg|m)OOB4j&_Js)aoWk8=itQdi02nd^gS6u+~Wy9I$-1nrF!>X1d>{>_#-XPQ=zo6r zrUw)&*b2eMdOCI}#GzDweYxPu$-dM))JVDhm{aBgC=1Sc8;s`#hVOZmE>4#o%UfAXq)44r)D_4F{>`oS5A)IW{n#4n8Z#G33xWAc-+kIT{+ z#)|jYq1AfykqSu&oFV!BLu_F2BLUo02TNqT;I7$l|=!#WP zH|nlCclzs*8tVRz_I-SbaTMz0F}SKB{)!mNq`q|x#CE($`^fw(W%A8QQpBMWrPjPw zSn@D`(h##5bx`h?+2C*gT(pH)2lV`jcXcg{JxofApRv8grAd{yg8jf3rGWA?legJ5 zZqdyf;6ZED9*k*p**rW|Vc6_VWyX#ksY;dOVq+ z<6D!%#~CDy@hv9k_kP&ZxVW@_n*@_&<&)SbL$^Pphw|V^&FA!fy>Hlbp3LW|d31nt z(lOhwK=~fb`@aZYRQ+r{qSgC$Z2e)YQ>)_7D$A&iy~IdD^gSpCwg*R3CT2>8O8agf z@t`D-aA97L(MRSRpWz71u}n-npj5W(J>;oO9CI?;C-FLY(q_G{qgK{3g#fX)YLN^z z42FNcV(HGvH&<<_YgKOgmz_SZ8n;hIXjKe0Tu2U9zK!dkchKk7G-^{1D]c=$!7 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%0A5lqh?7RwN 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 kU4!^ zuypUxp*@n+@@Guh6IMsC{U+ntMFH#rqQID#O;FZ9mZB~D&<^MaLpi1o^e%WqeGaPu zDS#TDGcYGb;DcMA$088lP-@5uc3%Bae;1oLh}J{UM65eJ_AW{z;J2hfa&XHGs%+?~ z-Pn>WJF+pOThHdwhl#SbS$=tWdGrtG(JyUp1>WTt6&X5{XNRUoMN@@;g^cEmYn2Q%+yWMrq}CS3oPRT$U#-d5U#;ypsbH zn4(Cxm@?F$?a>-j8-JQCZQqz~+o;~Ue_j83t)Ol?ba4ceE8*}q>E_s*KXkS6(&eUR z%4368dR^Ilq++}Nc>}P8Z~fyX2k>p9p8afm@=u=)p63l$w*BJ2UE(N5$Ic=WjS-wU3jn4glWxz8*3GB7BOx2I4OyC7^}yFY<=Il7L9}1T&Fenn{1)ErG{FZE;zz=9F`^Yc zn=WUDV!0uJ5ltB!;Mqwk2a*QmY&NI#U{Z>wl8ERF0vd}_dVtY{tHLzZC^>he*&)7S zblThMmKhe&A~V&;9ljbkWYok}rB+a6Ot!qPkK_K-YP-}F%6MDRp*_3-;ym(kR?)2H zG&(3Q8MEP%Sf-jSQQTS%Qyv`CDTdDfYQmW`DsKjxty;lv?_lZFu=}j>ReFR0tdLxz}AbZ+rZ@69&Yc*A)EN6RvmtPCcv?r}++S7)0LLrc``D*uh< z+0dKvX_%IqiX%xr$D8N6i>z=#76PISttt!kE2Eci2#Sj>qma1)0@V{F4FS*mPsz=_J9}_<~ABy!>%REWXgWSI(y=s6VvaWnboGuNapi$)e z1SOX2 zvm!m1f}BLJ8W}>R?DlP`dd>0iekp~+Whok{CS~)j2SND;cG58sxsI*P{{q$de-tHb z8|U&0XESCgb*dC>5tdIw7k2T32U}Pw)|s3lpL_rXCrT&ov-p;U@%+-a2a#W*bieu4 z)zy7on`nnMB{-7>{=vky8nSP`q*U*erlkhpdPaXgqQBewXMvYp* zn#>Fu`Y!Ttp^rmV)iB>>Ci{xZ$}!f5E=x0A!{2rc3N`S$HO%|2Ah&heLs!u6dYuMk ztK^e`7`UQ&YR++3ZSN)4Rctj*nQF$UT0y@vW-l!@JZDyKSmygwM7 zRy^h6K6zcy%JDK#r_dCdO+h_=UGY9@c7D+rJUn(YpTa;JcU#3>dWPB(v+owy(WAE& zoxglV(N0X+K=2X&3sDa-_>3&|IsePFO~3aGcrLj9*9&x1_a^;Mn{vIcsaN&gS9N{R zDMD(+B=%%*zB=v;F<|$kQUgbj8+cMn?-UNoq4$IxBvg&|rBS^w>{3H=haA-hOA2v# z^#z`BeLVGeBQmx-R;MedTR)8hwM>| z$5Xt|Y9|T7t`V8)3B}8ILTsU{@d zglfAoBEFq8{GuM=EvIh%Qdu`zF^s1nw-&cmz@UBuB8?;m4``^1D2KPPlx+#O)s?ew zXLC8AMn}z#B8iw(e14le<)EBan#5L1OB~d5vea@PvskNg>i8MARHTK#E}%V{gMAEy z4D-oZyg$}$%FAZSPk#r_Kz^UjgLbu?l*hw{n|$gK$-vv5hKXrbkEWhN9YK6D+;i&JVK8Y@I8i}hKo!1G!kh-c(BiF#5$@;h2OJubUK#vO! zmNzk1Z$e&Ixc!qFIH1~SP0#8)We)aLd?%dntNl|9FbrVe7*Zn3@R-Ue`pa>g?XD|LxQN_Gk-o zpC0$A-aY0DZ#U|H&**=zVtqmsi0a*_;O%<-@9X;CSMgvX|Qu4 z+a?DP=cds`c5zfbwe%JW5L5GdHr-+;Th*%Yty&Ewkf)L1&V7$2Cxo`1)3Bgh+nCR5 zSnqe#X&j%;DI1NGVVK=*<-|v9Dw0#=Q7`W_T7-8Jr7DbW;yqZ4@aHopg3l8`#icfEi?MwZ2{qBtZ|LYp+sG^eup_ZJ<()*x#5IqYAHSK`vR-Pb; zpH~>!CG;`Ikmtk7Q+4?J6lyNOoHzUf8MuRQo$1?067Mrg)26l{EjzJxImolckQ0iz z7|+Pu#&@utHo6YC&Da`;m;0SwK-!s<9PSk3G}@zN5oOaaFLX-ftgs7DnQv_|bp-n1 zviU+7?o__zjK7!b8HBx!BMmX}naPFS&(j%)j)vdG20RD&YfA3oJ5b6g^*D!od*_(6 zAfA+E1WRL5*=bac9#oroUuEbq{VDtKT+cjcH*ac(ZA*Z2-O)3Wd(Jp3s~MUse9L%M zlP&gfh6hbNXYAM+x$Ev|oOf_C^|7SPv;I9~=1+K6?mJ0(yjOPotEkH_rlcLXL3Y_G zV^?tR=1jPsPvgIhJh3ecY`$sCJ&kC{p0JT&wDY9x?a&i?XZiGF^e9a`ww*V9_+^1< z`q{TWi&50v?$g4ah=8$gql-)VxtX{DU0hu z(P<2w(a6s7o?0H>VdU{8tRItu7nVoq2=?T(88Z2bJE5bF$E6^KD0Z$kj~R=}JNt5*Yq!7%3%=WR7dNoRpf|}pE?KW1gH6ske2z|vIIqVB z^NMC{GG9q1fhTniFKT$m4S#KC=Z*T-hz;gil9B}hdYC( zlU=B15*9;ZoK4PDO;UKI*0+zC4n^c$Rgr^;m>~m0{~} zwV0LLv&sguJ1ro$9}b{*SnW@GxD?iNout856F}wLTOp>5((4pgdNe!5l>v{PmezVt z-MTBrv{pzbwc+sh;PNOqd|oCEhu_Pj;qX1POrUSzljp1_?h@Y9_|!Rf`6)kb8Qktb zZtb+Mvb0YayB12oaWis6V(lY8A}I8mSqVFl`Ke&k1fv>v(L*pdzLm8K`*0zbZR6)) z9p%`{Pp9-8;J%^cDfYJ2xUf@(E3=AD8I*HlVGrq#^Ja|ahvVroi)B>umUlG?Z6L6B z-cl6hz;RI|bwO0X^Re2xt>joz_5n`){Tkzv&&&1gyOP^Z^b(mrG{JMKB^lk=&gqA4 zDe}ZhcU&bCqVl%7Q0U~@<( ziN;F}G8*OG^HxTzE-J?ntFb!A&A9n%F&gm&G%sO0aZiSJH0XWOay04G{m~LV+TJo; zaxE3nJAJWpY-zbK2jA)0mVxio$ujVrde{-e_eTn>_cF=M`W*TqaW4x`yzFy)NNSr7 z>;VgF=gr!gFJjL0Ff)oy599HxkcGsoiEpPmt|)F#1kT=c3%4n`ZCKcI zFOY3|P|IaL1)3F}H;Wf3K1$Fz-Z>pxMuHX8p7QxEEtL~!ant*JNM|PCxj3JswJ@oo zi>438G2@<)1dZo-4B*m`(5!t9tE9q?JT(LFx0hX6`83AOOZ9RGJqx2IMUsBWTMJ!zJH0>qOuRM9$`?2RJl4&G1g2 z-yyDJZ=CE5mwJ77mchx(1EA;RuYi~Kphg>)qCPLjWcIyWy=G%8+(=s+VRG1sr}2Hg zu7^+fdK3Q0G)8oW`3tEw>qfCzI5#FSfZJ@jcu~Z_B`ln0%29=!Uv{YbGbJ`&HKrYX zP3A{RSe+MIE*6Sbw48KTv}8KZm(&|5F|m>dJbON!ddwT)oXq^WoXDjqpDxXuq-=&9 zOSHgB`7+AcMP+sqdrHcH9MuL9MZzwzH5lV_7}ckC9M`xQ?D^j7zIfFv5Qz|P+IGSw=I~p*SxWl+1F^ca(Px#muEMV zwj$44WPW!vjz@8yDXR1}JsV?dB!-uaaXQXeaoo%)LU7wXs52K9CIl-j7CR$o-Fs@Jp~ zKCZT^3AIgaS3A^B^{m>Zp2N~zGSaHL58-B!HcC9TUO@68HIJLxnEih!lR(VfUgp#^ z+Ade_cSKBem+?c zJ0PZ;##T@sch<0t`!<7CwDGGbj*m!sviAR#%bbh{-?=4A6RTh-6`b(c0X86Z=xME?-kq~xlekqwEJ@`?`q+H`lpot zc=7MMs4sU~rZQDX+de&bx^d}rci#WuXP0nHN85ddVw&21Ez0)a{NrXjmElyA`V1tm zk4plloju61+nk$Cg&zd*`>XvhYhV#T_Ws-Z$zEK0Jm|WzhWY>gSyhy^kUAIF&p* z8HL;N_n4gj`n+ z2SCf!=hAsstKEok6M68sJ5D%dysER-uk@%3A^bbTfd~Fkf8N-}M4T|bQ|Ys^ahnkg z+}R+T;eNzMpEz3`uL7t8$lD7%fA}c8i$>@Vz!$S>6t_)w{L-V7hK7`#%;Wtz{u+t# z$}lC5?T!US+j0kde2hw!jI+bMA4Ph!3XXPB2<8PIrMKaXoh&QOh&wYLkJ<82&Vch* z?Dx;7^F}eFmkVH^-QC29dGIt{F!3qEbG15Je@~|CKpb%Lg}mAjaNS$=zj56X|AiXY zeZg+sYixx*HS~X9d2(}g{|}BX{Pxbj|L^|$6?awlnCj{o>*}ia>dWwIxNX3tQibP* ze}_MdkJeW=7vJt`E_|%vTQ&Xg+g+}H<#Y)T0Ok<-HOI-F8xlW zI#PwCMq9P9p02w7uSa$1^lRPCbsFSbRaNO~t*mrco3{b3)x3>4`LMUv)x7)4fYLDE zr9VK~11LJX^_qrlF1%Yu;P>FVxV1jkU2imo7kBiHRW#g>G?lv2P#+F2{duL@7#izo z;oEyqtnOM@T{EK6>L2Uo*FCka(N@3e2FgGj%G6x=oyur0N#FL?x&a$#)Ped~SEIS`6OGmYw65maky^i|H3w;GWc^pi%x$Xc zd<`#sv!~j;+uN(U>MQHI#3NOu<>W8>`*gDUSN{Qxo4Q6C4J_hMhH5<;tGV#g=E5h< zn;N`d1L3DX2VUM?ty!nps~;P~cOTU?)@qHmbeS~^f4Z_(A89WBLjP5CCVru7x>gy1 zB0}DQX^_3D=JD|2@7DD5X)U7gyYO-I^om;V2mma+M__}s9=KolSbzTZfUbFb(Dy({ z3zilTO}Eh)&~S75qfY(G-U1Vs$BTE-l(BGF8rIS>ek$D=$5qb$6d`iXnd=bzE)PLnyU0`ke_Ix{WW4L z{sPyu>=KWOgZfI`uj}@?@Yj__a}Jn4*Q*OOSFdZ4U8Pp8>cZ4@UFwgOMtx09Q~D#Q z`l}#abDFKIhZp{%mbmZh46IT}>yP2FZ%pAA{f;4e#+1&X79b#41M$=8)KIqOK-?&u z<{XrBm0H!Mg=-byqXg?e0s*M{pz6iu2LCjPN_}+r?yJyV8_m<*3bcp5ZB*6*LmI%4 z-hN%wzs2icKuKykkp_rv71FQQt5A)f*88xukc4K#Xah)tbl_7<=dpXVr3*5=IH%!9 zblYP|__401RkdC!yr#qTTjw_qp)78~T7C~IwE_0)@7McG8(sKu4KjJJuHP6Ix1bXAmyflyW?9u0 z(foQ#w+(pLssp>L&97GgygpQ`ju_PD;%XG0KN3=`DfJ;EpmFHrK}3dXwG3shrPW5I zQeRo?C2nbeQ79C!x1}E-uexGD0cky@JBKly4=vMBtdBK8$SY_tRI{U6By@5WV&p2# z*h=$N;L3aOr&;uE#QT)%Mzi$WkJbh%K;>Q~du4d7b2d_`Z>c?`tMgaQ#U5yc@V@y9 zC@v};Rsh1k2PIngm6j@K*_BqUAJ8(QpJr-7zoiNQS|haq1k*w~hi~8|&}r1F`sWu| z7rOkzwL0nmZ0_(6Dsco!R8Xy-Y6=-M|Fn7;g=W<=0(o8ma;EdFb?z&mKmTrz3 zV3HZU1>VE0mIaNuxU#1@ytr34jSBR~P*+u*1CYe}XanS_A2i^{@Kmpi>OZaOdYh-A zU--UmbG5Es)PztatSf(P!~sB1D8H$tqPM~_j1o3dfv)jhrJpKm4r{c>l<~(|+v0Yl zyQ=QGX+fyLweYO2^^uN-&IWZ0$R8^3g?k{PD5jbb_)9hVDRc!|h4yd?pHdU!JW!j` z?HoFJT@j-#%~&I%0C+%$za-WA!wA-s&d~@}DU$m%%kx%H(BDLLg%|3i;d&N+&l7(3;#*0USt62>#Hd2f2P$~t5t_?zPmm+R;xGa@TYAL zZG=?N2!W1HlhsWb#f?i*A$|s!o3)Xn3!c zRh_;-8hWhIYPB9g+cL`zG*ax7Kn?1iNdK?PVhqkYNfwY}_|sTXi#V)Z)O-Z{4L<=m ze!C2v-=c0^i^GfG0?Q7E_p20G6}KwYx_-XddnpB_Kf`!rVFWTLwY<0Gwz>p1j>eyV0v zqV6K}v&J2x-lqatqGao&yXm2-$MSXH7kvGuelak{ca-CAQbx_4ww90@C4nOh7(?i! z^r%XAdUcDzx4mHV*3t4^SqF;mWJSk9)F1~MA4lNmE@^2Ff!yfCYSbq|?@6~{b}x-X zh21?+!*S8w16WbNHMp{?d#zfzR>A*zK%`&Qq3(XGfg?;96y597QlrO4jZrN)eOmSw zf7x7G2Y+|J1NV2oQzvB!H$BupYD1-hcXe$Q4^r8o&jb|wGY^=FpVgrru{YI*JepZ( zjecybOx@C2l}Bqs{komC^eA@eoAlRQYJp!xo8RCg`N;~jQK4A^sXAp!QyZyi*+LGQ z?wKE|^t&2|E+2ExZ9dj@chujH71agq0`vrE;vhxe1vub*KMGwxh=!>b955MUo%+zx zR*ipYa7({hX;jvB^=V=Kuk^rlZI=>ffFL#(e~+3Dy%^9pcfa2acohu^k`HnY&;9lb474k&x>o2nzuOCMAbV>o z17kff0I#g-Ue(hJ*5e#_N1z8C0Yd_GY27H(hOvr4=NUzVt{>KUTE*LUb@NgiIE~DJ z0H0GsS1b(a!5ar7q2}BQs;N;^jX1VlTG#qQZ6(P1;PAQO#qSL-zB|15-tgkR;l=ld z7e5$Y{BU^jhr^3M8eaSe=z*YU`%!nk=1%8%um02DhTsj<=a7CFf zr}__i`{8p{xGsK=e%_^@_vq&y{k%^E}oE^U*W4)vcBm=$3IFk$CHtwp7QQ zo4=tJmgZfM_+H46{_QcpRr6ajzkTL+0DcFs!1Rarui@V(c>f9g!Tr+v^oQ@iM}K(# zF8$&CJ^I7@_vsJs-=jag|A_vO<~{mDf78$DPb(sw0Ztt+X1{*Y+NM5=23EZeZd|z23bG4+!7F-q3cOzE z_yLvHpehBOrbn%MG_-f9x%h8d4b=nVgX8-3O8st7JPy^zz+M9f(OB0IW~th!_amBw ztILOes9i$ohonJ|{1s~j^sKd-r+EmkM;vUgXxVR7w9ME8}7 z{z@y{2K>`jJ*Z(V5g+3XJ?imJtp}90egGTkml_GLzZ_ot3*B70fk|kK>T$hp!`&d^ z-Gh1nr8T@(rRe(7U%N>IFaDC6SPOimm3kH3)s4~GfUXI&f>Ba+l|mi<1RKOBI=}t> z`Z6>G8m)n&FI~4k(e;4MMPEPB-6v?+KCQ!yAcCI%6ST2`FE|vfb~mt(Rp?3|zI#p& zYM_y5w$xP@2{Yb+)Zq*nI$KqFfE2q#hQehCNjf8D%$L4U?Mh{eAqSE%kE7mw1g>)R`} zir2k$b8&MEMwCm(z-L-FJrQYiuqr=a8`gpk#zBj|=xkIfG{pQ6-6RX3GU4g@+GC^5 zrQgHBjTZ4r1ra44^d(EbXHXl63$Bz`pf9fKei#0O29FLPEpISS(P}}JR=^;g(OoBa z&zq;IHo#l0&7&^71@ox8zpDajMYpfhAi|AS1E(>%P-At0tNe5W<@~koG1ZR(F{QiM zQ5*(pQ$gwBAJ|~mz%ipof?C46$+^;vqel8VHKcWzZa8;_?|x(W?qaJpfNkv;qcl*1 zF***mb^YAS+?*Fb^DNvxp3xBB_AI%livCq;kaQ*;&<~VOqrJo-98K9p&`l-=Rum0(w ziH0iu)aj>}eroj7M?VAfGe|!}kTf-W{S31-IxV=MC9mzxdPQrfdJAl35SO2Tdebse zd8GDGWkB0;LqkKoy`yymsngt6ul}#r-P?;sT(8FKHF&*1PAfrx)e!nlf9xh5u0~hfDxYeL6nzTX_&%oFz$tViEgh?q^G$#58>yp{9$u2K zUEiLngPT#mX`aS*vUE)M0$Tqzz}{Lq1;a00SEO$?;B{TyIC2ql;hUg8sh3&0wF15D z=(1iK*U#YELD$LBtvcU;qN|Vg(oc5{ym!r|3+DHn`TY{O@)w8eSPR3t;bm`Dj8$N|MnBJ1z^?7fzQDv!7hLeJ8|_L(mgO*lOENgJ89|P}J*I@?7jMC0cnwVq^Kp3LZ-w#o6C(Q>%_+TB0rKP)`YP7x9&-47 zV|elJ(F?^7#z{5OAm>!Cwi%a(hL?J^rp38$Fje%uhD6=GG)zB3{TT(E1pqSU(fF=E z1$TViQX2%BTD+rynoE61x(|(kcj{|uebjN_eCVBq*5pgy&_g5i?{~Kv;GFK25NO?3 zY3c$9K>qQ!fp3@ILC8<*7i$~93%4{hs1XtS%JVdgl(o+5#p|M(w`r`eHB3iXvF_WYJKE&@u}&6- zv3EvkG8k>N5tM;H&;<0C&ANF)tJE3%L+JYS54w=+=v;>;TtNqHgXWkuFVW+N*Wsma zVMe~y)E(|W^tnX3QSYW^^kwS{2n}9hIg29qR=f ztI~_YiC83@a7(hc7i4ZPD9E89BsnzXDoD_owQl_pl;TijbZDfuy3$X|v|1Ig09>tB zHE^|x+O(>ru4=StwK7^2i1oTe1c3UZIt%?=uKxa@O#L|1zqnV^*F*rNzcLElS*81- z+JH9EhVTBV?nI#HBxH?|xe3Z$eTaC8h#FLoG)6;_iD?L#A zJ>9jg9?gy(BLO{?(H%i-?$xgb5n@o^ zbpu2XTxxLXgUbLR{ImhX0El^NU`84hJygIO$V>w?$=!GLt08zbq+y58=_g3Gffumk z8)&&}Esi|gtG`2{4ZL*2r3WrGxPbG!F+hMng?6PoyGM-E2b-YjLQwhQbqM8i2rBp! za&rMJ)lEP4C5TIX3EZMC{e(POpHRp033M!wJZ z4RWaMp_)ML>+?|i`ua3#Umu|M0V-T7eSq3m8SR6A!d8lV@ zGjfJeuHXxiB)eqsUA*37;`c}?!Gn2)$jEB_1Ig;PI%@89vx8(mSXCRSkiQUX^h23l zcuU#+5oGsAPt_hao;#UEd|?>J`C|(3i731W6y75W=y{P8;LoE#Sdd@#iGDz@K7dyr zB)A2-F60)o1HKYF-Y0gv5A1k9P78fMNm}@oGW5M3yyzD2Zbr#v5Rhg{@40pO9@7ID zqW3P)Go%7ugNrIb>LVrvFhuGjAoUTEdf#U{xV@OvJ(tw`ObTF#6tHUXeG_NV!dc>< z)4=-YFtGmlsv7v1|Gc^MBeXKK{%%$JvRjC244S)%NH)PonL^;Mth!Rew_i{=I? zq6Ov>A#7pc$JxB2z9sE>t6t5fwJMdB^_38Cs1>9hg!X|6g8r`Tu3rCxFP{I+;Xm)+ z-BWpV)k4pHxEz4XBwP-{WehHl!{rIMd>$_A;PNC~*2CosaM=Ktr{J;?E>FW{94=eo zG69!uaM=!*9dOwRmuKPf99(w8<$1X5flCiucEM#YTpm_^3q8H6w$M|BOBcNBg-aDK zHGJH!7Iq%T5O)ZGhb0%Ut6OR_E(f`Rn?b>oT)51k@I75hsh$d4y5Ryr**$R8N$N`# zE;YE+;nD|}ez*+4WehGW;j$lbyWmoROAlN$ax*-d?_qkyXJx)%b^~gLq2@gsf$GC> z8G=g#E-T9>VxUANfHN0~Jo!Ke(N*nL=fQgCD&zC4f36Ga3K#83cv8f0} z0&mF!4$tA3%mXiX^ha)q;^$>JDCIV?+?|J#e|FGhr>HIzRP@fyNN}c)E)Oj{IOxdo z2>Is*ZR&)~_9EcenRgq?ZsWM`{`MtpNp!#IuMKwumHFK%w|gnSspoinmzebFdOPC? zMF%9d;%KzGYE%4Ue1o~MIIsms6e)d-QkHy~^S;)*8^RydG^ZmQrA0Td8Q-+yy4=%Z47Ir9+ot~H2A^A>^F?@gmkars6I=dli`ViYExIZ~)YW9lh zO>CDso(8dfxZL7(eHuZo7axa(&7&Y z?S@UCl>#Men=E1;iX;=4J?umZD81L|SPF#~jE|=Q;`>r1Ga(V&-up_P4-`s!!7iR-TA?pQj}`G%!y z()*R}T;BGg+n2Ko@9yPq!aLFV9=xr*ZD|v-U$ocl_T_AKo6}Dm5DeIu2J<(9$?45_ zcblBvjOEhZkbXlN!PQgy%Jh>wq~OiZ?eSw{dA;Uk>IPB(RK>gvg>6$g9F{J#oTRA+ zbE*JbfN!E!qBGla*yY-FJM$~TJ=?_=DTh9fWQ=OdV;424_#W_bOqo+~-vG|#wN-vO z@&}rVk6yC{-e1Jf@Z7z&>G|l?r!9w(-!rD0;jLPDq&kZT?AMsLV#X(I+WkeYBW1h8 zEu(C4QQRkHb`H3^cL-$YEdjpA1wWki9&A2bH~ReoR@yD6G#g#yqgWbwR+0r>=YrZJ zWoFX!!re%c^yIe0NqSIwve(bapWKKm$=l;t$)LuhJ(L6w8=eb364o4j$QrZFRT;tA z6+^pfy4O5jY>Xkw?mHsSE@&yCk)3J0;1TLY^1LsGLPsM*aqmR8Jc?AAMbDG!4Iy}3 zvUi7o#}%EjMLU8+g_4w$!pqH4Uc-oFDc(3DS(0-Pc>*#XPlL|d1no)w%}DFA2yBt& z7Bnn!ZYGGP9DiQUmnI*9?e@YnYN%F3ZbDD1n#&`nhi=O`+%0d#=D!h~i+mk|-jUk1+E`=I`Z)S;o?2+#?o!GH1$?Vb9o2qYQY8FeLe6S(3%IajYz= z#mIVI0TM!#Mxi;~Jmt7Ph8D{Bh8S2Z|H25CC-m~pfb0i~Xdo9MwK1JV+}{}@?|OG1 z1ZYb`Onc=+9V@r9@X8*^1K106H&!IV)J6xHW*e1J5W zk7lz*h-`eyu4_B*(mRbJeAC$7`Df{EU?kURc>vRZzV4!;g9q0$VE)N=8CXccBDU2Q z26H0_+}s{9VtrZdX7D`Ij^=b~s5vr@3x)0c?Z^*NsDEAha}XM*Kc+FNk|I_Y$s z<(g}efftez7ZvXck+d!{I&$3QSKL|#vKr#BsTg2F*5prNUhZJDCo`|Ma$5(*R_QD*R3|lk(}H( z%B0-M-#B4O)+aQ1|C`0HWCIw);7dA%_4b8Z3L6#%LhytIO9g;USdf^NO@((A!&mYStBlY^BK*0`hw)SA9|L$3t*?2v`hZEXDFHvLgk+cK*1OF`grrO5W$_ z`V_@eNRcB}CtNUB>}4CiYV=B5GTl#<#dy3J#69V3ytpX9ZAG*4 z7HnN!@z^#VcSR%&x{%SF@OFDqbxxW-_6=nnuM_2z!X&mdav$xITybMu!nPo*Xp37S zQX0^?you%UZM{vBnO86%(1ud`6}T}E*wr}er1l~%*^pnJG2WD~;#`WNs#xohTIaA| zKSLX(4zh!`jv6UTq>#B|SRHSmq!hM1(lb8TmUJ6AX&g~khA6Pn)QRPhN_pKA&uBoRL$}rF}`rNoz6Eq56|LY!a9Ts5uk?d2!suB1oFwqsI^4?rR~I#aW^tPB?Onx zqoXMZ(l_DET0#+0xD~~M&p5u2%+*>pt6`dn43|NjNHr7}+0LQZ;guY3m&!qkNTQN> z8RiUH_Cdz;WF~%KU_z(3j(6LSgof_fPCL1<2Bx$UCs|-x3I6-7h5cmn*e-o{^pQA` z_%h)1RQYd|6{OSzF@>g(dhlUf+bJP2asQN`OrlFqfuBmHnU(Qh+AC zj!C;BM5AUPd;fxTgm30VOOO-B(aaT{~IRtElTQXD1F4U(*5XtcB^O2YfKlSZJ$m~3i`bI+}w;7VCuTO)^{&S)% z)rj&gLUCuxkEPLGP_)*`Z?0)6&mlJ5F|l1~Vr~(9#6xLBn_3%90^V6{Cd(C(Z08As zyUUbajN8tuw$uvVoXooEKz2_mn(y;N^m5uwNQBHFmq1Qw(t+~$*%C~~f!(*MmAN;Vw4`oJj+Hcu=7-%=dn`n#5O5# z$#Ubn6(u-XCRdUO6^7)2EV!>ch=Oq#r)`m3<&mZQdE=JIQt>?S2|K?e5oqzr>*~5N z*%*#OsNy<+$?lKmqCA0UwU!?vs(~C-o z96Y*9xw7_aSEz)$t#NGpY?h@GXtB&~kD=KN$6aN+Vn{JvlpJRkA-bBd6d9@`W=9z^ zljT_Eu2puqex{g2QSoSbh~3yJtC1IEK%~r53 z*F~Y7g?$)z?e3N`soG3Nm>Q-SEK7EQIPTn1jbws_gja3I`KVwOGfx%KT690;ggt~~ zAsT`5`tfMKsaNC;XUV_B--BiG;o>|VBLxfBT~KyGM6y8Mcy}qXRTdFxBwp}_alBEz zWZ;JU%-C7TU;+DiXK0(3Mg-Ll&P}0;VckisKrI1(BGT`^TUIHD@#SmfN0tfuZnsqP zZW}pYu!+{hK{Gyj0h99es+_HQ-5BZHeU#7)l~xKFew%zG)|ReYmrAzQ2PQ`nY18ri z&s){_wECLj(+xQI<-GSSwc;*UGx_nc{59;H4&@`p?52>&t3|1o_d|umUo0Y?8bE}k z&gPR!J0K4u)8mCdQ%uwfV>x~nkSsQ`I_4scYg!*%q6uypOil{(s5ow&-aC- zaGb~|<+?3>eHA&_0=zho`7rd?TDxvES;X(bsJv%++|r6czfwd@I*d9Ye6@(M>!Gr} zuAEn4Xkdx;2DmlwYEeS@-~C<#R^QpA&J+v=cG?67V8@yYfPd;@N&qzI0@S8T9;HffmV#Rzif78z@=P3k(~k+9~edUZ(+~! ztg+i}WQ)Y-1M6gC9eMMq|v4>1RVJ3QWTryQvnn z+_u^!fqC}?sLm@m;G@m64=8`Tnl=skiV)o_ZjdO`jHy*;h73ArrM}lMGHXW>$>9A-zC2gaUQ35FtB-(iJVa{}KrF>*jtU4(=OZ(uul; zc7r;vUiMnujM^WkMyzx<=RYaTbz7c{K+Nr5hQP7=&4Ck~%EV|i#>a`J)IxUX9~@FK zXB?L^V(YKO`GT;%=9pU((x>CMX-n@3d3+t5_d|1#j-?c5sDJE`J!k4rrwB3DCQdh$ z{qzN7TegR5rwF#R_Jpt_of4r?b&3x^WxlncKOy;^M8r3+gg3LDOKBd_c61R36B9VA zQKk)La`uJ5YZ;hUS=rqY>GO!C<$jpp57x!x)`>hij5dwga1y({gE)0acX7Z?CpG26 z2m+vd9|t}}89A;qas&qj!K42n~rnhDcd1(kQ`fBJYIz4&z6-$V42_A zDZ)fb`=(C$O0>@O2xGr&@i9gg9dSBoWnj4^4oT@)E|IK}EtkMLSv7V`BYW-}NX(`< ze{Cz2b(uKeRo0!DYbm1a*4q|0w|*P)?Tg&gf_>nu?c^QF>LcYItLy{YBct{$5ABrE z(7ES9r_p6C<(@_zl92N(9iqwwXC0zCi`+Uxoy@dVhlqAS9py62u@sk+H=UeZj!e1S zUM2~dn`M%a+~2=E5|)`erN-rHbZdCiNnf<*mt4w{Y4-S$+N`wfbjoBgf}ibR`B2Ac zqSEA9RyucwgP6DE6Z2WN#pm-G?5cTRZt{m%_H2lOvsYCDX7zVSQHYye0x3_xOs~3L zYa4?dGmFS$sq|^ya^5i69!xFEk~FC8UdpbH&+K{_n!cqj80%hofBkJ9Uu2Y+0(3dw zPV`UQ3vP^eYP7^%&egWl{ogHP!b$Lbeil2+)-E5N#w<5Yb*8tT*b`@eY?xBEe}usba$o1j zvau`!UG_4|KzA0BcaAQ5m+dihUoHC!H8b5uA0+B!=j5`DDL|ggwxIhhs8v<06y1s7 zLy8V+yl&ijl*t!kC817-PIjc_0+*so;a#lzBqjNK^!`ZM;w9W%zBMk7*xn=cwhft- zrvZljPyG0QaImzQL$^=M8jK)BMw0O3h=gB zd(x6+3-3yn*n6dT$T?}8wLDuu@oJNC#JGBoli1*wQ}&&pIQV^*$rIUt9Bikv2tq@P zYl?!;+>J{A37@3m?Ku+eafQ@#F*}7(TTgd@x)23hLD838E zZ)uMbv-5Kag?&hIR39~{Lq9>c`QDJA1iK(Tp~c~<4n zoTZ#uNRi2u=TU5t$N@`~e?qOF1x((%fWa_@eNr$48Etj`f?E+=;?P^V7{# zXV@+0AF-4vXWB+6L=So^KL+9qfLk7&0?UQ`q~xIxO492)wOhm#VJ zxneb}j4w-(*d1pzZ_PJr{CqJ+B}@%z8?Y3dbnJvgC(Q+rS}mc0W1th3Z?bcMC>c6G z!FB~%q2>PSu|^Zdfr{AbKKpqRhqT?m>6@;E~JzGgz$VAqrNS=3qa;VA=o)x z4|XziqXqNTkzWr-EhvZc+cW27oCGwfJfHAUndS|z*z70zT2i@ytiOrMXMdQZ!=eL@ zrG3+M!p3J465tU%2Xh`q*_>4rkCE|0(YO}(D6vGO%7jX%`nB;?v)F*3fReyQmmeI` z9V`2WRIT!RuGck^rYq7Sxv*IuH=2PamA2%8LSEUzJ+4u%NXjwZ%kjx}3z{b?v|-3w zil(>){o}eg2Q-QelyOaoP1Yi-h@JVvR$!&3UDpT4h+$wcE`KidB}~Es`c<(H6lg_Kb4jkpGni$Ccxz2MHEhYVE|e_ z@`*HZysK^_EQ_KWqt$kWrE_xb(C299#AFkF0SyYAE%2Edlit)^vWKZ^m;}+hn>egqAyvVx&O*TJg+1wOqTerc3-qmyzyzWCFUTXqCL{2Ax*yj=x~+sP&Q*&v@ER z{STRNyoorNSU08Q77CDyO`V|Zca@m*GPfNoqEwGCg?VOmnGEa;d)X54^?67noWhe= z3@jskOMpwC*-u40aCi$q4I(zf6FVYLnYO%jJZG|l_z{<8g>ageUKT9 zh$Sm<#^ax5gTv^vX!*^U8sTVYdvq1Yqipc?s_iG-q1Sd-{n&A3d`w9#aAQ7_R7>M- z9ZhDNUXV}|!b{2?VZJZri=0(_stt@AZeWA;eV%RWb%uQu=)JoDdwmlAhO4-9v!@TdZ@w7CMwp~Dcw2|%RW#h;}>~3nXt5}|t za(>YUtlQxgAE^tK=0||@ZWz4Z%&lz5c7jP!yw6o7cO&PF(%~OGhPz_A)fv+TUNX@P zP|zciaXv8bAY^lW$dCrcLN#&i9Ao6kI`W*)@RS4|waNp9Ihx?Q zfxnV9ww+d{7_m&q=NO|MF+IVYH)+3KmOdu#6a%{5mM^Sl9&5X1s^+vsvMYCdvGhHi zZot=(G9-M{pq)wHG@8Xz<;YMIg7GDFRWiDW6y+YPBV6b29R;Tsyp7YP-f{LfQ{!hFQ}xUUR1{b;i<>H9ax zRF!Kau8Z&(sI9|+AVwrVY%*aGaJG=>6bcsit#(`JSMYxslso2Tj2s0rY-qQ;x`TW? zQmMDSV%tLRj@Ldcsk^1NWm3T1mz>>CD5!MMRgB1ia_P$Xkk{4s2MX>fGUD*2@10U zokjPx z{WJ($YYW2X^~u(`(S9b2fi^y4sxz?$;oFOZ7;9u(eCqkC;$feIWU6hCzhJ$6XBgq$VLoFZAp=ebL2!BaJvc$Y?>Gs zxXo@%7vu)o6_)IH3e+E3W&xNfgfr$YZ}kHc$$G{^o<*52ID5*Yg;g@1MvkX;svJW3 zYT1;ReZOKd2`U=QoJ2{u==f_r5Z*^ug6y|S z#)c)w2EjZ;U_|a`j#_E6%XekubXh{#XvDq)09s2r1XV;_|UJ|R^*+tzX?yOwM_y-uAA#O_De7jV%QQm%-Ti(lHwIa2FKyk)F`Sc&($>|jt^OKlv}UQ@Fs zuYNSskzxX@CD|;X;?nx^2{o?&-(l;sILo}Eg-pGDam4ssrS&_p9XiwrDo>H^;!VdYv)$yc<==j6T`ghNMmQ%dKzO&Z< z%WB@Vyks0p42`X&j*xhDV+zR`G|5T4cq0`W6c8+@WGtX{IUdAHhu&(xMDx!(ER(L2 z(J}+=btDZWIx^^6T0I+mAUEPbg6{G`514Aa8u-avB0GIV=tg)t4yHZ%q-qy!Je7Yd zUoOIgj{xfGHa11e6&Gb+n6-Q_qKkgWN9V=zI6tE3wC2$Ca)}&?5#h69W=fOU?vrs< z!x2Qi;vwyi@t9X#Q=DBs2PWeja2G@6lh~7=alb|i3cz4rR^-GD1D^{dAY6Dvdx`Rx zz9V#=n6lGFE_%@XewZ5!YAQ&Wi~JF;<;3ga>z*n zw!-EysEpPM&jczU(imb2P`U#xkg-ko1Y7#F2PIFQ18RFVj;Qnvk;MTCoUUqsjxVj=x$7#Y_nf{(P zef9*8YsnGhAAWHn(_uVaGY_UBq4*QaRV7{7^X<^@DEVHe3VF_q^&G&Pm$p4vSUU%!1kw*T#uD2 zQU`==?kh(?u2+)i6Djo6_GE2)7F?>FVt|tZm0KU=FFUhKQQNkxY0s~J(1nEDQwBY` z4{$MZ+lULf!?u(|m{R2aiJW!oXDyFVCRWDY6b)pZ^kaXA!-(ArlH7{v1i`iyU7OFtm3o#oJZxvMyKybPLMx59z(vu1L% zWV*iO94cGdn@XPZ<*xNOQ`>s=e94M8*5F|u=+Z>+|9_aYA2PTU_M>$@XYW69>8x7>8!{q3T*zjJiA%h-}nz~7X3q8zw14K@~` zSc805K4^N;r`T#@d3>B)4gr^w<3%KVUT!aokXWJ~NAfNC-9-p#u1?6~Zbfg(L-#9rybQ2Y!FdSLUOx{ZUAehvDV=^fpLf$4 zc-tttwzK)*W%V2RtfyY}22ML!|6pttIR&iQ19E(^Z}VheDydQdCwTnACr7x9!yyP9CI)^jMd6uvrh;1{lu?WQm zer;m0jDh)E^$IgL4$fa0!5E(LT&MO@*px;JBZ)Vrf&DEB)~7*bSktLA7zOc2)kFpn z&mS4DuV-w&a=!#=Tj6k){pkG?&JMFl6N)dQIIETFDHGvOhpvXWFQ$pg)hNl(d_@}$ zKtf+hlkyinWuZv;orbWNBTa_DZluBynTG*5DsR#g>EQ-J;7l=jF3L?-9bw+ z#0E;oHiq?2ok)hG`?2{kV*c8@BR0z0J&>0yN4s>;k93luF=E%SA~N>WKIyU(t~4pT4d=YF`#)p{I_4vu!pRUChR~p-Em}XFs zqIZRM^hP#$%O0o`Z0}Qu)|Jdwh^NhN_G`v-M0TFtT6U);N2`pK zigMyc0FUJ%fS7E`0|4QW^bX|#(;l<#urda@C6CA<)H~LhpY0E4U2v3^6ag-{Oxg6l zE}BeP_Q8|b9Bh34WoP~A(fka%Bdke8dc$<$?qcv``Gn-I`O+oW7U!bdqoDWX5wk0B z>EKMCsk=I>1Dk5D08XiJ!Tymv1U|?}Zcia6By74b-47YRjx5<+KKSD~ImNRvCY3f6 zT;cU}e-T~#SDd3`I%#>o>ppv=SlFm)+G}*H$a2Yvz2Ty6Ftps^zpn2m; zqAiWxLEIz{a@`r3)V4ozriY7rZ22U}E|6OHJz9`XuqtZWIj&3-wS*|f`) z9hUD;5so!6$vNiKo)iIpy+aH+S*$qt3qk?fRdli8?~y5Q)XXFG*E7K+w##ueDQVy+ zpX~5u&flzYNw^yPC<-ENkO=cbAeg*~)(us-Nr6k+9U8ha-tvK`jLL<{=t=)$tm`?T z?AdK$l-ePmgnMEqkf4*}@`yBO6G*TtPN;GBajW|{;XZD2AGf=YJKV>e?&GuW<1Y8{ zIknQw#yISNNG}fSGMv%nIiv5l#$QjwUvG=Q-X4FwBmR14{PnZ(*Sq4cpHn08;*6(0 zY)yTbNPXCr`mjCqVMpr2&eVrzQy+GvJ|s#$kt+E_s^k-?l24>cK9MT>s@@=V-Z%dVYTdL&SQYGJ(D*5(Q$+xFUzCBg) z?WvM)PnCRosvO%><=CDo$BtAvcBIO&BUO$asdDT{m19S$26v=ta0iwAI?lWK(HTeV z2Y*Y?NgPH{$jdaEB^-nGy73&@74&P;WLox=%;5lt0Y7QdmDE?CAX<%Uta2gpdt%O{m`@v}pOIri!71mwy|D5 za*$;%#$tp(5VGi;B7j0_I9HZOO#(=2Po$D2HHY)_#UOokz_qnXLf7}oyLGP$DhzWu@rdZ^@N|bQ)qRAl z5ahH~qOqif#+}>9)QF`XL-nV*+*y`MON875os*a-mk&AY-)`HV)>Th!BdH$~w~$ z-XL>AGl#r)IFaP>$d=Ah+LF&G7ROs0cFEvHbYBT2$!&tvN&rwmufP2b#9}q)I(OdGDrI4`%*4iQekkMTw|Lmd~p)% zt%{K$VFwkR8+TICa{p6dPhgj07B!$liqFcpfjW6!nihWVSDtJZaUAyFE})IS&Oq%b zDn<2}<$Y{fU}rM&s%>&*w-_i-+{Mep-0 z2L%Y+Hkz6?d6E0Jr(}AkOD2B8cZjyjMT?muZu-0`cfv(<d{$ z17-dOW{%@#{8rcV5C8BFzd1-JlfRC8MxCL3{dS`X&5LK+YO}hA`WDn0M6rUjZAOyU zH0;~BB5Sjfgg{qp);Zp)R{F1dKwehLy^g>#d+4eP!%ds?(gwn{)yjD^0BuCr;Eed% zxa8okgm~G@%5Fu!a#q>x6XC_+HT}pP|Izy?y(Bay_s|9I|3=m@Ze!&=96!IP|B^Wx zM(5PtzJW?_{lV;o4ZgPLiUB_%#fPNoaggJTqEn+dApK!? zPgEv17JqGXxYA$GHR8sqS{3n-+!vEs*Kehv36WK9ax16Mbg?Js4BDwioi|z!v-*d9~)asiJT{*jAocY&az{p9eVN@5;orw1%`W)XZfy%W4T1Z!nb@^$}J%)m{Z-DmXwZ{h!2^uKNT z3hn8NeoH55ZPjK0=vtnGOq84aUgQfsGhg=PZch^)k8L%-qwG^?i34V z%|mT$e6$pcOaCxc3B7zfdp#&?vvE^hFr7A3^&oB4NlxS@0Js6Y&1;yXeDyHg%5|P5 zpoAc8dtf`%e6Vdue1PPl7#HxsBOjxAJ!rHmuNzB=+w~yvg-q3zZDltChFAU69YR+! zcpJSIG!U$kRvV-rTH;@&K^xNG;UXqUH#ZdTW!EGNj(Z8<#u`~aHp&*R{co$A#){t% zHWhZ&xgEngSNh{XEm_b0bm-tEjANm_Y9F3A-Nd{zmTb_OS}Zqb?zhowRHF#0kaIpRh*{GvQXP!s{ zyK%{>@5W`PmQ0H}iDnXw*G#*UullbUeLtt_T;7$}mAgK)|3+pCuAEo$^t8*WN-|vM zl^Sblp~jVjWzuhz(Mo#@Ow!r&U(Biz`AV99!H1iQR#!gkf4GJBgZ6f}>KD!WrZ@cP zxBXN<6%D>rX+`rxl*(0XM|{p=bxN1>h^lW^bkhX(P{+zP@xxGg;p-~t+QCc8p2yN~ zEvL1IuzlGR^xXca|8+%c>}N>hyp1&KubX!Ju-ly3;>14AKKApt>W-?DtK<&I1yk#R zE@GwMPYm9Wf^`FjJ(MVkZk1kDwyOFK)@L_FKMUEe({kABYNda8T>pF~=T%aRm5pFa z%wxr@*q2pFxQYU2$%E8>4^oa*!a(|Q9=5Xr{ zD>@M~uhzz5K$6SrV*p`gtVvUN$o~YR`L+4k^2qUKMNr5w{}cF1a{$7;*7*#Xm3(tb zQM~O#{6eaXl@tNYE85%qg2WFvy`Emk&HiIss;nU}cME}8B-wl+&{VDPl_fR7AFVqq zu^3x_dlO}7a7wsz>b&Bq8A{F|SeJbIT)!QAuBEZoEu-K4sr>#~qlMpAYtlPA4c-v@ zERE0)?K;ga6SOVe(-InPvs-C*>!2poAonBt9oE`iw5F8Z36eT&UHvQzO}?@FpAMcu zR+A5L{TW3YCS6ptyJwumYo`^hB#VDuGo7sUk<>XrYvc!aO7-FRF*#41Gsa1}+=J44 zvL=0!iRWdZDE*%P|M_3-?fKg-rMgr__Y)g*KhZCa_mN`i9#k@Brbg{_z!;9=NL1>| z{8#TXH$DF^bZ&nSm;VHp{|7GrH(dS>E}z2X|ANc^374k;V*)PQ;IbVqJK(ZMU%I*~ z)k=4@xw5C)ynD90Iy_RTw)FD`cz#9Stkdsy>3{q6zeD=D)mt5HE_|pzFZ@uyIt4es z(wD`naQ7)(-q&DbJsRvRJiVu%@J8bdFMU&A7XB9Ce*u^8>&L}o_3G;8!XI}v=K$;@ zeOdY~jdZh8?FZ<;gts5-7jr;!t`C6!y3%OQ>6{GTeHB3d2x$F2TsC!AM;n0fW4K^y zKZCp9g7RF2$G?EfUjb|neE1W%+=EBVCJ^48r4|!rcM59EQt7aJdEqM|5hZbun7- z@D5y#!sV-QfzmGCtWhrNfC2?u{5HJ)4qW~vJpK|=zWW`>?BaL3be5p-{}Mj`04{$3 zmp`mjyAka7;OS$y{Cl|k1#V{+FiyyfjBv` z7x1tDArh|D!%N?VG@47l(_H#qrP`yv!M{O({}qz?q*ATvH?>N&Pyh5)sss9G06+Z@ zuOA|}KE#6E!}|~L{g3ea9$xR^72hwtkN4lh>$`aU2(S2l;phF7Go2}HflIoX4B!2? zx&_YYf3y1EIbhj$o2GSW-fPC)eVZzO@n-=21Gqa4cmEnLf23<@c=11g7!BVA0l538 zaQWFVu=u?$!2=MVUvw)~=>dJwt14ZMdR2AnYrUp=;HO?!z4Tkd_s!GryKsM8}Yt$jp1|~|^3MS1tXwZ*&*}(khkC>kdCI=bgFZD*H zPgB<4^_KyyQT1JaU%jud&tzu!9Ot1@@6`#f9Kke42zz9NQZtVk(K@H1^IbzeG#bpB zib)3lqr~AY5$ZQU{e%bk?I&9O8BhD`gQ|}xWF^A{OqMI01H5J3053?g+Jd+0?U zW^{CCDC?jsYkDzK)OGAUZBQ;mY-JuGNnLBC@H<>n_W%Y@_pql~^lw_9JoHgqUgQXe zyD@qi*ww(w=m_Kn*Nz4|lmT&v!Do=qc@3ot@Br4x{yH%*)=bxMfLY@a9E-uo?r>u# z-MGf(lV9Q=MdU%j0GzggUn;YTg)@YnAQH`Bq>0rj++c&(D9&JTGElnkH?$Gqw6$p) zJb0thHqfFBz{iWSBL)M%17@RypE88rf*zH5Tc4v{6s;4~6qRRJCt3@31INmc31j0iBYl$=#NO}=JTt!>v-Pw#7~Mg9gVD$;6~|B> zKvmp5j4uARgz|4I3OAtSZ1BT&RMH?Ce;6eh`Gd79j@2^lI{rz|k5dVNvj87xd9HEp ztbk*TV{z_WCPzpzIfBb1;ly%{V?2&?LMHsB7Z6b5T^wa>93zgAy~Z79TAYz4#jFhKF=X_Xy`4SrKMfq!8} z1{en=VXxyH=v#L@pfB_CmqwO}f=Iae74pZ5#g$4Vy)`;XZ|?J-Mpk=wj$0}VthD1d zS+3#i&c#0)Wtt0vu+B$GpUEpJy%``e*}z3@FV#3)XebF$g4hrm#DUEq5L4A92+XJ= z!+0`Hi=)zH!*2}s^buEBrhfd^kk8YWIwKGKZ*cT9(tGI_)4RQ>ox#K1mDqSNyG2W9 zH;-LFH}wUR&$5UP%N9arT4+AwfsR#HE zd!CIOJRA9z8dO>aZjFpsyci>{+(IAVrJZ7pxert4PEDPa6ZH`8)UX-cji@@kI^hZ= zcuHe$5SMuo`WNcygz8cXIN5s|*p;=HJz{MzNOyS5jgu3r*)fikljQ(wkCcl)WJRM4 z)<6Th%8x)+_J~oKA~kX-O8PYTJlMPsz6%cAtfgL{c1^-0(fwFn)-VruP6kRtG(uv| zG1;mflQA5VG2lK+ewalca>lLX*jE~ubv?uc%ZB?k?&VT%@yl&S(C1*XJuS;6BTl$w zc9|0AKFf7T@=4S^+cW$9+OByxw25rO&1 zj?i!#mZ0mxDsh0lx}Fa=N&jOD=1?=oe6#pJ2G8%GqpA+VPXlL2D!*LjWF!3Ike5|~8z^>T$4j<1GG7g! z1SxcKLcf(oBve`5ot(IkX3=~Mo;Al#zJ>h2oN-fV$68fIjGHnSs zSHv~FKz{avKIXqAF}9~#O&_N2mG$6CV%{1oaNSv4j zH+pccq8$1U23NY3E>z8p+!#1;YH;0Sj8FqjjSh;2vPXvws;4 z&Tv7DN*?Y8d+7%9N28wX%2V6P#4(uHJy=qC&c?JVJo2Gp>yRzLkZ(sOKn$HAKlnvM z6DlXL-c|-#7M(aw`KKFx%JU93zrL2O?rN;2vAEyFPuj53(0DHkgdiC$!bt@ z#V<}w+OnLSBz1;D+OVt9L&{`edSU}XGZ-Wrl_eRnEL$dtv>8^SO1Xo*Qjuv!S|prG z9*A)sd!xNa9;19`Z8S0)-IZS&qCa8fNdGucF>;BZx3=^TI#GlRcNWw1v`7#+h7;eJ zIc*y8fVMnW8s#Xx^I&0Zm{g@Qa+S(to8&kiwQ~3A;)%W+^Xo26T+%Y}&y_oS@e%Fv zG@(N7(uBnmm3iL=Z+MKIN$HtZjYh0i^vd3K;qSVzA3gYw9*mj(+$~a@;F30jQ}sDh z%Cw;@1Mi@vjbuM+Fyu`nt*;rWlMJVl=@dF{!3)s^B5;d(>1zj>SK{A(W zv=(s%T{GqwN{|v(B?uGeI4;$3)b!%QjIm_R5c<+PBX5rf_v5rQVCJ3S8d4XV#&=w` z;F}zstqex?1H};f%aHwxS`WO-SYqu)+=!uQHESCyRvBc;SdfQ4(c%# z3xf?tDfTt+9xWAX+W(8=y}$$P!n(@_)}1iWiy<#%G1E%s@Lkd!WKPptCkIYtdT(%Y z6zyA_BcZ{!>2Qjq19 zNXcx&R#eK#(*}fd@Nic&FWsS#r=67(uE;`#pLY-WAO+KAdr9rA*?^%Fz0!uu#G}-w z(TR~uc-loS=rtI7r5_FW#oqfzVy+*pEt#M7yWKS-LPk2@yPNZMRF9ibfTW*)q z>qvGfy^az$r#F!wHsKx+Hs6WHdREMtI5C^%nifH?M%bvDv;bf3TG}41?X?Q|u0JQjN=P3>Q7^(U?Ga+}U7K5uYBFj89D(C_)Kyetk zE25#a4b&Xw2@f5dY3{Vw&|=pxduJ;m{V)=KXQ2F~BNTkdA}tSO!kUdtxbvY2BQwT! zYz*NvAICT?Wls0t0^}(FF6Bfsr#%P%W%*{j0xq@HF!d{`b_q&zj514w;q zlq%&U-+(4m(HF8YUw0>FQ^M@n7z!06dsb(v(rl0*^#$B2zov&vH)$VH0yN^IG$dn` zGgwIwq0$5NT%?=Fa+ZQJj+XLG7x|`#oTsS#BvZbbA>XW#Z??!c+j-Sd8z=d04Wmn% zBOf?2vP!*m4Rd4!kVjPT5_*(}54*UAv5^e^a;5_^f_sX-f_0QMbVw%6j*$j`Xs*=L zJd-<9Wr=8vjZRdhDLe5#&dBfi*cJ2~VFMqbnJGW;x8q=_5x+w#46GjPj#U&T*xNg? z5gU7Z*8I14$IFv!lOwBR7^Rbu&6rUU$doM7NU1QigbzcFl!k%Q^YD=)RtkNPv0J+C zgO$cx0cK2_enLE9Sy)m~o?|bxE(AeNRVD8d_7Hk&C)-ATD-DjNJ4#m?#>2hW`)w; z;|i8PY@DJoDnO zkco{1TTydM$FI^eX^hx~SG5fDBVjC(cVq<2;&n!B0B&-fo1V;nI`RHLp0l6$M+0m;mwH1iAGKaQ(4Nctd+Ev9!wnSDz%m*O z5L*Z}Xi@h5harQ52 zq5w_94n+?TTYPjwAepTSQZC*rdhSGHPdb%lbjt5(E8TG@P|?WjVwMB%Iq}E&p+>9= zZIqGcrC|J#1j@R3L#dWo8;s6IHblW_mzu?bo^(4J@xYqk5tWg&q5Ov=bW~}m1v|!R zZIpskcEuwmcP<$Rz@l>nXwaJnHVz0ua7V~s9)qmh>6skWIUZu=W14)9ff^|~dc(Su zEJ~x2m+lDmFrlY6lvMdC1En9-x8$QH>@lr=+E6x8+UhJXP2~JdB-yK3jXmy zX=)>^J&7IdQ`j*&W`t8qN~d#OGdgni9^(VPbli`{#^@nhNz=kc*OAViws>UaW^l81 zv!RcvZ63*U0LsnaI+Ar5X?H^!{bIu|=%P_OQ55|kVc~&r>jd<|PX^1DH(0|RBQii$ zZM=v}5o<5vj%2_OS1(&HD>@}jU(~@vV;(O$(TqDMc9%u}ruAX>&+~Y(31a%!i2_q} zt^<(Qp1nWL{;p&Y*V+A6{H3#|^vMz%FDrM7-X$%F!o{&1$MBaBXic z8R%Z*^k6kf+ra)-X7xQ_^5*0HbIW{3ayia1n;3O*}Tj7WQ@>vmEpBmoPysHu7VMU5~ zhXjN-OGu3I8!(`9`DZ#ADhWi`B6F_k@=rNkwtB*rw1 zk4Z^RjEt-78Jf~FE;b6-!V~(%#5e3&t$MGTy=wRJ@rkZkEwXx~Q7%Vb(MW4)`2W6^ z_Esd1e?ZfS7O3zfE0Q{{SzJPVOkjL+Ok#XwT#{D>&pwe!o;_n?;yt5d1|-HrMJC5Y zdwY6DB*l0p_lfbOtoDnJ9Dw{@!o6p&#DxA8JfjlgladotqLLF50n;Zrc|g6YReL9R z_s^D^sD%Didkv0@jqg{rG5s4G-O#6oZ#7@GG?Z7eJQG|en~=!Ms&iCit0M6O*svSw7xT0V8F*NCZBr|wtgg{8zN$M%nrA3!&#WW2E9JP7skr~j_m zY)_rHZ)fV1y3bP2TpgL#=*7FV-I-SDE8F|0JB58tFF&DF#+W%_8Gm*kmvN}-vW&Ky z4rk0xb+eJNkS=+6qr zXN?&1%yr|KalN*W+1>N;m}wEE#+JDsIQB+|@Ug)GL&i@2Wy;v3Ve`hOr5ncGtz3Fs zpu>@Iufx6{?^DO_+w?Pj-@179{dV>2^lwj%IrOcoRp3c*H<|5z-JAKM_OF>+@7~EQk@hC@Twm`=p^HXMY7sYM(xVjPWUs{PlLxIm zIoZ0F&6JJ#s!gd_u<+Ch@7hi+>o;cV(Xx}KzJES(TBX&;r={kLng06kz0(UUe?Gl` z*L>gYTp$0P{gmzBm0Ue-M!tC~XPg;+amLS6@6LGQ+;`@YD??@u8J0OSqSHS!M?ZWw z^I*R`vnnjjGppXdceCby=rns3?7*djjfqVJtLExJ~2?xMW2mMpS!zq}}UbeqLH2M<_mv-#BG$oBUa zm(1$1Wc9*kOMf`oerZ<6xl4C_b75(vIe#u4-O7F0!@+*bN;|Gt_G{*vW!DSbT~;#9 zZTY!ZzRNe&t+Tv)X5#YVt%odMKY8eK`{6$=ubtRx#mEVNtk_ce&lNR2tyliwn}6l4 zd}CG)4=TRO;j{ay)b3?hC4H>C%Gb8tDz^$lS4Djuwd(dan^)D%Utsl(0@YUcOPaAd z->4#MjCFk1G^#Oj&B*aL*1SDlajkEy+H2QNp1pRY-@3KdzK_>h|M_}tQH#-yj4 zHd+@hy(zhGpG`Hq(>HbNxN6g&yc;*!j52Kgxrg26uk$%>o>wvd=CMnvZXUF#)8;`- z7H+mavuJZxk0YB)Eqb&$F@M08<#ye-^!qnvOOI8zxA-RC-%^VFyQSKDvh}ZfL0cWJ zr*Cy`SZv#mGb(ON=&^X)phjD_`Szam{pGfQegCj|p6#DvXKyc1d%^Y>M}OLW@uOi! z^1LED+EnVYV`-WGI|jEtxnt&~mpf`7e7)n*zpr;(sNu9TvTc!_PYU|(obQ&rv)jhu zI|sUavokYg+|J)#*zYQrSYX#RW9ePb`&QgFV_mgfJ1Vc-H8bY?uFuzQ?>hLQ+-}F; z>g*0S?%Ms$yuWtOe)Dv9lZ=nM{j%Eaas0i*9&)z#o}^{-_cVQQe9umA;}3m0)c%3o znDc|j@0EW%QQQAV*R=Q_T?Wtjae0MddkIs^CF+5WO` z!-3!S_CST=MTg^as7GG?a-g+oOIBXJTfDHIS{n=mls!W{BqX) z<}bk?Tn`!wls-7+PQ`=gLpmPx=r;FY$(joezNvlZV7}mg4i2-MaLCGP$)R5z&K+_H zyL%|ys_5a^r6mq;d%X9^wEV}8?B1OJ=%$u&M`y0wa9Q5#}mIT zZFTb9f=(xQukLd)@653$cZ|Dna(It2r@Af-JXO6{yHjKLj5sy6*Wpt`-~MxIai=_| zefpO^ZCu#obo1GPr{@OsI_>fAqSL;Q&!2u*`S}^EbuZ66THN{Uq~Y_=<~_0T?19sV z&;E>5#N*o8fj)npEqT@MoO?`#b1laHan7N3m0z#!?(*x^fbV{tpE38>Sq1n1I_Q$$ zZx{AQ{MPvJ)ZgBZ+V$Jvzs~$t`&^~-6W7%~|6yp`^X;BYJYUuB!TI=~o}RyFta*XF zd~xBRzu(2Rb>?1Na?$!y!PT8FHQRdl(!RFmFID>MpG%#?Utg-)E${E^uebcYM6;0J z7e#;l`{H_oe=q7i=XZy{9WH+x+xl|ZlA)I`3`xIyv!nZ!-S*qA3`n|o=MbMV!$0g+cb-X3-JXvEU1X9uphdhg%P*JcJSyjFGSAJ>)@_PhRd zx76zyc9X9k@|tqJP{)JUJ9fQr-EY#>>sLJQU7y~z?jNr|cl%@RqfdXF>)7f>N3Zrb zynau=v8VR28~Gm}yK#J@%gqA~Yu>c$5^;0PuLEw58U5?c_8lJGyj-Qyt*ysv-YWIa zxm$-SJ-hYIn9x5j9ZvqULAf!1mb<_5&yQ`-{rOt~+rL(oE%(>PmgWEQX%z6+qF+1y z<^6KVUo$Uu{(EZqIe+{8llS({KP%n#oZakpWQl;=&)SFH-nKU5_U4HXZ;vhT;r5&v zrSBvfy4-2jIQ35V8&mF#t!s04<=fqNn_qiilF?l_5`-)?NK%s!Oe>zuPr@y7l{nrq5UgD|`0xvk0$G&uWCbKc8YK`Fwe~w$Gnj?DG7R)5_=f5iq(>S=ozXjSX`uFERx2z4lDrdF&p?TK6ISaGi{Iox7U&&KhJ}-ja_Pdw( zwo%p9Zx8g}@pkYJq3=EpihZ}J<-B(#`g^~xo^Sm7=0Vfme{;|7!`ypCKKMEn`|voa z(GTRimPg3CLQhGLf7=?m2X`_oyt2+fg34K2AsLbEknEB2 zAvqv9A~_-DM{0`H45=kjAW|!&)<{7}!AK!UZIH$zeTy^!X(Cc4(j=tGNK=rOAuUH* zgR~ZD9nyNF4M-c2HX&_Bx{Y)P=|0i}q=!h4kRBsFL3)bx3~Aw4-qy1nwpiCavd6mk z$ig;TlB?OgcOPWadejb^BXwTeWJaFI*1LGeJ#iL_JNL8gI76rZM4I2)S=Uk4<R0(kM3>FqZdn>f#$GGmSw8*vQg_Eui z|GMP*`2J^Co1M09fop5K9qO>g?eu_u-1^-8 z_NG?B?|VfRwCmZg;O&zK3$|(USHY;ac?+$HD^jT9{c44dZ|YPil~Y~hY}sfB;OGPdxcdt(c4`|42PJ0))yuKfMe!ULwI7a3N$X3Q+2- zt7q}EM|Kpi-_YP*eNT7yzTR8i`yqu5xAOSor`{foj!pLHZadwhdHL@=LMzVjh)&+^ z5ppcK#Ff^YN>u*4b;;r_6HETqYI?~B#rBnS8~>o>l!`%~qiXK)thjVUsR4&)l&aD1 zw^I8OpO)I{*Q#`(ePN|f)bCw7VBgl#9aeP>ZUv(Sb=c{)Yrhet$=>1o1$2BUm z_)6n4=N|`^aeMe}8SgiLm02~YS6RcHL1leMR46xXV?a4i=Y(?iYrZd6x5b+BvrgCc z8u6j2*G~>9UJjktdbyqVu28#QwF-ZX9Z_NQ_JtKZ>Ta(v#oDIg;c5jcwwzX>;==bM zDrR0?TJiqyUn>rAyHW8(9a8D@{qmJ|cBx-!+MBpaw{B0bNDz-RZ=Wj>31j`;LC zSI_sauUq5xWc96UCsz;Jf3SL|kYm-4 zG<{gz-zray5mnu5Z1pHz#THrTW98&qIFw-Os)HV!rHoRmTstfw#wVOzZZR1x5wOG^$He_t#>A4 zT)p@LYwP{+)7Ez{6Vp?<$|SL;9V`=fs1z+3elAA~k& zyZBs#dp z&GUEe(!5J>a`XB_7d9{MwxfA;ms`yjwf@w6)8eES7p$MOuv_-L#krY1TmH5-e_+T< z=fKrfF9%*8TDH}|^uSg<4@b3XFl1A!#0%S6Ret)uRaOhT)}6=sv^JcIXg$cr@BT9=_;tp#;CCzL2e%z`EO_uD ztB^HiY(qjO3<)V#a$bnfo82Mnj~8xJ`9Y^PwwBWvw$JO8K3;d|TE4}a8hQux&+^TIcexEbEw z@FcufzNg_EXIG49`fNDY!H_TOII;rlgPI?TIvv_q{CuR5GB@7D28&#oP3y^rd+>CUW< z!Tc|m+{Eqc;x{XPJ-1ZfulMeM^>w8o z^E$8Wu&(o`_nSI*nfY&*kI|*Oo;X&!>yIxQb)7PAUe|JQtGmuKT<)6isZO^U3p#h3 zm~Tb5QEm5iTYu(LxA8Bdy8p3meD|Nr%<5h`lk}*S$GyiMmkvF`n;!1*eJ%IM$4lEr z+BWSQxqbi8$WsIVjtt1E)^o*$Mm-(+H|_av^?;u1Iw$vh)ogapB;(?q_NCVKd>_BB zXVW2fd-@eNM!hXuIcofOX;B_M$3}&G&WyS_XK9rGcTUmYZ3~N@)TDEC@tvch{ogE! ze)Doibo$hvqN}ZZ5$%Ii2dN%XeWV6R4UrllHAd>^TR3KY%}OyX%8ZTi*t9Mtv_YL- zA8uy$n!A5*ufx4-_qLjTrT2$LS9^D!Yt?6e0h>OxSCsB^?)Tn(`d{hSrcqO=oe_H_@0!?kGhfA4-JQR0lhqabzOb3uHzQB;e%5(5_Y0eO zy5IZ)5BqIc;vDBPd}rLi>!0J&j`r;zk^fHr^0S`yHyjR*A3lCl{Jb_-NOsP@>CtgY%xHfCmz@TCK2EGhBH_-3K=YeD6 zjft)SXA}4JGbByT*EQ+8tPx2z@5d(fk35)UXmBX0_4)8*ay>kG;`o)xOO`%O?mWsm zWoF6JDXrg^O?mwwEoJnTaVga|9!^;@_FRf{x9cgV|GA&y*7V<$`U}Gb#U6+rbhdD> zK~)yU4f=WAf(4~Jb8QOB9)3C0C3Ji-5tvc+d8KJ{Q zKin|PIC}RmuMek(t&6@ftbn8K@YA2_4|g~dKYYTo3B&(AabtM*VKF0`B#j(V>(p-} z-p#%}V%E)9Bc>e)8X34ge&qTElSbaJ{rAZDH!nvPP8~67!oDY?3g^B5%|835-xS;S z^qZnqAHG@tjF2Cv61ss1`7^&28B>Lju`>xF-w~2>n~;F>gghBU$Y1{uawL$DS+xmS z-JOv1tAq>#TtIOvGQi4;l>DBMayEoq?@x%+SA^`eCd4%s_hkureSwfPdqPSMB%~+u z-TsD{aaJWC^_4~p&Gf{>O)k#`Fr4&?v`m@T1%%(Ww=#MgxUZDU0u zrxDVr6d^TM5#q6rkcBS@DPNcnw=#rmu1v`6BtjM)ASApdA^AEJa_4Wr{zOQ!n-#gS zn2-?Qdv}?Te))mF79poR37P6@MeKK>PGf=NG$ECG;Qa(boFCwKUMu2=`p32>WM~Z9 z(~6KQ?t~bt5wa$pkVur}vjFreXhqz|5Hjr!A@Q|Te6|x3x{{DW4^dyx zF%b1AVrND6qR#o;K>J?_>4>@qG$f?%HbQ<1AY{Y}LPl@EGthbFT+}(0kl#lTlJ_Ga zO`Hg6oq+nRA>=->A{*x8YHLMK<5{4QkPBxBIbGC>yd47C;&)rnaxC~*x&t9~iV<=a zbf1+$$W`D9@Bv*6C=+#$EJ(=4Qz!>?DRGOCL+4O`Z$h>Q5mG#zkorCG?ps0{lmM?G zBNb8pk0FE{Mm+-`5i;G1kR;S4W;7xD3V|Mg8RG|<;=OH4LNXVEr=Zhvqyu{h@pQBz zd2bT(?G8dBAOqgTL0^=01bqJSGa-v1TmQ6y{JB_>{C&YESI8mCbc4)R1#fTGAmkzP zIXOa}z~lJlgp@%FMEVRG?y5t`4?hy}2s|=0A|&_^LK=aOGa!>kP%oe%Y2ZsjY0w+( zSXu;a1n=Yf5mF0s_~0EOJ5cYZKcHR_guF-nuYqp0-Vow=A7w&L4}yQ|LBBkxcR$c~ z5BSy)b?O1yK0v!xL0%`$BBXmbcn^BoZ3VBQ35jyHBDV}yq$_yzDGkn^IDf$90cH|WLu*Mw9?efHa;t;3-=&?B$jpbzxcwg4e} z(XRE7!P$6s@hx=XEFr!V30VOAGnRwrpzT=5-D2?67wykj3!d)=Z_&;!GYCnA9tBp% zGsx8U2SL~Og#4SwiX?z%dB&q2c=iOk)9f$s0KD$;7&?zUM?l|A(9dh2aX!?07xe8H zw9yK>(*(a)0LRUZXlEuN&$|&44Sl!|dtwip5VDkzThQ}Qc_EjejTP!U6K%DgjOY2R zNK??bFJ#*mcIXW1eH-mezeh-C*rWz2uo0ICSq9n61A2~V3q63|-9+1-pk5cy{(4~e zHpp8l_){77<5(7W*#-Q5PRJnCrNl_cGTL(mveFW~y9yeWavHt-1+W__Hx+0r?mWdvVZcMGDmeuV9ajH$a=JpfT)bZ^-)|=*Zw-ARmT!U@eGK!D^s7oK{*kunw^245QhK-mH-Pr>9e2n%rvbG{CA>%ipr*2DN zQ|ZJhcy4F_TEN!a35Gu8fi0g08vuD2ei3x)i2Se*gB@`FlaQ0s(e}OIG3w$3c^U!R zbs4t0C~V(u)O{c9K@e>3`KE+!luIr_4ws=kpX<;Q*zLGiXe(^~F6h>2z`un)-UKcG z1z*oWw*LUV`lAd#(CRs4ykuSQ2y*foc4H0XVj$91;4KQC+d$`zz#e4aU03L*HDqBo z+PDjRb%hRx)CWyKD_`j1eb~D{0qX~x>mZYPpc`MIF1=wd+e1c*f=+K?Uy}g81n*)| z|1xN^8+3gI>SVnia_|)TG#L5~-VR5e%c#dy_{!pt^OBH({wQZ7c)JGtm<*Y@30tuq zWh{W~OaT8D?S!ntUN3;oHw2xlLZ*8au_7;FgRVi|I>U|@^o497y@g(PhHNy04XqE| zZVY>93%~mW`ZgK1=LYP=GWa$x=(QE>k{4*!tpXt*@q8=vs04g(KqCAj{PJD+qbT4! z0+~n|hu^T_2dM3YpBM<9r_F(_xC{FXTN{hIoj^PNp)VUhLAODJx8P?i^rb0iP<1o> z7WCq8=y3zcLLXpbw^4>8iON4tJ{LmUBS5Euuyc`U;|loc{*aB|;BVdGD>{M(Q=td3uqhp2 zUmAnPA+U32p?g-~XA|Iv0KH~YJ%Mdn1KaHR1hNfV?gg7x2fQu^{%(jOH zGXJYHbjlw-1onc!2YZ5_gFvGvkjG1{A(N0VPsAC!AP4b)@q#`dN7h%cPeTsF{vl00 z1bj#*knSPb;8`i8Mo68JULFNaj)7OWMk3iGl}Fl*bP;J3(tM<><7hwV?2FU}X*7N> zMfwTp8q#k^;O~&iAmv4R2;8TU=HPxfQa2<&q#)$2igX!e{)ps?``5TeBeg(Ugp`J~ zV+tYj!eBE%lX9TRHPGuX@Z>0HF$TVFChTuB=uRkjVhf*;0o&yWxm@@UpJsjpxjncJ zaG+Z>zHBNj`AO=u6e!Qkx~*u2{)?=@uD5%RqX`q3CM z#zy$ec-Yg!(DUi=3GS%N9K;nth@S>Q-~NOSxgiFcj<{(DY~8o0+jGcKEcCDqV(jkF zjq(){m%xuMgRaho&HoPesU`edBeY=?@CL)?Z$a$j1;0SxGpeAxf8ZxB0`C*Z*e%$+ zA5niagDisl1mX7t#Fl-5*Phx>=%^9?>^)+iOCL}N;JgJr{0x848G3USI`=o^zXjU8 z>0iVo(4k*Imu)2xAA&DU;In(d1`j~K*(v4%!VrRu_1;L6_fv?heqMt?+ka zV4LUu23|lvhC-%4BmO#uR0DD3_h|FXWat~ptpy(Rge~a>U9AaQo`zVoJIXo+UsWHn zQUbo97ySPi*qQ#Yk-sCZE``{>GVEM^*t-tU?Je*()j(Sp(5xL|kWtXTe2DM1z+V@G zZ9k9tA4beP5&T>T-|+-QT84V8K^w}zpFy=rBhaN0=<*%vcmREr<$&u0U9As)u@b!6 z0v;OB_EU(bw!_A^guU#5m|`z@*aGFP!u<=xb0ttmC&aDK5SLU1?{|T3MNp@~utN** z+zb9K6gICv?88;W7N;Sff1q9u5wk3Y@2n5|=LVTK!alZxT)l#SZUY|Og+KcM{?3J8 zNW6k_Ag8n7dk?`c{Q{XLuqUp-;f#LScF_JR;`<`7!|kcOqi=Bnc<^82;CVA{hSJYSqy&>2l;IZ+U`J|rl9O2 zu=}lH&sM?*RRB+Kqn{TGUw;F5n<3r{gpGXyKhX&CR*Lc&`mzdkEDUtmgFfO{kg0p< zd$~eC8=x;!1b7Dm|1j{l8QN41viLoC6a=0B3i31#I{$Ju>II+qJ@_#M_no0{z0sb3 zA*;c#*Ox%=2*}_Y_^bfLOATN@zC%4f0=6^kOgQAU1LSHQbZIK$>U)sA9}r8I0sr=( zoee;PdAM&5Ki&rPdV_jLqwPb`mf4_dZ^)Vf{eqF`lgvO|_yqdu2|g|Wy%$0zpCK-4 z0l&8fdL4s4-9z~K6v$T?@*alGJB|KhGw4od$Z#9*t2g4)NVKO%SMUM;rwmm5Ieh60 z$n_NH(=GHhHzSs^20uE%_e?>3`=b0z&}A!RXf1ai2LpOGVuEW8*Iq;p!V8WR8cK%MLn?~g*<5(K%Q3pIwy8h3o2l)67zOOj^rvvggfsHAMw)KE~4MjZl z95(Gb_&W%7Yl8T07v!@bVzc3(dmwy97IbG7V*CKe;xMFF&{Z4Y-48qU6ftOD;0#zn z*JN3dQSjUQ5qms_?s*|jJcT&45$x3<#Pg*Q@2o_O{RnpA0OYnE^vfD;DFqr{hh8TG zr$78v7xc&8qF%p%*FQjRtx?~%;K5Yb$#}HyHt?)Po%e}DKcKgj1~*znEZ(>?SPpF#GXAZ{H1 zJFp*o`iR(S17zqE=o$`vZVEZihnRdU^!E(jm4aP9NSB~NUKS$`u!C+$9IOUIRzOT16%Mf?svehSA@S= z0-gH_y0jerp)$4e@O6H$i@Txgfrt}N!;Xfa9?9?-c~SRwkmFCVleaUyeYzJg*82n#%_+)}O`aF&MVZ+|h z@f7Hq19(~-x>po-B>?690p68|Je3B|HiHkr{!EAcNhmwRD4OkS$@eo=?{O&~yre!W zFNy60O81qe{}odZC9%x$*+&A zBUn=QkyOe-E-3)3oD-M`up9v1mH_0Fh?Gsk&jX~XB@l6IS#|5$ke=BmAK4gkXkmnK z5QS2DGl11lgYm6o#f@3{A&-fYXmWJZ4Q5O?2Q)orF)Q~#@)4{)q@(p01NoBa)+US) z_u}UJ$5XnBhZ+10kTPnJ0n%R3iWX5)6t*$pn5-IfBVw6jBIfQyYirzgHYOZ1)i8R7 zRid=jFg+oc@4TF7V?qv7Fn(xLEHffKB^{q-V8_CXi@`+! zrNdMfg{7Tz7(@)zE(z_fYs{fMQvkJh>2Az{XjZi=3h!LK@l$B&8?dao{N7c#$Y%&nfWh+aGN;VcMa$3M*$F1z^c)A-UWWr9ft^!CNmRmK zMV6k~V2b$5Hd8*+F_E1Z%4;AW0#esrRn49jGpE=K+C($UF^S%(r|a!iMCYchwMH}Q9WG)&&BGXE608M^R;DP#_~6UX-E|i9v?Za@ufKHQ zQnD@$D!2$hyp;)(@1RykIr^e4s{ucDte=bEf|a9*`LRxxJCUPZ1nDycH9hcK0b6AX zru2@e1ojpV&k{L**|c@~U;m&}jNRG6@*fG$zw^ByBr@^iO<;8fHAfzsKNu~OHUi-P(zwu%J>@1O?f7JX2UxeeIdj>JeYdJODPJX5bY7EjVRnfKM?<9R5qQiTZ_ z^xuonLMaz3A1*m0o3UygAB>`h{J$t#w*9>&38uLe$XMp(Hy5_RQtpakrDL6xb12^d z$p1@$ln_#Bi)|61gO^)Gv?CHs`1y*V(z_&5rHHONwh<1zQp75zh_3weE&x9WvYli% z==~2xbTy39HHP#f;t7mziU^$>)9j{FUZSY3OB7=gZ8J8osBT;I4!BxYRF_`bG0-JT z0Lc;`L=$5yrfab1(U0h#AcLoN28AwNi|Gm|KWdhb)~jRr3B?3@aO*f&s+C?J?LaZX z59x(+bU;vDhnvL&2cn$Mo|~>^rQ$+~rsKOYszcGl$Z%_MfgtL^T9Lo%=@DmlA$Bnb z%3at|*IkI9)JU{O7-+c7k8YNI{Xlo!s<$J`!O!X_ZjmJ*wQMUu58MR{m0KV!N>ua^ zBuR}(Q4KY%2YKk0tp}nVvdr@kG)@nZ*qOPcuB>7}8Pz?7T_pu`A0jo7 z_AcdfEB#0mD~GaihNln=ikVYXj$G7e5xi(A!FF(y=7;+j7Iw;l!n=jy$;F#W2_~6? z@u3h|L;o%%*aU&iiz3|pN()XgB)d==CWlJ{OHqsm zwCFZcz}$-sgAOKBN(=m^6MRV$1KFUF$|;;JEl5=xJm?9$e2|9IB?;Cnkr@lq4z%Gb zfstaQ(S`{HebP2tdd(%x58&YnIM=l{OivUt@cx9hmu(|Wg`0-=$?AG>fz?t%(_ux< zpc`KaBR-bEO(#Gc%Lo$mC4l10m0ua5clTvT#F4?t{~e7u33TzlqY+01-OCF0K}I7w zOwm|Hl@(06m{|@3IGaR}pUv@$`sv3G>Xvo5R5@XuCa26f%}mr3k;%S*&zkFnLi&T{ zqsj?_YwlRIy2j0sBUZA_>&poy!yH_(Qd;`?cR9hVh7xgzUJ1s`sgX`e!^D?YRZl!|*Sw`lx82)I@MbxK@t(=lF9DL<_u3RlG%R`y_p2ZfLGk)x zCrk#V<;|@i7#L9_lCm9Poa6yw*l18nc8sCStKY03=n8j%qN+v<pvUTq#Ibg0D%n= zcn~Me8pH@J_VE@ZFoK2b+)szIIG1yd(y?i_M$>ZDoys=eLT8GvD2gYs*?}Kd!e|Q$ zy53s|ZzzI(NK`iC&Bj>&@)js(IVF2bjV7%AQd*{{IS9BJ$_>i(SV69EFD29ofji#)&yu+9v z1H`kMa0j2nY_-_yP0H?A&D8_o73srFJs%^CX2jkKfQll3Y4=Y}o0BGz)GjowDt*bPFB9-9KHD{#mzqQ_)so~lCt$UNyarggW>RI6nZu1` zFJ!%t7wsexhuYa~QD;?@Ny%ITnVV~`_UfKJo(s4Fl@D{C|}Ve!()>2=H5sR5=EHi%(QBzNlytTE57H%^iyh1EPp zdJZIBIU$iJQS;U#q_lo!`Hi#XY_hn~?Fg#rXOkCasYg8A0aVK}kUExEg1-v&EH+im z=eo%3ub){qPug=A;_!OYdV-W`Axg-0=utvtzqVXidB}p7(Z@0++cEmhUORw)IseA~(Q%K0R7MviQFsNoF#q zAh`-8m9>yGlgzHNyp#hJXrR&?5kR>&j}qE7(4n#U9ESq55kTISfwli=vO}gI z%G#-5DWp|E3pUgRrNeHK(x{p;Xr+MqHPj)B*5^$M*rbL!#Mhb(r2wBAsx(XwKr#7z zgiy>G(+II^Zcym0lNixRhm)obnR}@eCV0yl>2T5cQ2L|t2wNEXL)T($jl?64)o zvN0X&r(;69tI8IgoVg%<4d1HiKHbZC~#l4G-j0wv64tE`);V!tm(AiIk-&2-FlcNMG6R^~R- z(c|vAY(;iG#ne+gu0#5=JJ?@WG4)Vda-Ey}bzF)*I#U#%{B^Y`wKZ%K>0$acr%dm%fjW^?cVSGGitkV%bPvr9P&n(qDnJ7Q zbrskYD1yXG!$(xtOjrIb2(&;|(-l=*R4-bpFb6UHIxLA~1?mK63XquHqZJ`7EoWEe zOXWc@-L(O&bj`IoS~WMC{PP8P$yTcFvxvgfn$2ycYZ6Vf>W6+ifFxQQ2@ewJcw01Y z9Yey^OrA`MCgP4Fv^YiHqXcgqO zOw~zd&Y5bE(?L2qq+~LmX{!{hW0foc`I6}W0#==z4A$x4B{97*U-wiqgpe|N0Bwn~ zYf4Cnj#)O%s7$7DgYs>Nj)ye|G=m54WttO-!gcu$D!v6P_dKL~#)VpopA7MYAJXjt$`^4%0HI zSOdN|=uyrH)Pb|9$OJ{?DDCDz-$a;n;&KC|kZe%Q*dq)lGsGg;q#12OG|YUx<7I@Q-7pxK+R4<#HDoX6 zlG@S{qvc-?TOP2&n&6D<5E0mP%7Y@OL-Ca#==W zYJ!S%&lRXvsdWL`HfK=15MOQ(6-aUFF{ZmP?kA$n2~m<6c^7mSG&CnvrogxL>cJh3 zOoiOk!>fl-kG4?a4lEjoLAav#k%+S5F|LQ;giW2D(#cfUK$$6A-$Urwnu3dd^lA^m zBAI3s<1D?BtRpQ{)VyTV1q0P11tl`g-rZyaOYy6(F_A)NAtyj8ZEcuUr1Vxh$32n4 z;8$)C@km>ZRCBPy=4 z=bBQemjw%@75JD^t6?vT!o?AM%`8KL3ek{W7U>YgVuJxWk~4{H?IlEQ=7_{T|NCAR zwa>J_uNLX*y)BBgR)4=IKzizfh*C+TP<_vnAk~e|8xAt7*~s1&B|&=x%9N4x@Q&vC zNG!QI(`k&FeJrYEyDwJBq&`AeWR6hmjELWJC^h6fr61;t-OY1-grL+CTDd!0G}fa0 zC;%OpOA@2#Xwp2^qQHw43uN{*HhWJVWx)+~&hukc)lOg`kJ^)pL!Hs&TC7Swv;fpT zoQt1&e{y=DV1t~IaLv&|P`_`E)m9TMTB}6LS-ufc0Gr?9`pVxbok1QZ&+4mk`Wyil zktjx>oKc+at8#%Hg-BfmRC&rlefnusU(Fc)l%j|f$I&G@n9@(>5IKUJt9%Mz#mvFv z?`~}4R5C2T=96VP;Vz~Hte)@ZPn$ACp)9AoQ)FnIh5)F6)gPy&#HlPU2QVF35$#A4 zSrsRAOJxw=Q&zs8R6cDxu2m(PUEFbtuUq7Kp6UU}T@LwsW;suR{u*tt>}cxs*J*?H zSoDzos@@3CuH}uk_17>1=4RM(LG4u-1>wcS~>zOPp z0M|yR@4Mw4wza7EO|lSR>mxSZRyZf-Y|9yK&I6m~XpiPhRo?64QM-EU7ISoeBny5~ z8=Ywn#~jJ?oaDOH!1`Ezq8(6I7 z)FFa!sgPq z=Cc(L?J(+;b`?#(gR}Itn#(X@jzb@XUc}ROn5MK?`Vvpc)q9vGc`SW}w{e(Y|15#X z-{4))YagHb3x)RCo3CRd?8MO##pjUe^p4I(6#I zrjA?zdN*8%3j|gYW!u8;W(PgUpCNI5Oww2;-gE>ZeR4vpj$irMQ?j7DV(vCTZS7vQdk|Rhgu8~zNFq;Mrz8bX{fCBMEOT)+HLLlS^=YH#_E=(?ocQ|cHdYi z%XDl}0SmMQmSiGsLSOb9VcNzLm}z-Wz7cw#=735@&r}OUNMfV&gN4>{pkAq(#?IXA zDIjxGH9gRmOj18f)wGwnot`d{rc(oMYUCY}`4E|CYLvXK(loV7jl#57t%ay1;d^IA zGFR6JwLSvW-TrT&mRCj_stXNXMm$G*MMs8HY3{6qAG+#a?LsR4}f%uZ+8JdBz>4dkILoGF0GZg8r`$b~g z(VCvUyEJN`4hi;+)~T3jr-%37#E%&5$LN6O+}p1UWRPp{Lex@$E6f;EkA>?>X3u^*7}S%P*1C4`XyBRWzIG(SgBZ1xb}V z9^yBQijPt(?e}8^aWe;!XO9#Br*T3r$sB;Y0400xae^6EvJYTP9%|BClEqE|KRZtF zOft9>wLS^KR19GPk!1no4POTHaYx-q^MjK>6E~us-`pW%}ClfT- ztoD6P315J$RM~5yU^%pbginYjYUq(Vv#7DL6E#Fson6+|6%z%!r=3-6gz(x#!Qxl~ zQyQEvQ-g(SkO*e&>Sk(4u~tUQk{+9>!xg2+rwnAt?-ywUX|0Y|)_mX3)G%A>z5Xpp zUhzqSe^S7COJ$=HI7zb%)2|fu%IGmklg(PJ6{o(&PtxR>dB(pdY085#EMjg{C-)hSX z_S7q9e5MHTtg_x!mN51Bt={N;hbgKm=Vs#e=@da7ES-NQPH)Fd6&R~*#h{E+=~eLE zRMyI#(#X8LoihC(oNK8vev`~TRA~ebR+&!IeRGubF~iS=v;TM_mal>Pi;Q zFG(b$XR@ytbBAI8G2a$6Q0OI|n8`*P{yQ?+j^&@l2D5XANIveR51V+2XY@%Dju=xq z$5m#r^|-l1o6Hy;#kTQlntixLyi~)6Tub&4U$*<}B5QLYsul=X6wvQJYixH#7w3nlW( zs3eJuqAXK+r#+u8i*s#V)H{;rUGfEuP;b~jX-Tf-wk^@x*!;?pTq~k>{3Z`Y@mwF5 z8v7N$t_P6BALoQ=Hb0V#2Px@GLzd(59& zE(x%9=TrTaiaO3GD{=r8hrQIGJ}acE>VayVnAdHE#QfX>afW=CQ#HkNp48PmxSg9hiunk!y#gtmv1BD?rd4z7oDhm}6N0;ublIWsM57TFIB;~N04XkQ| z$?Ph#S`td_OxnA*cU~>^555FQZoYb+r;T>*f6Cwm@*DhaIJ)0J)5o` zwDOlg6;^t$l{jM#rZzAm)=DCxp6u2$9yheI>l=)M>m)LZ*?BMWOOL~8xlW^GeH$=i zoizHQJ)5d#;p%m4U{#&jvXMBWRULi9P;5O^OJ3)xwfNa|{JAXvDp~@d%ddM9c{cb* zWG^RX=SNreW&?!O=kuU}e%|&1S-r)qS_9t+s)6tH4UkoR5SdBKk*!+J*_7T2<@h52 zc`871a3crj{J8d(8&#O)AuxWrmprRyN}&N8RSlJGYcf$zw3H7FmbGDxx*Qo~P_{a1 z0Uh6{qK-f72XKLIDttNr3fami*#ac2@*Y6SxIv*!PDF~hB7YAIRiB(qjD0$43QFy1efkC-zB9lgauwPX)>YKw}f z+L@XXd4pYL`QZI6Duq`Asz2H-wAGCM>JJ{WH!k05fktxo|7*r=aX+ldTP-wHR{A4b zHR_wdnq*42TgX~W%$mfy7JRO62yxt|!o+u(=*O04nPTdLtaX&Erh5{!mTZlBW}qFL z#)v0HzE_o_UiYM&^-VzseXk;%rL6ShcRpzsL)L$<(pWWETV}rdsHFZ+05~fEA*2(i zQ*gV=X7OF2mDxafw^lV}>TFlhxQ(Riy`+T^6Y;u`@>(SS!R;!Vsy6`Bs$keQj*`cbj`jF&sNrL0a zz8xwZ)63>V9`8^&CHWZ2Bo=1!kFQNv@pT)e-hnHYsJ~2g-bF~;-0tft9z#i6C$AuA%K~a~^^ZT$w#qHqoVWSf2z1SJi%yJs z&1-f8sDg66k*y&8dUdP4`wQx(J~`O5Zm~dBOAD1EO6rZ570?5;7J+OGom&UxQ##s# zYexnWW$T2tMA;dUe}6=+jl3TG8Bo&d+k7j3xz(oo@V5Y19pzgpI$bC4vn_Yb%+IowRV@m@UZ%j}k|uFc z&VFRBVVYUBdq3gJe}eFTOUc8~H*Ww~*%VOC8g*~9+K(Cl!3=vJ)_l|Dr_%sX%M>7j znY^AvUX-Ksw#1RK27A$}V1P7N^;CF2MQiblY`g~mu$~NPDPtg;@#5>ulueDT_JQ3p zxcOpRy}j4G0oFwZ3uMlLYJfa+62c_2C*dC(_0pU?lSc^UW%BZDCD)r?D4>>DfcV`_ zj3m{uLNk@oft3Jt*9PThI=3BfuypC#5_n*8>(0UgmA;8d?C#T11V2v6%`?tyEiG4rfQ!h^CM6uDktWOUnM97 znD#35z6Q~T_m})|qCgDmU*LJ=Aw_LRsTe7aMz00_K-IJjGs4Y?yx3JlsVA!Hvz6wl z(ddsYoQc zVk+Qrq@CU6V#ug@66rkZn4pldAy$Sj)cYBj4ifNOtJE!}zR?e)=pb>ow~0*stj=p@ z_Y|*dD6cIE58vKzFyTwJJWnuxBLk|*YN}G9$Xre@b354CpzN$eEoF^>_YBX@I{gIW zyS(J)zj%}NCm3gPi-J#*^=IzSeChSmFR72Vb1HfAKcNuaQ}9WqQX+~k_b$UvvY_P4 zk*Gb&x|2-0EThr#DenMSEw_NOSE+X@7eJc#;ucy0?>LzPRyd<-l@_45f`EgM1W+px z$n-lqPLTdmXC)_Xx^#y5ZBume3SW7eOo>J7oh8Im8$cQ8d3jbP*#C#TH-VBYy9xv2 zYu{-t-BPQiR`gm~-I>3tvi7X1?#{}rs?P4pr8BasdZiT^@iX(QBI9SrkEp6tBNho{ zFk`VAe3*lcVGLuy!*Ey*))`~K%kdlr8w^51!hp?UzzE}E84Q@2cenTMd;kB4$m)_Y zXM|8y#eeUD?D3yP25x*XqbA?{S!6oK2PnuN8WBG8vmQQ=1ISA& z_j5*?-Ai|u3u*V~_PB%wYfVE7!*~7M9?yuR?rY3E2ygY!za6?0B9Teh zNX*k^1_!(GmS3pV?)N*DW8Tg$1k|QXXXQl&xlywv5hk2H>|MjN=(sRLVVLxDAUh|8=G#0S0FvL}O*!V^7 zJ%17PtZp}QtI*+ne=)cXSLx8v?=e6UX4ru7! zL4pqhkpSrRkxzTf+_(U>%H{&HSTMVP_UQo2L?)2456R8zK2y=5N{INL&jk3eXr=;P zh#{^z%Co-|Tw-YGsBpPr_qNXlV~x{ky7uU2k;$*>=8Jz{UN**P%=$Z@4Nk4Ro8ATz zm&zjgUj4aR?fIJl*08Z;E}W@sfN%I*@TgQ?+fv=)Z+{c?Z{VTaI}l3t%L`_n|t}!0xU1@NaMABZN$oSV>h|q|Fy9uSHz=>{~=(= z!j76L_aB^7zg{|3cM;0@rW?N=JZ6oO$LxoHJz!;g#kYHrs)d+W|3<)ARPlo^|3SzsQu3( z`jAh}KR2Bo^g9(@+~^cu|J!DXn!WN9j!2|gRYuQaru!XWSzf@2t=6Du-KzQfq1p@P z(|gK49jtv#^~XcCudV(#UHi7`kB4hNRQ>Tt?K9OMkJdh4{qb1swZBvO@p$b6)gMpP zma9LWtmVH`v3b+AZ>j1xZ8q-*t3Mv9{Y>@8>DudmxANoR+TGP3kJO&1{&=*uQ~mK+ z?dz*Q9_&}RDV2P`{C-3Cu*W{~3KT-YhMD3~nQu*;@?Z^L1 z#pWHY&HdjM{f?T=d$IcCq1snhf1Iw}^@o)o57&OG`lH!|KdStAwD!5`kH=~+|8eEV z2U2+;ZH|uzY+d)wDuR_PseI+{?p*6YoK!?@ z9l(EO04`~OOEpsX`Fn7Ml{#Xrgk?G3Am5zvmj>i9A7qAq1NHD#1T1_`sFHi?&x~ZF zyROydk+CM7gtM?ov75XmCWm(IdrjwQ-B}!%TQv!z*J-j-=KT)*`PkjGf#a7!sXT7Bj0@0qR-m34K>2b}@;%zv{Z$*m5jTs6tw zf3uq;T|>1I9X?5@qAB^E|7I~?y3x@OSi?g}33S)08Qk`lMoRHP`Diz5MkE|BpG*5M zEp7>bG6AH#^Y{FvJ?%Avjw>}CuqOs9vR;Ub?%7&WB8>c;0d$rCT{5`6RwJ`kjyG++ zM!vlyJa$-HE>53Lm)@>D`u|!gBw)mLB1-lU?AMzv6Mh$pVxpYYbSauBcqO%;F^%sp zHr8HdpkHj)K2VDU1JGTV!T>EmawM=@)bSt&wCxV*fpj_&f~DBXq~BqS|9_7!ahdV#6Kl;ZE1f%~huo z<|01^$mtM>ptfIRq1;sX69&LaHGnd`TDjgsYxt&L9n~JG0_xndhk^SJ1LAxYi13aL z->aW8pq9o1RYVU8j3ynItKIdxuT~g69HdWuZ-32@ohdqUQ#N>?x0x9R!uJGPsFjyU zYrkg5j)XN-T<*waG$HzdA40~z_ccS#EA${AeqR6KHI|AMK{-ck?Ug+B+Nk#Uur5^a zhAwi^-Q8dE#_J+^du|4p?AJei-4GlJ(-?#8PLyeHeZ8f%#f~dA3hxR76J;k(yxzVX z#m?0(pI`oZwda~{h^ckW{7QM4B_8?vOqUOqb4of|BZ9V zoTDjqo6V{1g01%0o4oZ`0TI$tmYfLGiU*C9`%`aHcV+aO3jt+-X0)-ly}7U-(z#qU z?=lLDeecwpJ^UOE;tB^mCJNnKwI48G?ss6wdxr8REZ~zVa?0FWqS`@eIFC(K+Fd+A zs)VC!bbrZP)Ehs%lb-{#Yzt>`54LJ=duvpitOiP^$i4#p!*5lrN?8Y3t!pkmxjEhs zz{$be6iYW6fZl=MHC^YWYndjZ(msv~1}6nCf6*%dq~+qDG=QGafV71~LWsr2aURE) zz#md}__~ujZc|rk6u8i%$OrYI+Z2icv!>TyeyQ5EpSn$*4RmrSs~wPZCaew3mJnJ^F0k$4#RLr4g}^ zE}@y97v*2PT~RQf13b%)xZ>XS;Ti?rF4QFJ{b$~8#mcGzV&2@}5!GhOn>*DPZF*VW zz}7nylTc)wwRgFU_|bPLCa9RXj%1B$_Mjf9DgYe`rA5T@FGbmOo!TUHY}!YuLA?f8bq;0So~V3sbi9-)*{Gtm;Mq zCvG;x@Y;Kn(BhQAetOSWs@eJUdlXt$58?|5PCR($o$5spq0sr3mZOZV=WwTb zh$R3=pNQii^os}o|Lu1wj;>5mCMVxv?dm7>SVf{bOr7zWJJlAArpKXn@9y_1+*{$B zOHaLHJf3;4qJ+NO>^Q@x@&BAoDzCl#UbX!zwG=1fpoU^yg8`qz|NRxebC@O4A!1o^ zlBe%dZys6TG?DaU1__|gOMLP!MLvbvU%&}EUeGP&^LMFBFU{f9LU$q8<>>nqRd?wu zhp+4M`_%IX`$fc2!~Ngir_QRuVH^@z<`P$jboDLo_omZDJx-4KE~?#^|JM7xv0g$J zQ`?KmUHgCY{odxj#FS2$>M-@l(|4=eG`jh8?Gxo4{5;e;pz>ee?H%9f4%4+S`ao1$ z8{I`O--QG=gv6APywwjV_N59ifYNz{oSBjAT(C3$`2&h!tO8V4!}YPcB1U`ZI9>b7 zx_9rOt5fvrGPYHR_b=<}X(AVMvmbs2sYCTroRCWE_JqlSJKi6YRbJ0){-K#XTa;0=>;Js|s+P#YWSJ8$)xmS^5 zml3xdk_@9b~Vlj*!zF*zduv59t;>P`oXB^gLe4S1G0Y$<> zkVTEnpFN-utJu6+-SXCbO1Uw*qojT!#;vIM`Nsy_>iFQwUa+!V`Hl%ivqpoJhrT$! z8~cX<8b=W!SaSbEidpv)#^|uE(+@}B>Lks4R%z*B_1KcFHf-|Iht=gR_bvwIt<(Dc zEYv6io?Dg+GylxP3L&Zzy_Y*#h<%p85>dHlQr)Ie;D|N)mPvI+ zRb8sseyyr~?Nn5IuK;q(Iamuuo4 z`@b0@intFN{r|7n1FT&pL<;`t173gNkI5ee5M<^cYPaMgnTVukqo&ia)(#3A^oVpc^buxi_vijjxFY<;bZ_=T8nt zwRgBia;DQqyjcp3keG!pKZ0UTk;NP@p}@a6f=D|~_u=8sw;dgG9_5JyX7}D*ClUCO zqj+75-K(YJ{m0O*vX?Gp_v86v_<{+TVk~}Dto+|Uh8$gW$8nU>Z$6G>a~P1~ui8d? z@;EA}_6ERzfWGfIax23?kVs8Sp*Qo-M|CR8vT*nWzAB?TNrr`QJTYRFG7aIcoIv5N zx>I?@mb*_Pt6SZzTD^MlbtI#DmC8}*-ZtMZtz3X!56@UqG>Fwr8YKR#{oqa1)Z#5xmSURynbFJ5&gz`Vb4W(4E~>)GQx_I~Qjh|L)0 z9QE6#^W|ZkCD)O5z0nspL>;%!cRzyc!p(zrpnl;IOXtc#5kKeld+Skq`^!62fBT+C zEq+Vd2Q8<&!ganAbaeu!Uwzc#TRFf{ma@klv-Edd03dnx9viU`X-Kd8Web3A{8iTF zxYy?E9z#Vw01VC9qwQB@1QM~+rI!pn!GHQOOAU&HSQpHicBJ}?$1HY~b;<0nqFs9D zEUM(nJLmv+aFxz#JpAV|blz3b~pDNoM{gMmYF?@@^XwEVv4$LTRxewyOIZKu_i1NxOe%CLZ zLp_q;RbL#x`QI;_tba#m(Gt)^CmCY&d=UR?t^^m#93I^2eE|P%Gyu2_J){ToI1?Yh zAI@1(q8dO48~YvOc`H0sbp*adlS7TBLI#lG)+5*@3n0269weu81`7NtG`wKCx&?dzekBTy3P~K9Tdj zdeMs3MIhxq!C~yv4bOA-hZfbb?j4}q%0F1N9Cs0nAD&abumej9cS8U!+81;JP_RtT zA!mmbM+3+T=xD~%!+@91=Yo1M+=Eo+oBvOi?75O3D)HjERk^#T$bUPQYA)~hYnJUZ zv^OAP-6Y*-TBBkf`)UA8>SUIqbB4n2ZH zTCtaG6iE7B9?1Q_t)Oef_+VT@IjX4Sj6Ql3eqm)O0#hEu0UiVFV7Vsk4Nr|&;y6I^ z+T>G~>#qVszf&p>;F;FhP(43-23x*m-KlEq zZ+mLQ{?k}tbfr&KzyGPB*VOrIk=~Jtg!v$T^{JuP6kanelvV?JXw|Zv<$!c`9E}yt z)nM<-9sT`RcHlY{gJ3Tr8(lPAeDA6ik%YRE|B0jeOZIY$Us11CZ=lZ(bqk|toK$(P zVcFYa6;l!VwDPxD+uiBN^lP2hE;TIo?@*)MhxG>=h*$lZ@3ul`B&(K{>onzB==tLY zBE@(>R*_z3oWaDeiuwLEM9|@YieU6Z|C|BwAaSuTmJk5#HTA79nlufw$>+gE1VMD& z7P%Dk{5J-~y*`Mt>+k7rC4$Ny7yT_XsbG`)kLoqQV#fE z7wPkzuLOuZJa;{(NP`YN3n|Mtn}#Q(;R@1_U8K1^GvXE>T@^X_=ce;9=^WB|SLByY z+~4KN=he8?T}7kecYf}9g`Qz&eK6(SzxMed({{&SHtqkzbUh+n%L)coZPo9Yj*m-6 z-^sW9x@w#cujhj=sQXo{;209->n|ueGTa0Hn@!VWty)nV79T# z9o_9uO}FT-`DVXaZ?>B|{iIjlZtm=)-OYN^>t($-dgE-~O1f?HOElToNm}VfnzZXX z&0cdmf#zNFXMNwx2S2i}p62y#)~{b{cG7knJ-)V;)J>bMtj*tB%`SXjPt4ys9RmPA zK)}CcJL@I&{#LVF&$_LozLE9Jzmj?mAd?$OYtT=#ZX8W6bP;Af+evy&{H+eaTUoc8 zwBX+`bgPr)i5WMR)@iq$+^Cz88L(;d@}ZB^uc!U3`dl{X_RqXL{gF62Jln-a_&YS% zXMVPeF=Or7 zi>Kbo3{JG@#M^Ydoxyh3;^Rgy+pagVL9dm}(HFw1jb;kCw4St@gFHb{fX}wgAv(;a zfw#RgfCUoZIQrs+u365tq}NZ^I|*&bcA9TD`>ibluYWyBx@99~8@PeZZo4?zG=B#q zIkA}LIZVCK3g^w(9t>ar#L@E5p1fi3`&tubPKz7{aN2a7F<8I7ZDzfe-00VLdT^Wi zyY;Omo$NZSHtnYU)ZCsAC+%qFQWv2kKJYWJyu=>(Kv z60sn9|D~OFv!4ha(Duu1jiY;m>wBH&z;_s6ME3-3V4gU~cACSy+HO_0&B#T?(UoB{ z)(O-nR4{fLLj6Ca(<41pw1%Z6({yR|cqjYZtn?>31u()`zs$dC+gS zVje!E>UrGnU(tQ$5gzn$D z8vyp<(XBTU^G0Cf=g((7^J2)>+5JI2#dPQa8Ez0%8CNqf*sh;7sja7AyLPb^Q4j41JU_*k3MA0+M|?aij$ zZuW#(FyEOqI5)p*c=)tcZ#;FezL|8H#TJH-=V?~f+%$}z*}?5Wr=RYavDTZgX)vr| zAYZNkQx1bB3$jDbQ$r?`xl5e-QvMgi@Xywk*~}K8JuW7WJ|0z! zF8km=T9r#{`p*MR%3fZ>1r2&#!}smhuO_>~pQd=D`BHwxf0v2KHZ|d*)(r!j!w_;| zN6x_~?_ZEPj69HAGKVn^WM{9~J@$wW`~4B)b2oPAfkJr;sIZa1dcEc@E}pR6%Fjkl z1`>(D94!PPZ4&p1y3;c<3HN|s6!Y958M(fd_LF?4*-8vM{A99w9cU(vfuf?D0#XK8 z_j&>V28P$@8$q#bwme4ZbPwY%GeCAaNq5r>!7pFOOr+QB@HpFp99Lq52D2yU9#74; zo_R72m51w#Zx)?bPHhcUN7CJ`&kp*Tk<5$?3J;Exe&Xm9v6Kl;8P2SH&Q1tgvt)+( zQQ-n_4#Z<>?WL=23Jl!)t>lJza9ig2=oq18GwtWmyFuhMZ+XigTE5$D8HCCWIgKO3 z`x$^;({g@Yac1Y>Sw}u9I%r$OOG&?e9!|uZ_Ep@Wx_L9MrEOsZhB9M@NvT0^V{og13-5vnB;SD&mCd0x$(ki?r!*?24 zUO2+}6wo5;0c)_H_tXA>SWO@af>&{L51uv;V|UZMz&UNDneINPrVHD_hMA!ai?V6Z z`Jpx3Y0=~%BS>1I4be=cUDoEkFmJzF#*L+dIuSp-O(0Io)eyGIEEhxw+*aC0lwJDf z4ES0YZcw(kotUL}iAK}W*C%o#ZSb7-GoH-=Z%2$e%rxm5BxTBuM==TCC%qM%wdXX( z+!+l)zA_U6whp+jXmMeCr<1l)eE#Ik15%7~mEN9yruNe+p}Z$2j=nmQWnU%AJ!zj+ zkn!QJfrb>2rJFgfC*L<&-v(c^5Oo$>#^f1lp+hLef8^Yi+>K_W4SrqZ6F?Q2 z{w0PfHIhF5c18|I+mPsVoW)2GoQ_A$zzBGYqTgX*m#>V|Ux5}W;A9Y|gcfW!dspeL zSDL%!;v4P@Bzq;I$9*MsgPyiAwD=!h3$#n&bHOmuB-iT6Enu44WT`f@Azl3>D>CrG zC*6)U)L4TRs~uo$)P?7$<%3~J&Bvz$N`~&fKIt{%=mWF$C4)$F7aQgVgMLp8WrnLOvAY&V>H`p8CpA8-^~U%QG8JlF;R1@;jv=!a>(Sg8l9aD6L-T)vr$f(=kxegktzHG)445q0iylY!mNg-gB#oj+U@kZf)D~He z4DAl46`D~uQh0n(*MIU@eck+vH7#*;Xw4ElW^_^XUC%SPo-uIjB9Y09hcf)~{Mk9- z42(3KwzbBO^fYX3XgqcC!nw7zXI9QFES+CABQht8duwP)LKg}jak{n!C74yf<;2m} zG8zGp1>Hqy&#)fb!cVkiS8~=IBFP`*qNe+B(#y1}KX*)9&f*XMD~_g?04qA3>^kv& zM99>uAS5#;Ruizm8OOUs34oqCEzX=GEYRo4GIQhreuD|OLW?BBEU`-huybX=%%lp2 z&A(1yo;L{AOSI#Tba1SYc`);=m7?&5!W_!DGLWyMA_Jbe1wD8wzPJ*)x#h$M;x#OT z-x>q{JC?=qs@`1Z7ym-xw|aY!unIS^57tDUfL+@>fbJ0kjBOiwly-8%^FIs-XBF&B zV36G~T&c$bgYh|9nWB! zI(T__zq`b2Z}qY+JZrAu4jJg;=xuA-uPBcGiG8*WB?N&?JSgYbkVV$T){ z%SDx`c}+(@$RGj~-rc-@9oN%EodRHkuRpm?tQ^Q2ar8mZEgQ~h2iQQCJnZdITp~RE zPWdI5#H<+=Xh8f7N*Xw=G#BxvLF%5?un}MZ*P6W)2@&fz)u`$|218l8*+8An6Qc$h z3n-}tFRvAdse`qcwt88fZS)Oe&~0be^QE;q+K=5o!TMvp8$mO-Yu=^pIGXopaY$dR zr5sf=AYB3T>hZm3;`tlV6==EMB$tIr?M<{VX9l)yxBwCZ+!Cz#Pfcu#_&kt>RTk4& zS74SDHanYMvky|u9Wu{(lw%aKz(7gTF+1l3J3uKN@K$#W2 zQdnrvQI3+%kX~g+PjjojALek8_sy-@)(#iXtp(ZwLzC0ZE>Sd(9t$N#b!2A#-X%pe z)0LuvAdY@KDuEtQe5bGr7<=%J1pcUvssRs++G)N+etGq90GXvU5y3l<96*x;ZlF0W zlzeRxw8^4N4eE7Db_e`&Ql!Ah+K#sxb7WRhv8#%sOG-NDUL6t>^@ya`!L_m`MnytvX23E$L^uVCdF1=i z-NzilAg2rSKIa+Q$(rN^>ok7P${X4S>baeE1szDEybiCAY2j()^0$Y+ClU!!;&MzF>hA~=1~z>2aLOs3 zu^=HD-7}1X!J;a_z9Z>4fV;_c209D=7oodMdw|-ts_}d^X!LYdJO8-Gnb&sKCL0Y+ z?hHd7*z31pxF}B<`W)Vm7f>OmJmgU)$|qOh|54&If+|U8=Y?HqB)x0kMM=zZL2!Y4 zsx1artZb&EUBq+9zGE2kqGD+#z;ULYZjg^07;gcDMNcC)J;as>(Jt0gv;>;X>LJ_W zfSGmZ_<3}9GA^8qaadZbN zNvz$6l^AjKo;f3hfqJIRBik?Ege;IV+YfVy1lM7E-7Nbh38|oyR2Do#yf69q z-yeI?hGAIfqkPCa4LUHi|HRRp6Rr`eIYIlp_mWNEi+ZELNBdXB&S*H|Ub+r^Ug+wJ z*Da3jt85DGHnIWGlH*Rc$`vxvmx)l)CF?C*+qj;FhU&N z?tQk3(gzm|r`2lqnX2Q~<4cmteK10}X}8aBN4L4G;SnQzkq&{FSnxtK7sLDyn&X)6 z#j_}R%%N@$^c+DiCVM0MeN7Z}Bt?mll1Mj$YXZjtp|_SBv6vpDVO z4YTcQK*8G48^jh7-L52|)g(_lDX>=2>)GifdJVveUIR0Z-n?LB=0)=w7-l$n+kzL} z5WSvvExH3@!P*6DT=bTutZ!o+qSvn&79W0o^J)TG6#DgbFvGrQNRk*y59(Cr^OHVJ}5i@7Yc^nu8AZ>rH`oWN!ml zl2+4cbiK`dx`d31^xw&{tM$Q-w+DQI=GY@xae?^e+8ZB7he_`gQUU{)G}s#IdIEy0 zxj2UcYR#vBG8J26Lv(n^buptPptD^BnNAK*`z1e7zF9mAIwxE`k&iaY@)lVI}F z7Ij7^biFc;WhLtmXlBt1pY@1l(-3>bznaZlIQ8aLbpFnfgEb)HC~*UBA<1>4>;UJ> zA-d*v&D2T2wr}aAyql9?+y$2bcxwQSfHj-sH;Ce-ZdV&de*n#h?q{VVkBEpeW$??|=m9nfuA`$dn#xMzhAAE_w{Bf-MDd(plT3)+;%?~sAj{Uf{Xo)T(CLET z-E2+WP%b(P>!j3k`;=E9*_rTuf*m>_50zIVj^_RD?9PCgW^bg59yX9}Y{MhOjyN2! zuvSL*!bP*$FlYY*235baC0lc9bfvz*ZDhw+a$$Yg z1JLLvJ1VTeH~Jch!XMiqNN9#w67f-jKE;Euffsg;?kh{W9-(8ME$j<2+gVqw$C-De zPaN&4oh+ZsV)MpDx?<)iNr7H>rpvy$f6cs)(lHB-;$BC_9#TSDCtV<*=yeLh>DWV$ z*oQ}|AQAGRTv}g&i6Tj_&!1fa{=#|^JUhlrkQSlX3yKzRd_6gQ+@O^tSy&ng+japf zgy}MTtw($$vYiok#Sf)`rxyyn9L^v=Zug6QR{(-LMF;4pT29lynW$o~;7pbfQ+4YN z$B47OQ;-u~SHPa37&-kJ@_+0R9!f*XEsU(tME-`rtC+yS;qc(p_j^Yzu_S$R*XQfR z*Px+x^xO@g^0{vj=&E&1YX5sokg)?MZ$5k{z@AY+69-f}3qxX8ux+HUI>=(n==Uey z>ZHPF6RH4#a~255;{bL9gtS+`#1#L@5zAx$gI3yW4LZ#pdEz99z+KS=bEi0(3Ff8N z?D!}(irct28n~S|m$?Iuf)LQnvED9>1~#DnOg50+8Iv*soqPU+r{ zLL4U8(TpI8)W{upk2F_t)Ee>@+3YBtZcbmcp`>p07JH+=Sl_yOlKI=^~wjI&44j8BX^0 zTH5VL?ucK3_%f~TZt<9==NsNFvMe!c^iVk{*ODkD-u~mG+71lQ*z4?~+onqf6G!)O z$D+}J$$T8$=fOt%ppunS*tj^lci6hof1mxiLHSV7hO@F1b_XVR`Vq5{%i3SkBWS{h z3&OwGPkZC}6VLe1kPsZ7Yx6I?#g;WQ*IDFQ(d#7XFN&4Hsuo>Bg3KC!a*p`viZ3w# zj+zOW5wNu2!He8}{j{0&Be0F|YOv&^yz%?;w8NvZRd%(lcDlZ>nn;==QirVdnk|sz zPLV4TJG;}RMZaP(8?GiG@vweyV!z{edEbb(j>w<6e|->)+_-8Gw;VKv`eXN8Lra@n{$BXg&i4ICi<{C1i3mn0|a#ORDYh z_agD8RfI7EOg@JiR#}F|7-s9{<~O5Xs9+*EG|P5&E^+j3UJzOe^y7GvKS&NS?|l~^ zcSY-9B1{-B`CS!-51ADq=IEQ#M1w6vn*jFO)7naRXhv7Y2HW%iD~71LytQ~W(dA0||laYX)r@#xHH^^C>tK>9jajNQy)+h(3tL#yFf%dITBtn(uV25o|p zkfGkco|W9+YYds}=(NkIIkViXj7G}h1U$xC^a=&5AUMBM@*B= z;EH&;EENB1^@!4VPVM^PxnOpsY-zCDcll3%-fu(8tEo|f#%l}^V^&hmfjtO%=Ad>m za(UxJ5H|cw@pW;FAN|6-SVCp>{bx;w!)v~8>IMWC(z~q`d{V#??QZB0LY6dTLrM`y zI9Rx`PlQadZ4ji}G|c8@_H~yWn0$k5Am#)fl9)rfto9RC1b8yFIf>g=mBLX}>q^PM z`X1%MrVXQDv~Np%OcUNE(4V)n7Q2VMP#j4c2VN=o^`YR&)8>_q(I}1~-TgJ}1!&(r zij$1LXkp<&mV&p=w~aSYi+dBJ9$8ZzT&RWe>IQ$3&~c}!9&lvI=(bTr)2*4&(RH=FE}@cvkY_H@}Ak?pKvBDW`(n`%4+oT z2?t5R&KBkwX5FpUfHzSQUx0ma4*89ZL6_~gC`Kn3htzE=My?Q9Xj&Ga9rU$z;OK@i z7OddQMM`%)rY|J@b0pH8-Cbx;>@OY2@AJV@v=v%z@s_L&niZL=m*cveC$(gVytiDn1E+5ne))7CB7FOg#9|sbO^#0VgLs&3 zbW%bc7pgzw>{pf*aY1*7*AT1{f5aWLoorw*1beZFCIdwB4{#^BAJPT7V}pk(8U!$L z1COrI-ahFP6?%b>R`OuSF6Ob%OR5j8@FHWs1vgXob`AWM2f5lfnCe;EM0ND`SN)FL z><*9(r_tF}&G#ycPhudqotna653};y!Q>79E)fYF*W($FHLbma10VgP$1WYMFTWk7CNc{udEIAYO(?XAJ(cJw9K;!SeIye*7XV! z{@^`#>IDd+#Ap`KnNH=fcp@IxtpAPmpHVwVg9hr5rK7iGpm zJ=<26GmWfM?3%OlI|ne+(jbOw1r!9pGO8Fjw+w7+N$bp20#;JTI0mexA3@2qqcu$d zV%VMrHLjKoLK@Jn!SR&5QE$;;56~{jJAp@m|L94mNei-VoTO%jJ0m|ZE^#C)o_UAg zlj9@0BJaj;3_3qaNA&QfO`w!f?kx%~HQ*XM=$eHV^})yFzKm}ykHMhIh~1Vq%MMG^pL4PZFZn8cDU*4}8PuMRz}O!)A1AK|9*X@D>i z6uqr4qPyJBH7ahQ)x5oeyLe$uFil^SY8Gbo_os z4UG?-4gg|PU67}jvOwAM&~yeb zfq^>M+!BY`f_cA**AXN0Ige7eYUAEvj}oHpDMIUrUg)`Qd#s&|?(;&c5ZzFShAd4x zkSC!B-UOF9tWqR&O2FCdOxEW}?L|pcdHQj5&#WR2aCL$Q&0za|)|s@M2^99n%6QMH zXo+nkgAQ*clPI)$WgL#2l_8f@6a+rI3^JJ{*JmoP45@WJJH#t6Mdhh`Rst^4GYT>r z>*lKG8Ao4Y5uuzwiSGnjK!b?MUDgkJ7Zxp(MEjD;Ui8{&ovQ;7(C`mzhv5qa8q zgfF8eDaT}LQZY^k`0kSfNihQ2+mvE9XbTYU#u>?gfJ?^kL-Q`A-Y~*dql*>h4cWwO zY!Xh#Iz|aiU=-x9+Tix+0z_YMb}vv9h0e`3*uj(g9YI|vinidG*F>`)S^sjKcT6ey z!sv=StuU*DTM!q%Nd-lj=g(YKg8=tlOOxyOiVp%FVNe#%VH4#ef({Z$u#t8Q1;9i! zd4e?o;IF7IY+g$@n`}^bbd5*FaR5*pJ-8|%44m*`YTFS7R~jaSf;?m<_4%5{opuEDu5Y8u#%PD#twZ6QD>_XWxnuHhnyE(C5dP6c~o)dIylkzOI|u#ce6Lit^f4eu)Ur$WDaTgIJ#?oKmngj zXS|sGLoSn?Z=b2=Ro*EEIqj(aE=hRnc}2Y)J)*q9xg43NE&|2fIS#;Kt3@wHG9(__$&-qlG^f9r&Rcy(67hom5gx~n2(Z%<(M%XDS zs~zzg-9#c+*vx-IHrD2SZ*Fe(u*{V+<(Zb|RR@X<>h>8Dx|TvE zn&uvN+s3Tk@3l$N`&kbr)2G2;njLMGetNqjk&2iirr?C!-}17x11Dw>sweqPcigU= z-R&oKJR8$9B~dX11k(&T)i%;p@o_W_b#&lZFSE$mg?IU39qP*5Tao%PdLGqJLsLza z@?f#Yav@On8=|58^1=Fcij^C}o)piFfuulLFi*=a(|b?i06bwOP=B}#l%P%CEM+(u zxAxdz2Sz*`+N~z+I_XxaXVmc=qQ~WT#0jVGID~7|+^AS_)E1zny8gNjdWu&Io zk?PoJ3&$5fAjqI&(_KiFuq1P@h|%ELJ_i=n>rYns%F-;kHb067wRTqWtrO@;zvGd~pA8cML3`2j<2j(<9Yp}xO-Lb6;w&8GQr+qb* z-EB_EQJ>}HKXxlrq)8mj2kpf>MkRjp1YYGk(sg{w+?-#Maf%@1Zdl z0zl4@j^ubad-vj!MY()h5ZdF5hbr44Op3WF%q!o=+^eKUiK7>Y*F)j3YR%nn?(Ely z&%k8iqZWKd0mJcZct(syUX!}G|^t=wu(U-aM7LU-miDgQC(2RVV`h*#0Jjb{A`LPi<( zy&g43^!_Gpn?TsS!uSQ#{0KPT(W#JTV2EtSA^Rw*hcx0)u(_cA5zM!9#%xrOCLi~6 zZDGtTB2JIL#U_Ixmi8%kS;n!LKQy$tFGzlP&2y3V!pT5~#wD=Cpk$RK%c|O!ia8Zi z&lcuimS9%M1>N_;rqBiI;4dU3q~v6`yTV zl7j*Pa*=tJ^Ki3}N1hEyE-*9@jdAa|_zVO>#x~<$uIlOQeQZt$_6#2h_dvmS$rjTpce76eH+%8A z^1`AlMk5MVg`pS%xhl^3p6eP%Mm#we7?#8Y$KELDLjwos?0OcWVzmg^{iG%a?YK>C z2@)hnQpBsK%RvKkVE}L3a=?5SrvK*C94YJs^477<6!hW${I zJYcOJ2gnv`mAaI_ZP#aE{17O6iJ$PK)e?0AjWWiX3t8nj$*p7GhIDn$02_N!Muxxr-!$ z0L;XN2EmgH%q(27CBiIpV~L{&MJ`P#xx1rGTxvTAjpm5U;@IqsVTa`$Xlh__DzIaV zHv~ql4Cx3aSJf>prue}?9xqsndfCvt2g+ga9 z=TOTQFVvL;Nyh?xojp*bKb!?Hxgn-tDJ&paR^T44BUgaw&ay#Q?FXBaN8r}&c1WHk zk)#KG7Df6hLos!Kru?ux?9{|kxz1?Heogd`idFa`<*kM9{{1@nlGG}qidt$x4GDla zPlQFX1OTO!oEhRmK@NQKE9*8et(Rpy`_YHgt!x|R0CGeqAj^G{ z9G}%RE~AUmH{BgJ3ZmCO5PVO=Dna)X7V~V>a9=Ti4Q_8YhuP z8Qd#|$vQD49#$#Ot|GwhatS`T&$E*6Ia4+ZKl`ptdC!#uAc%U+c^XLUdyj(Inmx3s zD?@FY7~j)g7a=zUhB#oMId7|d1^rS~Iu&H~VSR@cK5p8-SA z`ny6shZhjI91bsv6-eukrRh6^w$wG=z;t&_;J!_dNlvlT?1RCClr#qTI=*}Rm+X5X zWoBXBaOE(2maAzQO&Q|V+_nBTqndvy%vj|PhAT3WVu@BG!R7nC`{EVv6F*TZDIy{2 zSTsre;1XB-)}WM>WWlWbWb}=rr3&2fN=%X1iLw`vjO$yWTPM9uS;rdERo9+X7E?U| z3JY>#JeN*^vb|%?#iFepxnamHS5|3J8v3|ipS2Z7QHf4-9(23PCsg&ryl3LOt4p<9 zG+f&NFq9|;OKH>i;53#*IZ|>b3d=iERULxmZ82u+O^T!QAx2}R*?I7@>g{Fpuhg5X z)`#+NqjAyP$5wCGWn>2lm!?HY12|v+&H_^Y6Gk!au_lQBMY_rsMAmMQ+m-U zV>px=2i@#s>wYOT=22XclxN+xgP7MxV$*E5L1|(iSt;=17xzKB+XNvEH)6w}VTLHy z?De}qq_8T9lswzZ89o}~g7_Q=s|L0~rdhfgu+@B?y5iL)uy-o8TEIG%hW0*EBKA1i zgwYLg!7Pi-ZDg%WDVFl~(Zs3)g0f^sg7TnDvdEg$hGgE^E^5zkATOOG`7*nbqh1{b zAw9?R1ozPIt6sH$nAY_B` z2FY*|P&Ch3ExYZK=VHPtUiV{ll52^5yB8IOu<;SZhXALTix;R>z!9G!#mB)8s9!cR zZt>OWr0YF+hiw(d9K;hSkr=*d&2GiTG81et%b7ECzkKmreg3Q?9ZoETn~>&CzlM~v zlgzIxX5ne90GNX3YTqd#WyVGTy9$d|-d5X2R&7x!9n6eUIni^0)Yi;%EG5nvmTWbL z;(hn7>;FnL8`W`>bt&3DWgVJyfX^hD?6)XT#Eoccue&qL!!(7K2o!(ey0IK?mJpwT zmUdetn%zo1rk|GpjOd5*db`)WuBr~3>(N9clygO&m>jJ2CE|lX_9-<$d&{h@P%)RQH zI4xU5H2PMzr}YU~JwMTB;FtZk{1peJ27L;eE*%HSU)6gaM-6REfs4qEP(Gjn#LRv3 zzGDpDDxeB7z@Qs60qhOCA8z22EGtt!OhN*}{qkc>^W(;ny3^*GbYn{63L z@`{vcf-beiO5dX)3IZ|7`w}aw=dLNn$Pf_M;Vy6* zzlt|sF1HjIo-Un4&`)Z4@WnrX*TgUJXnmBNL%-7|KU~ql+9P%2!{LmWXGrj=6%QZ} zSjjTTYiMYn_vu+d@u~yxKjbTC=!z5ntjUzk%$u~iGB45+fP}RPs^fkUK@V1}-z!$> zZNi5!H?<{-7<9+^QQPJ{+%^m#MnFN9p|qv-9@k0dfLH)e7MCoath>cgfD_|N&53u?fHQ9docsyI^W+sf4%v5G!8UJX5s|iJxr3 zS68x)9fRGloRg6xMYTNq(J`sJY?XLIk3r*uF1NDO;oC!EZf@|1 z>W4CmTS(}SjZ5f*o!D&bcKgj6T;38`Z5u@;R>hgROMnM%VTN`&?+LLyBGt9go%=9r z$3ANxGU#*UQkNn|3bjt$h{{idJ28_(Aj2P3PK0;l0r4?DA)yu z!fD7|EcvX#enO?|;p3nyb?lLv>VPvd3&V7$kX;EY+)V7Z%HcTr0Ed)ST3pX#2$qex zGHbNaXl_Fh$fSdU)qh<5Z^%yl+$)EJzOoy9`}@fz^US%k^IJk4M0CjZ9}`~=Kz3kV zw9l_S5WLn3bHHZ8hI86MBCjt~*?Nq@n+O`{pf}S-MeE%&pQ6&i&?3yNLx^hd2RPt_ z%C`oyMDmO#UAU(TsYK`yn+Coe?^R2}2Z-X1I>`<5?pGph5misK=Rx>ICC-!ip?r4M z2$2aGh?CxS98F3Lp;INvspd05Kw}(zU8Jw=48|EOEP+EOO8(-sB5~sMGP&~MAoHO$ zT6s;2%?}%+U5GPEH#>P|A(|~f_8qo?a0ary8I0-_Cq%AyGzXFIN+ww{FpfKHG|ctu z75-r72?=LmBO;>!pV0h1bNan}h`$7(4D^{THw* zRUG}JD0~(#X4%!jj#m=Hy^4a;`zTS=zTo1G^<-MoYv0TnPN?~FLLuk+K(0xuVflO-I}bz^ru*J=7AHm}+Z^pZf@fs+P8mUXVt z5&N~8Y?31^e}@!X7(jzEfJG^#H`3`UOSu5dv~#$6b5uHSkEg|Km@1aZak3uwAUOgw zu1u5tyDZ9$bJ4JezSZ0tj{iJR))oZtu}uXP=B#Pcw(#o!?P^MXX{~17YPOXt2b7tw z?{v`bA1tMXq)`XP$$+cVVq7_|!VPcbOb(8fGgnXL5=?~z?pryL(xkwIr)9JFhG@+e zuz~bh>_+4q3P_`kt^zvmcYO^MXQ(4V;8Vz6x0M1!+`y@D2q(uMpfD_qu24P6#>Oco zHUqXLqZ)ZQEA|wl(5gD?c({mOjwW^v)1Gu0Gbw&flCGe%z1iG>GKOUl-{q&Jaw4aN z&s;4_$2`5)*5I3GH-B*kj-zKWxeb0m%l4`fGg4r-$kGs_8$YHiXs=sqDQAEN3wy3K z-W%rDU+resyR1e$S_RvW<)(NzF$x$CZA3TpmTEk8@shdg3(~6%e9VhgJ>?Ls9%FV%j%BOE1d*58b zavX-BAt!|4KGqpT5=>_6=p>A*JG+s%3_i!%livUWi330C^S)>^z`CI<={$2p9PiJvF}1C#M_$Z zMvo~7)N81CabdWGA1?kC1|%(w)Kph0P?{qX675NezJ7Y1o)EJ>>?=y6z}>Xm1G|+- zI)B+6Z&6xWmaIkT=rM*uR5O5gH|?vc=~lp^Aj|n>r@FBrmP1Y?x8%{CZX7LX5BU(9 zM^6)d6kb5OhW9>U;`O<4EQfi$XT9H5MtF&IaVafqHgc7CpkfA`M@2s^Dpn$sb;MEs zQdfk<^#Q)C7M;|3B&xUIVGD%hr2!c2HZbZSHe@AXzo#y$btL5hsie&WprGuNix_^O z=Z>)gR{pX<0I>5Eh{|i3z{%|w#tyRdg-a;h16t52NRF=|ssLRmGR&^mR7>!0*l6u^?x}J?8-Wp^KJBdgBB2QS6UXmCLJ`?Tnl|; z=7m+4k5X{EW|7ec&_;%XsSrGi+aaZ84t)(JV(876aYJfPyNo0rwxtx4V;CCLo1?77 z7uVT=K4zpa@s|`gXlqeWCH?qeTbn(5@!X3`vy11vOS7&s0a0BV8o(0H3rU~NnN)1X zzbelP6;j-wBo9N~aQV3v9G#cj>#fk+`NQy|Z$FLaF$Ld>v%}Ke@yb4_Zn1K#4>KdA zp2CR^A6$pvMT?%hRqH~htYBdui}2^0Sz1ZIn_c2#^62g*szmK=9`*3Kw~-u@F~g6? z5T7mZ#sC8R(ja3?5&R9^m2ET!~K);5>QB_+UV3BM~5#LD0bUWXP3B}Z<6u^4?|w+ zU5ZO3A?E39M3MwCrs3fKuz%Q*~dife!LU^r0>>rV1kFWu>*+afLK&afTW zfoXHT6$Ofs)YiQi&I=tI%;KpyNA`STaej7gzkPP6<72?_LB`b{RMq64VM5n2$u0u^`l>g^`PX@0RSP6Pi!X39FY|_ zs7`9YH-Q;Nv(dPrh17c7$ilr+-KEjAa~~7R`WpSNs8^AMK2lCX)tJMH-^w_2l=EWO z=jiw05YJn3N^ZZF+cTGVb79_qliNHT&hc>xuJsG(y)Q44fVjS7tkrP2y%IHV%;X&jlX0(MG zYiUMq7%X|2J~<{>A-fg`u;47?EKD5vgZa2O4C@p_PApIafn+x6oRi?ZAVJJvM2+OVvYauu?Xs7!UhMnY=0 zA#+o?q5B!Wjysl`a-7VrO?b=X6699lb>f zeaYycRqDQ;p3^spP8g&5L@QR-Zi|Jr>)@oUyphD+@#E2X%53OI1xhUmW+W`b1%qJ4 zm`p!no|VDysSQbE%!~(!dt$h)dN7wzRDE^Aa3 z3Nz&DxswqMj;$d~p;2yuInZ%K?$-yPu>z-aymY{K#TSzPJPR6XE_e%(+kC)p%h{F+ z&E^~uF_mTKV9GBnh->Wvv-3vmi`l|RoS+elD}adhY$y~=6U2ayEZbNub|EaZ?1jI^ z(c;KQ_cMzt7YU-heZhFt^(ram#rk=BSs%DX%8@`nIp2!L_J{)mUID zP{CBcFn<v#Uq#(S zr($-m5X78chsi!kzDzmEBBX1)Fo3slFHkNDFH(RqI~Ek)@y!9qW+8~bTP8$%^0Q4$ zIi~zI?C%4 zi;ekNBSr70cdv>%7XkQ_G4eXN6fI@G#nx$SCMB2{;%nGp@lhgCnk;t51^~>>9hbW9 z>M^x3Aft4)TUhz^W*%g&sS!C(v8&aO4g7qe$$SJTwSFXfQs1|wx|tqq?2~EB5lkmQHUX+a&Ym>Bv+;r7SbUP z(nt4#>=>zOtM8PF+#CZB8BX9UyH>HS7`L8d+?AG--4n?bW?|lDa8{x$H?fs8mUq~W zsGEHBwJsT&Ww{c6|411MD^i~S&i|U_l9@NX(G6!`MT@SM1@Chy8Ghne)9Ub=Y+?n$ z&o+g2^JiC9mseg~Jh!;K`pl)q?1giaET&Q34sRfgubQ-+zCShd@z{}APhIBWIT-AH zLUud_l{KJ+;mUm(>;MAEMG~=PH)w|0mBnZvKf98#)%=8;rX?y8IfuE1Y%aB2@}T(( z^8(sk7F|ob$dk7qRbB5vVVy1uJBV)5*|4krX<*nGGe_-=%BC<)L*1)nS{Aa>?7FK0YL^u}BDUk`%@e}zp%QBi&0`$c z=})6{xsn>m&Q3{;EL3^>UC~}Zibr@HeeP9j#p`_?Gwe6pQ(!Wml%#GVK1d2CS}n{@ zg4i|$MCy_Q26X`K7?eH4VT0D0N)|yRPC|#;F&2!28Ibx(YAsu$)^wBhb^bCu)tu}kQ1pVXxNv^D57d)CM1_o6j*Dnk+3zm;jb za4G#W8gVL{B-m6Qj>@(=;(#=z^p6L^M!WiaqEntCO=VTFK8i#e8*8&`ml`kXh%Bxj z>c7)2*9SQ7p>`$X6tU=8x7`E}pJXg~E#HH@b}bY$tJ#V}KBr^kV#QI|LfnI{W%-72 zI{#CNUTcUhph|Uh)B1owzeS#jc56AU1^i*1Qz+nEgm6l0yT$bb`4vuy%aEie=sb%a zD$vXfJquF;eueTp$ldUNju+QvK`(@Ssmd@y9+o%3l2XUMPFzAP=~xH#$;iWWM-qJP zy505?mO=E zIho0$C9mYKuo5U_`+_2oFq8pSB)%rB@;T8DP$<=uQO&PE^uDnz_EWdW7i2IhQ^NtoR@*LWvdTgRQeDha0$*Kv3w_TxxIw zK~*@X`-&bC5AU6%%U6pD9wv;_sTXZlal>u(xvE!R0)N@%q}Pw`F8U7f(s5E^7P**l z_8ao(IUr8(bx9%Cj;5*QCNqTO;)14xer5fENU#Km1RcOrVgGZ2JoSf0UaK!O} zi#RcRhAi%Phrm;;npAXV{G~LxCK+}o?2WFvkz9U1Bi|y4faGnEoDpJx`dLqdn?Oyf z^IXT99@iHEAM-(v^RAdiM3ivl(RW9)Vmfp-P_!XZIEe^(V~<}tD6H-*gk%wW&H2Aj zoG?5q)T7yw2o-Q!vBC`y1+vsd|1Q$EU>kFwamGT!RHWTjx?>O?QwL2nR+cD#rX)DU zED;ooKRYmxyM1e-Tah?rRxyvW(^Vv2ycj7Ea zt7~>;sj(kRS$O8JK^ejEuGHZm0oXbm@To*?>(S*PhmAt0y$3SsVWloIRXqG@6 z8wWf$-Rmfyh~z<$L{+FgFXrOZeX|{R4ZQS#{K(jpovc!E@vX;>)E8Fd;ZO3yvk=22 z^0SUo08!a60~>`s-h7LLeKZP3yG7#!(E}3i zeq4{fKAKfo`;g%)s{4sPglS#NhlrU~*!9u@>QG~@Cpf{Ohx?zGRxeVL=>H|s4g%zF zTNUKS_8`96I_PfPa5@%k#tYMPbTp27vi%i(g!u`h4Y7*-O-(h9zO%SBDCNmeSS*jY zjj|v{I7LX@{)G)s{Pt*7<|7_P#XKB;h4cG?sKf!KbUvbS_^S^1{A(1OdiNz|ZnKYy zolJDb1zlV6M+-n&Cu(N%bb`>6bM65v9o(@ZAbn>3=qwlPL+v|o5%_?B9IPZE7c0i> z`dc4gTU)Uzis)TS_-3r6kXg|FdIzk2iPIY|h!QA|ZsU~fuH{=B;2ozrdW@iIwm7)q z{`nS=4BWqf$h&`CUYK?Nsztw#Dj{EfUGGsA3Cw`N*|gI@17An)Q{m1j3%;ky<(}bd zudNJ#6gekS>bL?85@cw$1{6%WHq{u^;fE5etGjcU{2c9ms;TqLveOsfar7aWH%ob< zug1`O^GleymvhE73ved&k}CHI3eyvA7UxXMnQ%oE4o*!UJ-Q#O6BPR(l9->1-40D1 zJ7{`6wFLfkFcUj1kwQ7;FNF1Q6el~I$Msd+-d9h=(Up>oGO}nlyKYVgya8@@SIG2S zbp*)AL)^3=*V=r;I(Inn{*@lh_q;N^_xf=~aH%xo-w9ACGBnQpVAyGUHlXBdwi8{H z#J@0c^c`QYneq|5@+o#h=5;#-w(twaEia?`6qE3C-cW1Wkzm)b-l|jthfv$ZNY!m~ z&3COn_V7~Hcc~pv9~EP2qBEFa2i&&KU@#@eQ(zvT!A-7u))hBcpaQ}+=f*gTe_+A7 z=TqWK?MPydF)?^&nys!~&s+_-#Af8p$=K{Tb{v?}{n$njgaC4M+NC{3&&@cRbwye@ zxmj@vY^-MuupCEnV~6T_Ok8rB`r!-cxL9ac20_xbP_ABGnce0PcHTN0eZO8 z%8paWW(n(tJJ0kL42sS&2D^50Cv>!dOwtI(Y8hTM>VR;?{i#CfO|2MSFq%%%Eca&$E(Ff-^Q1_1~Etj{}n( zUH_2T?z4l=)wyhEH@*UPp0$igK#7@GH=a+xZw0636-BQO^4@{PQO!5Y>LC(>3D90S zKSWI~whJ-=tu}T#^buPz(&02=t#~ok&PBu6|M_JkXK;N6`WaB z?lmYBOsy-zXWe>~A=hP|r7$Qg#KT+2*%sJlx8EASY^EsK15!RPUxa2GbL+(tcUdKo zg~G7bWO>k#WcpaKon}uiL$-7PHxFmDO>vNZB9ydCnX){3Ys2(#H^A-M%;r>dOj4V> z)TyLQ2Pr^GJ;C2Oe^woYNQ27@FnTFsmELtuqX_##FE8*v7)KXJKl&=?GRR4f*i;S6 zVxLU)Dv3I|a3*nmfm40kd>GC}rKRF3*R5~@6P9_pBB72wu&uG>L=tbt_2;&C+v_jH zvH24RdZFUy{ikT1=om!4T~yxKuyPp~0;f194)wo}`&rLgonj-$UhVZbmS+1|D4<*F zrKt}yG#PQ5*{)sLS>6FM*M(JA!MaJQcG z{gZAMpBeSO&>c4yZL^2v`KFxPlg-+y$q~9W!21n(qT=ZC9711_0!#(Y4NnyK=B8&| zp)?ZsF?ALgslXIR2LrhF5mqet$@riOK)`${HY=@r=fyLw+ET#>Y?o_J&mTRG8f#lR zH;~&tOTVN$H<_7Ey@HVqqOCmEEG?Rdmz6D?35-4W^ z6Ro+A70{H7NRJk0YAHK4$I=nwY0FwpIwvvOJLi2hW_e4@UpdC0($OX5BEJn0@A-*g zXAX)KZi)*Ty5U2N2H-zQJK)!&!FD%OEEm^KxE|u1eE_|>!dj#)h@@YKi)q_<$sKg# zCptpZm1Shl`2bv5x#E?X_Ei13m0mJ+5robcg3w8j!cRHh2oS|j)t{?qI&Hp1-}OJ* zjC`_o=Ht`V@E%8* zUS5<$k70T^*0>{VObWotT?aYoq;?>4-|Wg2*7$K1orM#Ryrv`0zb?<-3P9XrG3n-Ci(ieTt0NkkEQZrfqUo~ z>-xwFuYwjfc-|@Gg~I9L=J(ie0xm1DXz1%yiF>mGCyvHJ5WN z_}UB94K;I4l_Me5_spwRmkWyTcd2n%#cvG5?DIKm`orX9jNS^y8^hP+#cN#UzR@eiDMe6bbu+z#$ zrV0s@dKooA2SZmwq&!VqqsoT-b5d!NIh@W%krppfll4#hXz)&?>^MLe%vtM zu;a{q-)Zg6jgO%`jj7fARbtGj10XmS;)Ln8t6<+jQd3Plta zvu?7hvdx5=9>4ZVeK9P%GJWXCy(&+j{^9X0yb9kE6#MjdS${hj3HQz*6dl49q!&2yp-{^)$!+l=E^RZF9~N z=s9xyH*?@P7kO}~8InOx`eW8*n%TEzu1WxrSYqFmwOm8|;@Z|N$v#>^XyRx_Tjm_r zjWxO0?<;u^Dpdnd+u}P)Y@zR0wL-?p@0}C?<2z z`~VBBz^ek+=6%arP0&hEkIT|q9L=u`d5+L4oZcj>4SK2b;x$s(;wwPrt&?(2h`#!T zJ0uDat~wZ$ABv;8D8M}r8%P63CYm^EYK(J&D(fjwcYR@Pc876~gfgp60n&g@uthMF8UEXW~t=i$6vqHius*2u0g#I>+FW5>EK zciG5dU5+7#0Ud%(qloV=Ulv!4PKC|ehZ#xg(+#sx$t_xWj<9&u&(4|+z6L6*;9N6b zdCqvnbd9bM70fV)Hd%L`FzwX9@8OO5vfz=lg`RHuoji2F{NKrg2MymhbMT<~Z+&(V zpUYzhjvbgjc>HAj(4m>5C(VEBD~m=%x*4*l=+bebO9iFYOU~zEtSro``OPL@KEfHX zoC1?>jx9;e5?@NO*Z6eC(Id-at3FHnKU(sVW5FcOgox=}UVWbIfP~xRw13u3GmLtG2hYv1c%@nB21W!B4rz!^?|6RuyvnvX1pohZ%1h zWz;ZY$+$bNFDKS0$fXKx^w=IYtQ^9rQP}2J_VJPCYbyA^M&C5rE;4}3|MBNNF@R^$ z#4|~p=Ol3Va9<7MM<3$oeiScYAAR@$WR&J_lvZsv&#@TSz{0H;d%ur7v-_09M9Cp`H`d3Eak*J&h z#s}#?BnurTnjW8||3ISCFT{Iz9BdG!iX-u(GWRMqmoVuxcXH$*Qmmw>eUVvvq3YIY z^PuzP$#=3YVc#73uh@tpcz~V#uUeH#FB=;fqkj-Nm7An12A}THix3})zVcZj$$G~S zN^)RC{~CVa70MdP2$D0mP-2i;^5l}X;fIuouWR(_o1SOchA2gO;wD}>WpxhD3#;euTsQQyULgEPFuaU`h z$>qGxzR=Cq7AY5cBiD8Fs7CABZeArv_Ojh(^~^YQWt=nk+pj88{4q(s`08q>o%+of z;uN3zKZq5x9^JMkMPwzF?=&b7Y|eD+R60~rI_mY&zNkaHyRkO$C{Ib=~RJ)^6LPh zvzh?kYepINxc1L=8(6Qom+f16p0F2YBNk^@8@e)tQ%2Icl2o^SXF3Sp+Gx#r z*1FsiO&VUJFOd_ZiVb`$Sdw=L)NEFtqrVI0irA47m6BEbB8TjeVt_pc6`u7k%!s&+ zeqs#qW;~#Evjz9#68A?II-ALN)ChO31` zY_Yn-rNyMba4rdy!*ixMS5ad?Z+lXcGq*z;_HhV`r})pX{@u(DB;vy>elkEJ#BhJ3fd39Tq zXPiCa%?g0zqS@L{Tok<^^Dy^@xfILW_#V@M?zk~~sVnw`1@E{Zac0_UMX^UDU4n8M zn)KYiMxey7L#E0^HYhiaPF(iuj;RHNrN@xuIAq$#85}VSB{0&hyqxJeeZ{OM=a*oi zZPw!bFh6`br(I z>B$bgfqu5vfos&&2-FBf+Zn zy)xWx>y-{HQ&z@YDSi*BN!eLX>cAabv3%aY^h%sI-4 zifmT1Yqc{V#17V>4%IrnwiHhnl8|GC>=U*->yyez96Q>HDAe)-g;C`3OPz_Jm8vu5 zH(X~v&?NrgtkY0B|1c~_NxtGtazsBBM|a_rnouc*^&d9-E2l;GJ}Mtudp*gG4wCk^XX-F?2RGvaB-Zg8e_?9_R!@)0$iJVeYa0+$YV<(Qr zn3Dt*VSajN>w;FucFV#rSob7RvhzwcWb1lnDL-X!MP)Mxg=qBCPle>)i%yjF!Z2D) zQZ%IJ?QFGTV3BAED zhI;RLU_fT-TDLX5SrK5}G7q3zhT);sh`}QNbl5lG_0dldkz7G@iq|KMa;GFN1BY z?_h~JN_v@%*uf)k^;vRC-rW-vS;yq-aKW+OTLVj|*Rr~~FFffEN{ zk_=85fJgtp5@U1I(R)^qa{d8C#7Fsr2-Wl%QIy%pGurV0AX)(XMIma!LFvT`9KwOP zzR>5)2u4i1miRRnICzOJuY{+qmL=}e*vn3jfrT$mSttDewRbGLaTLKG67dWu1V|7B z7?Qy9NG7{>5+H!U@j7Ic7)M@XqG(ZA+hco_@$9m*PO=~&PH^MSjVm|c3^xS7fk0fi zz>yPB&+eYtaR@I(h>X?N>`Zq}KdP&%tGcSZt*Djpci0nzXQfs){TefM4$0|=dZF?> zG`X6Hdx_wqz?~dtXco&<;nB78EKEGbV54-(Uj@RxVUmM9p=v~dM6{n+>O__pWS=RV zmJ|X!nd6~KPyjecXpbyp%m$Z%4tkWd*JZP~gJGInjKkW?{YLGok=7q^3btDAtS3lo zOc~y=8uDW7m(nmGgQOX$b*dIsuTsuaSiz~&2Z2?`H?83f55?BsYy7EU_uVUp<6nzf zxZVS+44e?h)^QO&)IDmjr{X2HHF%`r#oT4YYm!phj~1}&iylMG+1DYSsLE0sn%bMvkSg@uhN0!wqI5ucqU zM;j0A;s&;=$}c%D@Ae=Qwt&}zgg1Any(vgRJWnn!$TD4J0$eit^}J}UhDV&=3Ef2y z!>*x6Jx5fR6O_^r|4k-5Boy~N)>I&%W`$Q`X)M#|8VZLtFT5iZ4{BRhv*4*aB5QlJ zkP#VMob@)>);(kLA)igw`9~8wEI-M86C+#&x-^Sph7$!dm9;^RgRINZIMyeK!yZ~6 zWhK*gqE|$I#O@Mka*dt3I2*6FN z){3}?QAF^q@twcVE(&i@z75!)c1LoulKq$X$73k)fY*b;>%|ToBLad3Pq1BMI%2iw zfKWtd7Ug-eD4Pxr2w?QXr^tpIM~s?;HtmG#!GxEKIZEY_v>9Sl=0VlaDhIK#r?0>ri6UDno-d`<-Ct@y~X2)r+M(^8fK zxz0|sIIKp-p0u3)h3xkpx8{AyqI;6RB)7b%>WlES z(Iwmzsf(Wkk1y$(n568wuICgZu+m1s@nUJ|8$A$nmo$=X6TZMn3XdMMFUy62+PaKfTMES#lUHR z9Y_vJBIx^^xV_7q?>tg9*k#9)mFZ$8to~6KH*VYzi6coTnbw0ge0273chiO<#uD-= z8Fr?vT@>+BjYO8KvPwPeK=YnH5e1jDKWxZpOJ;?UV2;uabCbRG;zXUJO`&yCf!YY6 z0pt(S$Bm8D#|<~+6drDdv)TTAQMz}%G~}?RlEpKOIz}huT|9tZL^4Q`1LRDn#Ji=I z&S37*DR@LIs|$U+yiB~$8d|bhvDmq@C_>L;>uQsCw7e=I8bzU3b2;g2y@S+F$DJdU2p-HX7yiz#ANb+lU+(Uk$*%#vxqP`X)v!)R=@yc;q1G{IJ zwMc6T-L}yujOy0I#{*`qTtjPC5rBTybdd` ziAaibB*pJe7Y*`>p6c`>mq?Zb$hN!X4LKi!naA*-HcGkGs-hg9jX86BLJep9NuahE z!QwP(E-!Ck!%rd(g=Bs7vJ2XQS{SjFqx!HAbO^(#qN7RWWcZXh%iaE+54Yo3&H!iR zolm3Wt#XLWZh}Y3qUlN+4l`l(kT@eRc=lcOJl|9&6=aE&@gD^rt7O0mRaigwA!FH#$6eeSRo)obBLTd zNibv9M3bIVB|qdV4R^fxdeRr|GT_*eaP2h36^(Y&(X>Ajl9FrE<4hJdB>gxZ621HFF@UiX@9vd! z8zd}!hon2VNVm)Tos#a6v-7IkRH;(ykNP8sR|0mOp>%V#hgex$H z@0Fk99IsbA$LkcNbAWYUY;$kE*meZ|FPgTw0RLyqJlwU+oOu;~x8VOtxX0_u?LYm> zZ~`fL7yW-per-35kN(x9+>54b1^_29sfht*W>!s)-XEY+3-GoJPjh(RHABePgI|1o zx_$39gwclQ19+2}wF*eT+=O}R_V0*U!agt$P=8EAo(=emA^#A*!q-0UU7x-`g4T8^ zpI$5GVaTK3YeLG+GS#DBsOK!)vG!)$in zScEiy=MHuQO4V(`I$_OQ)E3N}0kqVs`CqR~1h7++5}xdWZ=8YWYXlv8sSo{wEnhS1 zklR!|3(Y5xLNfvNY?xz^=PBxA2Zu*`1%7W3PF%F3Vc;#cYfj)L(k|_n>>q7khsO0R zL0K`I0B=|r`@b`u6F`~Eu*;*`01R~_YRt2Q15=PAr@mPN=p*RK@p466xN-fDu5Wh` zKk@P8^{&W`>v~+j15ir?1QY-Q00;n)ZC^<${rRHfG5`PobN~Q402}~pX<{#KWprb2 za%Ev~a4{}0FHLDcH>rGxw~a78-oESKv)7vSOO$5Bs>TS1jtIrLiivn$s-dI zm>1$OlQ1tYLna9!JAtXHb8at^>~V&fZ~i>lUAL-EojP^u)Ty&{x3qcBEuaB_j<2`h z2KWMqpSAEG{~X7cul9>R_>Akjv%jEpeRp=x{$w^Xnz8m};vDH=TUYE`eT_Z65E@hD9IDI^TRd;JCk5qzCw($Bam z>;@=2u`=`NM}xKRB2oHZc;+Aca}xD#1)=vAZHi7l1yF{M{qF&&ISZfUf6zW>5$QyF zQxP4@B@XBC`KJT2U#WuKMJo2jGTF=^NZZgx?r6GHZY} zzHozhZsIBq@OJ|IW)*;93tWqRpUN+%`I)6gJpk^yS?W<#q1Vk(wPTDRL$w*IWN0=+ zlMLNv=#t^E8H}L*P?H1B2evPusYfw7^s2X%AOscb-54xYWkPGieDO4Nv&!0z1>T?* zy$qj1Wp8-5^&nDZ&PFv{S5>!17}wwxPffQzhNX2oMJF1{#8b0Q5_gBNv%w>t);+|G zWl&-?i|%(HnWKh}kzsXjsg9@@IcR?fX;rr{ii~3w0>6>)N`c=@c$L6!Av`P{5R%Ud z`K*-BD)|hHcCtQf=Ga0~!2VY?J=;Ng<`Jvn*aCWlqwC27>RU!DKC|U07hOrlqaG5d zTP&VzK^^(pfJa0q1=ORYsZps@1!iqzXEM5}fL>5QH&7dg$c6@L{OEk);OIOOsX8{F znRO(I^U>`#8h)!r=U`b)%PRDrD5efs0W7X+j;hnuqe2tGD}vO^%L$Dhp_Z4;X+ z3;>vcZG93b4?#dL^2!VgN6+2hQ)}IN6gz4}R}@SQlQZh)1tD6Em`69yPz8miA-nM( zPWgiHRu#50!4Da^T-)h%h)begwn*J*^iKIV-xF13J{CLJRi8 zLGgUrUNn@evb87*8x21$soyZ6eo0NAU9kzW8 z8olbY=v8*`)tybt+SCo-TdY3h2s(uS)&(4Yr_OM_Tk6DBVA)0-Z8^s?d4EqaPHX;N z(@UCZ{KVA$5KVFWDm0!cP6`pWgaYNqsD=k%v7E7;wjK?31MedO8YgA9QCr?rX4JZ3 z^AU^H)h{z@12NO64aer!H`2UbR+^U7T32)xBh%zF&j^cWyIR|{*rnDkdrQT>;aZqc zYvYR@YVDC`zgpWyMSJX`aNW6Dtv6<9wQi)DiV)>u%C>$psXbQ^nzcnPnNiL!=vkv8 zY9S2QasNJ#{c{!Oh3#3FTEi|0*GW%#%-YD(xn`|vcL%x^FgNn9=~DS393^6*`a!dH zd922)-56VH*6xcn)$dTFG1jC;>*aGD&FkfAbS*s>t76rQHi^;quS%6~t@(1$kU!3I($Y{AHJtEn;c#oTl!w6Ovt4pG%l?`xFB|n@D<-dsn*9t$)XiY z1#;1f>xg}qLi@3)B4pW>3XiM^y#i7Yt}YVZLBh3jqKzaJGFsb9^-eDmUBIFXq770s zTq;@{DU$swZ5L}V&ddHQl*ks3;`5LX#E{dTDYShGIN!n0G+aJa&x@nGVUOLa%bxd} z0?awRSSk4sbQ#;1_zi1WEc@^NZ9UTJdE=8nX zZcdk%E@Gi36Z+7Bp8Pq)+Db;KntdYpJ5MAfjQqiY_dj1%`3xPXa;t_&Cb;mkGb<6{ zJcU)=nqlFF*&S1>>Wpx&+t4i3;9mS4eOZ#GkRVHTxy!auf!yhGu3Nskm_zAvc>{8s z`TY5LLI0wht(HY+&~oyuwKSeV%bv5=vfvC_ zD$ZKVoHJeks z=`U<-+<1_*(@Ew)3Ez|FA1vXQ<@uMD@V$BdRV931o_|9LzdX->ZwcR@=igt#59Ilu zF5w6B{4baALwWwUO86Cd{`X7xm3jWFCH$&9|Mw;Qd>YP}N-@7W&kvOFr{($6O8C@>Ki)=;SmbHlx&w^gFIqEq7HsznsH@Ga3rq62?-lQap{ z{3JY0tHNW*WXGk|ql@HC6FsekG(;6VM0Ly6qdXjJTrc`qhY#a8`gpA)p4O`#rQxw~ znRKr{!5a^%iQ!V<3(?(m+GO7D$Z@QL+2JN!u@sM}Y*raoJ#|gUn^jH=S5o(Ur?F@X zBd2Oeo^$K$bFTC=?hM|l#Ph=pJYjMzQNd~?XJS;jYcb_(m&b7NT`ni$Uah&sr5U?}Iwo~gVFdJm!^L;NxVJW< zg{1Lc#grQ*LL2;S|?HgE5$y(ff0U$+ zF8=p996dh6r}yaY`dw8XRqU5)y)Am!Qy;cTcT1Vi;d7iH?nU9M9$LiAh6t*szAq|> z#Y)6buR*w>Exw=Pf$mwaz-Lh8B_1scN8IhH-)UM)X@s2CZPbm$>Zx9*^+C$OwVL1w zQaF2&Tk!nKsb(owi30C072AzQib1*W6q<|PFU`%_^6nmY z2`)7nr`#UKw2c-Rvts`ykZG}3>3W87ttBsptCG0?r`!?ZyMSIAaf7d+X2ne09bZD* z4yLEKbQ^`3ZQNjRczA*;E)Enf;odM}6p8qt+xqAs-j!3Ar<=~qLR=VS32(=(^Ju1v za!J&wT2)1~AH+SZ301fbRq)*8&aV?WUSliVRi4VSDsSu8fn%RSD5Sd@y#c*;Zi^ZA zwtk#0Y{D%wkr8b%tG%svQq*GU3fz(a)}%e2tGXo?(8Vo_VU|tv){oU_X7z3}+)E3E zhZlUX-Pwd_DG3tQ$p8fqQ7vloS(yQlRUPJCFcH0j<)y<0|Whqrz{YUhjM znKhd8^m^$Y+Z3K%6MOsZw_VjS9b1|qDot5MjvY1zmDsUzExMe>#i{aW)tkszK|v|z zwyp`|++tSaq1DMl;Ze1G<_fBmyNU!jclDZLAoZYunTF-GfDte!$mvqf=`u_n-@5bV zu+iHMBKGQ@R*&u!D<_S5_Fbf(-nuZt7?riIifEc-i>As>J7`thTg?*XRmjz%eKcex z+~qQ^)##Bid4D?KU&Y02K+ZxDv*D(^UhTd*9zXP_-M+V#-hXyEW7AE| z>6#GC)>_(ek*q7+Yqjw-4(OG!fdKBTg!V-X4I;!cF{fpQsi7!ws zfP|?DCpX}ARjy6rBy$S&v6*O=K&P_Jq}>~NUeifNjH3hS&S@Iw%-!sV@a_&=A%NcL z|B8It_`D(>PD%LC6t8aiJa(FL#{|0d2|foL;85u0i7X?+jHd9}%I}f!G^4!fu4*$VQax392k#(huDu)e zO&4=*sAR5{%zU@Ohg$jWD{Wn77@4I?fm7wdrBzy7cZS(6bn~RrOsi(XT$1zuDcZ}R zO}M$7G6RTdWjoat;a19=;h5VwJ=X86iCt7bpcYk#9^?@Ck21vcSfF6A?2*lwE-Tar zY@{G^bT_}vLkS<(+FI((a!oWZulR1(8|9!M=cLX?(V+WPdRrPX;|T8IOt@X)&)5XA z8+bL+bb}XsQNv@<1)sZ7HS74uiVHlwbyrTO1-kEZha9azRDcUsCs78T;LfKpI$zWe z7`(O9aW@{lfCSt@x7d;t(U(o2X?GhmaT%liZGA{9C?O_q>CJ#M&(#Y1>}(gOE8!lg z66NloQJF=HqbuNQjH=O{v{qeQ>(PXVt`?TwVY^7|ELP#7>ay;l^+t5Ym2c9uo8E83 zgBuELAtYad2yI+@z37pxShD<|aYCK)VIHgU=RYXm5^Gm1;4~#_D|9rN4#V1psFOZG zLkF+68u78BR!Usx>WdW+9}tl1>7VgAlkz`##=ZPCB*l$X^_q7PUS+50Bbwmjj3kaM zXc-K<>zB%#Rg{{K`$k)CkykVFX+D-;_xRSUaPt-3z4$3DEZY>Dn#?+!t(i^)RyXw` zZ$vCuY6Lduw$;`zkvbMv+wzSqUM*~+YDJwU7qF_ud1Ews)00;N%0skUr{khKdm*)J zzc2iGJD1hEcX!}Hi9gIl9~8sk=Sv(~Dd@6$n|#g}mjUeb)nY>rc-G{1JTZ9qpjN*p zvl)9>m${hXAVa#ntIJr7k2Ac6;Y|!b#PCxLKhN+x41dV*pBVm;U^%>1MQK_D!4W){ zTqF)MeSDBPb}>DC`msyo@#P}&M?VStd86pVz#p1=8=HteBJdSz0Y6rR zf3^t!eG%TG+4%XYX74fd`=YdEDLU8p3v>4t&h=kLm(8L)LwN*`@>(Mf+}^@zzCxbn z?SnYaD|rt8`6;V#4(CMWDXF_k)TNCIFGP6Cz#K_71n?+BHz=kxnpaxy!|luDMxHD_ z>^p>hGm8;nY)2(D5Zh_brSNLt;(0Px*AGiA-y_K@G9=(Acj_6JF@afU_ z^3xH$UW~`l{r0JIzZ|cm%}7edr8eVI$v9v$4oF7IW-xMd-h$hO1s@O=+)0m$=v}hm z5xdfe)RMLtY00o`h9w!JHiMDrS7ZeLI6pUBagYX_nbuB<*@rS$Vx&Az2lMDI%Bj7y zOV~|Q6OY*L<0M}pDg(54pO4!&adA$cr98AG))Z@LYH3~uyw#$QX}*Gs^f^}mbfN#h ziSzcH?p!9B-j^kb3JiniHRN5`4L@HZK5Kf;#tS=XYQKT>n>g3cX-`=Lb{@cC+*Ny@ z%Z0vzzbGwqAfeWqfcKDqD-e82zG$O|76Wc(`12(g!#vmv<>ryvqPnJhI>7!M=d*6{ zG~fr$e<(M==OWnZ{AzhQ4El-xJLe5$1|%3>&9KY)6_)`IviypG-{Xd#c>7TD_om-t zz=j~fo81KGdI-KyM(}Cf@A1KGct1)iK%AMV;R1M|oLX@*=WXw8Ap=4za~?t;Y+$?t z;Q=W*X81ipX!dR`tAbu%#BabePOAGDx3Y@c{k50iUzl@y1;M+Sb7%SAP<|on+>9+w z2e+dSJ@q`>|0jcFzK3?sf>-@Fl+A*um*B@LZr~5kcC)8M4EW(`-^YCm1%>~286Wqp zLjP7WHB?5FhbcdN3#m5jizs_sqq1t;&z(d)*P|BN>)mi6*ZV!&xf3ZTQoVtX`^MlRIK=gafy(;fC{s_m z1$Bb8JmDuTar&4q)_cQ4W&0&{L?dbh-Ulj5-j89`3AO;AV$mB;f|f&f|&lTM=Hv z@Fmx+dH!9l+Yp`?y3Miuc-XNTwjV#lu$hWimJ@FneosJWu-LkQ<;1icl+f8Dq@ zudUVmAi`Mzf(?nn4d$IS?z^L*SP zTAvN~yB|jU5%?^^Z}`82@I!3RC)Jy=^iyo-yFyPPrx`tt6O7!S4nM`n?4A1qeO?1Xr?59hWX*_2!ak22oLdPZ6QDwg~=Zg&IX3jDiBqMLo!eB>eFKc`z7@g-yEdwv2{9@W2XO@trJ^wz@tq4i{kf24Fe3i2*&w- zxV*`5!c0jm(fybcTO{?G&%jK!iK(wEqvhur1?v0STEm;C9@4uEf1diB-faY-hpB7e z6s{YUaPe&0FBch=@F77tAJK-4YPergP?kjMVM+Z!CF--1x;ONqS`A;8)RjissFthc z*B#WO0!4OC&r@V)O`ako@j zCpb@SfS{zR%IB$#uqY}d`@QcmVz5e5Taa1=7f9+$@Lr<{dh^sBNDWJBTX_a^{N3qOwf$L);di>5ujV16gS@yW+bH-9A zTO=hzUoy^xmzo82mnVYm{`X_o{vHMM-TBILwRTc}e{-=rAvVe_1KwWjk8d4}X$n z9xqYXtrFC88c~~83+h$R0<$01tP%BSZtjI`Yed-xaIZK3C)djO^bqxir2N_mV*sve z6VxZXCyYVpX%|{3l80chU5vw?^2O#bTqnyi{uO2tHmw)+GOkT#3O09$(cFkJI06?j zbvwMSZ#L7gzeCj1%l%+MN|sf-yUkHpw80+D-R42qA}HriaR|m>r=(_-5p{{AMgl|) zZz#m|m|Uw)@LDwnX)e3nshe#`jY-OH#?3J}CaD{>edZy!UQ){xqHdGap$ekzl~g5{ zJuIo$fv6`WmE*E!^L;pg)Ju6PYaWK*2nrk(SDHuQCBE#v2FtEDkAY)Tp$}Jscaw+-`*go4Jc*Tc<{gq>4#=6tk=zuLBK z+qT}?opx&5w(Y*PZEI@Vp4#oy=IOaSS7)sx|77JRD_6woinpQU&i|^b)s458m2aaRhyPq@s$3UIJm#`oGgUql z-1irH39%BT-Fjk-o{-%z0A-b-6a#=+Hu@Fcx`CuPN{HW0l+aKXctvS^bSb5 zOcj;Wj!CJz=t-GeomJDiP=NundFw8TB=j`sxOg5U@DD!%eN#^s(n7n2u>I}7L)lgQ zMka8CO;YREZBnn_@>cGK0lV8#10KH&^ewELMDCWPVy(|qBp*)g1^J?EKF}|^M-*8O zs)+qpZnVDR9@QFiA>V50-dB_h|GCry$2N#J4pAHM0w&AA42Eg&&EG>cv`gH8x zIxT^wIG2*R9L&5s>IG)uFdDCo)FeC1glk{_)hnMs6KCje_-{tN zi-|tbB?r7!-pK67+7jsWd>^n@SLlL187F+flgui1I`5!gvceV6Hd4}bOK3Kmb}Jv? z$mU%9$AZQDAaE^o$VrEKD^K9;U3C&OQop!p+Oe3vQyPMDN*nk*6(Q6-pMV2q8lzp zAR&MwmJrj46Xds4DijTBMUrZbTnVirpDeGM5Bu|$JJ3g+SE&$$37Ye+JGP%4E~I9n z4!KrMU#eZ>m2AKkR(q|8UMx!ryB9!WZLc=Ap^M&l4>pmb<%O5NJj+joeen&SSJ22%NzV`TfJl%mv=yuLU71_CxFL+J(^V zf`nY`YKQeYS)D_iwz*ny4LGw8T)QG~U66ZZ|I|E#>X>crk=44v&Dm^>vCTa&2EB3o zV)ukt)O^56gqa5%7zY2q$FuQ|-_V5BF^3ROvTaS?a1SQK=NY}gia|G!54OP5vB=pD zV|zgpj&?lIc@TWTy2{G0S7=Q@rPR^RQtznvReS($t6Hp@I`tLGc^)IYQs0apS1Vy% zq(au=1kOj~PlJh5#3)`^;KG=%=zbF#xnvj=^%{ZF&lyOxFFeYH^ge!W6m#kCFrUS} zD?EkbM{+(&mi1UQ9rL(F)&S=E$Zud`M~e zkxf>c0+kZ-%e(rj9Tu(!GQu2EMQ@}b`YmI=L4Lk=^~UmMT3NWxs*zB(29gdKb%ko0 zaJ{4l{hRF_>)Y_Vg;-FyZu4LP54k~1So?MlML|qR`|7(#&xaEz8V4JNjf(0SabG2h zCSfQuBDqoXJYd!}Qso1X8IcZTOA9mqm8iA}mxuP-TcQVEr3m;KIRo@Gp!g z#w^1{0D$@exfexKY72}+?Y6lA<@T9WjfKvY)Q?USLlF&Y?k!4bxM|32$o}U+2(Z&( zw<487k@k5by}3i$`9kc5h$Ok;-ktyB@WUfi>&gF6^3;9>7M25C)4l56^4}oTh4f$a z0$&QAy$b6T_wxSgX-9YfO9&U7x<0b;jHT7|ttD&sCjzND$q zgZZhrcrtKXxP&v5PN3<_u>VYr@zBo1DS4njD~9&O!{o!_NKPB8!EQezUyzIMv^M9E zABdvNlT7@c*MvFKr(zS69>?h$!hRc&uI>=dB3$iY&YGYBzj9POqC@{76}cu$40)GP z&n1t=kT2eDp|f68Cnk#XYSJzl6G#{HA;udCC0OCrv$`$E#eKyMMv8FOkR>;S1bKKt zW4Oe}#=(xK5}Xw*L%lT=^n+RShnbLuPUU{$Tr}34!7T#CS7Zrf;n#m<&}Uxj`Itm4 zAdIV#3Yfy+ZL(DfDJe#-CoVMtL1NYYWzcJAIjXAc-N}4NT|e@Y^^wl>-<=nH}9; zk#?h*Ka~$B2= zv|?fI2omN*3Y>Ac%1kUaLg`Nhn)$<7>cL`_&ANKBh*aZDJP~Nl1_U z*}=cj!DMTC$y>3dC7JR2K%&zI^GToh^*_sab2MU6WGObbndJKB@AhhnC&NmSS-?0Z zoX8KH3Tmv%pNhs)K-}cds>nW(reM>U(t*R5h#zC_99kKPZ!RWEO%4$Vy z^R1U2UJk$bQ*rws2q0~Xg=B!S?uEjyodTvLl0VrV)8qXysV!m74Ue~a{42)V6*lnC z&<%yl?3^jGBG=Neb4%hrAqwZ>Cm26MM_5IX2D=AJHxeGu=GCLCID~rL(lL2qxU`4T z!wAER0d0*nga}k%Hbmf8U#RG=6CE}56b0!Y%xlFB2Yl3yAdKM(#=K03VL>#DXKKhs zZ2j|$-^X{d9vu6DC|ckD326yk&&#nE?5^1!$=s&QY-Kb;ItcI&s3Jv47Q}Kr5OZlI zMMZ}bOhp=YT&GuL#%`FICQl81I-ZPK(28XJ8&VoIyqgP=gq80&+u<4Z{7?MmPHmRF zX>4}_k0HM$CJBW|9Xl}#dgMs9@1<1S3cXdkNce=v2AsDkv|&VmlI3uJZ0R?wcc5)l z(hSL^s1rAEOd3)#1V&G%t&2xI#1}RFJ(j_k3@j2Jk5+k}uAw4u;0uy} zm6|67%brNCG-BXyR>pJMbeV6G0DKTO_UPAMsWv7;gt^~kC!sj|1>VFDwm=Z=o}b9@xlTT1G#RR(_lUQxrT>>)PI z<$@<)CJjF0J^psWSP@M;)@ZARLO$Nyeu}W^A=Y&PL~xU-JE%gTnCmS_)<9iE6awrR z(%JLlIJccCb1PI6+A6p=!ZpAIk;2i$B7urPpwWX=7M?I8NXYT`EaR%%b%g01$B+id zpe37KdL!|tSzBu8lsF_^flTu7Qr7VJ3V=oP@^!B|!q$b8=?lA%!eq3cWs7#KZ+hVv z#Fh|4yX3$D(X*K%W4{!{0gtMY03e8tJ;*$5wih(yp+Wi3iXXuPt_#IDtn)h(it>?N zVAzuA(kB$n5?*Ek?M^{T(BBP78nV{Q<#0b%q}AagvBcvcn|f3`w25(p3~o3x zW-{xqPeD0#=q6=E$E3DYW21yeZ+mioN4;PN6EOInvCR1|Rw{r|yTp1F-;WLbSnTvL z6pv3vT$10bn(?AhJd70sQI}V9%?^6CCvWXtv4vhOI`B8MK`!czR+A+g z-eT2)G#9NMn?g?^G-<$y?u0~fYCyZfK^m12Rg)+CDUk9<*-PqjfsOD%UHK~g zanRscA+2grx3NZxOlBx;+(!yFzX54&rmVM)+zHs` zGTwuT9+lWuqqlfb<|CGt1ac*dHoh5Ck7>hc8<_x4oQK)2`d_#7RHxL zk}gS151|*`av_N?M@f+>KwlpHi!wkG0mA)M@Ds=?ZLZD6T@H@lbmorLjyQn5B2h~R z5)M&n`X6o6);38PjUAj^x9HFR4VbB(XHR%Bs|{TSrj@w9v=)C1_qsp?dJ0nGKg%H~ z8A@U=6}3$XL1{z9KK>X18AF0DjP=Svxwfe|Nel4dtPtNzkaGgxB^N}U__{mSl7HO1 z<)gWAg>Jl;+nt>244s{qUn!ewfO)guber00J6p8g9STp4Wpi??ZkuJf1Q2zaZdjh| zJ4x$wULA!wqi)EfzIbgkA3I1FN~m1==Rr1n`aj~<$vSC8SrTY^f-fb z7WJZy_qrD?PY*fiui9=*xni1HxqYq8rq9lQ=x0^D_nD=upZP&7KSfgf-3(0L73ZB~ z{#vc~AVmB`zx+h``tZvRW$dybr2R3XB(F|oH}vnskYoM}$16+t znzmE6U@gqS4Jef8{-svcSH%A;E(6+vofTVm{#?9u8Em~LJB!3qN2x{!>w zyBgHXAXKx{2It5!pO?eiX{bqwt6Noas471~hx~WJtv*-=20ogT{~9!Ef4AJO(8B6K zq5&g09Z~rPI%@AK8K6bNEDp1xT2X@xuJDJoUUxnl9)}wn*AK#M26Vb+slE6Z$WdD1 zV7TUTc$5=b2{`7pmN%YI8F5jCVdowfCvPr4V`S%7)?bc_iK4c0z;N5*T4c{Dt1AMt zl7OZ)*ViL`Z=zjXne)N{Wh!nJYu z{g`0i<`*Rc}uMzcRk*6^i`#*aD4{|FKblce#od@=oXT>YunGXde8o9*-+mlhJ z4YM;uGMk{dpC5nE6fR4j2n~qnxV}YW@%n}01bUQL`Lf^fN9oCZdSO&f?8_{)y%Y8mk_w-6(OhP@Cw=Jj!2wJ$qn&~w64TcV) zBZUfMc0;SfrSiyk9SD`dj<^G&%MvyGON!?Bc|p-<*3R@f zLP>82RPc}f$CN^JgZ!y+6V2a|RD~!zL^coa7K9KQZw`Qc`N!AnhiXK(S0#n~%syFA zgkn%MXqvK*{#W&4RCP8>zr`eEl=0k6IJF|i%=K>QJ=&H?!{A^I>{K;m2i{3#4G)o* z|4NvR+Z`*7%#}X(A z>J9T?q3l2!WE}LHLPby%x4asT2E!Ri=Mp?mHPL_64AU2;RjOtqH8S3=ps1%C`p_Mt z33eh<$e>9l(De1SGiX$Y_Y7eV*cbheV==w< zmgq_agBcuxSvBx{EiH~vEy)6pz&3&Ft_qPu^$Zl^82w7|Mx1;mj>XeGAjqc%+7ve9 zVS8Z&{2L>OoA=av=j&0EI(a9mZpqSqbI8;{%!EApq(aRppTr1{xW+bO?0r)GY)Fd{ zO_4*qH5Q>bDHw}<i_$L529oe|tm4j|xWBda z@!=b)p$O?~ckufeZ`#1?aG4CQck{_7GOmR4A@IELdE9xwM1bw+~GjS>XblyKQZNV)m#%Ob8kAy43 zQ%EwWbw8`%Dw^6D}&zc_ar=>Q=XhrRt97$*}b}l}{DS-uGRi+Ju_p#zZ6-=n?5~R(@Ft2WQtlTOWysG|dfB*)eGwpj=Lqd|7X*Aa zeR9o}zIg718C4QFAHJzsIr9S{XEY=)~BZxky+dVE1Y__pE{4<~nISRxgL z9x$@ElmCm3{sOES#rDv5pc&^;YC)Bz+GQW>I!eyD?11788T<-ny6E+jJ8clUrOLG? zm*Crn@yCqySBN7m`v;jF%x*~&3cqNJ`ZaZ=v%f+XyU4HZ!bRanxV%$#=MEm#IBKF` znPxfhts4XrqL0XnKE|gOT|EQu-3-5+;s63|ACLydvY9$@$F3c@tybGk>?Nf zf3cdcN7XOM^dAt074$#u{|Br2VQExNo!ovX8nK_8SyN*dOM5#RJ2U(L52{)E1LL74 zvBKqdzP-J07P7sN6OtgXSGowJO?>H%jG}A;HHg@_nD8Ii5IC}g!KOnF35`Dsj19PAEH+4)ltH``A4^|ODjKcT?$#}7oK?rK%1+lIq_tTPAF z7xbOS3sFySXu$OH>_2(?y_7wwYG}Ps<+(ZBQFn}xC0In_uJ3E2^Et%RkxVs{gQuPF zGjw71IndF;c6_{&E5z;&Fqv4oOF=g;Xk=+8>gx~Jcpa>#n;|7o5N*VP7W^*Vi^$N6l4&>#j>+H+(V)##NgJ>PNl^d|WH1&mC z-M}$^(azdb?Q?ng0%ngDz={!%6u{^%^}uiT(Lh6Bdz)p0yB5C=RK!}%UO=)*bfG)g z_wP9VLL;kIpJ9?o<3k!c+Tfdzgaua*#U|cfuzY$-HbAz9xrE4FlxQtx&4^)He3d$% zp;+LC#Lt15{U(EuMfj7*UYtn?Q(#$iQp97 z;76hjyiUM6O2IMy0_cq)!EuqnJP{$oU7&FI?yS|#!IN)x4^Rt>r8&fzec*uMIY2vi;s;8jvR%0}0eh_RunQzpNPl_+N zW0B{4-FvWjfw%6mEKZ40Mp)63rEGve;?TWOS}qW{xLe1TS((GW8`kPoWvee*%WidOJd8n|Dv9k(Vq4c2%J!D9PdV`mbQ{%+G{uyp zfs`DOzU-IA>7cN9hC+DAuW5&100M;Z8b3(d^Oe(jT|)!vwMS#s>Ki#TS>h|%71$&l zAdIV8Th=(hWMhy@h`6EJN^1!@`qX8*W6 zt6(7?p)r?uzKWq8aXDXbJYa97pIyEvGxgF3hj5uxa-cZC%1m|Z{?1QC#Eh7wA6(ut zE6G`eb9Q||X!ly-jl00Hm!Axzg81g4I0a^R!&hKH&k+#ntD`MrrMTjVDr;tj!`gFxHZkPXneua2<0H) z2_^fz0g#HNDrs(=WbvUK%5rb^f*T7Pq@MX7Ni(6Z7y9^s>F!vP=nQRo&v7 zysb8%R#OaeaYQAGL{6rDle8ShOahBXbF{{iyh&}28qOml*KA1L_~mcEFdqn*?vDn) zqRF^wmif1oa(XSxYq=vAv-uq8gUFvKyaC5NJiCqF96<9dM^4ifvuKy&Z0WRHZ_iMFFf^!^ci7k!9WvP&LnNftO^)pujC9K?$i>z9 zGN6!fD;Fnb<6Akis%_L;zunYUgGMGn@gHj*x(M5Q?P43 zS#l^&Bjcn&%1arnI56RSa2+(R#O-_)GS!>l!Ap$s5kxRB#h#cdD?NfS!=0si_V~#t zaJ}yxBt9EF=!i3iZDTHcrNyh5Nr1E^MrQ)hL%{+_m{hn(j z>!P{qM=ssN%f&8Wlwn+G$8K$cExc+ea;6rKX?7Ol?qg}pO$zMDt2-jZf!&d#7bLqe zgMezw7LL9>uu7zNRxb<7U&;Gv6f3F{OE~1Cn3fN?s5TS7D=mJiNH4oPE z>b8p zUg9rf;)po!y)zJQie^`Y!trH_&AeIxTt&(u`ImYfc34#Y2}uI+P|Z4b;hEFQPWP+^ zMXAv@w-oofITcF6Th2&LO`^O2>WZpAd>g;@7vYUODdyN!uNuu{a@HFHcvyeeZskfG8t3}3kBx$Q9m-qkjLm8&M4tlx zK7?l^4zsw)#Qc)AVI=ru=a7|CxMML8Oq(p$lvbO~37BA)CRjVwAxjO24&=uOoDAeo zEs}purRR9gY)Rq8*M?U1A@O(_G>lj?-P@9*#3y;vJ4NUE&{(^IVb~W<}bkeX#DQ%jEKp zUWw&yjS7nA`i#Yi=i-lVFC9GzH9{Mmkhjt7Sb3R%7aVRV7uZ4mbqyG~lwWcYVXHSnSC3 z=tr4ca-@)k&}lttR^b&!Kqh zJlku7MtIeBNjj_9&VNZG>QWvop?qtO$5VWnjmHOc_Qu)VQf;YO0ny9CQp?Dl+HAS`V~?MX#Vl_11jk?_s_^Zt9wH(b z{jOq(Fd?}dWQwtpX_o-Y@K>r5Ake9KIYzF(x+Y=k!i3_=)q}h*>aeUKz73KjGZ`|& zPc3pLo`P41asG9F>SB*wfHfD_1eW*2b>k~(IssQ$%&IOF3@@kG`-Ao$tJENPuD_mR zQPRZV+&3|j7dKRLQOxKOgf%U1yCLMhn3^5qtNZ$N+9$b7BJgEGE7ehm6akm~j9k-d z3stkCZAcx`I%oXZIraKv)goRl3_K@mpAm+&t>sx)Dqep31N0k?5b`3Cj^@HOnOzrnsts zwuTYH=Fv9^VUA|CrWNUqrMP9u7#-h`W7;Z4%Tx|A70kEjsTjf$g(Y#;)R0%+qEs86 zoDnMze?5fnetbR5Q6$D_G~C-Z7T@tI$?mn7E^@)Eq>%GlZX?IY_&6)MsWG_&GA4xx zJxr_)dcivt_1cjklqHl^bnNodx$>nf)GcPt(wRw!1q;AjJ0+k<+w!K_DZVhAmV-i{13iEERIV?4UT6^xpKll@b}oivLPg|(TM&K0MJ^$l zP^aWfgRpZF^wEEKOFPEEa(hzX*DH=nZn1U>>&7HiD!fWV2;nNjKUp0ZPn*arq_UP& zOfbpZG>aqy)LS3NTtYYPf$_#$NZMv$>hfdc%k1X4_}uir5H6rwvjuS`7V-avzu9j6 zy<8>4gaB!Cp>ft;OG1$nj%h1P*9YdFpQ9i2wcmI`O&2vX5AaJ+uRtAx0YzP3O|ME0 zAjT6MU}%vUct`AR#E3`4LhkORrX+ADqhS`eOp&u-eL=2NEWJ`>MZT-@oGIU;h(5GO}J z3FDv?@*N;pPJ|kDkJWiLV#;`XP5kZ^Kkyd@^YPqyO{xn??Y_;({h{r2JHrN# zbVL?Cp5%_~{KacP*oCAUEl;fHzsKNumDKX6c;ab+TlI&bH(!C|nQq+jim#B;sB@-1 z>_iB)vqygpZCzhFs;BKxlY$=~!*Ep|JbdYMi_duoTF4^C%0E-PIMe15%=m)>=ZYfw zWbgEpyp_SrPO_kueKjWA9S1pOL2gN}3JxzwC3e_O!Jq%(McmmjIDC5l|~KwIJ?)VoTt z{7Udz^dkwAaA3NoXBPw4h}W!#kM;i3AG`*UeHwc;`!kpXlM8#BICJW2DR z==4O$#MQf_&WUoIJe%z}wuQh?rygYSU?*%4s68b!oiL`C)AFlIIB4}1F!ilv9tXw)f<<3%enMZ%?~_H#al}T27iQb4TIyyv zr+rS#N|e%U{!2Z?)lSkXcVwXW`{v?X#9qn}of3S2nA&T|z>p!MmPr;2n&`T8Vd`0D zoQA&XOE2MNBG3`*6NZ2k)O*54mBtn8WElPYi}ejqf33%wb}-fB%&iNn#B$Dua?N+S zZ^J`l(xZqZHcfse=EWpuK6cive~=w9G;v=(kqmS2qvoYM8#_xy7Z3vkUs_rE51mQc z6WfP)z`H>LqUJJonsM$7Pw8uJDKX!by93Du93F*9Z6actN+2h|RIcJD>>)k#N+W@^ zglE}_x)c^`(vM$M6|zMMY%Y-$TNAh)Ik8Y=S<)s0V+0{q4`X>Sl2>YwT&k)s(TxrC z8%!>J!=Qh>Z@ahSo{Z;jxt*|%cJ0o0R2%#`>xzKJaG_txZ!ZFeFc1W zL->#ghZNs}({?=*e=awjA(05B?C=O5cijxp%x5F=iKyFogxDKfbF-;d#c*&u%?%k5 zFG_a)Zn$-nGWjNi)&@W*y;#2I_1gCux92u8uUb7=DB|dC+wCuPMl;GeR?)@kTvY2N zV&HlG8y#y9W1_isP9$5BsxTEzpD(CYcTDoU=cSXh?Rzbriz{r26$!xHiVwTHj zzb&gwGj+W{_Q_I$-a8vqvuk7G>Rk*asK@YSB#;!FJ-gqK!RjF1s+_|wJLo}thdq{l z-9Z=~V8tgmH?J{m%mG-?56j+zmSxBq)i_?U2;ZrS%)Z|vvMjKGiyN(pchPhJh4QdD zW6|!UnJhs|$>8S$)E0E7CY`jK3d=zdiP(>(2&C2jH7>Zf-XdG~xVK+SZZC)8$o1vU z^N|YL5wHV4`L$cO?;g+9XRRuZBEyvAIw>IDHnwC^cZMoZ&=Yw1o2sG+aguh4rR5_F1gDx*q+x$CG-Y`2ZR5x9uUhKA%J$o{! z-=S+;%I&>YodhqJ--upIb^VAt%`&lMiL$`NF;Y zCEam0%Gr1-dmPl6%NvXBkZ8n5^L##;fs8(LT_)aQybOMFwg{FFL$3aKUfSsUZ=)Ct zCZpR2s<)>m>{He-v`U9G`mhf}IA4}Ju-v4xbNOiN5@)-B0btT$#ARuq4HD{M9@&@Y z9X*n}jFZjKDbw6;`!7ahy?M_~v+c+6KxcE{1!&IB_u)-v0NX9;;~t?4j<9vH)e2d= zw!51?A(aO({J3yTf5y~7?GS^OZxDX#Y8WMsY^I)-=oZchC6^$K2^jP;lA zusx|{`fZvW<&VsjO3=H4NEDggX#_rTnP#io%?AIdZTIkE%&Jwlf*a^~Nq@0}3Tim7 zTr$|>CUfU4p!!Hj+exfl+?wm~f%NTC-@7`7lM!uN!HqHHgsbFk%*fNE!zXP)PuJ#o z&zbo;5ox=4!DQTBMGEMR^fR4*nd8pFo=qp>8%YHBL5T5(%*p9pl#Z;7@QGt*miDg# zhFUC zut#Goaj}Yx2d+5LJu|G7>OKXny3)EQT)~g}ol@PnI22djlxXyff$D2zNh&22zXCO) z;*_;-M1f+R5sMu#ZFhKwoWukrurQc)@&hs*thy99=)9K=aTXj@=*34>*{ zadws|a*=(z%s8E)K=%94*@+Oz3_sxBr4=7T>;(KlR#yylOt(O#*e-Akj>>0?L*`e# z3YP#mY&{NHmaR2p&0$Ofcs6bgB$y-xh$p+|aEp{VWIII=C?Q<#uC7mKZcFhS{h5c+Xs0p-pbUiIcT`v|fAx&Qb}{WX}hvD%LVYLWV?ZS?c>!DrFo z)TLY<+S8TXsTr8DE(#-_cmoX)3>Fel;B`hc%YF|E0T@aasZ1=9?P`+ndiEJF=kR(; zK`K!Avxy9sGboS5%(r%ftbiKr6XAe;serdX!V6_&3g{Q@sO#A7)UN-u)u6^YT zc+4i57PU5lz8sDFGn0{)sb<&>YB&A#44r;DyyIAE9hb%Q7}vqI&~k!>2UOe1#NEqodrIxxo*>i`Ip5tzlE`TCCaGM z{6Q-u&~-q!-_i-17zd%LW&K0&9yf?&OM9lJUK;FHK%WNqjCD*~7tLo~mN#maFVq|g zqABo*?r zs{SZDxw!w9>GAryKD@9>#i{AB{%`eiiNJ%0xNRysUCFxTnj!w^m+5Nd$x9VJ?Q4P_ zuS#t0XBVX|zRRY8!;Hya3}FD#>#KR|mfd~Dzr3RR0Eiiop3y6wX}?c#_8rMu+E<_Y ziJ8eg73M1=OjzbGwwzNB|3uybJjJ4f_?b2EBSaP4JSF* z>Lk55=BveW4JR%)u%99FF^=S}4OD46N28XZlfWM%Eznbm_GkH=NqsGNV6iRd7kjIP zPwnyHvK?GPl{HUeDC0JZ-j-0$=}$A<*bm+lrvkb$`y)0XFtKim929AZnJz9pV~k63 z*680IMIh&i`#`kFjY_f%$vcvitcjcHI4S#Civo)IGx30W&D(bcJM6%+9lya9$~2Um znvgWB*sN(XF=xS4)UMrh@XAj_<>^k+NG{jFWZWz3FmbsI3=a8$CX};tu(2^7T!niehFxQb^9=^ zGlp+p$8&ONpWb167mVY|94^V=uC`<145oifTxTF;CD1DY6=rNdZ*y4T}>Diq_d*?*!BMzU?Qg@tELx;4DL_rugwTm6u)t zKVAg>S`vF}$iMPOKE%DVhh*(A4wz+@kiUo+kT%YD4l6yWI=_#Y>K2vK_La3&0 z{&zFl6MJ~$$;f$o?KsCCV|Y+%T49DsreBDOF8^307s`3TIh>N$`QlDr&~hiJL+o$5 zw9G_z96W-jlIy`}={x?Fa5Ju#ts^VXP;wL`9GumO6{-JBp;yyqC^(7Ir7BXU_m%7= zFYsmD*`AVYWL|B|#MxW1xF_J_md}Uk9Kx@_^N&;t{%b}cj!l21zRLda7a}VS5|U~X zs}E)!#aAm-9-AdjLGc4ycyV}AkU1huSQ6;ZG32Kp(>Ec<%CB`Pe44THL7p>zo#?yE z^Xj25sGkszbvAz~@mcEYW5F~UTK64Y?$zg!xc_y~8!1Nw{6oIv*$Ww8&hp;NGW=sJ4eJXm>sx=s+~IF z2k$(){oa}0P;22bLTRF(*w{|f;WmkOX0Jm*w%sp_0D7E1XRQ@U^Hn}s@=Eb@C3L__ zKpV6TtEE7rMlQx(iSJRjbd%-M+Q_<=U1=*R?hQCpH9OepJ`leuH-!(-Ic~;3EsK;X zizH!uoh0i*F}=p{DivwK^!hJF=+4KYbVOZ?@+2Wa{H|~c4>g2sKV0pz{@!zz^0i$4v?sHQQHNgC(=jL4T3 z5o#|#7SjejB>D+`02s%&)1=cxa^AuFI`tp9$b?nGRotCIL(o570l6Trhq?qhO+?A8 zS12D4qaf;VBm4#1%386nLA`&}cV4Fs_TqLFnmDh*#@tS6V$_(Z>f0>Oi3?fqo(f{r z&>l>?qW!`LU`}=Gs{EyP$0D><_i@v6 z7XGY0`yLQowRpmJXH10o`(l^M&KpVPDqCgVUuCy7y^u(4UWomlZ@JkZW&+W{Trxt~ zOO&-JDg$jKrs*Ns;+T}I!x%cgO3+~GZau1x8Eghm*z_TBJid*n^;d|_uA!L_#S@zy zN9bwHTirdXAIe4IH+3bW^>fR&^m?IHHdj#PKdD}@cSZPON-bt8gXr7L-7c28=(Udi zzu#PLu0%XUuBrFX*k zOr7DV_LM~A=V(%C)-8%dOw}uam*Lfbx`v|2kv2D;rYa)*qD~-=f+`Z<;WLq`J_eNx z$2YO*6Bmw^vY7mmO-1Uz^E*wJLIdHJ>@>1fjuZM zDz%O@5e7d%cx&T*G;R7ci9y-M5nN>v10i2;zN`%FX42H8?y)^~3uAIG-JC?GN?qI8 z3b`(zjQ^+T4&N^okaw@N@(_yaAf%}n8e3P=CjYO9HX~2{uEK9?7Q6Iz%NV}Q+|w5u z&Ne3DBZT`aiQ7*R-=92gmOkcIZ2x81@neSj%K`tIHtP1@!Hc8g$2s>`F85apH(`{q zk2=1;BYv-7TrX9ezhImY=4e@K>@9}l$FSqaUq>G~{5<=iSMoRmh^^bdYxoU{aqH zEX|Esm1qITGHfZ$%e>O?_;SIJq$*ZQ=iktTPT!ChY!@h`WvMDUv*PR{6l0MBn@6!9 z-iYsY1AiQaJi$htE6o4NVG)Jk2_?Qb3(kATc`C7~T+zh=N5Ak(#zh()-*g_Z{)p9c zC{uC(HF?Y0I85ew5|SHduB$C`FJyazQ3-1~lC(zgTMFlU=vaPILyLuFkRJr;i)MR@5Vjg$0H$SB#L|6z zI4Gm+Ihzl*tN5SWE-SZuEV)pdf=pV>zTXTS(_=nNT=C}i#3Qj&6VV7 zPb{vKZNGAc$#S|#3_o^LN4DKn2x}HtV`cjNef2TB6D1s(C;RToJ(EZdY^MxIlmWfq*t|g>?TAx3P1L2ei5NeE3`{_IbPLDWV0HXVJtFzI1%oe6P>blzU z+Dmy%Xbr4J^AKrZ_&+kd|(VRvhOF*=BR?}1s} z@_^hvphdh-#mTdtC{*_(^2Ae8&4=%Pqc1-cV3+j3e~YQAq zK2G*FWrKhCLi0y`8>`>K^=jPd1y9{Bmb!$#5$)FKy*BqV^iOVV=JV#9DwV$WCoc<1 z7aAmoLInw-Z~kUllnZhNa=u_bHWWY*Nle#uRZq6{hxrtSo{678L~4XZB0}pg31W1c z3ZZ-My*3g>f!*Zqo&OI2!$3U0kqNUaI%@&wSmEkngUNsU%K|j6)p&2K%!K;3oi+4TyGMH4u%6fD2jGSLXFAy6!wO2}jhc1& zJz#9G7W1^-UoBo2R^OtnVAWd?M8+( zp`q=_unlfQ`+-WSSZK+0HsvH?U2Y%>DcAgE8oqc-G z%mDOmOLeppeS03<+>!hzSL_XZok$m`RnCNWx55=i)BK$*9 zDm;v}KLS=}x{A+(U996zCEBNks5OmjepyWxZo?Lm2_lbjyR3Xr7Bo1zOmiGJ<^ttyDlsk*Il47`Q%FX8$Cy@4<6MEavcRIUTu zN*DJ1TgP+2hn}R?|2_8s+2h^tZSQ4OWsGoAf*E<&ge$R!>Wt=l3Aq$HTtdjL&|4h{ zWhhj|C|9AY7!@kCh*7yhfn-AM75W>e&{3h!Y66%QJx!W zLf3>lA+j+_E0rjT(IFM)V)U~@tr#s+nqEfvVTsZheWk+E8U0zsYt3kvLfMQqD9t=r zfjJANT@x-tR0u0D*GZLx215m`KwrJw?wardZ0$Ad>(7cPYzoXrZ@Xb=4WVhU5SHU~ zcA|jLmGBy){91|jF&f!XqWx^;d64J;EJsww=xR6!n=tg@lxuJ#UJHjAtyAbTMi(n| zgwcu45`E6-auxOkqhHG;I?8C03OmNgsp5SpHC+;Y#b}Pw{F>47wi11VesRO-PL$8J z@DrDzyuCzN(HK_2KD!RAg2K*YbOSgU{XOfNuorHG6hUobt&`fsP0)%_Pe!*gazk5e zpR?h1LRc%`6_S<5V59&rNx|K5P|KW7aUW!6R^p(|a?IQaA#iabBLPxF(z-K8K^M`4ZNx2hmp?HiW~D!nYjO z%wb32drog+8Cf|7KML~Mp>p!sF(}svCAX8PLZe*oz*ctxQG1PSUdlF)K}U^jUe7j< zL01kt%SV1W4m}ucWX%%_P2jK-(1+vQ%kfSkvS8SPV!BnNiT;|E+HPOEljcCAV`*u$ zC_%OI%q_n>`Qc1AEImZ@oqEj&hTWEZ1)hoAZ>D-d>TrIW)mIdAbNiq z(W1^oFJ)c?h|WjejJ2fuER+rpba%S{xT{S7vQqyFPaU+ugS>A`ll zqCBT!6Vm6!W~4`)jYy|iNe7C^=B3`rNaqxhnd;#hC&R395??7=a-EodwKAk<&8tKsGmv*Cc z?`J=MT1A$BVLG~;=rs2Hh9a)7k}usgFbV6(18%H$545$NK)x^2k88+d{agKr`Sc2+ z=W}ho?2gs4tZ`YJ@ijP++r}1d8?oA40Ua$bSv}zK{fd6>no245?6)5IRc;FHRHAuS zz*A|*wH0uR+t?57>>dF>bNhMHp#JhR=4S;oaLZZUnsgSjq%4Uf57%=0O#RV4Y`GuX zObuMl^m?w5=ebQ@#{8~47h1lM+t{~d9^{8t2aq=VGLfF`S^#GKW_8Z=j9C6<5z)rX zOphu5A}t8+MAqIdQzMEW)N zlym#E^~A=dQq;VwFVT(VL@SuS(X|xyhh&jHwO9e0T@@Y=taEks*kDFSm!}54g|j>X zTvH81x)}yXZLZa~(%9u7nwCVgopmeL`=jlKqlI^Iq#Ch&f=<2fkz%6f`-!Gx5S^Aq zbZ>W}Q(691DbX|{)a-zR5pHW5h`!u4dEdPKt*R%Z@OqVhJ&O>yuAezVd z9L@Y4Ouy^Ixy>e8TflZW=V310AS=vqQSQV#fP0+L_XxbAr9SNGw1WjjxW^#gNN`hue zf@W%hraM8?ouKJS(DWr}`Vut#37UZf%|L=?FhMgTK{F#kGc!RmD?u|WL9r$P5jVY7Eo`=<0b%?q%y3TR6e*&UfMzYlv!{7u|$LI!l z)wmqdVuh|UuJ#ykyFyEh^_~)VO~!+)ez$r;uwNlZ-X=sJGg`@IFNH6o$c^YnMk^5A zs{HSkYyxrvg?NNOVMO6IJj>g>LUGpbDO4v=W|g_qeAD z_7+ILeCyvPs^LwAe)gw9H5^pv>|WWTJsehOR4*&;npYRbJl_FcFN}G<1N>c~VcutO z#Ozfh(Vmj$5Upmk(s6##Hc?tEhU5&7&5&XUEc9@;t#$ky=&9zFsyxv)a=}qH1B4#3dS+IHpJ}=w&fkf zc<+`<&5`ymJl$YIScZLtAFosk$pIa z^<~W?NgWC(>;e_P<}f-UnsG}$6fTx1X|Z*i7>YYj*2Esr#yb=?Rm5842-s2)Yl9=; z;fh!r905BNI+0%oBVd<8P~b-Na)sHe1dN1tqv(FmNH|du>qnztPo=D}^J@(6D9Ejr zXi?eyp3(41dx`EcI*Kt++d-oDTD##wnA$;>VPsMr)WIBuW+u@I%6h5k=xX04#=;#P zWX|Rn)WKM|N1;Z{=UDhaX?|kcCdR>W6*k*Z2jjqBBheCv8_{fqRylTv@o|9aEnS*D7=j zQ=bfb6>6;9CZ@of3SCv122e?P7-zZWQ&U+sL&V>{mVN& z6nZctTTFwq6nZ+t3e#YYLLXw-bXcg+R~R-OZdC|+XNwtdr$WBoR+s^M6)Gv};GGF? zD%7p0E22*nn%riam<7iaTGb{EX2DMi-PWTHW`pP~(KhVGv%#%UX<(a}1L+E#6-a|Q zU??=8bsfxwp$d(|7BUysDD>ynJ46IFEA&+Ba&H9oDbzNvk9Qutqfpnp{)oQqEZamT zwx0QLN`>WMjm-yp7m2E|#^ys=7pb`$TTeZ7RbfwPbx;p|6?#>3Bbuo+e?iR#SggY4 zq}D+LELW&G)s5&bg`An$xZ-do+C6pisNhmWJ06TK_J-A$p)-j-F68Aa2*mqUd@7Oc%R zuvMY&7_ILi(d9*Ry=$PNr$l>u%=KOYxA&A~cp6t8e}p#_`df!>;*apYLYA5|4EvPP zrH<^ZZQ@G!QlU;+X>cX{osnF>Tm`={x(?3ov%q_m`iDPnfVVT3das7CLbqhC@LmIx zdr8geZmYf5!ZL;0v|jC93p*9MFLRc*4vsORk=6?9!PT1){M_ex?Rr?Rkgf~M4bZEP ztiQ(mf9f~FyAr`OIAY!eo%%|YQ%>kSh5Y@tiJM@wM2?|7vk}Fw{BHvJ_k7ADeRgO! z!91n8qPu~bmnd{)_j3`gQ#K#!zD;a^n-#jVJMPip9;G=JQ`i8HC^WC96~j~t*2Mt< zH%HMqRq@DL9*@559FK-1Xr3%fi$hPi-Ed2^3~%9BcWV?K!?7-ktjTQzY>b9I?A|7# z$U3fTJld0h=JmbG8;eKli5Q|;CWdI1iJ@Byuk-#XYUPtIhKM1WZ=)!M=G#BP6YR4a zps4Q#jQ65K>3#3;-Ue?e2eD z?QSS!v=%b;r@dR?PDa;3dsj%m2VPO=)BNYX_a?NE2O+Z`$K!SRgHXW;$E@%^?}N}u zAzP;dh z4h)p&R858NW$1RUM0UNxw--7MlJ$ON-;Tal;MOQw?R^dI9wasQqs@Kr?0FL1Xm`Ww z@QFgNJGY7b@C~C?j?Orv?}r~0IuB>`{op)b*3mCrwuv{OjY1c7B~+tOSL``&Ko5zM zreS}0Lye!S91nZD``&(C>rK_3;csk^qA#c z$d01%zV{#;MHl%#fbAE^5`EHnuCE1Zhsx9!RoB7CaIQjYu*N=y*%HD1otOAN0rxNy zt@M2gSy6O_?=ZZm(8lt0z9Y~QMH_sd!%0Rf5&hYB6w-&w)Ne*~3~m}OH7m;R^?eDo zBTV#H-*Mt zMA0GN-=G^KIrjVm9;`F_(NW(&;JGNe()uHOB9Y_0s%-Hy98>5!M&Btkpq$V@8Oa&_ zX9$nw-r*S3?Hk|E&~L11Q@}4!7ezn%et|_%Zu_H82t%PIxT4lXg+f>1idqwAEA((tw$R03h4vO%K^N1<%X+^r zvq-myCK-mKhRbgi8^_D?b?ah7bSI-5;1jFcXBERHNYu{Z#jws3W2Lo;1ySTi^iUM} zeRgpoithI~#Y2-!l<7|vKTei8qqT5~@J*43*1{>`Y=vm`n<^$NM62Iaag#zzaJAh^ z+^*2IxY}+dwkt$C2Df-dA=)vx#c_pbSKtwUSBQ269^suT5$y`RB2yvS6?jFJLbNmW ziM|Ta&eSIcDnz>wzZj|z?Lz!wHlr1eW0`f3CQeL^)oq$+caiD&0)Lw5bWyBjrHQ*Q ziq%7!cw1^ZK6Ph{G|{5aNw*a>KUauW_W|*ZLbSRMh#wWAJy%f3pAe9HuAoR#i1upf z!lMxF)zU?#LcJ^{{tS_?&_GK&M5PMRt{_uXD@413Owmmt+7+}GwF+(QGIwJO^5!w+A zb0c~-iu}Gd;?*eXD00QujOg^Pn?FzF&XD>1#3=OTi)9M^V7%|m7uU})>!`24K**Es zJwT_E1!5zI9Z8~y`ojLa|Sw&kz-fFBq+WUoC_E#p2YASc%#S z$IMth+lus=Wab5vvp$ZoK0OiK`WwW^@!Gv2mtZhH?JV zgff(h%^Y^AV^q!*47*>UNX|?|k1Dh(XNL%jrxf~gPPsQM-cjh8oNb~^99QUYP8yVn z?-{Lhl%vgZ@vB08(Pp`zf5?!~E!jInJCUc*L)qotcB0EHX=PFFHc=t^D0F>p8dQjZ z3jLBj#a}6gDwKvcD@C0`j@)cfC8j7;oNI+DF-M_V467Ck6&j0S)uLG<_I!J>BZ|g( z+KVGmG~eGrWX(2fWwF1bSTNfRTjB32=!b~RTInYG&WY7ZH?d5i3o)#_xK*L)7}j0< zT_HLd>LJ{7C8Cp|9?DDdWT>ZDt-|PJsHgJMD#w)CZK9VrrNWwP)1a3KMkJzBfZn1? zAvy)EVGs4PLLcQN9Kmq4)>nCHm16;}*7~Y1z@JZ{F{{=@RvMRT z#j;4OE!B$EjN}MbEAC??`)#dwJQ8c=wc^DnawB>tiUvVH@kK=Tj?vu&^cU^vpD)H4 zHpji%-(PfPB+mf*i^20`KA-A+C5GK65$<-~81{rhw4*(nbFFg<*9j9nFJ5)6^Pdw% zFS>5_pBqI_x$gE47B9{-bM~PB0@0$(F*n8cvBVnpbw$>3LUE;)TGcyE<$S* z>e`dg^$LBTN@$Zp8@z<>S7>uOp&bf6#ppSOPW2$PU!hMb34N&0_Hsf;75b6GzE>!% zijb(6=-V_xDGE6`UWP*Na6XF^x|YjVsnAqL-4$wNG(e#Rg3xe<+E@rpRA@Md%~9x2 zjFu?$btgiXDbypI&{~Ch6%g8}kdZ=Yi$VjegtjSkC!<{oy}{mnRiR^D3B4x~obO-l z9Vd<`l#=lrj2GW4w72_e?%kqv|cURD-^CAh+*9pNY7uHbOEBBj8^d3%r)XismZ&nYsK<~90snEF=^L{ zeT?L&f1`*$3%XGp)+uO6UT!(qiaAaKo)ia|LT|6zPj( zo2QX)qsUQ+M!t=rtwgXkYqj@JqH`2Aq}?V)MA4G8O=3Y5El;~sTo;$Ky9M2YKHFtd z4O&Y7|0+4@CHiFn(fo`UC5Z;!f>`LaWidWGN;SBtmiP@_h<;B0elhgOa=T6W;{4Ms zOZv1y)LlgML^0W^>_Y9gr7M61s!L5B4O*whG#~4GW^4a*+D!kl3KVCa&dbn~y-BjK zE9LN?B{8`yufKhazneZ&fgxG{uk!i7OYd~Y=s&BejHmND{9J45Xe^KC&CqAV{2O{1 zB#But?MR)4tz$Gk539HZhB_1Vc8O6LO1uVlu~$!V?c14Nl^^5dt@Wtl{J2k-ucn{d zf+g-)T3h%xRd36rJcrV#)xGDB_lrju^n!QZJb2uZL$Vq3Mg*7Bn{&p%#ZaB z*>`Sd{mJwp6)fvVe9y|$C9|f7WVy#Q|nx-U^YVd3;nTIn=WNVbYMpA2= z82y}Eb^lH#pQtJG5NvN!4c_!7@;V%3&2Q}{HFaXVsY5nR$%kpD+mE-9Xj4Op^iMpE zkJY|5X3dfs<6EcFD0G$~d9qBruEwFDHq{qs=Dn>EFpVpGG>;tG^vB zV{KKyMf8iq;B=cbu|{OvP9-GY7FFNIiKVU%420b+Z!vj^ng9; zG5O22@w^V#oKa$d!w`l$p#q#x38~NlwnArEga6+RNkD5&570aI4CeEYk{<07Iy3Ff zbO6%}n9g9$`OL3Cng$QEq_ZHtw;;J6_W4R63kG-Wgw*5g1tl8kjAqRxQR-$o2-b2e z!8$@K>@o~B={#T!JcR4twQwSRDt)h&J_jahfqn~MgUpFWbc4)~HmYhR>}UCY7*v}E zOEfy!S)tJlm-*VbZdb6*6{!Cg`weKPO_y6>t@ciDH_~G7Ce+*;xC`aBevcsyb=irM z4rz6)`5e-1S+Bqv?VYqYP=0G6owC#E>+hk)bzO^feU!$$g`bg~OQtXGjlF0vsf+(H&?FS#f8+{{-cwjlb z1=$aky+}@H_WR*!rh_xnkkSeNe%RZSczQ>%AL!Ojo_H+W z$$fv;@;E0G#YxQlPuf&0%NjTycIqYiKA)RuhQ0>wFU!#@^}@;`y|Z4H8bXPT^+hVx z+RxpIc1r4~_tyW^p}Rgnm!9nJ=&z5~Uv**6(%&o_jr`tDb^1%PcVk%^bZU)Dkv8V9 z)aUD28CU2_Fc;gz7VSjOYmmPc)+439FdBP$wkYJ5uvUAacO49457e=wj{P=;{kB8f z+X}JPgtbPgyrm=ce1P<@=a9Zb8=jGk?SCA$iYe^XI`+~q_UbU8n?8j=w`vN3Zqp3o zn?TeKu}_I^ol-3;^u~O@WsTmHPB$LO=Oigd3ANZ=+EM6WS*x=?mZGa=llV2OH&XIX z9oNeSo%#+*&PVyFtdVGw@-Pwm$TwKJY;3)|xEJgYJF4efUcx?AhZ0@?1M-yTU4ry? zi9O+qE#Jc7PPbTguw;j5%)bqJ8CTaIv+QSn3)k|)NOxKu)+_qpxT-r-u>EsR_KW%H zFIzqqk}q)Ww;Wac#^iU=!YU8_i`HGk0%N_CMwXBE{Kz8MvJeMcN!Itc7T$wYM=Rui z!7;FqZ!Hx9-DD~Ry4|z{_LdH`e#;}qE^R%`vaZ$W&Gjahcp*%LRttLks5FZ(lFeGv^~e_#Id?@tXh_w z&60CjGMMcQV>_eRP958sz;>py{%qEt$NCFcb1~b$816%QDTl7+&@0*6dX9Ay%Wq}* z?Hub)j&(Q3x(^;k`Vc&dbSpf8bSKAphGXr)Sh&A}eaOGaabMy59AKSyS?3V*hnfF^ zQ#sD5pJ4sJGyR2iK#-0_kd8~RCt2cWNxEQ93ihO6PYU*=U{4ClvrFSx+A|c3`E;gP z+H(|3Bb`F+Wz4go?L!*YDCfgiK7}=>Yn0+_jeW?H#Vom)CAVu&*izv|Z9kP%dmHKN z+6O2(pdCV5tAB;`T)mqey{(T&x>Y9&+jX+AQzr|1Sn?uDGqa{)e_f~29nh(C z@9I>#gF2P&kWQsLtWyrZ(5IlyL77WS2eePv-^S;$%~hn~%$ z=W^&^3{8bP%VK*fOt9RGbc*E_q|+_mAf0VVccj8R%V?wvEbEajwroRsvE?w*<(9Oh zRJhdA1LF&-EO%T=}yZVNT0F%jC7Bs(1m`s^h5fJWjfN=EgO&?u)K`)U5hUz6%JZL zNDo_Yl?OAFE;EhVX`@QY;_Qn0Q;YO%h8)M5P@smq$x zDiz$;{z(1S*+|o^*CWlczKAr}8g!>Zp|uOHr~BE)y1g*Kw#?>*(MZc78C!KZ_+Vn7 z99qLnqy?}BX(_BjS`D`&?F#oH?F%n6ElwwTPX^Jqnf}1kpGowp)@Gwv>q_)+H==`j5WT-A(cIodoBI%buP@QsendB)Mbv#Z(YXVN?mLHQ_*|kZ z2NC_~Jfb}Zv;GB~+o41s97eQs1ko)ciB^s#x^WCqM;*~wV~Oq`N3?tbduAfh?bD8EboyhbVriYjwb&=-L6r#7MawyX+ zt!_d3lA^4`{88q6yGdt_oA_O=NuHZSIb6>4cBZ|~BAp3L|A1?QYjBQ#A3lL&@IC!T z2=2@(#dNVjY!vT_BjULDP84W^wN=_1+9z5&eV9I3|FizEzC%Bv+byjvXIaKsR$A_~ zd}jH@l4i}c=36^hdt1-44z>=r)>)@o8?4t^@33yOzGgjY{mOdMnr!Q5JKxqCaK{d` z&Y|Cvn&zS_p(m2*GUkzN41zQl(RH>T>75iyk}X6}SyGUe^-LETbjkr%Tv>Uc4d4z9 zx{B40=Na^n)ts4;^qNRRbfTBaFdS);LT#g4*+OWNyG1mqB+}g|RNj z7;B&pT!Aqj#Fp_e41#TN0sqp~-@L2S0KO}{Dvf?C=Q^b8{5K&z<===j(rZ&RbiQ|U z8vSC=JxGTZQRrn|9z?o6Z7b4yx{{=G0ns<}wx`jr@;rs~V(Z2;TCfyQthq@|kEz@9cqE{5XM6?a*yw-za zof9CwcNX!_wkFFn^7bLk=F|tW{TDd({TlJW^6OHGZ<9$jFYio}Yf6Z2>O}Glz$LKdiJAK0z zDD(#B_ee)Ne?~f{g9rc&;gS||tZiN^O0KFV%^___Ue&=#k`Aqq9!~KitrjF-!+!oK zHCAg!sz`o{X3Lkb&&#?Z-@m#y($~3k3K>IcNjh?YU?_=81$u5pW7L@#-_TC0gj;p#8 zy;T}%MzTHDj4j)k5pI77jcmC+U(!gnWqZD4HJ&d|k0cx04As@uGljaVT2<9E8iQd5 za2CRn#hYdGcv*ggWl5IDItedJc1c1W-h_NYfW^GPX1$vaNM1G}`DFtk2_d}yIk!H$ zYow8xk$=D48mVvJd+xbk=bU@)J?Gx8T0jVU1iDNShY*rYw~L-ngiwV(YbWn5!VXaq zWLxS8Rgs70gv}!M0Ae6ip~0>K=0gZOLR}K92Z%pvx6lwf7>N_=mApDB@ouRK-WIn^0g!7ZLxcIF0yEB2>jsVHHwfS)WDx zW8!gy|Ce|IkdGr&u?~}TJP(Ob#7`qsu?}ene-=Dfupa4x-hE>r{&NUb*yD?ce-fdJ zRmw#CKOj`ae-!5s{sOq6!Ya2B{w6>9?6(lA;b5vt-Zz$I1uPw+<-e+|wku;QOZ{M+D+D*hInQN>Q> zJqULx??u?D{4<2tD$fCPFG5vxDL*RcxiCM9_;t$r5x*WGW`Xi!Gz$=_;%?;wBdGe(mX-eiOaq}RD$1u2Uqq;iCFK_pHxWX5l}{tyK&Xmk<^Mr^ z1)&Ok@&cV6AymcF%CFD~6GBzIMfoh^&me@HE5A;1ju3LL{3hb-2vzZR<+l-k2SUiX z@_B^MDqkSkR=z~CjS#Y}e3@h$A!J+m3duG?$hPvkB-;of+sfBSwh=s6xyAcf>z}P!&I^`~l)Wg-{hgt^5(50|m z??Sjsy&GY>dJn=5wIAVbbr9hm^$5bN)M12ItH%*uquz(GQ$2z3TJ=GMd({zyUFsOZ zZgm3Tb?UMuPz`wp=t=nR2|{CY9O3Y7ZILRO@t4t=Mc`THBjR;!anrjR_Nm!)Y}o>q#l4K zo>%{yazva_e;?sv>K`I}z4|{8zCrzS|%Msz0iJNd1KR%jySq{M#L$+ws#o z_wDN2)wU+&OLxP+JMX4*LM2Qu?^@xfrMJa!mUq4Xo&dHdgnj3LgvHB#=e4b{s~>2E zo#m%kL=gJB`*>@+pSroV?7pL|efjI*R=gL713V>!{hM8_uy@m&lbWdVq5jr3J~Pk? zd+_GgKL7mg*1lLN{d-pmtTNQvmwQrZ`sFY|kzYqCdSd4kWMdki8GL48YdtDPx#TEj zJK>Frf8_Ky(jS60Q~6oJ;{FHpg@tj`tyi_xv8v{}M~4^s#QhH&UeVJ$qh?s1`#@;{ zFwI#+#skL}7J$;9g2LeGMzyMys>U1p#h9iq83iC9UKq1$bmbcpH_ z_fOg7M%8$LJS>K{aMpItxu_Hc3ge=-;FgjQ!a4044x)>Q&N{YkxGqw~^VP8lF*Y)G zYGR>Sc>RPZo+?bvoMNmoyHPDq+ZX{VvOE)grs&9QfwNC)X4NRq+ccg>C+BUu>W-Vv ztmZA9bnIFjGpK0N*2+_cw`7+KR>h8EJ%T=uY4wIwyq>o?XIZN@ zjD-bp#?*pV#x+mlZgQlE7SKnnObN$81LGxn|jlk`b) z6RANHOLmKhKXJh`tg<1ipT(S6v7K_jr%_{UNwXIH+^FD~W?AvvC;g;|JfKmi$bqbT%=E{9jB_#oCT<3>em zR55bba~is5I{{H3DP>{0G@(MWFl=ne(9abrfO?u~8Re0Nw}h#0>XO4QBYE~Y!y46G ze}plbS8X>MU<-W4Y60o#4M`4wrode`FjEcc{VI`r(cv6swm+Jp;hkLq1^wEQTjHKN z5kNAKMJ*y06SmRk)#MRskbZaCa6ZY6=s^h!VqZgMD(7^@_%#YVkuJ3d0aUJWRU z5m{afj=RuYO;cWT4N=ajCl_F12Q)s0N-QSVNu;Ntu}U1L$@NsP+uNWpTfprt>7I51ddi3>4GcSmW0+8AhmX+ z7Q?=!fZcR(utj>fYL~Ps&$`o=sZ&;Rr*uh#F?(Kf&rKP%AbaF#&b1wFQTA#Is)FKf zEIwnktj|FfsZ-jP1ZiK9#z7D~sh{FNR>LfUO(l~+>cs>}LI8k>Olq!|fYsu4k_MOi znS@gJLB8ZoT+n5jrZOuT-n`QajPcRLGYwaQ>b!*@?HH`qe#V3ag}w}>Dn<=f!yKm$ zPujXxHDXKWoB{G1%SI99YT7)RD55ZDR2;)y;sllA{nm_i+5*(BE*s@D8t7K?D=OA( zxnDkQjVyx$vJN+j!!p3i?5$$4iy_PzmR6I|qE<0t$#LM}Q-9i0m`l zjb(Fmt^qY%Gv-(8#wn1m%ABDT?O1(?KXDy&tzvR_3)V^V0xSjQ@f-*%Dotr=9f@*@ zRy<#!bCej*bmf%RyyjEWoZ|(N+CqGF4V795aGL>Sd?f(oWbVAvh^h(`ZafjO94b8l zJqgpa2?Zm9mTc54zy7A>Uh0S@n41Eley5cs(uak@1YyS#iB&1;U<uEFVi!FA}+7RHwaqRHp-Z&^=D4+d+Y)aS;@veF9BOB$`DjoJo{hk0;pb(;SQR zp+x}8Sh3`A$kK>fpEN7RycvukJ;|$aI)GUzNi|Th8jrlHt(MdG8=MBiy-o+HFevu7@}%)T(D;03$nQXCY%xeyMev;O0SeECa3|>0PQyYPT74#%Va|Y~8 z%_NC+YOJQTY6}*72$A9Xy`8t?L*=;!)1+iL5%^?PTXYj61vR<;Iispw;8-l*U({F? zd1lEZYctAqLwz7Qc7}Y)43#lo@6a5tnq>(~Sqqvoime$iWBn?fRg{zQVh{mjPFrDD zBs7VH`Hcpvp9HegTiA8pVG5f6MPdti2sj0kJxtHBwId}F#+F=pDNhmJG}@Hbp#W3h)O31|yJ3!=R!Q2-nlm&vM4Gpw z?gi|&Bok$-VmfXRFE&bUyl!^Bj$zhR?L~iCPk_v15-c6numD5Wrue(Yq3;X;*S#gV zJu<9CL~HT{N#ik%8+AXo1?ZPgMJ~8aKE>0PN$aszC3mXq^Tkoji)Yssw2L;Nn_|{; z0xBaD%f+gt)4^Z~vs~z5Br;ZPBx%oU%xl$i2`APRwiioUHK~|q9B2RlXVEMzJ?W=S z!TPh|sZ)p$cNd31Hx1b0$ZBpRJ+s*zk!U0}BW}_suv>sh(>sBi0!~vNi832z${Cuf zI1&|H3a81eg1)vJ-UeN0&ZV-vI;0g#&5+YJI6Dh;c%s}zvd73nUX84!S{-Jv#ctXv zorj1iQ+I6Fu6X&-4$3EY^!YN-u#2jS@lm?5AkWQC+72gb%?m}^;=#RahQYjS2Kk$+ zv>Iba!0}2`z`Wb72PuF5G>_5AqkoUj{?7*!GD=Sw*j!S?FES18`TB{rud$pF^1pJy z7%&!{z@E=uY{Wt6T?it7_X=HTph+Ch@NtPt*d}S@;UKVHlR^LvN_JDkq(HJ2+P_gt z-E~;v(FQa|xlpE4sETPg0Fg>3UyEj8B?)3neB4GW3QbR$V256G7AKu~u{7z?D8&cM zSSDg7R^6|p;D*u2qf)S-FURegW?G^wzltNQ+XCx5vb!UTJ9K8s)M%r6Zlqj84Az_< z!?v|i527T`GVWhR@iSI~h(BRus_y%@ShI^(_e*GI1ZET6l#!cnxnWD4PLaonCSc9B z@`YkWkLZ+_ct21Tkq!;2aa$nLsg#7V@hkOPGJ_|15`@iIBE1~KljoelX;B>Hwt}Q& zY;aovYxqVv#pZKWa-B=XLCY}he5+9l={fF(Il-}GXcq>$Q=V1%=V>t}k(A{5Qc@Gj zG;R1CBMI~?gSDFv&Y5I}yh+o1m={-HBg|L|oP~t#7`iTQb znoKVaVc%*3;F~5!#rL#@{p4ok)d+|0VF6c05Vk?E&a;q&u zp=nx!?Lhjy2_9Yqil8ITVuLVe8s1E0j;f0C(oR)lUEziUlfZW{r}eZYtJy0Z<)m4w zQLawbVr$oF=NLgrEi~5`UfW7iDXzPsocJBCXb@3;c-#;|0H`jyuaxwxmVE_|oO@Z46Ui|iAyEhNu@IBlJ?>=ijd z=WW4vs7N`9=$dSBtiy4sm-&DsO3Pz{0C(D0i9_^Q{L)4Rt4X67=C3OWV5&NkEhdxU ziW7Et-nig#BEC@#7|R)SQ$@_{^+H|HQHCr90}P8`tqvvPh4BLHcrtqE9zxug>LJO? zpBTeN+VL-cVWv5uVL*EeM=nea@)mP+luS%NU0bl?$x3ZF-A+|U=%)mr4?lfw?XxDtvqxF(U>jjT=r3vEa*@4N1j>9)V zAeW)8NNiP`$9)!-;fC|)qM3ZqAwX`@>ZEXUJ{}wQnH7!dwH^wri*zlU#sTJ zc&-@LtX0iAgQXK3!PG9#n)QehtR2uZ+UvN{&Q>NNe)N+N|5qeZ_~HP!8IbB(&Cfb! zjgL9qz%MtiEuv$lMJIoJNZhm#VP{98;ifGY*iX7CYXyT_7K9dPVl|LeC6qpcGzw^3 z^Gl{HVr~dylC+mrbrZk)34uSz^=Zy`h1{r~_Dsads|g}|wH84SU2kryLn5E>&GEE? zgx3QzAcO~}{;hSi|>qQ>Jmf;I(`&&7#D(s9-zrmyiIgl zT(WN9DUu7R%SX)soj_v0ffF}*Q&A?t2sSjeYAnOuC__sFK1?_G6P2=7_D4ro8eBJjrd&L!x7^|*- zi($m0^$o_Zzx|i{V7^^9Q+g95C;U}P=o^>dTGG?wLtA`8KAZ-a26t0nFUyNOZ%6B- zUyuC*ROd&-do)2hc8!$BG*aB1Rp2dvq~|{5+;^avW1d#)$?HSW{9a?GkL@tPXe0 zAs}|6C4xowRzg^GKP3b;9kWI7RyS#wm)v$GS|okqMvx6=X^7BrMjGaXQ?NP1zhXgA zH;NYcbly+I=D0YexqfUZj5&Up4ewY$Rt2eht?mL+Zdhdvka>I3ULntdf19#-FCi7k zCHyuKoBskC#BsD$j!oMnq%ian_r9gv`lps! zc~q;?F?;})$C}t`CD5X@FPw2uH5Lyp{bK&aYiyZM={FG|I%X@7?3Px<;E=Pmm6Rr; zV$Jh6x@{Tk%#2BB=X`v`>u$YzhKMG8W(6g$}`B1ILV_wA+-HRdI1%S3Qbi zf-d`KODo|-p_zTM3V<)A)?x^OLZnGHXXy5#1*J<>)ylfl66K95$Gjk>&rX`w zxkCLyv3{ZX&arePG&vkofDl_BI&YKnktLKduuW<9OS8E(-jMU(AcWYxvjh@3>M7qp zi*+e}&c_dS)ADB#K>}N-FwPEv84IzOxqYaw((k!Ar8%qeAsNgb2rPD3`1($?k z#tBmLo7mp!V`n=fh^PEoB#yUnX7HOPevHe3F<}b}{|uoEPneu4;8Q_tRA|CQj<}sd zM=W!g10HHYJSR@z^JdW}o)KcV?$;!4FNz5?g z()S55(hSLoyYbHfjNl&k&Jv5<{t{!#7O{+p3ka3BzyBJs2S^oU^@_46pz2cDH z)qcbXr-UMlTpgvTnW!?2;Red(5N~i}Ilx?mefX?!<5pNAAe}6MohZT@6V79DQ42JH zs*gvt5RB?5`>`rxY}7MqLDpUd;Vsl%1BQ;YE6$@VecL`+G;U!fBu@>DGP!M;FUN5n z^>5qZFCs4M8{ z0+)hS>`wzX?4iT8C3E9_cnJTBVirO^j?o^9@%KKVtUo#q$sfaP7!h-b5jwHc4Ch-Vsg7Jtsdfb zFU_j-9#PFj@hC=_!#JO2Q856EGiP8!=E(jWL{F29o?rox6LQ|yItPXFHX8LLQ+3{_ z)y6b9n5bnU(RWFW5!8^oXxqtB%E|;ph9*KiMg^UPcoC!Zctmn!G=)5$3Jy;v%co{A zE%g))ET^2uQ}o_Q$96sBtF?e|Wy?5sG2?`eOk28yt`JdM7!Rqt6viYk zKL)3{hc`~~$bxc3q@MQS8f2&izCT&(ykC#a>QUU9)@G6AM5;=0%QUwxM|}?UJ1l=T zOIa29BaqoTVv&laIzo!R`mA44axmHvfP$}To*`kWeMD^?rKs(2Ed5jHb(QO=GtEZ) zUXz^6u`-qUMK0%p=MyY54$pKiod>%uE`_mlku2Ak%QQaAhgiJmSxkip#{n$DA&7=C zxe3TJQ!x%%2kSFnT#j5I)OGP$)&n& zE=AfvT=j(Csizn72oh7*DXrJp8}h=*E0|MdO+8 zhI(L?drxCl-udg7&tBS$=PvOtNuQN1&$U-mAF>6XG#o#fcz?nq)$J zUv9BMMW)sgfA?bNd<6dv`KHCC`W7)UZiwcY_%^;JYg-w+nYy=@^_yvt#A7pf@#(RZ z^=2}b$yg*~mr_!jYfZT}*>|z?VenJzdkDR+@s5(}*VsKF+D|cmMLWsDoDlA5UJWns zt|f3i-OCn_-ht>b6t@zGsRpbed&w4KC`sXy>} zJPHoaAV!{x1)kAlchc-Ti4Vzqj_08myu1=8@lV_ul$m9JOp(2k(~zgfgIaIDI0o19 z>HudN5aJH4NPhYK8|87y+eeXp7`-A3oA^0`SP|h^s9(fP;KU@ylE+-Nc;RmNyVeH; zS?7m@)J{|QSKt;msIR#B`sRFXH_A0UvT>aUlG_TZIlvraKQGZ=y#1Oa8VS|{n`6tY zK&t*`w#M6T$M+Vl`sP`Ux5-j%-6^CC;;v2B5p6uvY8tq#nmpd_r`0obS@lTghRNz8 zt+r#Eu1%UPdbmYTqt($(*G8&HXEmU)3FXA<8N3Wyl^N??YJZM`R>~uHZBhnGtfbOw z>PL@`31uem+ituB)zQur1h>rfNtviK2bP6&Sq5?fb@u93few7S;!rZr4QpG7IZ$c2 z5rrh?rQNe}Neyb^z3#!Z{zSD+W2(`SidcL04VZ0|^&~306V*N_?hp0y1Asn(>h5Gy z;6c$F<{Se24aj{8|K7s!`?!XukaHJ4&Dc*e9$`>zvaS2Vm{|Mp{Y^{PlW4rx?~Yu; zC>>PL3x)FpIQSTtUHV-o^6L>d^RmBP{8g zuu@wHN)nl9LS4dxTaovG-%#+6@a0Bj=?PhNYys)J3xow`^xdbF8X0G~(|n&jo$lN0^QTiG*FOu2tc{c!cF55poFEG( zI9?{)i}{^%2@huMG;Hk`$>j4=hAR=ILD)P*ncwf{*P9MVg8TtLKR8H99)|>2gFcq& zyObAswF&M5H1GI=QbW}FnagqGU)qr^Zr=pXpsag_8CAciJ2t%faqzG|lIZ$J(j@np zar-IWtG0~w`oS>Z`=QPSxg*ZX##Y6gDOwM~iSK80jQryh)j>A1j zt?<~XR&h&fJ3)*OvaT9HpNGUS_N3xatMfV+9%RSe*J3b@USn)Z$zy?06=`j7AeX z`n&{QaQ#3Wx;S3Mu_R{kVwktaG0*xM!-$XK_H?>NxS(Qx9EbQPuPjI&l3J%j?|@R9 zFOg`Yu-P{1tYucAZ5lk28;OyjrW@lm&5Gc_P3%ij&Exq%$M;EYOO5Qb(54u|N%vuKXc5t!t^)EAVt`FhJZaO4#PTDDI5uF~LQ#0XoJ;;v-6fOw=W zl~BUjVfQ-h%ka4QLAzV8|PlgTX^D7k&iYded!9-oH)&x%{R`H8f27vX0XHs z7j2T-o2fdJlnIhbc`{u?pQR3tR??`ZarR)e-u`QrL&K+7L&UC1+};eCVo8kmx%ui# zs!l(&*>ywQ_i|Pkxo;5nG-FT4#@2cpAgNCx4v-Gp;F`~&^cGS$d{6V$7+WMqc82Q+ z+}L7bER@Rl)>YQx@(R=7nuz1g(j$+#!P5irxe|=NbiT`LW5EHsIFRgLuwibx z)N_2ZEA1HX+9)OWlg)dFjZ2PmkE6Yz5vPgQW-4P8i;#yE#6ZgIe zdn+yjxLJsm{($AP7b6><~LTyVs{Wdv+m$znwY2I@*QWLE!fG9opYQ-kkp=?LUgSkV5CPmJbe|~Sr_vERRZ)eN8XwP-6p9dx)ps7k(&voubWbOSF zy9xye)YHB80g$|hU@9@K6C4%FO=t##?!1Y}bJK3B{k{8lbnF1j_U|B)?4YV455&*T zPG2}WcSB^}Ng|}EyE?9J-?6W2?PJPy^p;@&J4m2DibT8ry*no)f@t>-yVpO8@>h!;1P5ih);|W}CLzCR7bwuZ{>f|G z+aa-#p)Qc_#f}c1C0*w`h~O{aKU4mN&bD3M>z^VTs%WmGL(-?Sd+j%9t~}Jiga97* z;6=zR2yO7dWG(pL5hO{1I(ul&oagCt{<`*^)PvvXh!sGyAde)PLh}w4@Ni{^zShy* zz8l>{4F5a#P_CV~Nc8WdS!AHEUuh@0bgzG&5x>&e-QM2S+r9P&`!Sim zf&6#xm(%GRG(@Na%#8If-PnFj2l8L?Q96iNs~sI3kn){Gd30nKWv?IWUi(uYiOP3g zlWRkHWc)$*`ZqddZGXyNYkwubzD<)+fXc1k7I1A6QL<2z{Pt}75kR-)V(dh!W;p4+vrYkjApUJZ8A6z)L<4?+2X0}vlf zdg_PQA!peB9+IdoY6q=$L7%8lfvObgzhfoS!xRVzznfIl5Gqzl_Pz<(TOaCRHNO`V z5%@G&gRHd|_kdKq7F;K&BxG`ZNF}0~h(k6ySkfU46T3y5KSUlhO}d|baN%uTU)ggn zzm&O6p@3fS+_r-P0=Dg>fZlxE)=ohO1$!yTQScB2YZP2dL7Cr}oTHQSHo6btBz&X_U6_T)uxKcPaPCZI|8&_ilE3`_K>S zX}S01Z=`dV^3mikZ=>CJx%=$i&2F>vm$%Cv--=E49h=!>U!S(c9=LqZ)*YMKlplM! zd-9_%&u#Y554w{ddO2>lfy?*0y>@d>x7W6M0n&VKmp}^)k>1UE+vgt{P%9wKR3{<`!DUDo8DUQ z+-uZROiZYpFLu~zgRT?K>B}gBm^pQE;Jq5!G+vBNrn50wPYrjvvlLA2OX~4!=mF0e) z5~|9zR;iA?6kJa>aQ74&USI7bTV(30Tw4#i47+6=MOEbbMv{;f{jF~swC&>WXSj3U zqRM)?SG{{+kf64%y<9s?3t8^HKqSM1aKH#8u4eqJxtE<}#&l9=$tj~sqlSDlYNzb8 zxsyB;dw0=T*@JcY#xqucEAQeb=?!Y1RE8oqx(o-e94ioeTMtdN&cC&&!Mn_FHU?>CcX%+sd50F9sDJSOC}8{YjmRe*M4&52(L1=d7durlBk8-7 zE#VHP>hqxpeoub=S03T_IQ*~em}{bOWJ{=eK2^T2z!N!PX|HvQgA(j?kRve8TDHP>*eTs5z=Htc=fJc_Us^j zod9kRBRo$4tZ85kZI9z3d*j~YiR$B!I4 zTGI4^@{z%QLo4Znnyw!`dQ=~%95eJ|!^bPy@uAAG%5bS~aA3GRP^kp)ULNWnKGHWlI8YiW zl`9qF=+JTfs8J~$Gmab?IEosNR?6l6L5$^yp_fZ2I?&&DtPe$6f29N6H7YOr{a;T|{#alYf-U7leU-}uz!OPk+>Tjo# zJ7c;Hty=UNWz)_tyY-9*SAYjK@L=&Gsw*S+mXiC;Aa`REnm!}`HW1$h@oO9Fn~dn& zL39&D*EiVuWTf6wQg3z}nGt@A32%e&=0y}sM(``PYpL0p4!`0HXGZiZDdT5rW=8HS zE#n!{w}a>oh+a*R@i8MGy__VY`IgfBY0%u;fadajJ{j$|i}uT)eSKpklhJ*f=wd7p{d9|3X$jdimnMQU+X=@4n1`ztOX=A0>C}nzL8|Zr;^gXxH zPRJSOTTJQ&koxiHdf<39+rVv)Eb~jP&lIOMdaw5>qgu~ynQzN_SA2AGqD>lE1~&{~=I+?Gir#Z(>BY z7H`ZlGcu0H=OL~cFRevfz(e(RWf0f>ozE!k$4+y zB}w8*(>fPCCnclu)_VXYm5asEjJR9xzn&^SHeY;9-fGNr#5U-Nz?Xt`ubS=Qwt>oT z1eISe&Gd;2^{VY;T6jBt;gY2AwC$M{|B@1|d}ekLVXLWr4pcXiRL^dPU2%6va8V(D zrbt(A7M+ax+jOuqQm+@rXEpsCHhUR;xBljT{Q4LyZ_+CnnYZ5Tp46Tdn>ZBEy*TPqt)&i&K#hMO&XTTAW| z$o*teWjr>O(Rk~BR`}S|xUDzncrdfJx0bwTK;GHMrXHQh=(_dyA!p}iP8KF7<}%uD zDQ({Y+CFoMTLh;I`MKh0*Koog3}sBXGEZF&u95`@0NFjhttb97ApXjxiJx6#+G6s* z4dh?F82KmY83p~r6^1t;ASO){%d|3?0=D_wocCVEMud_>;=x_TY$Tp^XCh=FA z@{{(WX=O5h1ux9EQa+RVEvEe{XzyN(_Svs>UNI9Z`;pEo`ExbTc8v0@W9vq_;bhzV zSLEkvDLlw#!WMJk-QdDIA})|?!DIT{PAzc}E1Z`$#dgm5`)gM4TS@u8;c|aPJ2I>fX-4^YrB53iFpdpjBo)o5l>5rY zapPE}d{hJJE60W_Ao?(Pacpo1V>v$1Z3#a~LA_rqp~+)MK+6GL(~ceiS3&3U(ZTZY5TKQTGQ_8U*f?Tnl|Hm} z9619=`}Jd5|G?1T(IfrG2KtVc^}geSke2ch^z-=O#ojJFm%Vd!yIuf7ucrW6y)&k< zlHH2FQU`aj`(j{%?PRx0UxDZSkOm*Kt5x~j>C=VmsaIFAhHll%>k-@X|6v)4CV(R&+lvS$yqy|R}F0@`QqdUyqPoH4=AUQTdD zA7~L!K6_%$Hd6nefcop3r+)Tamsf1%&7L}P<$s(IQ~uc#NnTlVD|=eWE4ug09xAnc z#D5mVf7>P0PxcP7SKj52d7NJ<=$c)>Y41Y z{7U`eIJTl@y8RUp_3U2A6+5qui@NVQlh3fv7;t4CF_gl9{Atgun%V1IuDla-+E^)O zcU-rH_G_U1)0dh6*{!u#@+2#x{wt|_=y9r(TEo(pGTLv)BR>snX;YGozgSPGXDsu>yXaztj(gYL$F;UHnQtYAZ1j7ERZ~R@Hy$ zubXjUJ500Uqmy)smA$WJdmeH#YdDqp>~$AgOWDUk*&<2oNHufUY{N?;XC_BxGo`S7 z?@>NGRS3wtFg2D@cCD%*ed;H>Oj_JW^h!S9X>& z>E6Eg@{Q`}#*O972;2_Z7N=&$Cg(ERZZT~aK-tS#|885z7zxVw za)n-+M|>$*^d^&hu{c%C=)RS7-=m0~hIRMpq7Zi};A^f$ z0)*J92>k6J0JhE zt3Lewe{=2G7k_2%=fC#HH~vM(M|u|Cc;=R;?)i5I-|)`aBY$#z=dt^~_0YY>J^y(B z-Y@^3Q=k3jH>MxC`q{bsdnSv&`Uk&Ne9I@_cJ|ng2cH<-_x>loeDn3jcmDiX^`qZC zYqh=m!z*uY|Jcf1AN3_y!oCTLOi@vh+pdv;sY4sox6qTY!l*tfFU2)CBzcG zZ${n^gAQYezYFo_@%g_|?pb_(uU&}O0q+pX+Q4}h={CTpQO75c{%NESAb$a6-UytZ z1pJ55#%};N4ZN@6^E%*s6n*$@Cd%R@LK6@Jarzq=1Hi&RTXavrBUZG_&T7!1k~P(qn<%7#SQTikaMlbGw59z{j?bI z`#|c8BNgyXgD^SU6i=fN@nH_%M0*S1M*J%|^2 z28Hg77Yam!3Xh0}v z*3hOW=65trk~tOyqNl-i6w&As&om7*(RjY0<{eGqR=kL~y>CYoog^~NCdv+^{rMeD z?2hIt4TTu9$UG}DB^oGhh`(>GI~ZD=2M)uuI73p8I5@JJdno6!ZPCkS6GCqzJhU?6%FP)NlUXfJI%sY7N3Tma%cqg zF7ot|@-fD%%@Q*~gEUf#WN20VEDArg*}~(1))`CpY5oX4tKz?)lB1igWSTir^^5Mq zVthxkC^1PF=Rh=*i`z{1<3Q|9BF-}Pq|&3YM2h0|K)!dg$WrCG%+~^U_J`YBh_boj zMPK8QkUvi&iwoMcuNE4-cGz4I@$XlGn2VSjsRS)HEB+8j*Uz#-a(U`I+#yHYhF#CV ztUvKr7*rO`a^E`rN+{ObJSd4g!oxOMn@A=7b|B}|k)>*-38J%}3;O$?ss1APXZurN z44*mZ87rm!Zvy$YW-UI&D`0%HMVmO~o|BqcHOe{9&Q)!#oYP#_sFkX#xi|Mclh5%> z=W{jr*7#;fA^o$HOsQST*=6}hL>AeLS;E!K8MvP=apNd>h-D(D+QK; z&KTq)slrZFZfr(baZHagZizA+!*fhynF>}LH7jRnHRGZP9+^Q(ZexUHt=a&_Ya)z_ zX_bRq+bNrtR?RD~jq*(kMwC`HpEhzfUnvKzP%W87d1dI5c=f8bnzI{Tz2Su;yj1N0 z-XAH2AltMSbMs6?FlJ8H>c2D>b>y_1Wm|Wbjfw_iEH_fGkJ~j3aMR5Zn<|YeSnD?G z^q?m2hm1J0vYPXjG%vSmH&DegY_*(*5|-=Hu}#jdY|vn?;@CA51?$0%Tv@iHfr?xm zW#}65I2e)NiJIoPOB%*~cWL!*$EX;Nfp+rBp_m}>+kTq6K}==2RBnh+>sliatAs2` zxTJetnVG2@@^=9-i3NyWq6PewCBu>(4j&;*y+y7rYXf%KbYp^jb6m7AZ!F`2mow;j z^Lgc_cpkd%ctQWt1k%-)jGC77=-oSc<<$`eO{k=_J~Hn#jA+eOr2@RuOKfPI&AtV6LnGnROmU4B*o=O1B&m9XV~?C0yi{)1N7S? zIKPUuO8j>lCA|ub6pTMsn5RZS@Vlx15;G8e4Aeyrbq`V-5evh@$nTk7!Z3=DPWnER z+_JCCdQs1zKun`qqRd85mJTRk8g8s!eMz$x(J`%p`HD#xW5N>Vamj#qktCF=rn^Kn z#stB~l^o~pu!z5A%x+Z6+!HwmF#j>)0^%dHg}ibw%4fwrWq3<=nQq3&c^M*}8bR9^ zbfeDQv32m%VUZ_QZOG#RC>1ToZ31_`;&f*=;|2f8z!|5xrDR=LUa0Xt^}oMh6;kmTcwt4OJeDE4SJJQVK1L! zfb?}uHzAL;hRYmSWQ{?ULTNAokIyq6VQW>IqpQ5^Ku5W(STMZYiiz%q8tj}Qmp$dS zs3@aht~MMhmb0Kh2@i`;!GctpWlR(O+`L&cpxdRK-YYA~`}0ey*P(McCwCAz2U$A> z^9f5T@CSf@>lsFg&Fq@gp3#u@HKR~>@=A~7JCuU%!}Ap_S!}&&srb zk}yE9$0q0Uxq>HU7SdPapTXWWpbDzXg41PWtX*g0LPo{bFn@~!o z_2isUH8j_F(lR{V2AAsf{(Rpi3g_$PlDGnY|Focn@t>r4E*Ylagq`%>WacM6}!-l&RSh;{!L)FFgtu*qLQ zH~}l62t#NFhQI>8r(q<|Fy5!z{_-DXJ)M3@`Td}uYQrZ^75W?Jmd~)=bkaA^1B0Lb z?%-0*UKnY@$iJU$yIG|=;-+0|O@E^hPG9(M2$l_KAP%EPN{Bzs9y6WmsVCaW;WHq1 z$8eKQ7W(T)t$EZMeCW>-2T?{^t%NT@6aWGM2mq07 zUrDSpjxF&y0001@001}u8~|)-VlQrGbYpLFWnpk|F)lDKO=)9tZ*y;EbS_hIY*S@& zc4cxdO<`_fXJu_=Zgeh0ZDuZHY-}K+7yu}s6aWAK00000000000000000000008ZM z3wTu3weUJ8Gn2<810;}y_ds|IAq;s!0E2{(K;#ukc!*G(BqwBKG84~Cco-3?#Y(|P zsYTTKEcH$6uhxpSR&S|queQFc^>MMcTHDWBi>rBo}mao4O(g47PKVN(S@F0lS0yz0=H~#p>Kjee^GoPFApt9__2`!!B zxW8MEZPr6w{AU9om8n3Iz=Ny=!d2Uw=0!Nn6DPb9gxtck z6q9@hAR8}-e*`dQ5I!+qXkUg6%|LvK4G$)??FqbAUL)sqEtq!OM4S`U<9ZuN+t5ay z=y#la3-EtX*CMetVJq3pvTjP^TiDmkp-07a2@i2Y(;O5ZVK4IQ_us>q7!E|MLZ<$)kg_ep`Q!|1{g>ILaYu0G8gU9sJ zkiec~JIXCPSgJl*wcAlH?V!Hm2TVIEg&kFNaqpa!($iUEid)rQ=Imw0Ug8UECmVk0 zu%Xhjp~`BqRK3k%PNg)bN?vC<&6+LDsupI=Np03xGK)ETnX#An0^7)}dmUymPri_r zFQn;rILw(X&8U`F;<3fVTw%^Uj)_8A3#RlEA+RNRE#_L2pU2uxIJC``T3DVH=cf%K z&Y4FqOS9s9B*pn@GS2B5h&bY$NSI{}B{hUPW!A9FT{fBHip$krA_p!aS>ps!tV<~c zJLl7ow4DouUlvg3_xpC%ip4u!@Gz@S@?w5gp+TMp(w2NNPMCDM)m&gTYpo`W)4ylg z>>Hmc^Zssev<*{xNnnZ1j z|016MZ|(EXqPS$1Ug{0R6^{y>E7{L*PU;NDsC2hE>RiD}`;V>xoyMC|mP)0|oO4?$=C;fsbhX=N z3g>)gG59*~cf!^et+hp0t zV)Y7-J?Az_L(X*O+*O0fxvRwa<*`k782OLrf%D}=n+@-C|kj|C(8Sg_Wz zfJf>tCtJWBy~G)~*lxiZX~9~j1?z+bXZ2%2ejf|YvMk_{`jGS_3%H|~I0Ij^Td+=A zaF#ri(!_lppGnf1uLx__i?i%(d5CS`t9$20%SbC+C7}lG@RQ;@?VkDTQ9F?%j*Vt-RQ^Q{ppC2klT!)PsgjI}(e z1pUkmS}S9-ZW3#Lj#zWSVaav`CEbj=ONQBEz%6c2(Y>3DjIc@i`y7LCjwFN(0yoI! zGtKy;Sc&0HVODrML=e*%TpAVuhkl$P_(+9$PWu8$Zf+cC;FbTcstfj!wgo!leavA*12VKpKrQMaS);xy+N3wu=?el24&_ zYw0vzn49ea$I~&vEWOkl*eR29yR=YqrkW0+W^+HOW+F*ro?c=JY)w9NIxKToivD4S zeFt_(y_+5Got9}cd4lb(r&HJy7J+weKW6#qwuf1JnX{J|13QxM#yTzI!d8>T>Kild zc6LfT!}5Br!`>V1_7++6*X{I49KUDv&7WJulpu%KR+(@SCkmkCRzk_Fw;lJn%17;ME*JY~e; z9;J@JZXqZ@1LHzKU^UU`O_Vi?@#f81YB^(pxKR8gve~tBGF{v|r&u%SCl>H97@Zso zCKYX&hNo&Ti@kuP{v)3|3z#s)NeFb4UCzReNA`&clEYbTvP|Ps48jyipiz_tr_$)O zoqMD&)*MvmH`iw{^Da?i|8+8;UI|*yie| z=h#Ng)#G-wT>oy4P5Bc!cDv|^F}r@_=%O1HbKda`8#2~sBJ=e+AM0`l?v@_%*(9Fl zv(NMz2lf-6eQF>0Qci7_K4OS{P@N5%uWue=*F9I?GsNM%?>dIQIK=MfFPyA%hT5jC zT5pmf5}!t4TP&h3FrBU!xk`q(V|2g^WNMUgPCbMg?6j z9D>uuvw8GC@(IQ&kvJn0O^R1x>-^%2%*fs=a?&@fvtu8KcY#tcxJ4&!guU|m4S8j{ zwO{s2@_r}zGD*J7s4BQI>cVdc`fk29TzG(uAtW}7W}^pYjRA^sW)Em|0fwHo;s4PHC;mds2{gYaKU z1>}q0-C#b08vLPO?;Jrw9sZ!LK;!bnIKc3M@8Zu7@P~e_MB~!sRh2(tCg1dms|W7N z(1v@UER*0ChG%6|49|nthEwk&8HG6>c!S}AjHy{3xG(={uLpkNC0LqEa9Z9|1s<4~ zN$tOnAXuA0a2Hd2C_f7x&E1vlgC%);hUbF2kfgPzKkdzjNLH{A^`;SLLE(-O9ypRk z?Rp@1J<@X_G@>vk7jDiaIND8Pf90jIJH5feEciZ3&Vv0T2)>Q&QBa$8RrWa8>utcf zjLdu5OY;NgItQ3YZ_6GNr!zjiM`UtCpBF20}37buF5F0j(u(^m6_B-x74HhtV5%<-=V#fZ! z8s@_a#^y6t2WK-@!y4+Lov}w*`(o%~Y#aA2fdpgU=W%DiPR9N#M_?B-wvn|jg>MMU zatT`w-(u`i=3D{aVeEFsn&5kk?dNf;;QNfNVGS+t0An+G4r}01#+EU*4xVD{HXgSg ze#zJbwsRA_#n_8O1a_RUiX4Hx&)BzR-yazJE6Z$!&lr1+u{LZI*3F#lkjYpZ_jN!n zV|A>(6Gk((#wRd8V?SojEl|wZ(?bO|ld-pa0;^=~?~FxZK4ahJaoy0sSR-2@v7fxf%Dx zzPwjQ09+2=W$f8p15;6B3D#QE5c?ihc|&0*W~0e)0I@Z@pToI$Jimv}vexWA>iZnw zO$x!5e1fAHp2#A&B8}k6bb_Df5`2bxpUo!tA6|k#auWEcpky| zg#^7kcGL)hVU~7~VU+2Q@z}ou+ryNf@Yrj4Y>eSLhGV#QBWt{oc@DFjZx;|egXQ1P zvv`Z)%iOE;Obd~6=I#s817+~%+-;aMe1!zv1q8=147mtio=$K%w_kG;ywhz_zFzQI zmI9j@ev-yxnSOO1!9V2_tnmQm><<)bKf`bh!vzd)&muUTM-`=6?O3kWKF0R!V@uYu zcF4BccAjhx!6hoez1-fLNidhkKIj^#Jr@WTGt?NaW;l+mYG;kNG3SRKOS|0$F<;@C zl79Rq_*=c?u?B{}W}eR&?&n$CDWd)3%o`BC%a9}((Yx2}_O97|iAvBrg5XPOZm-pw zg_NBN!L4}&iwd*M-cDr*Qrgo9ej6crHD|bO>~N%SQ->pcnA@6B(QpwJBa!~M;g+t0 z3LyUpnK{h!49f{Kyn}66!Fum! zU2id*&h+<~e!H9CY}WWWYkZlD34Y40E_ITzJ&rGiy?iW}_x3>waw|Nt}8Y*-Ruf#rW zqNUvpT@x*RZrC=_vLzj^X6zV{_6&GnqL4`%GT^Ah=B71a-%Da##`^_?*)?Rqn>Lvl z4t<&M8xyPcdf{(24LR@+n}!@1R%F?d1M`Z6zQ5*EU!BB!1%%nP=Qypjn4tGznw3kEmRH1#Wrv>{KNbEI*`j$xSA;y{{*2vg8iB&LW zx4PV6b-Bap3OHw~fvxve!39$-JFDT=sg|A9aOYIZ&T9CH)ORS0u%An8h>I}0_G*Xr zYKQhY@SLf=+B*-9+qBo}Qin`ieOMacWA}Nq@0HW% z;{{|X@$oV=5Mm;kuIOFQewS^Ky7dRT07RR&)IJGz9~nI6w7xRsom%I!_pm858NBb< zYqQJ}K!wPFaysMGeEnhppkm;x#D1N%pbkde37a-?bwm%CD))!CZL+}UXVZEUNB^=# z>JvHVPHFd8K{qsgmZ^oE<0vm`kI_@jGy4GYF#WW-{Q}=ae5+aqsxZ0Q~_4yqFDM?Dt#E8E`oNU{bp%5Zlg5qCHKpJLM2UO-9AA zd#gm(&3pxa-6iaa)0`~ziD1=kp$ERU$zlfrajnTNNZn?=wSR;CaszL@m8;3l$$SUl zI%{3K`&eWPPUf9ngLh!Q6}Dx%-g@mP;v~{rty;x3azqL!AWmj-X0=!5!g^RQVO4qf z!u85=wS59`Z0kNz`bqqfG&LQCr%dk{-8o8hZ*@~4H%>4Lqow@BS$yFjxwapF=Mt7I z({GmKNOb@~N0kQro6mNoyo%jqd=>I8XC386s4|7-TQO}LNRuya2*38wqZl;k`i*gh zrXh9hV?%3bM)86x+Rdt$GOXLR{UCRqZd$$u`S30^IsP$Xjo9~_g^mZY&nh~i>z&SB zeZ08KD`kK|y&sZ=P602tcY_rV{7oag;4@!jN9ZO+>kR?8sw}g!#8|R8?*stNzX(qzj8{{Z{L8(z)E=yTW~Bj~^@tzqEZ0NRu0gu@C!C43_SRyQ{2AY5o&; zS2k2>-9DN1EfRT;LAd1Thh@KP?bEk@Lm1fk7D08BjTek6Y0y5-n2uN&lGfJT0N2Yf z{5J$1>vr_iRpV_4+;Q5=R<7dBBP_Qpk)um{`HX<6=WXb;jbgk2Fq37x*l+GjABkQ3 zjqlbwN>OJA$&EyW?$r0QK!R{7ftUIT@@2VTk7%5x-LknK?-(aC&WAwt44ie88TVlv zBR}L1OMb`Ozj7MwA_P5zP`ma4q5mVr1+zoj`r(Ln)pW`OQ3r?8PqT)puT7jPWBw=71VzNfU*eh)AJ}l+~kMbV>9WE$=_eS7w z@=nF7s=;)NwP~{81{b^bfFDFr5?a%~_#7zr&g4E-`k5~BU6%ppeJ2Y(k3mvWdnkUD z&CfrB!&No0^6tgI1{;Yha2oSNlhDvjmjQ%JhF)3G)U~o_1WO`5F>-^ftk?DZ&uvn> zL1xsn&c8stDd{@tSpu^2Brj?w@xy)S8z}0pF?TCbR%KS7VMi+({~o3>7LL#MOuWma zlfG|H^bEceCo?{=YMBN$tdCyP#B2rC<0!t4Y(!5M5XY2+4f? z7zCnZCHalM!&s-R%8e6USJ^iVf?9-i)%B;KoZsTz^dN9ZUYu6@+(6(ZXk>c!y<>c6 z7;e~a^4t^;#zu4Q`e1&)CK1(O+xs`U0GTKL7kF>th5_@n_xwqe)#LURFF(j4(iUbP z!jB)NQr1OggdfP2WUjo|@z1E`X{&fmhcmOZ4H|ny*Jbvx-~J`So3EdRD4iJZ{6TsV zH6jQcYRM90t`hw}>@x4JQM40W`_9$2 zlUF}ASG*QdP*J>K`4UQsr!ZEX@zQGGl2*Me!n*lQ0tao~u7h++R1E(tAi7IX-jh9X z)k+66${I2pUk4?Ouc2%d;oZb40a1R#UO&bDZjrta?f2Qf9Unq@*SF_*N%28>S9?>s z20yfoa5?(Sa%;ScA0!y}8Rt>;5H<|kQ-z|Ok+D|ayWh5uj=&y+Nv0&6Vz0Nfi(qbA z?>q7e8ixxoDc(b%{9Q>ZUIxfeCTSoVfUe>g>As@-t!2Dpw`u1!kpgeJ;}vd`;M0r$ zRnQ6?v{ibmX@7w}k%Hx)#u4pV-2 z{I)vy=QAP~bOkS&zA0fu9x8;>ucWs+v%U147RtP?FC=<)Up;@^T3<;_P*}**L42O^ z?(R@MmQcuO^bxZ9hITiEZiq?+A)||1a`s9s;Hc3b6Z>2hCmfX>6399Bs?N)} zl2PDGYqs?Tl62Z#Yq?STrksXO^-jpvoNM$8TBThUJS7%$uAO5`n%Z(V6E=BF7Q#*X zoptZG@nK40cDw9>!k<*+EX8N~?LswB%6odTH{0!F`0XuwXeOtUq*zqJYt zhN90@xJrMsWihXAxt$RpvA23k$p>+;&D3eGn0;0+e(6~L%k-gi_swb2hiDwJ7>i?( zn(mbP3d5_asTh1k@@gEh5o(~R@yU@k9h6C)Sg83l-|>0!Zp$^}0}jkxopp*2aV_Rn zDqojHieZ=FWKf_Vf*&`1>upicwvG&IZA1rCc%}Ddt#D_{E3IF(IFh^yrF=ZGpE8?f zc8x!==`x0YtfgH|#u$ndUz3dl`INzW4SGDxLmeGIYGsIhFx+3{8WCLE7e={~y`OO( z`IXmSXCgRhpBpwWtcB>l*dInCe$p`(UqM~1A2HAq&iicK#h7&mn zP1wx!XM`R1zal+itTw?q+Qx^H=+m>!GXWOBNsxT7$Oez(>t;mWFkP!aH5`oW3fcW^ z$y&4w_PReNDRC9$zTgQ@xFl|Nx|O_(IYd)o^e-p=8yE6Zftg{ zho&{mv#lGsHkN0-QI%RLzxX{PNe_}|=xX*NkC}dOF^5kSst+FiL%v7VHEf^w@{D#;% zpa5#6A1WBv01fD5@a=R=53WZoC5jeA0&uAOk`-hFUMdFNfNF%>bI^*vuxW(eD08Cj z`Dz5+NOR)usoEm|Me>P05VE6g$isVl7b z1vl89Z!_3l${8C}opPS2yW}U*p4(zH9N}iMyqLSjCk$|7=^S~xhCk+p;E^Qwxe7aj z-(3+u<_6$G1e8#P-(z}|4pyiX5PzwD;|F4@*rg)sDT6`j|2{|VsUSz{DcTOd;d^YZ z{^ic(8yF9H-x$P*gF!?a$R4~v6j%>BEy0OMKgNGmD>BWB*v~zq%$e=eP=>v+^B5nz zFDoTOp%HwOaB*Gw`?Ir zxQ!E~!>{b=wf|_|317Dh#ql+KeQwWKdmyz%00wicSkEXFwRF}q9Nv2ew*T}w?VTZ6 z&D~Dx=@Yxb=IB4)tnhL}J0RhWD(HT;PBHLIoTRx+Y&w1}N%j&a^8Q`$L;{z_l3nv~ z_#uzcA5q)$z^Y*BX=bY*x%+C7s6a2@_yPCS7eOkJmvE5LKZ=P#{{G>W+k>_@KqBSD zrTVtfMVumNk1`+!rye+D5qAD3!Z-f#BeJG(hTda2=vL%TD~j?v{nkoo010EpZ*%?Q z63%K<^VU6&)cb_0Yuf2!_mjHkS5m^SUkh{ z+@_JhU;i|K08*z%*ke4Er(01Y<%Y7Nvus-jml+`_-zMjV)#v7#1V9v5)T7bRpetN( z2TwFe49T`(?O9I7Qdjr;cDW4`p#RyI4mRu0fLak@0XoIY3~5=?EscF&kSp!!yz%#3IE9D0IuZBizUvRKpTGf5 z`62FWZK&&DJCZKkkqUe8Dk}7=AqVPB$Q6<iCr%!KbTe} z__#zBcf2d%7w~b#J*k%;OM5rHNc{hG{xB)Ofqg*+s_#+))s=E#>WX;LeM7znz-W}w zw}bQMx>0;A>|fC3%03H3AV{%N7%PBh3ur&5g~A&uWk+0TgrikWAcW;IBJBSthd#&$V|7da1UjWq zf2UaagRECJDfEJGLIA`~#tG)2DkJIAtQb;i{WaL8e1=4zc80uNNh|(l1BGa~*!>O9 zvf?pQq?#zc9A`Jj*ty^p`V&VtDRs2bXPB+!mz=}f0%)5f zKkMInkgCF)MEaOOuMW%IJCA0K?1@=~JI#^-q+lonKZqt_*dR)9tk~HtbfE5OJY+Mk zR+F*UK)G0$Ael(IPsG|9d$Hy5vK);b*Ni zw_a;gtFY&0Jt>Ou%K;KHxEQ=z;X)>V3VE|k+$M52NUl-A<1#(O`+8V$>%A$cDpIYvK}3CmSD{O;~!@va6dBQiEqSjNCO;vjq~nb``6RYL81In&?s7u+5Z-N)Bi8L7P82J6 zF-wvJjg2$&wwR7=fJ&GQ>Q1B1IdjJ;t}v0bzwi)TECw36tSE02_Ul1PcS88-iKH`l zrtmqeVMaj%{qhq2{7;K~!630cPJQ)9QPe&9m}LiOZcM7EW^e$!XSIxSYM7F&^F4OM z@==R?Obhy=i=~aWnz)>|i%OD}+^t~^gb}5KW;Goeayl}5^q|(vkP>-j{hZuUXs$Uf zS0*&RE9o*F!#vq=cna+jN*}Tv$?$Jvo;MUjHB_@%3HLvyW|qqr>+7r{hFLMw7XD0A z*4Wx{3Gw&^$a36Mv<(AIYeFY2B*197CV>JLjI^2~{I-P7K*ty+I#If3+_7-X80cjj zX;xcnm86~3JlWYxs7LnuVMA71Hm(Q*aAp)X9P|1$?FpK3N)uMOR%BtdBqvMtu$0~i zbMO%@K8&p{X_<$UK)sQjVHy?>8QGHy_Cu^rNvw@D1G+yE>jOi0$)Xo0GWA?@;xSw% zQN~l|K+E;ezpRXDVyI&*wM!h&&K63Yt8z^dqDZ8ZDW?{Pt~z>R>?mWx_KT0Avu=i3 z;@Yz=_=mW~ayE^~+judjTDp|6Qe{!q$={6398=Jf$-kuV@y*d8B7Y?+J10&{;2$om zgX1i$2kA~{Th2`_TaNo<_#`Z^|M6g|_9#?7++puxMG0L7k%S-_&P5Hum8q$2>c^6P4!A03cqjGnAlOyJ;7i|FEpim@_V z>5AMx{EOenp;qV}087WT*7rcCjSt|nZ4&!2w`H^o(AL(8Hn5BsO5HOB%d)zW9elJs z2mdo)8C7sdzUG=()S8fu z(rT$x)U+EIBrmh6*w9jc^5>2f-~dU^QWr5YskU=B35Beb5i-N^fJ2`Tn>Q%-^gxFXUB|&tes^kw^44VJ>X57MPgG+)`vs0axWI%5v6xT{lU4}vSSE6 zR{XNu0~QJO)H0sPG}ufznnOIP)BM*oH9%W#`r+1?#r~U^|EfGn%(J7g19Kk74%G$AN*=|HE?pb%$m-}!XCRgQ4YLVS-=*_k6Btn!EP5GLJL=@N1laOA7 zz7#}OObgW(#ETnv2VSJVA>G67ooa052#L^ChqClRQi(nQzd6AJ4{?5pQMR zy5yUO4MWi5I7}`xZa zog?oGT#9~r3X~{eOA+?LYbXWwtlJ7-1<&FR)LVt&jCO!YE|M%-#=pOcyi8gJJNLyi zM1GPGFa>E}a}Fw;2~LwboNvp~dSoN0?z^({+XGoW(}Mpx0;P0gX)~yufXX(IJoR+R z@pgETa>tX!6{zK11uff44JfDnufMx)jd~UuWzQvVc(gYecLw3@uF#CYk}MB{uX1OutcJHx<8A|*c`<{=H(%=EF|@X^00q|m*i6iq?>#zDlfjBpbyV`cZSk0m9urafc6#GA(Pa)4H@{N;6G zhzW5W`RK2%f^@?8w@6P{{;I1$9=8L@8(y~J_=l zo4W!v#`3}6@ZAyX=$08v52=c2@w?C_Kckx)r>Kmls>JL<(}lltN2B)MX!9tar%hybN~Yuv-FcdPFIK1`~R zhv(R}09v=;61yPhznkMf)3^zs6}T$Nn{!i6Mw}X!*zILmOXphx{{%5DAQaD2pMbra zy$U9ZHc?ERbNuD_qA7XY^0I$}DSf5@q(mR2tjc(Z9mo)o1aM~OQbPo*PD#-uP^aQ} zG=+D%X8Fu5eyGZS4Wl_pGgSf!z^o?cz-kRUCcB+3j1(-~W{|j8rrYiRkRbHRURC$8 z5W}+MH>eS-lNUeq(2$s}4JaiEZ&;VvnEh%-SC78qu2E6&o70#JRxj{?+@NTJI~n6j zjswy*Y&B?o#+VCP^BCs$xtHZg-ExQwUQxcoPX@~6xP7oT!q>Xb&vSQA6RZLT{~`lHReqXGr;58f$=g+AsA9!R(fN*L?v%>QRK8wL+!`tG5R&G1 z_!dCbopE2Kk!SM#?(3h~^kmN~;U~}iBDE%#fPHA-Y0%E)Sf_P;vx%b`r-uzJivk^u z;M~}Z0v69~#^&<@mNi1jSu!!>Aj=$QplApVn>tEK+yzI+U1F7XI(OS2?8uAn=bm~< zOy!8X|K|dvpFZdUWZsN{_+2(tqL+r>d@PODl!rObgcZvK_@~bM?5|@2sPU4^GEfmiXe-BIpb#*XJ0URKMYT+-vlg|*D8o9$>UGUWD+o5<5ah%*I@AM6-G4n^iFbp>$)&r8&7FGK* z*E3p!da{yAQolLBC)HzY66GG)KP=3yTrVt)ux%)v5T27|&c~5y_PNsb1pc1xHaHu` z>yJ0EL6WIB+M#PPWnG#d=DD_rib$o263WC?HO?cw6r(9F-;k4F5 z5eT-%t<1VK+FCT+yOZ#WS~2;qi~&5U+Or)HPU@B zsi1!wmRn)<9mktOglpli`CvY@c&$(`LsihrmdDny;Wn`!`bzFsttTr}?wkI+V>?Oo zTdEmp^fST7<85Yk-|SPhzuk@6J!8-YOUv_w{_ccv|2qb|%LKO6yAR8 z$!;Jed%W{k62$Lt%%@f<$E1lHs-P+$MQ#@q1A#ZZ9`6fE*MSQ4O#}r)-w2$FU)cq# z(c@y}_1}KXohAL2r>DH?2Q@xyi(J4OJtBGm6ao1SWq=WQuH5}W?Qq`V%R=}F&C+1I zh>v?c{6r~(T0!7y*ds$~%3WeY!j&7c_z)$G+;Pt)HnuOvZy)T!ESfXke4MOtrRpX( zfeDh_p*OWLn*+o2Dh)#QK}yVTk6Z+^dvg|j4;=5N4?kP$9GK1=N;4CQQ+c4)NIz#P z!}!&b@Yq200U(vj6mDXWnga}0uOn7!0)&uYgtHUm<%VJaKVS0~v`xv;9}QW9Jv_mH zXn|}Yzp?x(7yK8#lKI@0KQ0E9}QumE9=aK5oa81-6aUXHk^BtMJl?4X|fJru%CJzXzx# z$(_MG$zFxUa0UG2m(IU7OnfM|bho(cB^6}8uSkk=D(6xs1(FfH6=iHFw%V1K<`Fh? zg={r{%)%W!xdY{+Haz{8WS8OwV z>^G<9Mf}`95=F9B@O#_qFT1l=KAcy4Ak}*xPcE7SzAh>;<35OI_+CqJ3;lc!2PstT z_;210^#3tB&iTpvJjLw%`y6iR_4B#Dyn%GF5}(2>(fs!+C~^fx;d-E8X-&Q9c+a;l z@HtZpowAhEf4qM-Y4XoO_wc2NEHC;3v&0A0MK9nw zmg4&5;bTlAlP^H17d_{d8YA7#$mbQYE4J*q4d_AJcaCou0l>Wb{6-!cynBAU;{Sax z>2)~34!qR9=>Q*DUeL!B@dh0e`BJz&4wLkPKdkO^Wzn-6`m!^8S3772zl~FzX19)0 zKEWmYu|2~Xl9-^UUumrq4c04q>JGhSo!8~v6$Lb~Cp*CP(R^nh`GbySO~sY-6~9!G zoK&~#?^jq{?EjjUl44d=?`L7rj`}m#(Bn0a^MI7B6cg+fZG4hy^oxvo*oE^#M!mds zclS3fm%uPl5G9Yo2tKdDsRtNycJT*qB&~iUxDS39LM7|u$mE^Eauu%9Ak|W}`kue9 z%zRh_iloo8ryr$@G{ETGJSJC2LlG1n7ZzRyp2VAWHn$2^R z1or1vLH!kC1O@3QjsWo~;zQ~c?d@~wWj2P2B^;CFy<6ztulU}W+~q~DlUH3dJZZ*u z*eX_F;g<#)`sgw9H$xGV070BMR;Ba(J*5!Y$pcu$GdBmE>i?l%5_#(=M-w(e*kpm@7#hEM4_zJ6%=D1@;x_2{q04s*?inti4}2OP`aL03l78`56MH#B zA?Hoo?PVyb%$Jrd$k(JM+a;?>#YpMz*jaw>&y8}>Dh(0k&d~EY^w`kTSIY-8?Q)7~ zc_xCbr@WYT4hZz#W(FHRo$tvC}y%oE)QN zkO}A>iqV>k{cymXl=o@P8$mP5i5dxG;$bOeoI^ytZRVX!7(xD%JdDaVLj;fS6aNY- z$%HbKAC64KF@D&FmEbb9Gg_pPr3wAH1uZy>Kl+SBO9IHy8xepCi|pbVxK{k_(~#!* z($YoT6IT;&3BNqu?7P@?7+z>;?BpwrC^^1BQ#mS_>ySk;4}Mi5M~h!AwNNrTUeK7I zp3%e2$nRkfzzCZqkp8{w+8>?YJVIqS3n%BDDsL)3#Xt~b%8r4nQW^bnbo}%V(Tdy+ zh}9Z*V=+{k)E`H4vIK?zC9&5EYOo55v0kfnZKw6FoV4&SDg|ji#?id=_9>?1!mya4 z69dO7WpY`TilUXMoS_xoQ?yv1tWOz@Ww;EhLiSI5SfuJ#CNCT1kIrn53q#jWK0&zU zI)pa{boq4A($HQ{l=y=8%8P7RRbij)7DNdOW`+%7HCGZ1Ee4U%hq9;g1R89xtZI}{ zm^E>O;cV+6$8=t0yYqTj`n8G)?lnL1d$%`Poim}>2|6b|4R?CGX_$k0cKR?9$Xrdc z&`hC{6`YtUVZWp-(yJ^E69Y$mIU$M>QN_vST;3UcPHBpw+5cWRIjKr?PKnZ|_tO`Ju#FCU7h`ymp0ovq$JZw~61n@oZeLCXz+it+oiv2==~@ z@NneY0oY$KZ?}waCr({YZub?qjMv>)IJe~r)v=}F3sv^R^pw(JU^a-hxufnrV_z2$ zKdf@&ERMa*J%76MPrShM%&UyJ)$+KDXWbsL5FIzBTxwCB0xZ&)T2K74d=BFgB41x~ z2wsg_7m{2B=B?=8yRWsAzkZBh8~w}k+#1jqMl5mqDuaLhSNAVs2|1O|GDH z0|f!8g#_XKzd%fX8(Y!;HZ}U+V5S${(CIp2OCX+|SC?L1StVxNTYrp8DJEoXJu@Z~ zO%elW@j~5 zb^TG<(%xc;*qwRqe(t#@lw7I!T_&%ZQ_1aO+3i*R(Fni^1@!kK3b00B<9=}Lyv+FF z?&{k-O>6D9oRFaQ5UzhFK)>U6mTo#Yj`5T_uSVcY;JMCAZLh};#GO&r@KhL0N#Vmj zuea`tUXK=aSXmk-k;QdmVh>*tEw~@MogPMB%M1_3x|feI);hwG0NawTz}mpT@E?{@ zX*qX7k=w*2f^S~TaPDV>l|KaReZszm!FIagj^5oSu=W`YNq3)@2ziEI;(nq2s~ec% zcKY$JHnZ33QYlXl_DW2B+!3HTM2QjRnl@fS0#e!qShKOObD%ys8u+(WQY3%l&q#DH z+hvO**81Cp{kbR3g3%5Lg$u2Y73Vw6D$M-xiaQ`qN>^EAb6-~i&ZIEi42ziD66b`V4YmI?5(Q(2*&_lEQ38sfZ+2MH9ffFLu=S0?`20*^K zL(#6QhjK?HYmxunJx+5Z)kW3jM-eRn|@oJV(sSeVXNgns8nIW{Z_ zv+(&F>b{pg_M`A(SOO!aKN7q6FNrPjUr?~lU&LiBTXaVA*z)wGxJQ#2p;@83sgF|T ztL^-I;sHV)KVU9E{$MeDf^jAn><`LwU|ad)(d{!*jX2`&a!<_aXpZNQQGlOL2NJHp zeYmN-Vn#~;d#?HbD}6ZbnD~X@1$KBPyC4$+@3rMYiIOlTWhWBeZIM{ONI&p4#4gxR zdUDsv z%r+-1x7Z2Mh6c)xNJBkiXg-Co|Ci*YG8wp zsYn5vZ!iAo0UtBck!yygz^DwdHKP@IiTX?Filf7}DU zZO%L3L;F1emlNx$Dfcs0U&`A;fYj<#mJsWPleDXFy*!a<=3yGdKki zr3?G`&qQDWd3z5&sNrcFeET}2@DP$C-E~wTRs`424cF&^E-^;CawourR4Xo1YMq6k zI2`0VUwO@ShO|x0)Y8M#2!dS+DoIWBj}&i^eCDFWM2nJ`573m<7lwIiON)%{0RPjs zaEn9tWPA~R%CoyW1ucI3Hhi?_|@jXDMH+j7`!oPz<)MC}edFDCZPmQ~X zI4VLFtwRz4i&xoVJc5!jGvbNk69qkfAuTaFx&@vilJT<6XirbDyD7G(VEAm#fc|XR zA!UaJ9t;}|Jbf7KKV1-;@_@{3YsKSj2V+y{Z$>SZ)Z)f!f9hOJHC}6ms^)Byc3gJ@ zq@x=ZJhF9NEJB;PL3vmnY&RkVJ|9EMFcZz3ZOfx0m{T5Stej2xalZ#kaV+yz@fb6J zBS@)F;?#a#Q3iB6uja5R)5J+rNs)|%mUK^QA*HJF=K1e>UAs9ux7-LnO(APf3Z$Q3 z9mj{bTE>yI{>u7NrU$T6TzG$hq`;2uhxWgMtCSRLEn?roOeP^^>7FbYEvj!m~XLIxQglM1oMU>{l!u>Nog6t;E1=W z%&Wv;kpbdcd|>=DJ@z!2T>LcS>1_Xizl;EUM*A5wi^15X*#Qm`n%Wrk-oDY*A&=E^ zsj@)8I4+h?Iv2BL5m0vhO7F)X3JDw+Q#CAjMIOw|*th(x6RpuV!M@45ckiD&fHnr| z7oVasq{O!|_T``t04Us31-`ru+kJuascUsPp)h`c3qre8yH}QZP#7Cw;-^T0!y|n- z4h6>;Hm$_we8wIpZ(d1PATrGmYJc#J z@yyDb`G)J#Uj9_w{Csg^srQH-QF*fh=Q)vt))u4Dfja~avCF%9_?T$YQaep6@5QNw zgjH0xGs#$lR3x{n)l21uHYI+g_gFPHcE9=9m7ICqemEeUTSH}q0Fa+S7N_0={XkO6 zAFi!EoyzG+wh?w2o;Jifb%vLXJ>-fnRt$@vta8OChG7`$M6!-mUiKhVHbqlYt)Cdh zBx+1L4TjcUDJ|-^eBfPwH+CQ<$+0hSK000v#LO=b3jD!pi6qWpi892KOvD({$h!(z zXVa^+xrs>|_eT);6`eWLx7H?PRnFMJfiv4O=^mu`Azbj`(I}f9@Ql4EUHuKqBhJ1J z?Ps#F6W6IlgfXi9J2%Z+`VW#|R!$(y_MK9%w4vzl(qPxy$Zm=uyPT)9B~}e;Q2W4>`{iSU z``R#`{qMF=xSY7Od?S*Obh@Q^J{?nVMyS>G6>II!1k%nE7yW+I z^DS!}uD{%lyWj?!emHh>aBq~0nSuZ00c0;@On0Jg+9Y2cIsB75ebD&V;9P0_8X~lI zM`2fG{q68hvC&g(`7=-0VBIVIkHcia=(BFZ6)~9o)g&u(4$h#-r}ZTiE4iWH9LfW% zuX{NV+j&)UIDvjN8bwl-OMfDo{y4hypNc%+vLB_He9H`bk)NHay#EZ;xCgA1P>Pe@ zLb?klPx-(fiQmzcJtLW4S%#+#Urr;xA6M8I%6n_~gB*2X3+Q~?wX#O$DL%jKdrLG4 zuZ&12hVbdkF6o4^&~>c`yG2-Zc?6)ZAsyF{^o$z8}8& zOgxSMX?yIYiX%Ap)6dQO%Xyk+=5$_8r_2-_rJ%=y6J0iE?;UuV6Fbmg8Lb7i7& zdTBh<>ffkIcljqO<@x(1VQY0<&<4SzM`J%00Eh)pP3ADGPk}q+TY6%*_n@=GNHqmz zaW}Mv*r0nIkB!s5W06Sv2#7sPr0FzGRpM1n>E7VHUmkBX`)n+uu&%pEf^Ru%zc8z8 zM6@*N{qHclJyd~!Mt#=X{ghAVhAVo(JtfG7t1u9B62q-6l%#3hARhE52%U5~!XPC2 z^3*s9s1<_=8o*iO4>P8A4G6@k$&oRai8o%uKAtcI?dwtSE!Oy)YV;X3KGe*=M< zSib(fs!Dw|Fjj4&iFnkK>Tlf&0O22xn6nL`z2Ut6XRz~R0y#D9;KppoGtk}<;Ix}8 z_RWOP$2Ppm!SItjxV{}1^HsCKq_m-e+S*sXicRz9{um-Yvj1JnXazQ*Eim^m6`9~hxNhiq9Udh;V?p#hmP)+xC9s+ID6*W=VMHu>q zISe%BE_H}K?#%XgA~y6$+t)~&93%wBGniw6O^$Ac|v@<+J2cJprUe!W!&nHoY(nJ4P~_@U`P^(91Q`D0hA$Z?a&Dq-!2~Pr5Plc11;qttjH)y1`n8 z>Lw72m;|k#Mmx2<4~~NKcXOEG=W?n*zEDq-LRj^k$H1P8P?3r3TD4IQ+@+)gy-@_d zI@AFZZ8#yAEF~Bkhu}l9qUDrq$aY{V9o0Q79bVO~&v$7Ku9LGQ4;*3g}K* z!l+4(qRK*^(n+`78u71nj#|iR;1gj~d3{m(>{~Kl<6+=!A-sQVGXbp)lQi z5D+$Ara>O~u5QW&STlO=E<8ocNOSki4t4J0u~^j#7{E9(S-0b2eTH;Z;uiHu6F_hP{nsC4W4(zV-C+uF8HpE_4 z^}Ml#4Ku4~_xuY=U>a12jo~nliMv{o)UB90qffv8ozr7sz0E8J0z#1_D{%A zeyu6to4X{{AhZ9HGQydmD;8pkfdA$(nM>rr4Sx5JG;#wKxHb#*WBgmebcEI;hs0J2 zUq6LNR-lREERL1w7mHNrTi_3geuEUz-h`LZwY${JbBi^E7s0$1<#WWhyFoHDOR!lX zFH$UPr_VZbz!ZV{;m<7+nr&L3+6yDdYe{1bT;G-lor6sP!t6~U2$_*!1nk?Nl(J3i zx3mhZtByESgL_%c$Ef*Uo6oOrV#$k9p8l;x)_Rlf^IuGYi-N+E9R*{ zjzhk-`JmD3@UKebR>o(<7z{>DJG)0=NIy|VONlcyBeUpXHfqG@K?ntw9QJ@2MjyBVUTDU+l>OUmcU)JK=z4ufycAh%&yKiuXB9H8M^MDq+r{N=`5 zQFCxGV8&s((gB#BkB=D2!zB;n(OT~M;B5>YKe{>uFVolFgGm<7);^6$(lpphlmlIa zQo~ndi9vS)3Jf+kWn%xOPbcN{WAD44)&S0V z^MQRBHdh;|5uMdy4K04NPZ7G5mc_MtI`L`0M9Hu{;cv?!AG`wF=5c!YFpRx*B5sE-a0sCw2mGmC zRPji2D6t)t?;^LOBDFKQ?c?u@PO$3Adhi2<%7|Tk*c#f9;P1$P5@pc3B6@9nJAyfm z_6O;t4TkOd@sM#LeG^-EtCkPJHrPnwM7pfw4m*A{-$7;YMrH7V8eMkFcyx>UT&wzm z40!YVXTE^kh|^Bn7mgLP`Zr<^VzcFy=zjp8Kw!W2l_wFI0c6s48+|OUj>lRUo2tY@ z2U&rtvjbJgT$!P4)XxFuNFf&cSyC83N~}6cY*ZA9IY-(9!7|41o`$~?x|hMXbn~eG z_c3|!-&c+G1fZY>kfSxcjH!pv^@&s`#h_9O$Qmd3ZI$)MiL$9T_Rx67gZbO!L9A=em@fL2#G?tzPa>6-jZ=EFfz z@7HJrQp$VK;))2`V2UMeDxX*14{c(XNH>P_(DB1C=55{r1K@I;x7mGf zM{;WaWG3#PTu4<|x)-Xm$?Zo)=g<;u>E{}zFwu5ccZkyCW8(8o&|iB)IK$kuCes^( ziR@+$k*k0*PgXtyItG`9E>Y#$qDEq-?0YdH=YC*!7_(^3#KQF@0kUtlNfOqf?5@Do z-FBxNa?bU)!?xoV9kZOI;cgU*IIwU`$DN2nEVY)sW$#q(KB^h*qc@vL*lbQ0($@h# zYF6wwy~!B7kJiNG!ko$d5$|CPP+OY`=@x3(^>&3!6@{78yxtxH#l8q%h`^=5F#JQS zVc_pLMb_x{!ng_3JqSBy8y2=Y)Z~sna6iS&L0IV}s9BTxbPnwJGfWu;4W`Iu_gNfQ zPLF8FO>6ogiIrm}u}sj)Nfl<(nn-V|8X4J)IX&2CL$ij8Waga$ld{p#V)?i`&W}dD zd_Pq^`^oy+Um*wxHW<+houA0C4t7`T48$VSpWvuCM-1f{+0;L!{2avYaaMA~UhP%YK^`jL+8e3L&*sULUf7(oRo%Qm(D{7=4HH z97@TC=6scmJGRAmK57eQ_&llvq;h{3^3P`DIqyNVy<-&|O0~{ zLu)$eX;0<&P9x60cc8n46;jMpOVRe`QfwC6%VUVm&Z#}ANxiDxeb90D#YDgW*qeOINNv(u3ocjAMLull2YlGizb3U51uxfNY%`|& zGQI9W<%yTygWp7xU?O6Bzd<4W4Sq5TTN82GJRF6*f51<+KA?8IK19C@KkYhp z9%BEA`F4K`zY%r5e@E7=NpsyiG;|$vExI{#-4p0dm}}AXUZM_Sy075;VgZj#5oi&Q zW96rqSJ?RS_GMva(*N%i70cOe&^t8As)D_&7i_1XU{7GdGID&zxC=(d{jDB%=OFHr z7&qlWk2<#Inu z1#A(!0WOBawvFphF$xCs65ds)5l;CH4ZW0mVU38C|Dd6F=hdAC5%u0gn>Gk@yZj;U zM{<{ZC1yZuwGR#PQdeyFU_VP@2w_~IqP_E#)XaGA{7w!lG*wXk(V*=}=0KcNlmNdw z0riLfl61(&^!|iOW-qMeKLeCa^>yj>(JVcG!SV60SSjJIbZo@JlUM%QLYL7nV1)Og zbqN#K#89UtIi{KM{)Sl{X-B1UI9fyXl_7btwFNI3DIdfdqpBZuqElvI$?&sr0<0aK;rQ@lD6)xX~D_SrUO4>rse=r9;$)Wj8 zW<}qt5kK&IK%R+@EEv@=r)4c~79K&sV?F8Kq%FNv9ZX9buJ9w3}hY5AGZw9YM z!qTf?_zxc;DUMJUGXdWbbi!`JUBgRo9(w@Xs zP*b~;jtb?POz#U2&_7_VosB~eDCHYaKtWakb3J0t#OBH8{cP_>MU%@ggZY2L0?>>f zMugR5rF{is(8KhB4Ff#qOfv0JI>n+GLh%$kn_y~;Ss5?WCCQe?PmyaZGHr@f za3XHWB%Vkb(ZlBaoOmP8Id=mn+0Oqqp^-d0#e0twJbOzWQ`B)p$*wdVFqE?QZ!Kja zp5qheTBPiH%(XBb6*ZE(%iN*MU0Er~>{OX9$1BzdbL|YAO`e5>53ZyLg-hr4h+^}Jg35aB4XWAou+82`egc~t^eml&M)0rPW2J^!M z=HmnAx0xS>`5Ar$$&}iucQLlgNM_?Bv?-r0e8bxcG_-Fr4);yG55bFz*|9Et^W)X3 zMn_4!;~!~#p(DtX4E$11xG{1UM6Id|)BA3S-^+0Och8n_y5}M4%P0Qf;Teqp{O#EV=XM`1G2JsTY{m1X zC%el4Jpan(x4M_-lHt;Y*!O51<1^^JPI>3NKuLs4-}f*0bFvQ*0(u@ef? z6+E(8VfU+yn@zacjJt_(a|kzwad$9ofN%qhy9#k`vp*QO(1rr$GW(X8eai{f18x_wmjV5Vilw+P z=@{vfAGrAz0(fW@opiD~JFzcUOH$APZqhH;<3(JLrmRQxFW(jRY%F|WdYA!dd5$bu zn%DI9k#?7GkzZ4PYbizr_G7pQ<8jIemX>KU{monmI+#TYa9x$x(hyZliVQ`;TSQF60d$&V4OwTIx$i)gF>om{hfAtTr6rWkxi zYaAXGPT8EGvzbbLm^u^8x$S$Iu3=n?rCzL+$^ANFVlBBY;bMB}&GP)fWr#nC6tHlw zRD$KJBXgTgZL{3O1oq^>VH)g;^~iAUd)wl;#xj_b>9Uy|ExN^YO8mK)Nk zdK2SUkTKpMTLV6IZOc}IiZ&rz4I1kChIB5IYsxj}T5_$q@wv8Kd)53*_;1}HUyR?% zeHYLF;`;=6znu*JsoK9bq|dglAf2cZYp6(2CD)R3Tm1x4{Y+MQd2A;&^*7l+meL7aw-8|gw#g{N<;8~Ts09C#QemWg*rjRt= zHyAOi0s%4i}(rF}wr9_Yi|NpTXlz!uy&*6EeIHVVBQAf@X<~yX`)uo7L;jq;r$|ldk<4 zruswdNZv0{9JgY765h|j!J~hzwj-|)v|$hfl;VnQc>- zsg_UW%Tz~C<;zrOOy$c|=S}6yR98*q%Tzy^%9p7goywP~emj*fQ@t})UZ(1rDlb!| zr^?Gzk(|6tm13Z#)XqR{sfU5O((Vk@mkwtjS^5$K4W*kHXe|AdfmG>L2F8^lc>>a< z4hAx%ZU&l4a~NnYEn%RgbT9+0r4tw!UpgIuVGjkN)^JEFRv9KDvEh>pzH1sb=KP=B zwkx-68;ivpK7|$i$>@Z2F_Ij!|0lj!XlY&IPc3z6Am}#@bC<7P=FCh zkCnlkjV?~+=QP87Ar0eaM*i0Xz9#xFBY*L~v>(R*VaRy2luncu6LqHb?9aA!*NPz$ z3HdjJS&tnLty(Ff60JqIVoUR~k^BFoQ9d$9oK;z&qVqr+$P7V?3C8i`9nCi4+8 zAe&}A%4ez2azB{*E=)SDLW*56bS~!TkC@4PgBUtHz{#(~6v>(|rWsqh2)d4Yn7_I1 zG=ZuP_!Bm1UqCt3#5W5hGG+Hmb ziQ{KE1^ycMYLK`$4oj29%?-_;L4VY10;hBX)OV}bj7y9AGf4};!~*lqR9-9mKq1D1 z<6aTPZCbZ08BTd^gm>GK+8Q}|4BWvZJur)RS3{(vU2dn@s3ZN3^hcyW!v07x!3b_I zT+E0E#%T=7s4sTn$8Z*0#QG1z(j zu?^TLc%>EfNqGX|J|_pf&#M9N^Ad5ELYyTLUsQ-MO2iiwf&l*}874J+KA~Jo(D}6w zQLzib=OHaJp$@}6Ni8_WXB+G^Z`#ud2aZz7#S}pw#_2v>?U>LoO$&YzcZ(e5TRAM!hMXFpep!vC$-R{1`eDiZVg2 zG25I5){kxWCWY-#wNe_zm(n?5xi(5hP&SIcOw&3e_Wxs1w*RK_O_bh(qIfxM>sal8 zc*jSa&4@@rAV-J5kBd9s$* zps+V^?~oA|r-?JG8>}q6o|C|X>dmGb=a(E77Vv;caO95HwZ9|iC{f-f`KX=LXjCZ=^ddB-* zay?`ERJoq;Bcspm}Q3V#UhlK;G0lC=H{`D5a57!b+J=!mjII3MewDrdsI&Dky*P}A?}rk zpD4snB;v;kLBJfDR@3l(dRa2$1)`to*tEjlFL~Xkc-kvjyD$AvuH$Kr$JQZT8hi`~3hxn&@J#0V6- zZF-ks#_)>iNeCQn!i3f=pNz8k7KKyNZ{_BMp%5OTrc{_A@jqcR#(B({e1+Mdl$agW2NDCtZno&u-{T*ZOJrAS<+YFF*_B(40;*8e6AUMkesKVEtO zQ>7KgM*%W9J+Q1sMaA;*X_`NnMPcQv((@lDDji70ccZXk@GZv5`pj$%@c|dqNi(I~ z)3JOf*mOQWON05bF*@9VPY=no`yS26eIHPK#tBq+XJXUe0bdfKsal$8`%<<6K}GmcIvA0GtK~Z@|VHBMlKMzuSk)4lP9~_=Myf@#gug z8B=Npnh2i?#?CEsu%k&PKf!YYG-eFH&y%7T0Md=ofd%xMl`pwul%D5mjHMdm+|mnf zGRjaO+G!~bqoM#k_WGvoI$I=T?z#TuW$p;GaRnm7FfF^z{~RGmbp5AuK-%kva?|rM z$yi106RwpGWEJ<2rI`(-X-p&&9JeY0PirxjHw^`lj3pCPe)k+fCrM+CR;JO;yGbjx zHI%dug~@Ufn7Es;V>SSNRHFoGiDWz(cF!XeJ`+M^OGY!x8>1+p%EmYEx~+Kal&ZYe zjyUcDtx3pnazAB5vQCP-dA}2lYRuhnw-EGTEi_HS*Q%E?jcV!zrKVnxdh0g|@f(SF zULgpe@eS8*PNaA3Xh-TL9*CaCL1~2HXApjoM!a9+h*$n9-7B`e=dgqq3VMy@Hwa(E z@bd^?f&=LgvUAkcZW>E|oXasfwbi7oyd?9c+!2*W0%)H87s%sD)DQm$s|v=%7imnS zIJDlK$R8#*TUO&{OH4>OyT7eZIl5o}<(MZK?K_dQ3E zxonO*gO@(#I!UW>;+J^c0wqJGr{^W`wrg&Q5Z-lyHb81E_evqpaYcDy#h{l=!l_iI z)~XG=SNV1uuj6|lSBO^Y)JDo*H);B9dEWq_7C)+Fo3&x@YLrNf;cEo$BwUC_0KON& z2;u(LUmN=isF#!Jed})$x7jD6zOlU@VoSY~h;K(8ZjFhYeq>77r=TyEx8li|n+3fF zc_D@0WAY(z2zS4W0b%!3&jDIVJ+cNyeCOth66%H7(*HY$xV)9oL zktJp&>9}!xfYOms?!)j%GU6v0aZe#fhW`}9K?C^VQFkplGW>oFk0oP;7UAB30Wq!~ z*TGa`lIj7IKVXLU-oK4haqpidIsd}$gUj;(Qc2v(0NwU)q)&M7qhy~J z1Ybz+qh5ixLn7XlCOtbTovTn1(ZZr|Asvo-H((<8c5g8f^}daZCX-njQ8!`Y`#^uf zPEjM0H8@_`T(*1)dJMV=U82$ArB3l{{B~8;SO@MYRR7mu{f7(vVYyaVr`8H1tQO_^ z;2UGD57I5DqDaLAXq{`QQ0LO`wJ3+Q>3xxWXJgT^MVs6t{r-|PS_|C#!T7!b8|N0` zPDO*Yd?UX0^$JZE34ApGe?(lz#Vh)UoelB?-&>ARzP}5J)H2eiz~Vk;;L*yzk&@L%vmRVjjgu z>#oH2jU7jLw(0L@zA)AU$9_9V7*qO#`|5{*yLR;388}5PhH{z@_td&=XLDk_MB;3< z+ic2*+G|84>i&pE4A59<_g*1y?%A8x^gS%xm$i8@-d9~mdmR~y5|hHK1%2oXFCPJU zkSJ{7{X_7>L22)Pjn9sf4_-Jn+nE)9<*w!9a9ydQLcq__VRWmUzn@BLKG@(<6e<UqMH-f^UL`94dJ(R&!zC%&EBdy9hKGUnw&vYx|+4R!Hp zzYorS&+y-(!Ihucf2j0tn*GH}M0#@!rc~TZ3$sn`yN#xL{Dqcg`Jq7hd?5a&y;-2g zO!*$nZWM}ZQH7#OE-_fl4Dh`@TBBkN6EFikUu!bGgJvaS#m0Rw?g3Oqen7_Le4CPt z-UH2&bnJZaj2`F{-`~k7R&OE-AaJ4-Cs~bkJ0ZN^m_|6X$g48;ZKW6 zv=0h;$QJ8Nz8?s7AAXwvbjtDSHThk%785re?$>?L+_}B@V?;tgr>8daFe*PuKpme9 zW!Z|pty)n<=T~Px_Fcv8W2SI_Ntyo@%0o8lLW4+aEt=ASFdBy;EW;3Y+J^%<;<2{V z(e@}zHrF0P$Cun2DMK__nr_lVjfn9+C*)f@sH5rauJU>`58T-(^Uw0(75d6Uiq$Lb ztTHd0T+&l;Pq8w6l(PS0&Z6l)j$Yy3jj23I6z;EmU9P=RTpo|}s+UO@JwhzFbN^1O z)*qlOWWpJ5BHBEK6c^2-nWiJ$KOl2%0k|~v`Y1!>buvU=*OsQ#ovR`0hu;zOrB-si z0i3$zb9V6DXxwZFp;UNk4e$g0H2dtJvVXbl?+m1jnM;E2Cg54xGwA+xXC@)&xezSj zEZiF}hwxT2m9{lfK26}`JE|gW_Zh!q6~?#f<8p09SHVx(1m3uWX-S%H(ab6OCp&61 z!lG!3%eH}^7vM*?de@|DbmRaX-pD6Ghx+pA%G8W>BrO)h??=WZtubbY(L&Z~?r)|i zQ#(Ks^`(7^>RUzld@7`EJMOdCoyv>Ix?|bhWwbwwp9tmiWVnYrOt$s;H11nA3(n;B z{T!BeBv(-7#|6p0@9BM=+`q4PF(;Ixa)D^~0Z70K<`MV6Z$RzDR!K>#0lX#Ww*JN9d zXZx*lsT$*tH99w{K5iN~W^bsrJ8s-~BCoG=a0r+8*6Nqbys zjFzLaEuW9X<2tnORWSt9qm8~@qJ`MfIN348S4m~>;#YoI$zwn3q=n~BZ@`obemV91 znKMbo$dByhAjwIj#bNe@@{CJM+R-g!+drH$Mg!;e-C|5xz;*f^vvgXwx(#1vmcHV9 zqIsBGzRDvIj(E8g?smN*xLoCk8 z#^am}CK|J;NerTWmUiC~+6-(&y`c?u0M;4Iy=pC*OvQPfMV@}jahV4rB&!-+@S9A^ z9h#gK&Jfcm%jkDwA6m?X@uTB3yN%iLyfBrq;aFauY1rC4C%cH-nwraxRv2=A>79B&1jmu#mm3nL-=imzk@VcrnwdIe`fr55q^`Fh`&!Jtp8=FzmW0q z7uq6KUv~P7p}y>d5P#XJT@1ac);ZpkyKHaD4bV4vu@{M9&Q7k}2uU)CLgkAgw z3~y|ezSWJ_Lf@tChQYjN^*u3!`7N|D(LLStJ+r?N)!%(8iOS6p0O1tb{g=$(pHv3_ zBv)qMlJ48m{i7lv08PYqsKsHk5SBN`lr|?`t@xt0r%aOiD;4WO7GDJHoeu>)gYgir zU?#-SUuk^$nzDBt14d=zOEhoCAe!8In<1Fr>P^RKr9KhK&?0@r^nRrl={W*PKEeZ@ zBuy*QN4HJt!2HiHz1*#y|Fv11Zv%qvIM8>10*Iu_l)Rlh=O}!jli1qc<$e-iS<>S9 zT-@mUhM@O~g0xY*=pp$n^4Fr|e)`|E{q(RX(L{j|^eP7Zi{am! z>YxGUb-uypSvjw~#c8t!k(QsI^V@v>X~p+;#W(kWEG%(QG4324<1Rl2^pSF;N`P9&9F?agrsc9lFdTr9kbi&BMo?2%(GYbrha4Bz z3&0l-(KC$+4yy^VtS~CcDj^Y$bfeOZDFOm!3NeJ4bSGnFFEI->^pq`rFb-`H{QfP4 zQw#!b7EI6^6<~q!`vuB1r5lzn*_6Z(ipZpai+)O{Ks$4%n0yopg~oxUVZhUmABgfW zsXI_xrz4YoptZf2p-^R-pY;R5tiYZLojyYn1ua9o`l+>3MeW9Xedmqx~2+tin{Ykd;YX0eLnhcZ;oo0!9SISTOy& zawiA_&w=AN3JulHib<1w{D=jeb}XGWKx%_Ga-@Oxgs2fQwBQkgXx*n^l2g6 zq(;9YCb;$U$0?Un_p#HxJ98&Vo614Fw*bwPo#=@f>U|uOV5YDG61-Wau^^mD9gJ3z zYVuvtU>ym+1&Bcn7Ol2{g9~kBbVSvA)?-dYNGrsl+SSS^>;s)F?34L>h`*8L@(U73<|w<=*rUac1hGr4S^%vLy0kVZpQZ`g5HB2(4&#$g z5}WVQTA86`SaxigjK)Z~Gcdj?q@@>9C*#`Z`2NFFev5#4W{Q|c)=y@LDKdM=6lJhN4-m5MjRCCTk6TwLlB?g0JDwJwwHa?{v0gtkm^ zPZ*Trfn0c~YuAT5!9$wk{Sybge$!tEeQrB;T&s~=#N$_=EEqMUne0h>i$eTfU6}62 zo*%r~R9X~t5_9ycO_?~4$%UP@u{n{?M1l<02s_#k%DD4Q|Crg!+o+t<5k1wUH zCPTj%gmOGOax7_{re4)qx&`xz18%3FxkhK{yFIunLkCw;Uw4{bkH4hZrx~}wRm{WD zQm>UwgHPy}kMMDG{3j8}3$<2DjgR@UXQ4@py5upvMQjn*>Ew$|o<$OmoG?=<_Yg$Q z^g%Rm_u)qs&9%pYs1?bB!o}zLy^Mvga<#Kh!(~?RHz_9ICtc*DXL#0O*r5BkbiZ1- zOOYHWVVM<){O;LljEQ)QL8kqVU9=+c{Os(M3iO0Xy0^*4K{|v*D3K3ihGPgu($j7o z=k()J8xf`*Zx=Mb_9q)YCHS@+y?eEkr9dA_q>q27wJQHxCxmi$#XHqm_OP}mb284y zB?i|<0(#q7VYUHk#VQ^r3_vL zky$~gYgw#ESTVMZPnOOer`BBCE6cR9{J7{ zR(#*nepe=5yMX%@pI16A@R9SWktlI%w6ar@R)5?nSm}7aE)&m-bQ}*%5?6ZsJi=Um z8NBOe(b?mRP>06MxLpi8_*ST0FddXjxah2}hl;5;Er5~;35(qRdVcxMq+fn7k>o^F z7yFw)e`EJaMCg-AP~4i4R$l0*-qrVFrUnzK!9;3CjA%}!(bE&8(KCb7IH~jysGss~ zcxN2TN?%qCZNNhM_s>$pjo3)}l3+tfyBH)xOvc_UhR|CaFUm>$d=rHcO1MX1n@U+| zjv@jz3&ojR#iOOX1hT?!-rZvv_>CzZK$68o z((~H~4;|c5s5AyaZ5ji43L4kz`7qCvtjUzkP01q6B&I#LHL|9 zruE>}$DA|xOh};y*CNStL~_XbH!dE$mV&TogJBH1hl1!;W+>m>J%4{UrrBohe%;`X zMEc&0W#6TQICO9se){TciuJQ&H~tLM-1o(|eloZ*q)>y8Bjckv$Dcd<;lUL`r7?&f z0v}jPLGPb%)(bNRosLzvzW6k9!PlP$ZzV2>;)FVg^m`|r{9O009A$6`a*q&RJag_F zGn$-^H9h?=b)Uih!AqgW241Hm@g3>GuM^9@TZ{kdo;L6(;6>??9{)jTWOf%JpYoCY zh`ff7uldM!L|#D1fBMKMBF`YC)2onw$BZ9C$VMOeA|m%8WSftC5Rp3)a;lHK9g!{} z`+ekfh-@U}ppV2RHLw*=c9(YZk(&_t1|gUE$j>73NkSgvBiADG9zq`FBUdBx20{i; zYwv@|iwPOLu8qxOU;`n8$FuP;#lZ1|3|`%CMdSg53?9|SCm;D5jP@G$yI6MxLZ0Gh z=`BQN2>IDSo`@8L{ECl!9FcG1I9a;gN8;zw27XP*`+X!n*gS9_A)oS*^seO1gnT8C zCnEockbhFh;u!;UBCcfiDNHH<=~65BV)-*lEuHADEzKhT38iJ^9x3q$mptfrLXoY1GiJit8CJ% zJ)1AbL^ZGYD!peBJn^Ev2ZK+%2)c7dkGs&fVdw#t(l`2X)r=Mra1mTST~hfziyeF) zX3A8fEluZQBJ>1X2klFzv(v$lM1wlzUK}3lDU@#f6iV3jOnC+Y-{t+9W*300=8IZu z2}>(djDVo5Od>zYih_Mmw7@oKf`K&QL{=9kM#KGPq|mD5SZhJV%<}!7lyp*od2x+x)?ZLFoPHi>S`Jo7| zw_NF0J6^q#++}OQaJ*Efzko~p=dJzl!w>PZoLp$3)=939unp0H@7rv|kIrv^+OWt= zIVxQX$z|MAX-ac@(Beuz)8J<{_)QJ|K!fY12k-<9?$_W&8hoGzuhHNk4c@51muv91 zHTXUaeoBL1)8KbCI6fnQ+cbEZ1~1UyeKq(f4gQn{pRK`{YVfx-_#O>@OoLz1;D2ba zGc$mjH8`)qJ8JM=8hn@rmo@k-4gRVIU$4P;Y49T&{GtZ`MT5;*0X$BFr)co(0H*fY z#O;k2Av#M-HPTfY>}l|4HTWwUe6p~2tP;QKZB84Z3zga56;HM0XatHHe*yt4-HuffM?@M#)+t_FWYgKyE` zA8YUv8vHvA{-*{<=LB%81{XDWo(3<|;3G76od$nVga1c^Z`9zsHTYK={Bi(O6Ktt$ zf^TZ1A87Elv|!z!rtLI%Tg|awqgkZE2Ws#d4Ia|qjT(Hp27ga3 zUK)Iu2A4JXEDipu24AnicWLmpy3HdR&5IiR7Y#P&YMN4mr)cp1m$mzBEuTv@c$Efw z8vNM+rY_e`U9NOKptJQ1UyX1F!D>aC?H2s9^QHXWL9ejM1d8MLF$hZJ$E`;z#yKAi zn$BI!Lm%IVY@tZ+YjzX9eZV%`1G$+*CoagW#xG7QUlaLu64{=Uw_aoyAkkt)l*x68jyoWC;8XnCE4a6iZ%^S4<8ma#oueLd0Nna&+#DGz zTTjt^ZwGnX#ZY@l9z$rC>n|M&(IF8N6=I@9Oj3wR5-~v`CP+k9AqbG`bW1AFdYInl zaE0*mv{gy>Ro(L##@njyml&oytLHGh5#dd=DD8eht|;?*ljOn-ES*M#nNzJrT>MpV z$>9Lup2d6KF6D-vq8o(`5fqtKVykCJ58QG=^nX^7CX?@PSRjEcG#t#2oKqA`)}1kBLgm zjXoxpUuFC39~#B}#Zm14Hj2G7znXokkHKd_QAWim0QkkVe7FN9C!a|=3hgjDlx~bC zqY4@Ik%?qHnJDjtylRrR3b!kGMHD)sqZ@0JF%=N22&hZeChM4IJ+}>d3|NBo0k}6- z4bdgxuLi&C94p3?^~ofGFjK3E7FuPyGw?;i7QJbvbGlE;W*W%Gjab+oKfqTt5NQ%3 zw_do|Yv?OiCLi}T8O0~0v0tu)KKTuN*OAV_(xf#m3cJxV`kY`HeNxiuZ%*^x%e06i z&pL9Xe60-)aUcKas=ls%x09>7%f(H5Uu@^OR4ya^`{9!L%x2BkFZ-XjKb3^XJRmmeN<=D; zF8d=X5v4+ArfW!pnA_DL(K)X}owJ>n#trv41xI;qwp;ruwqM+f~soV2*_ z)F!ouKU9YctFZ8>Fw`7=kLsyQ>fUL4Y94%sqP;tvjAWzz9d0*D|3p9A?zBq3j7O_d zCumr|rV62)oAYaBPc_I;HM?I8Q*)x{1*!2A>h!4eH06b&G;h8PF4i-Ad{E8hADF>C z$DLH)C@u4&Oq3#Arn)yUSyshFR|e%RCfyh)9ivzj98tdBq?7-EK21ko&FIB4jkA?{ z%^e~n>MIK6Ud((MeYuam1ksAYwLSx~uRtppm(w^&q2E@aF6IX)ru4WU!WE*)dU}wzceM=A zZAii<7mS7V-(z);HEE~3iUrXlOj?!vZVR;J`F#Lf zG5=-||3E)}d)zK8wCRId0FSdv2X`7Lw|Fa1`C3lXp@=$SfriQu>J%N-a%kL95*gOy zw5#Nst*c@jcCsI=uHp>1t*fh81Mc6ei8sBmBAi^d4$soMU&U5_vEJU!SLyngOGja@ z_AwwSJc?fgU5e-LQBE1WJxye{ERg*R`^8h-FL00b(}w)cB9AOep(&f$qfs3=xqV?ldV4!a)0>-*>!&jxe|F51oH8RHv_-Nw8V`JH1`tZ_S47c}o< z#%Mcx?6i%xbElNZUA{yvsTdejIZ;}@lcqC%;j5BQ>FBq8^u;>*VITct9sPojenCgS z>7(D&(SP#M|JKoe@zLXU*3j?x=vg}YJ*n$5Bx8P~7;7tcLv?wBmgF~xUvlJaknX#) zM*29DqABthUi-YwFP_&M&MW?vu^*QfWh?#-W;gO@_YUhxW<#uRL%1 z9#xci3#*H=|H6u*^vU*osXnrPY81^^7glrr!NO{>J>+AS2-gZMT4C{?lxZw9)SH@q zFu#f}$a>E7C-IgMC9K9u;T?oi7Vlu1>)1@+{i}3Ny^l})6c?n;Clxn8x{THzVLpWs ziNH&kYA{AS%;{436=EL#pP2sKj&xLx_w+lMQ=0h=Q*5Su_HLcc> z_N|DMSsu$zm&7TRTUCzC@?H`>bFHy6D^&SFDNFD^6?|tV=ih(T_^*iN+pGBZ`21H) z(>Oh=I6a!l9g>faDopY1G&UHrRwF{r7Sp*irFhbQK3Rw+NfFnRAP&7`>po%dr&Y;o zviAV#wT73|;T^_qlGqGg#^RtM{7qY16b*E_Lwx(kq7Twv0p%_|1I;_e)P*9uxRE>F ziEOU1qw-2+>4k;rdL?go0^)yhmL&}qfW$| zY~h=XP8*{l- zv>opVY!h=%!%boDNbFU%cN91*mM$)@xmiJ*)~No1eSRNpPd-0U-j7|V)^c%2nvQ|e zsc88TRyx4;l-ztqK6oy`|DJH8A4mV3Fh_dT&dn7JXI8kamOLA;&F z?=;IXdmq-%AzJi~!&PH`TO4DU^xN(Gu`eG0V)N55HJHDwO>gbu;Y%}}H!b_3xFVmV zkt6Jk`tb5K8P>5g4F6rdV(O4=48XG1n{YfcN`-pKOc=mw+*=V?3^ak?k5N-kcSLyd zABB#yL*a>hmVJug1}5+sBr=hHY$*6WcgJyD+3*)$t1r0i_NvOG07I2zOCIK6}CGSbyvPkVmg2s=EKb?%f+UwvfoP6hDlnk zFPrf zdj9qhH?6pn?wi2u9B$DVyQ&PlI~Fp^5td~da`=ayC-Dd*S%vDDBG>4oyjJ~5RskBZmpz>j!6YVnaP>$ z29NCyV1?N9!S3en#%%rQ0yyPU@eV}xAU&7&Q@L#8@{oaT0?L)q+e0FfeZQwJlD)M% z3sCnF1E&C8B%2%DncVq<=i}kggK=rTA>{4?F`7*oegB{_?i+x6V?V-MK`K~ac8U)vNa&FK6=}T?Rza>gH|92nT68m zEUebEaG9TlUAI>tm9IJ5&R17Ke>?Vvv+)Gp#tv}r_M6!R z^rHIizN*9rx0!gPD(y2N?VCC69k-EoO*H$jo-LkTv@Z|R zp0};EbNyCxBENHG)0wWfliw{=?Zj$Lqyy$#0q@I#ezE}3sd&Y3IvQacnBnjNY4%x~2fK>GLFL~Ru@9EyU?7wv$EAjJN)oNl| ze|oG@JwKz;PEnRYyn@(q`z@AtiXl1fuTr*{)>MvdR4cU$b+mucrC8L_Z!c8nw2p3F zB+P`(TCEVohQ=F{ZJ#%1(kYDWOz>v(`avm#qU}_Mw4>o`T zVH*RiJ_4wh=QdH(aqRMgbR{!8l}4z67mTV{+4uFKYwyY-x7hDh%+`(SSEGl% zjJx~)!`gMg$5CAUyWPFry&_qsJKd?+J~x@=ii{;(0b@EgU~JQD3^?@8!ktC2EMaN_ z*rppW-IM?ULQ5co5_$>65CWlz1Og!>AtaCxn)&Ac-t6w&NyaAm^!w>{=FOWo{msmq zH*c!z$2|hOY_N(M28`6z1|KPcZxDM-E#~Yf{N^&aYa*$+OvhC`ihYi7CCDmJT?X&m z;JKfwg5|EBj*gX~kjcZsxEo#^l{8XjqvjkE$D12nsa$+u@xE)BAfg_MsOCj&n}M@2 z{|TTS#{_ODScv)#k$4+sm$wP=9nHcFj@H^S-Rj;P27#jt7}_x|7aNe~P^`nXg9a%}RGNHB8rgX%qY8ccOKZRVR+Qvms;2RSRg-yeZuj}o z$|J~yl|NgFtPjeKJ)R;qtt$W8Bj`n`0Uc}nV2jsv_xfsHSd_Cxu$$F~?>_nU8rJFa z$U)FscAtDp4Z6=ei+kupclYZIqorefb=JO8vZivaYa^m~pkJ6>n_^+wpbWX#G$3ok zb{}+MKgj6!j7(Zr=Y~TLt!nkR@7&osM;}*imeh0?I>&3X&3Wny{TMH z7|pqZ`VL$d%1SSpbz)rRC9_V9OV^8W6=$Tm@1S*IT)AG1^Vf@U-g+^vSTDxq>%~~b z7%hDVuM6W6!f0vfJ7irL*Lt;n=(;ej^M=DZF;=e^<03DW!`6jy;d(JHSRV$j)p6nW zPFk1I#2L>d6n;~uuwN+utwVOfl7QLXQtE%1fGkr!WuBdvs7AgvX+*8cqhWvTZovKw z{biRg5hZKS483Y8c#!99xoYYDinr~mr3Wb9>{UzA>zjRVdscwZd0GODg9GoHg!dTG z(nAz7%~vfw)b}nu%&*s}a!%_z1-vyce7QR2tpE_TToBwm_e);DP_qzp5}^0jLZP6M z`&lh?7vMfr3tb54y|vKO0KK~w`eQ)vtA+j&(0gj3F9P~NE%ZG=e_jjy9MHRJq2cWX z^cS_zjR1YH1}gXSt29}Ur=lLu7QWmVu15d}TAqRUw<_@ox*MQBsf9wNQBFt-^kCrL zR0}-?(3@+amjHT8E%Z7-uc?LJ4Csxu(0c*Bx)%BbpjXvG-v;!`TIk;ay`mPH+(AGu zuZ4~WbX6^MJ3ue1h3*gNr32~#&`WBe7Xx}jE%XLJudRjN2IzGI>H*Nzwa~`^U0Dl# z9?G0uaV_*cKrb3lXMkQ<3;h<*3u>Y99R>9KT4)oX=hZ-QzS%9mr^)XU`RxtM zgV0_H=#$@*y?~P?V5tXK%3YuAw&uLE(H^m}77ND3V1~!w2&q3hw%jIiBkjsG@EA#_ zL($QpP*~7A31p6!W?Ybnbb>q|0K>TN0)w9<$Bse8nY4@HO_H5XeJ^4azL~nOM zi(+JYPY56SPbI(`HVaWsPK?1XkAuwR8c(<&wa%;D{U}P z8=mCxO(WDMIOW}xFJu`8l(+_Qm#oyNjcES*+i#fw_f`&0*tu~N7TLMF364DlVmvz+ zoxfc~I9`_jH_3l8_Hi9yjF`V&U5KoC(f=Xq_&-3w@%}|}oBase-+k=df(c{n+*D2t zedM5;e}U1lu+U}a_U)Kw=azKrR@kVz4GUZ4rfSXssNqRkwiko3(2@{X~zCM#|FL39jAzs|U*@@a0AQDj&hiNLvmt{~gg}9n#FcJzU zSjCu@yMvLA&~jhPTp_o)sa^9lCdY$=TU}d%QRVzVxQS+0mqgEZwfO{;!Nwh_K9{KK zL0oPcJ5P(6y+^gP#pF6VMo8C`O=8lu$+(14ki3W4rDfyhz}`DZ^w<3;DYneTq=QgvM`0yT?K)BN-f+Kk-o~Swd6Eb`}%ntUu zZi5$dEhF!wL_`qvQB(#~w~#fQ^uBM)}>evUCQ z+gWUo5jwLt*>pb_1e&|X>COoT4&ICHrn3l&Dxy+iw&@-Z_X%N2#I&=nm^5Q^vT=)T zg^KQha~7YbIpraYBlinIbc&dyLQFPpm4=$oWAv_LvL{|J%X35_;$}sR$(Yz7_V}rt zWV-KxDVSOJkK!wz;aDiJE!CE{y98>7{X5k~gNMP$rs$ZY!4H95gonWDJs+M0>$0QH zgHfEVM;G@eIUT#hGHpufE$8?7% zhBFLN&Q_!7z2u#!IcrEIX_>)B9i5i~?=(Dw`*PslTXO|>jg>3tL@OYKJvm%$qwyEs z9n+=fpl`!+RMxqiOgR-xrZfS$sxI1{62&Mcql@r$mxg78yszc-dcL)fAjiuzFBWN* zf3_n`Op?9SQ&0%9rvwHS=y{qFzc54eZLuPcb@Rh~r0-eYV}`H$S)MQ4UV*BSPecDu z%Icnu-Zj!JU!p|Wah*{vR-@b*M7em~QJ$IMMd>rke+!~KGf2joWX4vtw@l76uod6cf0bwg1B=oI&}?=<%E7|H4O#WsrA6;Y#L>|qn8APW>yhe zA^W=|u_7#=Aew|{_MCGRs33_igO{}= z5}lwXdag_qUkU-`FICEBls+~-$5$nAUa+P+UrrA)t@C(#IG=}&$n!)IJL09OhR)P_ z$lC)Sp;2jn7-n^UIo(_c)DN_t3$W`DbJBJl962`=Rxm#vHY$K=EWJ_yhw3$ zzRwpgKQFpYWjj&Y#d>Ga(uPJeINC!p zS}9&WVW+CJ&ktg_Kf=<7N&)@`9hUof-dOVzif|YB-&rVu-FFFAq=j9zH80nOTuLDm zv^8sLLoTC`woLh*oiNn5#U%L^l85C!%7cIATaYq`bSzSA(w!38(Je;MmB)jt7lz;^ z?<)z=83}Yg291~hFXI(z<6Th`PYVt4Z{wE4Oa~G*fOzZ2(NB$5s+3Uw7R`bTkV_&V)vIH5R0+O)*>TI(WdO(5#CFE z@8_! zkSYIOWMt_TG7ndB91I-!~6eavrc+U3!(DhpS~CuHigf3;L_oJSdO} z10dfw57%%W&PP35>*ry$WcKGXBf3sziN2#eK(OMvUWU_`&Rp^C!Y@gGhB`#rxxmZM zA)hmoeoqY|>0I2!Y{_ zMx2|mRk8$^g+pKSy8%&~{HSrQvK&!v0VWjOW6rq|dR&%$M&%SQIR6pqZLeMYdc&KN zVj8#@8;geWks^RY1(Oz`J*ZSY?Oqc0Y=xgA*W=%xjFPcw2Cbut6SW>>s{3syc5KX^ zMerE>i1g`P(jhV*X4<_J8IfK?dWUoCVj1D51K>?zX-|Hl$nyhq&xJA8{1L0apfbh& zqd8;A%B;6UGXTN8jCtU2?gR4N#iNz=XuZEaT0n4DNj4lBG(R7#j|LFj%bCU~E!+E( zuqUV5RnpRW0Hd3qTnkr(rBw+pkw2|35g@o%aw1+`E|+zQPKft8(L#7o^D1tKTl{?B zF42Q>ZvJq6DFMN~+N+WQ@&CNO_&{*4sfvHF_&!AMyQhp|gWml*x|D6uw`5kXML*OR z!51^=Ber0sdq@N?f#7$X(Ud5(v)h!AY@(1d-PPD!({F}uL?vubPvi}6Ev3^Omv*l6 zc-ED>tdnQqcDc{9ZXL+8Ho;K6ojA$u9w({zoaFX_Jc}aSMiFk4JnOb9o`t+ILN(8# zh(D!>KlM^tq6og9gZ_?`W5 za8euI4+oE5(+^=cdXe}(jQ1YXb0V3!`kLnhz6~0&blfa%>~roMcs@|vF-Rcdd)tL~ zZlP6ougCWDx4Yo|$veXG{mFPFJJ+yu=X`-wxd9@jetm3zNWQghhK@Kkq%Rg(gNzBM z2)_bK+mT;cZB(x z@!@!qTeqD%g+E|f%+wdn#QnbLiekx#iXu)!#hy)FEoqc=8!z68Xu>1n-xZdRQx#GS zwN;@1zW4cF`@@dFlY`_l$XOdb7XBTy-ogF$yTjh&nRgQRc9Rth18eSmA-)Ntov{))9P{y`M%k9w zmiu$zqlHwgU|VvCLcl_i_<3=9Z+!s&7B6xIJ&^pv_ z0aV!2NzZ-@Rta@pSkf>lF}=n)F>&vLR0llvRgmEOB)yz!258{Lm>OG>iJce z-uNPq?mnUhJz5p?m>TprJY!*l^9go|&GM6+mis`6zfVd3)AIWazK?3ov*O#AG(tvu zDLb~WK{(c$N5w@+e=P#qmm&mja1fw z#{^MQ)lr@l^<@Z0U%EPm8^lOg$9PqvF6=}QtEoEHu|ce+>R5a}kP`jjS&XOdUOEZD zJ>7dlbnBSbU86+!ugOjb);P;?$`;eaoXURpWkK1j{03FJXT&vmxR&%xA)IxsFuh`+ zyRX3Us@BwdPuSD^5bLqK!gSDyPsA zZdylynEPAob8bX0J6mH=b{;3w!@t0FUkzhxE%L%ypk4B7VX~sr^BS$)@mLmI?(YD; zUxHioWwQk96pZ~epRre7=WW(&)EnO*CZ1bcc@tHv9k(+sV!!19-&TPA0G2tP*e!Bu z?+}sShv_(YKN(o(5&r|j`y{+x!VULb1Q=_Zb`ykQomU}dxbKC@h))1>N25KDkYzHR zKk|Np!rzwz^8@}?{v_M1_d{7dANth;m-}acPnF`*pbCxL!8}qn!{w}lpNto@!NO8!0Ecm=vE~UNi zee(OOaL9j~Tu=%n6WF~E2cw}f#uPpN7XVcLg|PbrCvvQ%dw~nuSmiD96hJ}RNy2-lb>@(`ww-i zFM{9lYXXrh+@{?x3Gj{p4AGsh(8<28LC<4--!0O50s9T-F_`?svvs`E&pMArNqVxa zUjE8UU#umxo`;ADp}g)-L>oBoV-6|T?ds!*>G{uqDQWem;_`LeX;EC5zQ?<#;_2A! zzkeu|p*@Eg`jOz}FX9~X8=8zcMfXOLRyn&Xb~3)7Oqh^i6_d-}i(IfjG+X%X*}i{o z_8F54F&(;jR7_t|wj}`iIt@(aGH=coy`J)?mEGHQH17)iwpU zAY`pDQ*jfZtt%kI`3QA+%sT3FPqQ|F8FU?LW6I!xK`Mg;a(ZeboFP3o#_1}g-yHG6 zc+o%690}29gH+q3&r8Nu=!yu`PET@&4%#Vr%YIF0T76j7of&#b%&0G6zEe7`5zIk6 z5+lJtOB9BRT|5R_olbo>nvO)30j2SPdQ+sYsRN2>R=$X_49WdUIPik0=xUQs(l7zI zLo_lx9dSpAihu~Bc|P5##I}8w#$PCrPM#q=YJSVljR|HPV#7Dh4FJT49{_;V)hU}2 z`gnk5wU@?>HJryW2?a9|`IYIYJw9;KquxTPjBi(-(q<#nf*DaQ;3mQtM z$&ECiiDY@FZvO4J-y+RKRUixh$QpltqUt?rHx&;$DcvfTopeZYh}z7P`$aXXEuCse zHgwMg19}`G>`o=qsm7!ragONv$)tN`3@TN~aH_F?1SzmlA=Z523nn6OpDyCBZ5`Wx za*%twB41nk-4(gDGTKwgR8>XlT1`c! zlj-jLP?30hQ@T@4$tL$fQF|kB#d;zAZuShq8JwHGFgJa(`)K%N(y6SRLXYBasyW$A zIw~S*RGYgGrs@vylgjYsqc|$rECVaQgQT^E;aalAeGC3X$igtCaxMpH0_R+g|09+)D47z~V%UcV) z@&UWa1-4#33jU>m|8)2-_5B0*l5FfUw#2szG)D`z#Cq2GE6JU)&pcA2yDemUE|bt{ z&*Ki$&|`T|%Wii#_#(Yw0!cpYX&jQu9YY}JQuJ%X{VB?^8as>?;-~wU801*G{1Zc3 z>_+e3Eg+9Qu$#l!!6P&&E1j~FR?-|FcMN3qF>FNv7&j&v=^h7G)gT@2U0^46A?`%{ zZM{z02&PSDQr4OOsN59GkP(_XgzKU_fHPvjfV7iIJ4!=2X}P~ds+j2q71M2)_U%TZ(3wx;TmQD@62reEGrS4PovuSFZ{v(Cpfkj1nw#;n!@IgC3R zi{Se}U93ThJBWFCG)~%kd^@-fgvn$JJzTck!JO=JEbx9*#bI zXZg*@@ryU1aUS+WIN(?K!x*0?5VqB->3HxR#QzXU2XbaCn16${J@Z(zvXS^KrY@|z z4hA80l$ZVPq>qSM0 z8L^NR0W|;BivT!8z~OWc0@Y+hW^;>rdI)&r{1wV4dhcYYfpacstY+$TcVi7ELYjFF zp|KRtid7uFN~C4$I3n)@_)f%BF~Wl(=;mqZp}Ped9r$gGG@D`|J9lF(HCv3_B9dMM zE=aXC<%y7&3t9m)*~4_V1X5;YCoEX3LPpY#qLF$grnHeNsdaKcH5ouXoS~jJ{ zxi8tAor38NUGnWDQ@+VhdD0*Sid7XT-YOD_d5Od+kpjIu?C4h1c>+^=qOmS(TFHcm zRYzFSlIc-G(Wjm)MnYchtv?lw@mp#e=&};GiG*esZn?C5y@ny?@LQK!*Uz3zSn(CL(fC)N{({ZxKi{vBh~=Fbi{S#_^d&(kL~`7|u4x z{jZ4q8obVmnB1X{$YX2sKZX&e)X2Gu#YPOS!$|DAw zI2w-zKNU-M+OQw!R}}cyLCj#FgVD+Blq!C7glHewu7wS-R%LzT!5f&h8v7!A|Y)x8vG9tAE#cIUa z!XIw=HfeYNcQ`Xiuhr?v@N`V0?bI4E)k#h9F4Uw|Jjm(>%tK^f!gfDFp*Iyc-5of) zz|%72cLkr}5Y{N)baz#wyuYO`Q(hrJQFnqrQBVLebe5-22~BiEEf>%{#AiFN)7j3W z)n`H%gz0SOQ9j$T20Ig~jrZvW#(RU}JyxCGr5x`uj%RO3yiYeU-kTKf@#^$0hvz=cu#V?_=d#$bOYn{Q@p3D z(_6{$p5l0k4T<;Z2F81b;yqoR-X$FGX^vO7A@M%_u6TQMPsUj-zPjO_8K>KL)ZqYr zjKNn)@Z%EvID^lY;3p*b2?no_;3p;cNd{ja!B0u>Qw&}y!B0!@(+pk(@SYW0u&AZa z;9%n5JwnGWeKyQTyuX&;=fZqZNgfOXtQoxorOQ=yCf^NvUgE!i?*U$j7U@NRSPu5S zAQ4`a-!-*}FG|EU65%EJeYqC#C5ia5MEH&TzEX?$8;M8(w|l3=69p6NeFH(2NpQXy zrl$;Er;<4%WqIC^MBkL(x5858;VlVxU4GxjceO`+GAO=H#HYa7A2{Cu;@KQQRR2^u z^FX+saW{jB|yH z&;H1K@%;nqD^bKi7#}ZmSR|PfQv;;%tsPNzGSQ_1Y-qyHoF?`bxO4R` z&W5mHk7aOibqCENYXP}&T}`HDi$R;mz7*?rD?2Yy8102G>}uv$MEGsgc=>2CBq~Qk zHA98pQA5PnX<&C%ud82&gjz#_g1VMLhq3-u|e6L z6RC)8U2Kl%6104oW6XB9q?#Jn7oc)J4ErpEWO2^9 zHTuKTd@OW$a4f`iHZrvNzPuzuU)x`N|A_Z|ZbNyu!H$EgkACBNmKRe7f8!P{eRu(c zSB*p!(DcCRI410*$<yZN@&`1Z5Fg-{9OC)5hcBF$9K+oK z`(v)1xIVC!5}Me7G#X9;39(&N(P2VSxp+-k)FD%LMr=6Ds9Xt;8QgxCyIs~TeCm=IVwmh@0IT4b`R zIxiq0w#+gQ?3alLbvPY1ENJh5b1#c`2{sR4IyhpqRD-D72CCbVnQUmDUl3k^GpS@@ zOtN0tap1M;WK!L8B*mTsFH$#*f0cVjvYurR=p&_3Rj{nP3kHDn;o1a*Q`|KR1G}cl z{mUbWUdBDt+vspPx4iosPex#pyy{OFzoKSQ$??i88j_~FD}*XXm;L zIS@h3#g>2aor09uq3%X<8jE|AL8ph7Jj{%6q@+Quo)$fDcSPTVc1?u^jh3^gMz0E+ zB}cRlmFpLRe`S|<(Pd82Py7zB+PRyA30Zm3Q--a^SV%^aQTHBdGyz5d1nIp{uU81> zX|2s1<1|=%`VH?DUtSTGX^?D8a%sTH$RLpi~0Q7}FU?`hSN~r!EW^-1snJ z77>pb9Zn-NLUk0!68sAis`F&SOV`@!lPI~I8GuQSBr2QFCd{KiTfTO(L9B) zVuzMtq@FUoIsR&uibmQv@VJWrF?-80m7`@UN7tr80cUe0Rup!pTOqR>TDdpiM|Zn5 zem?VfKS`pV@0XxKqq!#_YmG8&ln85C8_ui^(|c6t8?!~3{z7*kKqTW)J`q1B(VDAG zETR^pH|RD|F^zfdQH2)KV;XfjD% z;szwZscdB73Mg%m-pg;j1~8Td@-0KAd8}6-L3Z3dV58#;v05sQRlyi7%^j&)P+J%5 zx1cgbC9TkC;ZaNM3UIlr!0<)6&-KdqBd?6hf-;`q!78YOOVvy4R^EayVZnz8=6v0}C$N;Vn$WVz`^p=k$)>aNE*fT)wb1mqLG zr>eUbp?}ZJ#uOG7x1@#~gzJbuM!F02jMd7=acTCokWY}hSo3UZX!Is7@qxkl#Y#e@ zpkjv^B;87{{ejR}Qz6bo+Q`jydTf|<8j>D!rgD_>gQgaYEN2Q9?$^=Ls=>T_y-_Cn zQFw?B=p9#xpUMijuD9qcVWy6Of?xT_Cq1tjZ>E=T+cV{t$A*qw-JT_T6{|Cel#vm; zj2T#@tV)^bI+-ET0pfF?x@g+j3WqEh*3dM|V8a`=qOLbRdeHmbD>ZtLR|Q>#Le;>i zpfGk6z>J`oovT4*u_1!1`zDosjxn2G3s*zW_Ck@b^9JVY8kuD<1(sc2OQp?}AK63R zw}fZ(o}P#2E}UomlkRSztjj@4ENn9FY7K%P|54%Izti&cGL!7uW_v#gvn^WsuF!fA zOra&QzXz~r$x!yvd#JEg@hQ!{0O?)fyx!a~UvKHygCQ}KM*n0v>QnN+Fj0r8rqw3d zJ0WU%(bTgY4TYhabFBi_oNH9y5`5NXzQzGAhSZR-;;Fnxmr8KI4R!Dt<;yRIn2N+u zx=yZQs1DM-aZMB_+ndnH+EShP_<{Ohfubt{N?kE70SOO~kbpW5K#n7Pdi5Gz&A}k) z9a0tKUJe+Cb5Ot5(;&WL+>wB-H;J&y^>6~N^#EW#Y-vi z8iRNu+x0U0L*%!?D@KC^Bs~B*CNe-L0YQGM^cn7r8r_@GsL}r=Z5SZT{V^?4>%>a* zCa_CGE=z9)yZwllr9H~wF0V`LL#+<4ONVoYDF=-*ODPYKl37YsWhtd(DO8)M)c;SO z(q0zQoG0fNs!!d0TFS;DH^n^pZ<=F%0?Jz&={cHnD`qadO?w+Mp=*|VI~H}9VToWF z)|_mje~eruz1h#*m$H$`GZ|5`pCTNuN`wm){-$}{V zo9hs$*D zI?5Cni)+%@77e~!&7S8e)$^K3#_q_YyT7aQJzwQ}1-^gEXlqO|>=St0`%pf5O)r4` z0?hj~(Ylp8aV&MJ8aY`TS*-s(>d&aupBaSuGv7h|8I}4o3iUU%%3HX+*G$9xbvRqd zc|S&etEODQ&1iHWmX#wYE9(+5D{phH=;R<`a!!FR=oiFKK^A+gH!(Bd;j+r_{eG^6 zb`jq%ah3s&6Ju=mRvKfYE$Zh9n@dq=E2W2RQ?MaLb!zjvEJxyPf~eM3pN{(gMQ9;DO@zaeut9|59A>SHurZLZ5fF|P%}91_7}_I| zmW~Eg!V{3TTDJS7a+bGub$kE+7ckF!5jw+PQ#$BuF1SZsp&?4#gXDD%E~rMii9YO) zMT@4?uC6?&k@j6Wp|reM{2r8yP}`?Wt2o3Kt6t>Ay-uXtvAL;wMYTSJzSmND7=5NH z%yNIFL7p5y5>}FXy8DPmvUSSQh5d&nBSpGWL-I5#rTZw7w>Vo#tI?)vD{hgri6fOZ z6%Ozz(iYz+8KuLBoR+kEQFlqPKOccra+B2_$Q}&(Q3o zTg%Q8C|)!3KDv z5ylV#m^BL{ z#q$0&bn5;EnjUdK#koy7)-U#!?q@i$?%y_3KFQm{iGT@lD=-yaY-i6Rc*Jx@Hp1T* zWV;ehgTS{dzsH_uZL9JY%eLEwCWyj?$Ko;gdgL*Wiw1Cw6Tqs z^~_5Irx9_EP<>j@aAM!DA@f*Rt6t2-(ET_S^Wvg9Tnfm7C5#Tsb>^5buQQuS>en8o zb!O6}D>DhZD5jvAahwdb7WlsZa88QS*bd=g&-OM4P$Kcd5Q`GQCDh+(Ffq-k{JB4A zQ7U!8yupf?>iphT^3%$BYx$g99gXk+kF!OO$oH#;B=u}X2ar*1wH>Fy+cGI(sQkg)8FTDr7s%r}JovF1Qjk6Ku=s8MotYF%uI@!>3ZLGvKcN&Z3CIDw^E-!>;?nH|f@em1$cm;5@Pn2G_uLkfg-KcdP*#BQ3Dx9d%BW0pvi%DhRn>O zb_Rts?~RY=u1#^eAAq)fN$VMha5*P&cy|lwKogo-S&jrjq%et*i{tpKoBLawAfPl@EWm-)a-pM-^?cPkM8aE03Mc#(%F_`P!tSqF4)gd)eiVhVTrHG0Rg zu#@So51^R_I6PdNzEtP>1-Qg7rdWZ#-CTwz%`e7gxsdi9l&Wu(RJoFy;JPumoq9 zurJ@n+a__8eR$N)a;i&cy6w!Oc}yu1muFHa=F1}Z?V8$js*;%Xy^@f1))|Uz9_WegE53DD zWAglK88rXqvoX=(GKTH`LHN3VCF;9mWMYLn>N|$}u7Gy_0m3&%X9#H(#SP1S56dO7 zn$1|wu2#s`3*BFiHN*WQ_AHVI>F#c#beZv66tcSE%(h7Ru_`l0y^)DHyMdFvofkNB z)`uh0!&^f2;1ljFY?#V*XP8aDZNsPGgVcd+9W|(?~p0zY6>CdbBBuW5YaC(I$10uAt#>Q zfylbubUzl}cCubZ+x>Xuee9wwSFo2@U7;!Jj)M}NVT&_$0kmqjqC2;4Q2rYr`gvAxg;$%sVARIOJAkA*5) zC_)G3h%=OoR5Hj>#3ZYxja9`X3mF!Z7ggo2XHxbc1+#1)P z=4y*Bz?th3yr|ZHu(oI=y(fTv=Po7K9Bt7h1S1n9rxI)nZPCSu)knT@+M)~L>m}dF z{$XSJ3|C=O&Q4$lZ-X7A^NM_$&=o81y_!`Nw!k;5!nBoEOtA0z!_jPwA(%` zcbmwTdDG4zmXrrYLM@`=Qs5Z|aY!xV?8ChNFEnLnveWp3t#-6RtnJh&_Us*Lp1#88 zuTxHgllB}K?6faF1$;NFIa^{-D=?WF`a`tQU{3(jo zg{x%5{R$87^=DF+&TZt(jMA9;T@6d00y|D7wL{9D{7*EEO>L2iwkD$_8SRKCquv$# z_GFY*azq%l6wNms^};)kq3F7i<_;s$+O@Ut`XeG0D>No!wPQj+Xi&W0-;|8;rY@e0 zi%nfz@=4LBJ?R|!GwhNScI8nisE_2KSdaP+L+-t4ZO{+|X$Wem4QfD;4joyW`ps00 z6|QZy>u3?HK4Lrj%5~OOJ9B^jm6R4f7plICJP$9oi|+~HY8xqEvYa6Ft#U_sn&!kI zxNL5A4z}og)(kBW@HECU#7uJol^yB_qASk9VUpMb%r(8vp*L#WIqEds*-eR&5box- zW}Uitzb)7gBKhmoVWA0gLpHBdO_~kA3CVPK0hJq>%GQ>*HFGbrWGb`#aJ_bgQayD7 zc~^y49j!;vWrp&HGnW@NQIFiV%9;@VA@H}fu%Fi|+xu%3TF3ATr=yJ>tsR4`dGw;K zwbHsuu3K7t8I@QLWl3HqpSK>aIY(Rcq}pGx-feaM#-EQ_c3$-m{-2Q4zxN*++wJ{_C*X!y#{DP6+5aH9 zJ|PSjESiaN3w$bx$lP?v6JmVbk%lkx#+~~n+S_l6z5Pjal`tmpN>C(Yqv@OR>~+It zn5RU|K8ayFQPh1MG}EWx&Iq_l6tBvdY|eaND7;M#4rd?q#WaR$M@ch#HzgSXekEVd zg?2cEA~w8U$)E6zl#=Fg8i93Iv_B@?h!yBrzPI zm6tH=$`8@G|1CUqR%uI~{!&I%2Z@tN(oAnNeC9BQ5LapA(WU! zpSUNQiCXL^J?P1BY>OTFOn!x?cWK$YPIjZ6>u9jkxhwp-bDl-=6OG=}p|Mws?tW@` zamYz`@=C*G;AcVLXI@}YAx-5My(iR+@{3YdKEpDAe(MTjZ7!z!FKhv~= zU-SC{9o5X(+{~xal8^c>U-gZ&9IJ56y@d_*dB#!6R)}|wX6Y! zow{)1UEB7(@Yu1T^Ia6hW<6K2s0n`TDo)0)xu%SwZFo?%0hqqQv|sQWGolY{OjGx= zqq~;w<>v*z$zHB*GRCZJNQxs`O_N{pbL*`PS`SXgM$oHOt%qbeacaF%ljfKNGIgav zGk7-`NYtc^!psixHTd`iDZ=45I;-23Qm$@WTi<}Ty^GtnL~R>I`Kf%=wwy3Gb16&> znWkoSVmhthbe-8ed8grtVN|Qp8;5_f@2{=UxU9%{P?47e6$z)47+8_#&}>C)hhE1K z09rt$zZF?W6t4o`5#%cniRJhZDprH8>IwnoCIPxp1?g_1_-*P~$F)9^Rd;&wWT_ui7_M_<(@p7e zr=V&CnXK5~`Fc(2X?>u^&wf=HO(3_5FB}kr^eS);-xl`ozXYhU!i>g{lhI+GX`MG) zKT`Z7EruCehy}2xT$6ZWo*4(Avx@e^Z=+s;__6y60h@Ohr~-v+m!&^7V=I zsyjbb`b2GV4Lp?Az)DHB`hF#8R7=ufSc(48UI~6)TY^TNwUnZwBwUU}Xx83bj!v!8 z0=`C-?Ri>x@butYEby26(}rjzQ7mXBwR(ib#-WwzI}Lc}XQ)?aI-MCYAE!Nw_pZ&6 z+bHaM7)UIk-}bfEaPh6=#LwCc}=$9dNrDqEtDa*3G+K{0TIJ{WBdFXx?%{a*Vku=-AwLMjEaj2|lw^RH! zhH!ctD_WZAcIiQ!Ko4ir>ikPRoJ~0&-=V*=X?6bB74I0vME*DB{I7)+H)0MHHu+=28` zOAoRX82uFcP2YAPS^Av9-*z(f+3uFH`IRvj;AbK@zyRnZ%)G_JEVg<11O6uL z0frFkqQzvCtztx@wr2x_(XgNj(1uF1bktT;;usd`OV0|2LL;cJ?npJfGpc%j?9bVH3mu3o z0SyxUmc}PdI>t{~TGC1yoKNL2pOQK6#nW!>e=k=THqSRr<5RKbX zE_IYQR(fV(YrVPFGm~_m`0GyLnRX`23c0Fg0AVVB-KmTKcb-#(p$SSEiUOrZ>3M?{ ziQ&#)p!Mtm#5S#GHohtTx|``x%SiXmmU0NlTVbl1?=+%C_)epA2bb7wtq0?{6qS(+ zV?zE|Mu2-cZuTIg-%p@F#Hp6*wQMiSt}%vYGMrX&y}NiaR#<*+nITrS@(gaK=({7) zcfHC6&yadOTF-VQe1uky)bY`Jz+hOzhiZBX6ymhXb=Z&2@T-+pm@aX9UJb&mOW9??FY! zFY`-jsL4IXAo~-$Rkcsaq_!0B-MwnmrL0@0TP0tjN@s*w_7n*n_dWA7#>>w<`lUEM z6r~3-DmO&@Osx|qW_!9$8oi@13jJ5_-Hp>nB%LhHGFM}rz~0>{K7LD0wS~^mohm+M z|GAe@E_V4|u_|pND@CwMO*OHjFZE~J{}DYD8ck!!*%gysy!=G4lx0gEBxz}IHW4v7 za3wt1@yB#$D;Ig&1!H-p;A)ghQBgf^4e0Tj*q=dW7Jp({yQ}`U+_A zWmZY+)RCmv>|~SjqRngliK=I&OZ5WNIS#r13vzGS?oFUeM!&4`^Lu#~!8Do!1+qI| z$7x7ZnkHtHEwN~BR`IR!OTOE7uYt-Y*wZAVH?h$K(8D}Kr3BTuaz!=F+E&*fTq51e6rqq z#wU*FnBoPXL&79$S3anNoKpqkIUn8xjZE5NPmrBIu2bU3k}V2KRwrK`{C+P0j zaaE*=OlNC!gR!2$%#Mz>@*g1PVL#3z=K>2ovRE>6?e3SzqFMeTKytRhj`Y{al^qTW zWy)ZVp_~@w4(%pGBiT_o!T?c~Z z4-#|lfoKN+v}YCQ2%8U;su2$v826xopo0g34jl+OY#`|HfuJJ?f_53CP_qW2%^3u3 zw}EH}`g2)?&W-R_w&sP7ZI!kIH3vG|tJ|}h)8U!vU)|oUIpc(H8J;>@-QJ=(n`1v= zmFJ6?1+hMc;`eH22i?D`i{~abBH4@9ln?3MkA&zdg4Gm%`&QawI;0N%tzZDHw9XN= zUu-a46ORcxP(jBWnE}Wm(B>-0AkZWg6e3WE3epI)u?mV1Xq*p9nXXNsjch532Gq#J z`=d?q{>WJI6S9JLRn5?S4}~JAD4ax2lbvQy98;FGY+hrjHw&AAFx<2O`K}yh3#jdC2G%z*(n^Moc&v9HT79#7UrpYBX!hvn&H@q+WIDwH z+u4)zkRhBA0>`1X47G!^kIfe=kZVZEO<9r)1d;6lYY`6rd9gKTd17%-KHVneDBIv} z?%F1V8(s{w!VQ3&f}d8pZWgjIk^mzSvvMG6>^`Tz=!AjCf-sA6DY)&V1XCGfd+mW-B|P_wN^sm4L9UI|Js1NJdwk z)lEGe1)c666-cf!$UKHgu}v2dX!^ohiTPGZv+`2C2G+|v-)f@cpZ(CdS80Qi(gPZd zhtswnpj3Kg>;}dII=VyF*^NaLl@H=xoo_s#&IchT=V90(Csu{lPLo;%(HQqVXpD~2 zBZV36!-KW?cgG#ER7BwD|6ST6{)e(P>57vTg}~B zmv8I@Imxfq%Lj@j4Zj+yITddO#DMa0FD!qyKSA%JlLEsmd?LNO(s9mgDbc4d&0(&n z(-QF(V3cqq2S;TN_|{w;+r+iXZk|W$A#y#SopyJpipGAR&}zE*5OG^Vv)ny&=soVK z`$n1itF2vd|CkmUdl1Wpw&$4cUMPGc=Gci0(XlloJ6Pm1+`V-^z~;aOd}hdz_fb82 zRpIRm-z+6aP})yLUkHzviyvUGbOX+qC1jC}%{I!KFZUe;7C)r#V8~!@6)mw80D|UM zRrVLy?G)x7K+Z!vXMjun*$y2Z=5=nGfVtT6BHqHvlz$;wv-}8ta`VN{uHvV%iWk4- zlK?pxKVRWzm%aV4=JF}RQ$80zf5FeB1%6mdd4cehPr}c?@H1y0KdiNUhVYb^<45f8 zk1hWp2x}{U3-IWD#m_zX$?WHc4K431Jmr1xb3cCUg?`wua)t5O^Yf^aDf3rZbhxWd)re zyydg-(|Ax2uoSHTu{oaF%Q^?@A-0Tq9&fpviwJxn=DMuz9u&;;n6o-auV8hEEWzTW zKI2@B1vKHuEokjoS~kPcMrlk(t`RYXjHC0QKz0=`>|l}PDq)k{$~_okMv7I7wtJNg z4O`p29s;C8&>s)Qs925L3;Au9@o0W7&w+# zcHcrv)WbaV!z9|_9^h~ZIMM?gDFH`#fFmT}Xb*6-$Io=qw;NA=U30h(Go^ujnBm-q zaX@o8$vQC09Hx0Xt6{RkMms2eMIpmqH@MP{S77rxpK&I2dI8ft!tew5fePwNC-^VA zVG(>}AP<-(=y%fiJ_?yUnmT?ncYNyTx*V5AHr}6+z5VyqM*l4TtRoQ`vx#@-lI{6) z)zWU2gUYI=ZYBCh3^r5h$}y*{q%*d2gVVY3|05mf*tpa$VPPBx8^_7cSe8A)mEU9K z_c-~b@R?-UL?^ajxOmhw-`aPQ7Mu&>{9;p4hQ7t<3dc|p+DzA_BIxc1*yh8Kmh-TU zdt5nLhPTx+ln+aJ?*>)znvG-`ZV~&t@~VS;g&QX8!6=??R35YW-aXsjpHP#hM$VJW zk=iLf7|EB*?1S^1(XdatN^H}8*p0+A~#kX>-AiZ?4CoA#fU{dc%Wb~FG z^HoLRF;KGQNQsKZ>H%|-F{o&w<(9}M>CsrYxrF!@eC{7n>Q!1#FE~Y3V<=-(o&&S% zC4Vn1aw++hH{r{aGHT`a-=$ih*-$Jhbldjhvg4t8=uKv=M~cQdl?6Y$~>8y3WeJZ&=V z-3|9`^yvPkxaItbD%V0B%`*p<6Y+(F1zi<3bxx64vZ0T{23hobr?`%%@j1UsH40=sCVHvi2 z7~Kkw4pu%Zlxht{&nKC%^C7xur)1q;I<(S(id23-oiCt6Yt9JF+2BSdpH(>@yHjybSKJ3E?lTqlHH!N_#r?A4 z{;T3{JR)#URowe1?!}6GmEyi%aett=%_Eg|QQUhg?y};(N^#$>xIa+b!;cEwGZpvo ziu(%1{fgrLOmUArI&e=@+rq%)R_Q%d<@;k<&7fUT zvN5@$A}*<@h`&-1|5+83U!(-hTBHW8RD(XO3QBkTLDS0nbWv|EXHRks@N z@ouFSKT|!e$Ez)*diGO2$E%)ej#mD71i@^)idoRh4#{uRNA+nq~JZP;{9I1n^^w3$~SbeN@LT- z3XOSzM=VB{dD4Pqa&>wR??B}9y%p^I2}IAV^+NxQt<(0w3EN~37@^P>BwH|wX~SKl z^DBoTPrl5zCF7)?lE~C)&SDYM?IumJ$uEm3x6yQtm&#&2FBlH#m&$s<+Es<2~J{!bT$OB{gibAS|9Kf9&PSc29&BZMn0@r%h6%c(zWI=p+#~ zbrf6aFxO^o_cg-o^0qy`CYt7)81;0dvMHmgZVD5;iiswpLCH(QWl^I_QK9_+MJ}Vi zMW$VPv^L=kY_C++y%yAcES-v{Q;B3usp84dP%O_z@nT#&s3%d`x$5)0OA458^}>_H`bT6C8CQ!XV6)UO`Ae!J`=jBhENZ- zbvJp0$T7rj98xxYLQ850H87!tKA}lOs27A5dW6W)U^h0b&A`cudI}L}PNTs{m55W`hMJU=o&B-*&A_o2 zEe?^R*0$J^v(3T{*vf(J8|L^x2+JlFzB)6?g!E{a?YY?&Gi&s{Ch3jUavM2I!Ojohd#YD=h#5k{ zoMMc`P|!&QgjMEDAYSPBzQscZK|Va74=Y zmD8e*mYxq8{V2FDfU5(p3we^NoQmn`BL5^HziI#|0+E~HT!LJ|aS)- za|Qo~e_)EV|Hor*b9N3S_{EP_Dp3XTxY0|0~*JEB-@yz`i?oc|GGk z$=$Y+#;i7+?HFio6V7y+!}7+xPS?ZTy%;qJ%Ae<%<=ubWfiiF#9dhU;K&i!LfnepBa@gX~T&XQ;H7n2lqlCA`ut$NO>!ds>W zEw2h%A^Qy#dX(sT=jws}+&sxEM~MIFI{hx}s2>4%)$Lh*H9eQT2+wTueT$dGyf8huZ&9j~TJp56^4Yac zCtzcBXC>BftLex(W92&Bl{%d~lCE~TP75ArOc@-f{PQKAt_r_wKPL?77x0oMUBsiS z7q|kMvQ09vlC+)Y!Jl98XVJ7+Sc=uLQQWTY22rG_z@WfOFtXaJU`acwJCC3nT`B^r z(J!MVY9a39V7*E=@9GLeY>7pu`v{o7f zdNvhHLeHNrK;Ruo=hsN9K3QLiq*Fus4@kz7_1`_+-c#>MW6K-Ye*3MQD3e11-ckzheoC0`2z;Q)Lr`r|a0m*+oAeYxUXzEQS|Fh0 zfOP&A88abc;$FUopOE-R8iXpx4bCFA@^$@9C#BIj;#yqv)ZNd;N35VNE#tP~5}-R2 z_X0n$+%FLB#$Zm$xio_1yMKQ`qgO<>MqjNoV}!I|63{D6WbS$uhRc5GrPra$Q}3@_ zj&X24u$nEyrd;t`;b!0MPqE9hu$T*rcFZtDE)ECD|VjVb;gkYBNG44o+cmrom)afp3gi9vb*EW;q}D25X`%uL=4;_rco+Z^DTS{MseAA`RhEJv{LH`N` z`4~I>b@EAFj<{8x-0N%lwVAoGvd{!}klT5Q$@kzapuBYz;xrF&YXy;>TPV*A5Sz{1 z<{skA0I_heRi0agwULK4SHaq{Dt7{F)F8PlwD`Hkl^wO@)O1|uTUOMjqq9udcikpj zHCD_1;Bm^BPK>0H?TjRi;p0n5BNy)!JTR9VKT`aj+!;+8BTg42#y1MbnZnWO2*=gJ zu}RJ>?tG-#JsJ_eax7HrrC9sOtcnZum6l|WqO1se3)ydk@y4q$Z9l(*hal96OmR$-!;2CP+L8coU#naKY2B6M8VwCr|K9QOvj>LyiE?AS2qeb-3qQs#;bwUxkFUEsFG$(5 zuj*;l6wgh%;&IfFo7Ip#R012Tp50W>Eoz*fsGeI@&&JY@(ap3D%(1mk_8IPNx*B+U zmG7r|73v*Tfp@A&+@*T%Rz3Hqo}a0nJ=LP@qk5iEJwI3DEKo!4^>hz4dQ*(;ba3YG zBcW$e%$RhIR!hfBKiV%4ZJJlAhc5*D9p;R z)!0xO2~Ziyuep49w^!}_bk-ciGTUmf-bHSFE$u=muke08h; zQ4M=v_3T_t0FI>R4V z1rDo@`S+^8Pih+WA2t4es(E-o^?a&&j#3BVXKKj5c&L{@7BfZfEtsdAe*<)c3eug= zY1$wko_sHN_DKa-_dmd%C1p+7$`_bde!^%yKcOwq`KKrN9A?Jl>awUV9v#c!*-s^siD?baF8h;F{sZ4j$V2P?h zGr3-*wKZ3bT98uM58!3}JRXW64giB3Z=J$@XH%RADx zEpCX`*#5-a(~(+qX^)A@+{nyz3f&l)Dh}`(cZ~|CpEA_r5EuBN$0oVKH52Upuqs63w zJc@`jxULj;6A!_XI~b2Lz%gnFj8Soyn$z!A9%dKuTNNH8>FuJ^!*JAOcG>9a*V*0G z0F~l^PJBy*-)JU?{oi8iwWmT?p<3NcOczy67;5D9H)EMsm}+8?CU{{mZHiO((fKj6 zm3bYK`?%_ZNuoFx+tz~a$?){z)|LvLHDDctRRefyh3*ug8!rYr-FTt41Foz}m{_mH z^w|r~B%BW(e zoC0A>!g52NMpSi;wCIC!)`4jdXR0+FIg|I(6Kf{nUwH$_wenOk7{Y zpRSXs&BRmMG*LnM4WT_Q%}|$*#bqQdagX;?E_MU&!djJ|0b)T7Y2h&x&x)ZRUdDqV z*@%TeIz5zrk}XZMdw2(ba#D07&_ru108NVaV9!v97!|Cc5KD)YSD=-vdW{{Plu8H6 zX^VC%^mENF>Q{;mDD>(Lyr{QFGR_Ohqjy(@q5EGNQV@AI!G7bk&L1^ z4~OEIIgt(bfc~<41QlIrYPl#D?L`mrwZ-;ig7(+)s@Oh7e3Rje-%S53Gn#th0^s!+1RG^6!H57EjfKCr0|ciri9P;mS^N#!{)B z!M}R8AyRLa7bxk&EZ%y(fqpml@v#M>Hn`i{ z8^$&A))}K*LXbDkeET;y&VW={nAp2Y_b&a(2K3?bJe%3P@@DQU`ZTfblSX-sl_4@z zJpU%I@snc3Sk^=2W0cm%SeE&kJjJ6sC`XNDvGPvo$eQBm_`E0IA8M!k?A^^;2M)aD*>ZgYqIZJQe?B=L!wgs-$$?dMKa z`-sSdqcmrbcQQMl!&|-`dfDa3Lu&hTqsg39{Y4EOU@UApCt{SLLE~^HYMQ)QpP;if+;O88V8OPs3$>@t75w5Cj z&+^hOdjz$7N&19Cy5&pKo;`v*Uy^?8koJ_)af-#FvF^eXi!{~^m>c-r>Nb37t$@vL zw9yJ1`pI#-921D&Owy@*F2$e2j2gN*3V*aP%2n|QVh)-^AC zxzoth`!evGybLElVL18U_^OT6Y5k&gU}}m`D&jrr6o`um1ot>tD30Otg~v)IA)v9Y zGtw1}t6tV=k3%OsS0K|lo{$oM$>R4(9s_A;)}{+pNL=kTqfBRU2x znn7eLIYov-@Q_+Y<2DP6^?=B-0P8Y*ag^>WvfNz}MIy*k9D09ToPVNmVvZ_sRTTDX z(&<&T$X=Dj>Z(&A+^B(BqQ!chQV|Q-RY!5WDvKkz%Me@~wm=B3kCk)nAw^#N_2NYj z{Cd;w;3Yqb8Tx?;ek^oyIq`+FOBCo?UhDD|?W&`qU6mEByslc(Rr^XfFa9W}q4pIG z=~xWHmtFo=&ZXg1mz-SkS6x0Y=aRn?xAGPJs-vP`l@+~wIGz-a=d0m7E*FmHs~QHA z%ivdCeo@Y4u-zpTqH97^wTNAp#`H{(7i`?Xaz_&3{a!HwM>nJ+dTv*ZaoAk|Szs(G z6=P!$orm7TAdGIJX!qBPhEG?`Ed|`}UMtB>5#?7UPy_WzLi44NANAWsx2UH?v}iU$ zHM(8Cf4LFGdy9DPRewTXzisD2W7%soQ|!m99>Jk1w@C+x5xl^!J~r|D`Jd0 z&`4Z-z?0J|fe&$_Ikrgch`}*IQ8(*i5Hs=Y$L*5NA^-p zd)ZBWTu1h%Z5ulALZ;$(&G`fC?$g=yS~`x|>J1%kfk7+oozX^A6*lt*(GQh6NB~!$ zidpNB5xQa#QNJ~H9KaxMz7gMe;@-VZ)E8o6T3;CP0CGG`YF-}g9kUt1M_qwQOFu<8 zglukF`&uEc<#xvP6?aSs#gU_?2tO}QIqGJxMPT0Pbq1RUNP#hB)0bim$NHKz94}VA zzPg`Jq5XVsh&#NT{r8go3*WW4E~|R|_3ONretWQ>D2Ly;!J-R(1O6N;42%ZwPE}l! zE2yBwj}D$wO~jbnJhgZchO>zoOhRp5m>V&4y{*j~^RU1N(7mj;Ofe4H`4w|W^jCa~ z{s-Tv9-x1av%*6!(#f690?~;jL07pZXkc&cbgVsgf@fD+rxX*$ND*|y6GLY7K zQXBNbV%<1Ldqy`h6-u z5!drYc`F-`av;zta4bC(J4fu)ap zAg`0CmzBL^pzIxKSD`A238tkes{Po|PhP8laF0H3iuH#XGl#-;P zn;}Zkg&Qn*gqhI@R+X`FarKS+%v1jSmn zyU@KfW*4i;gqNlJS=YLVve9S`h?;ft8%@#RVcEEAMr5_c z+tuQ2w9xs}7H{y?!{S}R*W1(LZMJxO`FML%Z|m)2)_MC{ye$oH;D<}9rLL)y~l<=--u2|Z|{vFD2voT64mwS8cuv$K6vu7+}nlYiaq{w11?e;X&1^7c3T+uk$M zcToPe+wfvGSUter+Z%lMw|hKXcx?Z1A*S9xc#KlsmBD>w>E4W9LIqKfpw3%%GXyvVhC5pAyUH(o&MI>u~%-X7pQVlcSv^-~%kw>a5!ak4Qr zoaN;U4~EUu04Rm~mcO!0F! z8zF6=?J#4y20+hEeHCiZ<8L=Erh2l?-NWk4SG}v3hI=fb&r{Kkufkb zvDYeZHyEx{h0{{cK()?I)HQb*s%OIOc!$6KCBcLS3Csob8AS?+s(!aBw{mL#3FP1V9P_>ZH+{SR|E#ZuJ~bF5=2d?=%^nrH$t?oHrdzSd z&UupcH?mkOWX!F9809xJ?hzeb#TPR;<+Mi~+RZA^iM$kfBd$15oP)tqZp`w9;XlP% z=X?)~Op{H{w;H{yn9df7e!V>Rt3O4Z`>AD3+_f=+g|DTf)!{vd^?Fat1r-*?j(*|T z+v5Xm#$cQm{!xBTPuvzo0XpW;6Bx`M-7F@9Duo=s4H8mv7ZX)JXTSb@tzQ^DcZ6-fj-q_ zw(Ex`wz_sfow|ppvsf?i2~g86n)$R=-?Ny{0QG$w^O>){Z(zQMpyt#2W#;>Z`u+>^ zHE@%f?zjdpY){AwT06l$tB{%qa=p9u_T);{d<;u&mT-xZT&T|{JQ|CCG z_9Wq7K@50Pj2SH6FnbDO@eQ+}pdP+qA{W%hH%!HX2Ka`VZK2f}@tazb^iR=RaTP)P z^5U6`hJJ|DX~YH1kFJSwTECwpm6z)UuiVFx^*o zvWm0g6e}IFkIOKj>cw92966_Zduufj`&>~M{4{OY|4J9=W+L3mQvN}g3eZR44uHQ` zi8crby~G|Or}H?=>o*dfw*NuDETP|sEYfc=rB&H+A)}-#nC{6{3*xRAXiDjCXyEJ{oKo{s3W9HFOQJ$&U9D% z8fPkNGF!C$8A9Rw1vpZ`l{LD_M2v~?8^8jLQ)G?cb87-7;fWbO@=7XQuV5IS^Dai` zTdBShYlp+sHrm5r^8qhCTEIz?Yt` zMHYDG*MfqV|30eB@eb^xuHyJ4581+a%BNXAz2wtdK7Hh~f_(bQr$r<8M{4Oj5Bw8B z`Al^VN-2oPA--a5Yrkf^Yo^7W#5EL2n`^~I?y}%jnc?gbk8Q0;`Gt;ZTZGKK zaxxZGrlm+B%ByB3x^1!*P7ZCYakdIoUe|Ce%xK5i)gf1H@Rt&yN?RPpN9Tvn1n=>N z&2aw-0V1Zw^o*NO8QqbgtsM%FvhK!l>`TTPEp40&A6DwGuC5ov;Xn@Me1u<)dq&&H zLW)mnKJ6sLnb4`TP>*)V`m|F%-@#`W@Mnh@Y@j*Bu)MKW7`q7L=z_tJJjI?`^ubaP zucbW|sy^*8L987xTM`^|=*mpqds5h*Cg(waMQe3_F-BIVSFDLzr}cd^Q@oj8?I&=p zVToYPC%AlFWh-#;4#jmcYH-4kNaG}t9n5q}Kk2Fbt zLS+tMXyN_^>F^j=SJ1h5Q9P|z;CbDn?C}kH9#c^%#AKudjWIz6ksK&8I*a_sbjlC%S4gS((NW|_CwqRp@eldoaF6-X$vHnTG^{50oSTUm zA^TX&i!t`NioD1wmlv7#y!c$^MH%Krwwf1R&}*n7UA6S(s+uQOEp{?nWKU58k9PY~ zNBxmcQJ9wMUk&lFibqZH2-i{{h+~=t3S(o%UC$(17)B?^;VNV=A2+2CUD%G&%12c% zjkOyt-+>hRVAk3$;tuidDC}a^y3wwZ9$Fgp(XNsyjx+e^Y#s94Q1C9g>PZPnq4lDY zV>=GUCY|klomifvt(3Tg?E?RJm3+g=oYpDzwo7i+bvH zp~UbM6u-{4Q*@6wX|8wDT&iW(JL}~n&+_kCok}DXfJi?eR`#Pem}l&PDVHFVCGEN1e9dQTb7744|<<38#KL7HNHrQW#6; zNaBe$(FOgnn;$@}hGKQ4BeEwDjka1~z#^Kb=z@VLHVDo0mD0>|d(w*rQ-goPmE4jH zwq-5VFf|sA*evXP%J9LsHCES&C>-xn!pw#qLR*5m(fLAXs@RWGWE9MTKhd)U%c*~tp+SK zN37Ka3WqeGfi9dCQX7p%8ZTzc!#3XHxIt4~Uus=|_jOqCOH2~P>(h-6Rv`NTWVR7n z@#!*IX~{$JU8|qCHxt86e0{ieUmI>@WpUGLl($ygoa%I2XSlr0)8c#=L*tpw_a^jj z>6E%7we(5YD0^S7Vb|a}o^%qP3m`s)ScMI;`0 zCbot~#_M12lfm_+eEc7LGDOxfh~FMV=(k7Vi^)~~Y77tZ#rfyO4_zIl0Y6N`;$YUw z@}O?@oI*J?MWmnj9Vw254_AL5S-`@NiTAoP74eSaaFuXpqL*Zna}gmMt+S0WcU=9hdOQ{X@ebwZ&6zzVtoX*BThkN#M*qSy+3M8 z9STa@=%!iw?3p|uYa3p38)YtM)Pt_aax&;DYpwn53lE`w+Kr(V zT{ebR^3ZOik0xQZ+>Do-Eu&)}q53}jSOs3hdCivRTwGeIEy81!p@QOp%ec^mha-ni zm%{QZfvaLrK_Zs_QNl$?G{-LrgfX7=9Da<}Qu@r4YbjbE>r_xN|Bh;ad-sL-O%(60 z8TmFuMqGKl8DFh`sB0w}+7mhf*NqBM*ysg?1z%_nLZr8*kbENax7EgDI4q)URhI4) z)tz-36=;;CGi-W=+wUO~a%e-xN86n|x6HF2kc^x5oC^JPb*y2(7rJn|R@^rT(eNdE z3r@IZ$VMEWbFbov#^K3K+4h(BXQs11GgW_PNq_JuX3&ha&P-^{nYfe^KkytC8(lj( zrglu7MvSH;pg8Nfl(T9R7`qD3lXn@bmN_DS;IRG$C^2^kjFq52uGTS=UH!MXTe@0& z#}0Uw!e_vLh3HpnJ;au))>BB0PU{Y}aK*~?A0C4nJ}`6zU?=>40D~-7P~-%RTyWw5 zy0TUZog+x&uL)dycZT772LCl-_VgS4=P}{WRryrp6VHFc2^P*xaSY-o(g^;R=ZIMA z*o!thm+IKB?GQ8CBUWzRbFnvjuncWyw5gx2W1qK0^M!F`J#}nD>-0f7HmdbJFquv7 zC)*+p1T?bWTeV!KW7XTENsTzf(S$?VAcm1-8^UgT(6^v5h%@+dlaBpaWBV2z`??*P zr1wJHp;>P7VA;xYQvv&Z0qQe(KFYMUqU}*~#S}y;Ok3jy zda%11OpTvvpbojUQRgr7_UU!ZZ8Yln%joO3bSxfB>a*imnnCSEx_0r`{8>#O8++@lxVijiW+`c1M$})#0W6au@gH`@?I;% zJ?#;n@UouGS=WstyS8Ta29NC8oIS5FvTHcIO=MhvD{5%JzF!ch4`+_LdmBk`0g?S&D+jJS2Y2{*xiZ6W5QYBhV(&k?AaFd z-*?ruwNkNmY zWYU_22BGF{sib{;sjO!-yF3(AZ&|}dW16!VP1~-~?D-me-!vU17mmgd1KVJZEa6!4 zKe)7gO9K1B+I3(8YwT)v)v>W0b-T#hf_&lrvYr`i--V4xW-W|MQM<9#nvtfshMNBR0If(sdGv?I7rdUI3Z$aBNO%awSw@y@w#xZ^2KK(d039ugxa>|%Md&459Z)>pJAU^3=^ui3mNN3j6DqCkxh``ps1n z&vrxBir9h4XS=n85mGKOpDAa%H3Zg|*jQjqStJ`sEPNKai=+{OC+n9Z*f3TMEV-v( z1!NbZAd99WZavxFo5*UjLSntr@=P6JjyjFl%Bq6RC-%vvJktz9P0^aGvQMmdyS|?Dqv|m&|@;JlK;x8fNp=3pvyW1~2hkPV&kOpNtl zg(P`-DoXZ%Q4)q=qtxxgrjy;ZR(YmUV6%zsIf$%3D=BlcA&vhnO5$9!Kh9@$j( zvq;@>$Y!!Xh#i}TYyta|Sk6ski(qVxwRjY0Hjpi59>lhUAX|kD{5)|7CD#K(cU}B3 zw!2sav8WPcdtsK1?k+S!cL!M`a<`L8>wA*jJ%#K9^p(iG7b82v63AWbT6A}wWs+Si z)PVNurHdw)$+8IjL2w=m=ZtBH6 z(*S-O<}1j4m8^i+mf?bpB0pzA`8>jIv$4dID`5zqvJznzj;xF=SFkKaLAjpE@39TU zjx^0P9bos^c9J{}X%@@>#U4`#yE~)1pV@O_hqt39&5;<@B*Vh%DNK0t$0gI^m6HiGPq zx+4qZQ-}@rhS>5td^xe#l{xRA4EkVgfl6}=#u+N3N!-72| zmJ50NE3khND;h4?55#UtyT>Aa+l9L)#D?w_>?yIkH&B;G{6EBY-@-I&#Q!4AJ`6(5 z8gW-G=EMC0Z0kBpcC8;uzQN5}boZOQwYrkzb=JZtFM~nIXd5T~|$u91sV8bYc_X?@L^AXxf;7h%?kxl2LNm6$VC8zW8 z#I{?V+5H-V6%peT1e-vtzSWssl9CgN-H>*Zw3rexTQLsP`4lbo7RhmWrnmVl$=0<; zHk(f;)+bJ|8RW~+edx;^J`2)}vBr7WR}q80;|zFQt~#jH}VAgfY=xrhmVOp zknTPs_LH>xg4l3rcc0i;@?|0ahS-4-f_*DeB44oYi7k_4Ks)Di3tV#yT*`;$s*t&Mr6y?h~mPIke!h20Bc?WYRn>VjFfU?vLj?07)=nc>C1UeV3+7Mk>q&xDcEQ@1SPkpSLSBXJIs~KLVjkjxdNyi@ zrFAi{N^CW;CA_)|*2a&npyV=M(*;M(_o?14<547eHy$Nd@`l9L5?jNY6FWp~J#S0l zJ*RrKi6;=Nzh1CJV&_%}mP9P?nqbM~OD3e?$9xk{BX*KBdy8ih(=W_3ea<)YjugM# zS*Y1gK8WmYLz;cfck&^`9>K`!8sEc5irCK0GyTB#@(IK^uqS*UpH1<*)CYap$LEuu zStWvPb}@k6HAw4k*+IU8^h_9vdLH6OiCy4=9V3>k2zH#!exMCXD-G{*eo|Js-`;Gu2d%@=sl`eVIKEH9N|`Ajwa5B0J50AvUx> zvP;}mhpZ~4;1zBn_7K<+%{A^p?3!d1i0zlmlh_E!%)}NGyTN^k@lD8XazA20#BOtc z9k%nM`(PV+msinY3J#+3^08zOsw4ZHSJUALVmH*I1okDbtE1972vg!APbRz0T9kaq zyXi3Qb!dF{9bX|NhoR(SU>JJ$b13cvm}kmnzRJfs?9~F!=9#(x`%H&< zw2>rzl`n~z>msu#{~|q?P}~EQKgh1{LK>qe?s^)*pA^iC*ynYSg(y|@sOSEcsAp9r zNRM^1>wMI+CNR|cz;3~U^%z3qD(J4J5<)B#%3ynK9c7pv_56rN#&wjDWY-RK=?5d) zal~9`v>l^NAU_uzMn7YeX?l$9z3#$p21({X%g|X{Pnk`AvfgM{UztZ*_g2uZp|YJ= zH)4&HW5k95>!WR=TqR#7QA#vbKGWlPB9z+e=E{#E?wsa^$`fMKsE2K%CrUmRtJ02GJ*qi9lwlOY04jq$ zm9Z4UwgEKfQf854{ej5(EAxmgC=_fZg;xsm)Y;6Y>@?6!e-5UgP1!@Nagbp93|Qay zyJCH}Dfb;?PSe2Yf0ni#xI%N)oYQD^?kyUr`1cF@%-PR~c(6 zJC$L?&P$e0>^sRu8EIzIYL)SAzEc@TEUz81gUVcDGut9NqAW0C99+rnn6i|7DK1)N z9LU~N))Py;h3uqcE6DDQWc|tR0y3Nt#jP@Cxm=da)CSoVdtzx6+Ygn;6o-}+hmVve#D-J+%79@{(s%>1Z=_ugvF{{{Aodg(mZj3Ut03Gz zB}O&P<_Y!-v7yrLSJEZ96!Z2E<=-L&2dpxlbaB!6nNad0BTBkyqKWmNBv>sI zwo*^?RvAYqZkpOA)N`>5t|Yo?VoY!0D#tloW%SU*nzUHXdV=P_nwm72o(oXYPZLk< zK?t(SnvN#?b*=U;!MeiSfU(()85_u|X?hWRQWsgIWQ`jkizNmvE&16782-}c7L0an zHGNGc>{kXb_AQGChIa3fpB*HdLcXMyv&$^Ux&g!R!W$s#FPV1{vKdk`&4z5bWN-Q- zTP4}(4an93gGnX3TOZk0soCg4)NF_J^E}z@(hM?bU?g6}gfa5e4kF25D@t0RE!F^w zqqMeY^NHDr1!xPMB&%wtQs~WRU|(2OJB^rDvRTAVOc!h(vHOyh5bG)>mk=8-*$QGI zlC2?@+Y+^|s@*{Ow~+E7OtOpfkws|VCN`f~ly)zwOuSXW}rwI7k61}n1G+OLQ`5hXoT&N+TTsy9Pg|{c3b)1BSTNVWDGnap}bs^+R0Ji_bE|4jfS-3?h60<~p6LD~20e*9dMuK8X09H{t;w z#NP03X2(n34CCzl+a7V8{jt>oIB`uN;GVa`0B>xKj>{}At%c!U)Yp%z!+zE`2J|&F z2Yjk)9T&pMr1_#-e`k z{#D~afS;Yk50^s6;k;$jMZ{lgBVKA;0OmQ~w=A4>3?BpU@4Zz7SmDfMz(GA`04}r6 zMV*UF04JX~7|PjP<5GBEJYXeY>M3-4emkNucs-aDY(<$`{+r>w`Z(0*f0DU_j1^hl6W7l9Ty1LcqeGJ8jCd0GOzR+O6em~xIqM(-?)I-rz(c)clZy$XW4jp zgG+S{ypOu-5+B0exT=Ai_34K=zMc_GY7DOcGPzf=96sKOcs)%6QpXyd4}cs1QbzOPEc^!K@rI5`IK&;E$BFEj?phruYXsa_j!OCrj5Y=M{` zi}=Yqh%??stTGXEN|fX?jhn@*dEwruHN3A;Fc+BC7N_c#cHn(T+edp5uZJOCnuusR zf;e44{8oeIZB`}pvx_Yr{Asfk{fugq1n)mAN(Ve}DI0KJItlg6Uub)Po zPw%_-OaqMHi#`kg|5%K!?(D@7h0kqc5H+ckK8p~KB_PJ1ai|rWVMbiJA2V(vnG{0%W_oN~PG z4Xnj?p%$xU(tIo*H1z3$*xiy(bvfT&XPa!_111~O5o3H1mk_oh>`PdUa0_8ZWyBTq z9(4rKZ6jh_1mfyg#7Dglvq)wHAx}m;?u+=xSj0Aa5DRA`KD&VU(_X~pgAk{ZtDG8$ zyUrojCM-C$2U4%{My!=zY&vLfTfFAH3-1{#PsWS(oU_d{FT?w%VK?HThgI$X*3}|@ zKp5bHSc9+$VMoHAgvEgA#nw#h@%N@XTEcNB3!qd~IE=WbJz~T;#7_bcza~6wLp)D1 zGjgzRJ?p*_bn`lgdM>$u<#Sy&;%Av?l0YVp-$1yvo3H)%BSi+Ht9X+IXrRalK1 z5F;NzsCVnJMAf6X?-}aI>)5*YF@LY$2bpKrP-b-Fhu|uDB1(Q!+ktHeP0@%IgAucXWU(gJwBQ2E~R#34C3l87<%Qoc!|{8K`8kM;_^Dl>_}?;sD-(F!Ug0z?lb~6 zJby4Wgyr1mU=Cr!&fYhx;bsJ4>|TVLL8kb$1#riLDu7i3u}`TzyDGe|Evx}}GBgq} zVj0SOG@}vVVejUMUTpw-c(q3vb26abD+BO*ODDi6znu2<*`uAk+Q+a`(k+bIc@gff zG`1Oer5{Mnp!epN@m-jIc@$-Y`HLgp+v{nsoWbp({*$^ z0CPHFScYYD;r*Q^O8^_!K-@F*F{IwU^N0uUVoDAyyaxE7DZU?0L!2<{Q^1PH*7-px ztw?QV7K{*N=%IDjLby?cV>%*^1mx`7-kSg~RbAU&m0VeA8`!>0I5H4%8lY<1aNIj! zvM&X3P;$SS zRnZ^6LGNI!&wL6vfA5!omJVM7P9~W>LwO}kXT&=vu@@^1ehlUV8~h4b-*(Y4PN@4k z=(Z>gacLG}UoXUP!o23cgM4Hw#Dx`hLu)qJb9(^R&F5fZyNabHo;0s`3}Z2OwWb4T zJ`>+R4#XUEr?K?Zy;u@5dK5^W9-Mdil24s{_tEusk=Tl&?4p zQ}wfA#J~_gux(%qz{|&|cEp#4bii_jKDX?H=2xgjr%@>ND3l;_wQ4BF`T=O7VUMSU z!TV}ULe-W z_^BVhyUyDIl6~jx0qjIrZ&yE>X<|M)ONw!F|9J;NW)qq3E;@#x+&Y0iGvr>Pb#8;nMnD|fe+0NO1~n<#@OcMyUh`x) z)`c?aTYu_(AIqvg;;45}tAEohsVSATq74the3q5Q;SC=;&9+W-z_3nGScpm2PmqQu zIyhvGbwE842hBW2dLE;A9V5*Vw=_BCB>xahMiGWLd+22TIhYu|5lfN~yIT++`yhVP zAMs7&=j8Tta*OzBE@I#7pF8>U5tw*R`-p5mBHNE3$CreD4|s=gVCY|fS)m>YX7+Yy z5a5K+NWiKGFa<=OzPauQ%u?6VTEqh?AtDDwZVsh%uG{b-%_6av^j&`>EQSZ_nk2;V z>n=?apj1z63HZqxTsiTY+!o%0CfCO~1!0q^jREV=YEJ7at!Z5a@pj$zAbF!xGNAjx zt_fJb`hafBrwsrc0P_eK$JWF3rA-|XizgvAn1C2K5OMz`$9VFSO+yo)S1my_%|XoY zM?7jn%$|Ta?j&OB{Gkb|tGtQLV2pPw6LD)V#OHev$JId0xQ>`QznQ(9+=TAJL5D`7X5WB#;>ehDZDVRJM zj>t|RhD0NJcS39yfmoc5*sT|0tBHt%lE}On;%RasQrkocOkxi0`c)%h`$m3un+Mm;qWntqX;WbL@as-aWY}f1jP2_Pdh@t zG(tZ*1{ zPkY4cRS{QF?9P*U#5u%ovndp^t($=OY3wJI+K3kNtySqK)G{DWZBBYFM7&ITe%Ovu zrV^#YLDGuM4`(4hp_qmQAnrekIE_p`Bm9&k2UEHowIN<1t?E!*PLql46!|$Ekx^=d zL?e24LTna+Se%a7jWldUDKjXE%$t!vZ({F>5sKG`-U zou{=x3?OaWkpC6tBZgCm7ShughL}yZ4aa>FU!M(j8J%EZ(1!q82~!D25v~D*KB5(t zy@>a5RQ#6v!B8E0cheZNjvWHzY_D=H)FJb8=<8*^4OPqSrqoj~&NpmFT$hWplCzy= zKq%vA9-*&W0`G&D<4okZ&(Z|dWb6D5c3es`6r9Vbei|n}2H#jIV)Ra&cce^m?@$Lu ziHXnyrbOXy4H<#iVK}z8h2c1JLYO-H_JjTrN5$Az9;O-Mm*deq<8IkYw)<$*Eymt+ zw;l{F-}h;*V;|RSA7ZPPh@;JjHLD|9FC%*PMr=|Cv1KyikarM`l@a@s+cd)PBZyCX z&~G&c~v z+ioL{Ck@T@5zmlG^}dMNL5P3lAbK|@ZEql6AA`7~2K~}>6)~9N-kak7kmB_L>D-NU zPHT>sOev5?+Q!dD{GkZ(KLZd`4pJy2xndP!jXU&v7Ny~pW{72;l+HsCZwy0xOy(Eg zLR`HU@ehB*sQHu{rx2G>Sko^du3v=s3E@TZZ5+KH@}*Rw5H~bHTtmOFwIzRUP#pVo zLcAM`7*>L~+(zM&+ek{iDfFJ(hw`@)Urr%%gB6@q{ zFE3x6MZ^^?9nBd-SV_$t2_bTYN^MCh*Klrm(t>dZz*58BfIZLxbRssXVnGRhY1ETg z3Hx@+0kA8!v*QU`791kj{wik^bZm8q@a4~dD+va+iP&_uWMV0>J$7~%*hR^n-ux`V zmDQ_CzEm7rau1mJJMXe>)7MVyPv7qoOm=3p{G8xsXO)1ttIWN@$q;cY4zV8P*n`+- z2@dvE;9pMc%sywfb%iF;S@IBbmPFQyv_8))zMdf2N3!r~eu))WWHrHD)&wP*nNM}W z0)ct4KPBr9%$r>erIetw_JMhdGxG@}W|+1uJkf{c2nH!13+$p~{{iO9VrvM=&~1$q zEo^)ZRkAIxM>SN*wuyc$%PJ)MZ%at5$W~ib$t+-onyO@0VkI_0FvEszT@wA-@tUe+ zA7IvSRkBZFWwux_Lx*jH5(C(0;i}{aVC^GR$q|WF*ntQ~P6yia&*J+Pcd)i|#w7;H zGB}k|BG^gNGtt2?bwlh7Q@5&}Vd_@1Gt8Ch<@^k@+YRxZlo-ZNN+hxz% zoETZoU358j4mP&Qp~TwdBxA~H?O@Yu_$9`cldR9GaS@-1^5}UF|wFFBC)`BglBUp`@cM@B(2Qh+O-*q7| zj%CFPwqxam#15=|J;9c&xSyEB-Xb=My?gUQVk&ziS<%g36Ej$BeZl76G$m!TV#(G4 z>&&j!7rrE%_D$--DmDQ)GR2eJ3B7z7E}#Q>cJK_6wGB!bW$%iq>*6m z)0!mpX6+jbHl;?pq<*Y=6TvdyNlhBa+?ooOJ!^2%F!n&QK=37x9cU)g1y})_+FYf43F7)L+mXm|7n?F1Vbug#Bgr z<(_5<^KK{HVY|DGRhA6f-DRwLI}zKU%x8QVJ1_09Wnadw6Ps@MCH7}vAKHESD`7eN zLfZWpcqeH&dt~?XuY?usCuw(m-<_lt?00F0eZWfQ6DRBrt@t!)Wx2SoDp!kFu_`3F z)KH=6S1zkqb;&9>{WfV8iT?vgc_pwX{o zLnI3vsL`)y9BJ3~ zz+m={jKf*idpnS+z65w9TO}p0?&rYXlI#w#ccf&W@W|wM*g?rghSvr5zLcCE-Y9t& z`$XCqmb6UXZ7<2^_QwHx(%zBQ`laH_>JF_JpWebQ+Vx9+V z$?r1HMB#4Ujj_q^vFb^JjUO;6`2-t~ELf+oImxG(HHC7Mc_!TEr&*3<&#T_%XV_fH z%+)^PXW9EHB7_}X21A|vQnK9b9M}WNEHTKwND~Zq7oTT8q=^{a&hF)Mp8ZF%IB)bt zpDx%rZ?tn0jLmL_?uJX&K5Sv~d70DG*^2|{?xeIk?vCtEy3n&u4U|mJ5O$l$m$`x& zB2Qoli!+2~Z(IndaGo8>P}BN0zrar0S({21*$2{>w|Z^XU1AR;^XRZV`7--eva0LX zBwu0eGX?v3!rN}8tg~bR+qNd(WIH9xGVV?OfbEv-)5wLo57~LiX4E;7{1Lk&S?4Y% zl0RnmCCjXNKKT>&lVrcgTuJ_vnX?4jvFldyXDmoEOQjE!KW9;r)paRLE@Mq3^U?%V z_=0ti%+uwoRK8g`BWov_=~ShZ$1GK{l2oshC#p=~Fl5cebXJYS%pFFSf_d+NZo=XYDL2Md2UYS)UXgf7VHa z?y{pG#mKWdi;~=CdqIjDUqEaT8#cZu#e=W6vl%I#e7Bt~PVwdsI;*~{P4VS_*x9xe zKkoL1VE-H)XH~Vqd`lM*`tFfeQ>yZP zPVTDlQ%>%x@taQWs`L9!l41OblVlj@T^*7&xK~$)WKAB@)gf7v*LRW(=SfbIk-V#u zWF#N%BpJo0J4x2!OPnNY@wHBpwfQzXyOmOx->|cfQ)2jUf*B4pddBPV7fycG;~qH< zKkMjBY`$NTQaQ0ZFqOduok!B{fV9D-=%z)(w2`F zz8Gq({5d6#PZf-L-gyS>kYuU1pQp6vpNY`fnN=>S9eAJag3Vl2AvJ*;dI-sicP+r$ zN>&+I5}(^cr1jKO!Ko>HiDY9=)ksa{Yb5)*FodP@&62r{f5cPyF3I}Nj!I4A?@Bg& zb_}pj1Y=EB4rb~6Ct}ms=Gy7TbS_%<^ISPyBQ=9F`aAEEWo+zV?(u8eq-Ju_Q=aF) zY)=5zw3i6sx4P-6S-fp85r++pZlz@LWNEj-HH3BK9VOfD`iOVr-FvCI(kV5&Ty5;k zN08l8!@u_TNbSt83dX+J+avW2e#dS%AhipxpDXNEhYd*W%A4n^c6q5eysNZRj^w3w z<9#HXSv)SaJKvlublJGImrDDF8agGl2QTg|7{;#`KP6d}P|k9BX>XB&V|N6n z=JJ3(!Y<1=C$%>p-$&SG8B2hjm2BAfwJCl1)V`uzKkU0IwLdTItJ-Z#8OVq96Lx*- zZB8A`w@KzUe0S>5a_M5@_xq{r5x4PY#HO&&y_^l_1NsZrl-Pp)LbDpSM|?Q1GC;5i zO*zZs$&#(Ab~H7Q=SY^4F8(yY^@-%}^^FYU}FZ5n@Tuqx@3Hj5jE z2==gVVA>q+D_Ng}TRMZE72HK$vqE#eaeGX!0H#uwA6 zWyoq@^kj?q0>Rjk9`R{Q_{kw6|DKLdNn6Tm4;AcW)tJ;}{L5h~>zKBje_5cioU|48 z(BF*howky*5h5kVHW>))I59D6UCW*4jcfVY5vrb^z{HsLya9b#$D586dSctUj<+2t z(sOK+v0&GAq{Gh*e5ho{f_k}Z;NysiIoAfhWTYCxl(Y?8t{zYboA?eH!jcXlY!lxv z*Wn6{rA#;AUlr5%u^Rrqjv|jQ+$SCY~8G?U{^9$)vRXvX})u; z(9Dq8DE&M?Io6@s1)es}q1gpKhFA&H7PU;jz)L0DX6ulCk+&=qzMQO@k$#DH887Tk zR_&60nJ=)j-1IBu+T^SJ!FV;cgVV3_fC(xanSP!3nW(Y}={Na;VwFuxza?{8v>|u+ zok@aW8*+!Qn=DG*B-{M-JAA8Tm(R3JzQcD*hG}+(-0j_) zC#$J+F8xbhaf-;z)ZMqzzv97?wY&TgFso$Us+9q&Ef_1V#@SaqL9#qzeIz@Wdmkjf zpQ48F5Lm^j!k06b%hDh6V99P>{smagsg5%7h^GeWFKDbpJ7n;%ogmY zD#J2dmAkV=efX)$s0@?hTt3~EuY@GErtXUC9FZ<9AO+nOvt&uR<1^e9f62D4sF3QR zRF&+|ipd!sN`z!M0<56KNY-iX?2HOZQ_1?knATHiE7_=3lQTTa>0(xr=Qy*Tb3_Ur z7`HIPtc;NCJTPx%i)3rZteB&lM~s=WvF+5?M_`pC zD+&1}qm~jP*~XCHfrU#}kTjUpR_aPNDajXD6UjPV8_en`Z6xb+%@pU@%qYgHS}0dR$tj5*`ary@dnD1rKgZIgd~Kp=E?xO zJFm>I)ZIpcrRaQH*jdF3J!>*lj-_FKo zv{N*TRMs#vPKj6~%h}@l>Ft#m$yP5OpV3}vDp{qqtus3)Z6&L{wmq<9$?Bd>%}h`_ zO4j;pHn8rJ{k5ojW}?zhvI>j)0JAM}XqKc*urp6!ix)ZcOjfo_cSZh#GgFj(l1=x| z1NN?Dr!G9>smdA2u3qqDsmfK!lGoi&PgCwl_QtyL8EMMrlHqzmy7IMTxL%O1{HVtE zoiUji%2UbezcUfo3&{>NN>9yH^os>M19Rp~#dEPEMp;Ujo!v>wQrg(rjLeQouAME& z?4(R3HidPlTO+lL^3=(fE{e+%5klJ5HJM!$cgfz^`W7&YWZ^3Yv#v^@WUW^C0;{pa z5x*Rz))Ghja+HRW9cZvKvzyXVvQrKA0dp=(-IWeYRCYA8yVBFn&Sdsf)-6%XOIUI* zW$O~Pc5v29DRTNfrTM?38TUN@N!#TfQ;~SgB;$tHYAVD*uu!Z*|cBq3*upYsmh`@z0%erxLCb z5t1vh5zz^v2D?~znRlalPyr$f> z-tYZOXW+{>Qv^aqI9?1-h}Y2zX|emkrs zS%KoFed;%kt_GSlE!=Y){S7E9AdDGLdx4g%Sl~IH4g_sj(UludM}aP6F7TW{4*}iJ z?8;4`e^^Au*~4?)%TJ^;WhF>YpGL3AbYcckQrog#Q|SGmE60ppQ|Y%EqzySMVyWqL z)x{)MF`$yybUJV`Iet?^oIPjIo0gIq=7f|QX3%Aqk=oz6+I!8QD}$(}-$=3t;cMMY zx)umu>t@moK?}Q;8fMXMpi|vU)GUkfIh*dVjMQh^)yi`=y+>98-(q1bl|&yV`KWFS zlRT5?lTZr&?raWy5!4~R)G&v>3hEMXqUO-|A)g`ULch86>*b_|iZLc?o<;4+^vC67 z^x)4GlW7kBr?Jx96wkfq({?LJDdo=8^;$@`T|xTnMgKNlOX!KRjvDgX^zm9vr^w1j z=dAj8t)){kNy@Wzg1xfwPxw>v8$_oEnl{o-tCTaxKy9S!uhRBqBkjFP8$BE8pjF!F z*+@sPBF8VtFV<@lJrp$9Z-k^DNtt}XwlQ9t=}DmL+a^ky3G(0mvgZ~$TS<8iYa8g! zk?CGr=p0b#k=c?CgR-R9R{8{JpA_3lUj#+xPxsnJUj@bI&z5u#v}JoNwVi$p+P~de z(rdEURIzjg+d<3!`KJ`yc{s&uCrv&Hp2{z8Bt1{lomZ2dkGPaB#k^z{%Cq0y^nlf* zcf&4cdhMo2Ed>j>RpJ&CQEZJ_e$aqCH$ zo}x#ue0u(RQXl@5xPT^~3l|vbRxwdW>22#t8;0-o=v7Ep*g*2(tHv?9Hix`U(HWaanf1k!UT5e(HjxE+u<`|#)NztBHzBW1R6H&9pTtswiA zSUKBBnUU_+lB#Z3RP0quZ`)2v`QXt3Iu3Nz!$jSsCxEU?PcQfA>7W~)SaU()saOj^gHuh^J$eO^^aS?Y>ps0} zr_!QQuLtx8*ca2T&tAXNw{~gmE1{o&@S6`M^y^(pKGwU0?!24Cwo9{%N3`c|a#Zkr z`Vq{%3wZpd#Zx+NH>n|H&O@)K^aNS>{%-PqMrZ6+%Cz%-L3i4t_4P|SMb$UnujnIt zlzer)U(>~)!{wTKzonn4YU^D}8~2huYvx>P_>(RRYUgaC{-moCQ8}p>`u#-*f%v2g z{XWps_G)eTNYBYpYBx|6TBgdO7lj@Z$#*UTdQHUNTVYMn=p*Q?bT3AT*{AgJh^R4X*L9Ko!DQ_+9;K`tGiKwaDI(sw717f9%!x$Fz z1x4q-?8&13Ka<+=^_oTDAbh=MQ7ou>WGuy@u|!mvq8{EHngg-tp@}tklm>bq+S!{& z%VjO3*ggHc1#|-P1&lRO<m zCaMxj1eHdZsLE&!D4~ssvPOqMKb|mARnU$7+Ba!$si6icf0*dVaV)#TBxM`vN>l?iBQa|5*-!my zplwG;thRKos)5cQA+cH~N)3+aKEx_XcLYb|mrt}_jzxh|PvBS_sLb|0q9dwWKw9J$ z8RK0OEtHi?U7LV7XLPE7)G%ncfpWqBVGtgzR(qo3yfxt~ktTd4(&Spd)KCW%7ic4^ z4tlK0BEIry9w&8D#P0q z`4y5<@F$Q>Q78z1D%}+26p}t`XLC=Ac^xC_@cnSU85*RjkLZTRf)2LqBep;@Wu;T+ z`y`uNqD!E&l3F2`<3wZItn_Y;W*#T`!pFu^?a*;hMOpPvV3E(W+M%u|w4QH=!d00h zjgj?0z#5D)RDv6yuU?<&MIxl z_3nuHb7U-~_f0l;Ms3fL82-fbd$bK=_!G}A=r-tVpCjJg&=XasygiZ6c_R1am%aO< zP*vBx`=Lyb7@utRM*5k!59)nE>j@vE|4RZN#9x(T)P<$@y?s!>t7Oj_*>$n^Lt&r^ zbGq33qhX+TJGPTqVi)^xWV}WcFU2BIC0Wu8chV#8NK_qkaME*0PN2q>VyP%pAJnFj zwWQ|P$hdZEzLJYZ?jX?t*jL^p0}wU0y(ZfW(6LeFlI8mb(P zl|q<$Us+fAOf#T@v$>?ql(2I1ztvRUMyr zlmS||xRE6NzQm&k5UW(w+-Ds62)a_UjU;`_aj5b=63eYqY8a24K{HaZ+JUY}v!L-7 z`Nkt}h~dwnC!hf!{Auq5WV}zbx+RYF1>sM7C!iQmtEM@JS+NFkx=ptyxY^?hrJoA`{tbW(ZoQP_Ig8aJpOhjEle#1Q_g@6jS^^>GODihHU z5WDE-FKI65@Uaj{S)h%_qa^JI_1zFF=_1H~`v^%7l^V|dD2Xb;BG;vf7RPTQs#ro& z&h?w%Gs&VSCRwDMgxn#e*>Uh$eM0(c1%ab5Thcoo`Xi!kENy~<`GdjIi`%(sM%Qd zkF?fKx9Iul7W*~~#psu>uOpDk|-`>YNJxaY>R!Fjp87-T~?B=l-U-g%(gfVNhkyI?O*8ZnS{3L@+Db}f+Um+ zDPOcLHOxV0K|h|u(%*0ApxbgRo%+xy*=G)V4eHrtkOHPSrs_T3*QG}{3KC94JReOEbpyi}Y{!xuQpS37kRw1AK zO{rlmYWGY@X`t4kzR$G!)}k;~M}2-mGf7Iyv#yC+hjL^kQ0J`D`edVlf5>GD3qmjW ztVg5%AoY#$31c>($s{JvO*f$9AUrqSfJ!0dy)ih(KbJ-QIc5R70R_s!Z($VsY(&o? zhUcwYEoN5RQIi*n9{OxY(L~hnvoCyhqWLf243MrNJJDhg{w8!MTKz&f;~MnZg*Jfj zyNtU~?h9?NccbSow7uSq9A1*PCl(E5ccW0y=%RN%d(d@NAANGrm{&w?mKc5aq3f^6 zk@oLc#`k9w_F9hdm-|=r-H*~5p`^KA8|iw^ahJup>v__4sS>e zemk+^-jHKdH{RYi7oCS#IiFg-2hhy7L=KV;BK{pwrwR3a^U!V3(KWSv52K{_M8f%6 zzDLkXP_BC|-+Xi)gy&v2#b?i>R$YVuPf77g4D!((^?qO(ZG5 zsol}H2wg8jR6*91a#&OO!&coS%?9nwjHQau0?^GcPbszpghyl%S`ES@vIuPixlP(5 zUP3#SGLMxSE}{J({Jr5NQ~+`xTWYwBPJ=p+HBpyQG3ZTLso@t?xjfOY{jltapAW?Pyz~ z>Ud8B^-%qsq3h8zoF;svAEHZDaBJ~Z>YdL+^oWSB)wtB~7`+7jGRTp7j6TSkPYq}= z-}^D@VIz+-YG3tbzE4mlXnf3C-)AVJDoMG2=oa7Ss6bXaHE-x{-xunh`L{dl`$|=X ziF);#tyfHwV>* z8F;VsfMl+`lR-^FzgbK3)ouz$1Jg-P!bY_N6)BJ+|(jtZJ*c><&;;G2GZSWY#z3>O{~q7 zloN;sy5rHGFsm)p$>{V^lmtscGV$nbb&H<|Da@Ipfz3>6{CdT%^)d%0i4AcV>8Is$ zjl)`#6h=bPzBkNj+)XmeQxxWu(LhBeHEx)ejbPpmBMCvnt4G6o=;1J2C^@$BEdlvF#7X@zoHpvoiETb< z&fT|B71xSp@6?@J9H%h%h}QOq_RYnk_t7mrhPBr!2@%Gt7sh*dBuse{SJS}XE*U;_ z=~D})d9J8tuyCq0rcvBgAD+~kKcX>z@zve1lhE3_Oj~E zZ#s*+dW$eluu7GADr#0(NZb5kcs@-n6=}qN=H%Mo)hcs~{&Lhr#))-cvdiTUH~+Zs z(W7Y|i2XcanNVNk+rI-AJtww1W;_afU-s1`8?Ki=oG^Yl`N@9V@$=lzW(4VQZP~l| z?FpI3{@5?fF;1!ud`a`V`A{TP|kdT*jY!OJti}dI;M1Xj%ip0)N~- zBBa^~K6QL4B~nC_*y{|q%rbud8(1tj$GR*yy7Xo49A{5tl~+4uB%sDAn?dglXImK2 zo+ZVG=|2OTS&mDXmi-@I38A&LWarCFObP({$jr$vVB?qSaP2e)(Kq{gT%OWCjKB9E zrk68v^raUty3{)b*NjmQR(7zb5#}91^lg~tQ`+a~7GO76G*wolw687Im1^!HoBmX+ zhB+&-JsKM;1}Nrm_$gLu2S=7s`-K{QF+gxjt+_Uua3TV-;S z@3UfM^P2`~Y#P}V6|EKR*=hpud$8=e9Mnw3USY&DX{s8nr+1$PG-5B?ESIc9z-7hW zuB>dw?3!*#XN(%rryp8Z_u&txUcNOB-KR$w`Sr{tnEJwduN{_9f$&swV1sh7O?GUF za|{XDGgGqZ^#@efKlPudxOBA4snygc@Tu0r@%{aW*;+hkdbNzJZ<`j{Zb>GJPZ}S? z+0;-IoR!sN9=>k>uw>s|??gMFWOMjn?m_quJX!vhy>GdVZRxx=)IzZP*2vb>G80_% z;u5>jX=OjjaqBv*n`L?J@*nDN6*hBErbGY3``?nb;<*>i(G8Z#FIO?+hjc#N%Wny6 zHE8W}sJX&@Z*|k!Y2^b8oNpgYx#@=Oo8Q<>>8&>IV_%12BX5Q=M~yOf10d-J@z<8G zGk&j@u@J|Nrk0625li0>^&-1@*CLLt6}9VqtoW;QwB{tbnmYl1mWVW{Du%U@y}Ou_ zJM5lY0-e{HFW&}u^8?+h8MzH@MAcddU0`WIO`F4<+BZ6=U%Q_>qo*fh8yZ`&C)$@e%qD?kPRj^;X0Xz&U$ysYCq~hso3G0s-!)k zH!M>m^=7M%s~2UA2jn>+OY zTd9LcG&SX=Z_Sx>FYQGE0GfOxz8M`qft3{wIP*j!Ms|+i$d8BlMa2ggJ{lN|^h9&6 zWnwe#&0~$YV`Gzw!#9L)ukxt7A3jZ@*n9&rsxIsny%6Kus&tPvCLLlCq*gcAJN@YR z6;pO;Elu-ruIkCXhlT?Qh+#Bz++W<0_^gd1K&T@D zxDhHuehI!tdgWdoAw`0Luaar2h&)NsY>)$`(REHK#&#sdM5URUzWrEXg?RN)@;T_;`^8MCo-^O_{aNirfb8?ut-JG2M(6% z$e6|<#CwiJ`v~Vpbfix|5L~Hj=*G}KSrEEYaP8c>x_mPAF4rZ*m~h?yuC{xtPlPc7 z{FNCk@B!i5{Tt)&<~+=}kNxb_>mz=4RvReq#WPxjWFXs5HHa}kz6#3P$;`a`QXO+r zp1E~O$wlaA(@-vKPm_^o!tlQ z^iheqQ@P#W^kdkPxCS4}*vipWRU{XGOOz7s{|IdfsD8pFBiNAk$j-1& zA?B&|A<&?hU2~}trH_;G_(Cyt;ZT{gc}Lr5h|3B}7(;mL@cbmE-&wlU_@}w+E5g3J+JOu2V9D=gT%tCTn5ev;6-b~vX%e4e z8>Ie(67b!>9U?mjnBQb5!)K-FS#9$cvrHFFcxwwEBe38sud`=zOU-!Kv9_SAhJXoh zs|(~G(np~XYHRYSD)!00>8_^sO8|%hkZ#K+IkGTLKh zACS0Y{bOJPH1hhb44;-hlyLcF()SVTiZJBteOd-Gxm*S}cUp!n`A!7a(O;_lFQsmu zmeY)at`1CSFkH7Z62@!CIHx>iwK5d*5!9Y)*uuq7a_XYQmO~$|xk`=cRO@j%C$2wH zd*qi@>meFwodu}=DGAF039?Wvl{a+I#M(0Bsn3fZm~hwg^Jz9OAl;2Jb8T!oYx#1$ zY)vW+W9|?e%F2+D zWPlZ~{zRUCd1=4&W8y%z47Tu0JhSe#2CndovKup`jBAtfCB_R2w0@FzU{hD`HQ0ql zZTeHpDq);-Oq$}b+f`V|^8TCTLQ)5W;oCph7%fNtW9>VZ9p`3!B~pBD8t8oAs{}bd zck#bM5pw(&#Ws%(5JM_1zSIP$9#9|EH>|TZG@9o>x`sr#_jDwNa7cV5k-Ma+}tcKY*E5Q;lw4 zYy!$anh_|cK$w`9j!7m+A;NZ{y2Hzv(a_*9v;d37By!?`|4ACc~B=z##alMwK|}gGHb0ilFf$Wh3YLI5Y)Q zd{8YEqOAgpXPqyM%1CXdlToiesn?JM*fYb1RfPnGN{h{o^m*AQwct{sTN(oDRrW$h81ti zylT>`M;NHQB%3fDw^*)Y#-UC{NrfvX4k2SXPc|UQ@pOri4Z_xerIGB1Ds5i2J)ZBl zgr2WI#F&)+USe`}1KruAS~Q>~fT{v{*q14$VjxqDWe6XHR~ZmJo>46%T0Oa#@uGzH zTD&W%V$U7XU#^QH7p%V&n*Y#JBIdTt0oRma3Zq;a8Cs0b4?1e(A#*ntVm#oPs=lF- zofNfwu0-Vdu@U6_0#3Xpu(4|R!MvK#OeiyF{YTjRgxLDS0D+z(V)qa8vUvxvdYK789HiG+JMSwLv|2|x z=ll1M{qkl##HkHyE-pu+Kj2eY&}yTLNpr5_Bum`8sWAn7Yq!{B+lUn6N%uU|LVN3YEhMbFi>EGG%MSf{RE;{*>SKFGM?0`6~!Ntj- zJH8aBZ%yFk500>8M&{Rf9rTtTyzNqk4J#Nse>8~;=xEDnR{`_W`8~%Cn8m;m`sg6P zC8nuduThvUUctDk@6tMD({eehp5XVa*vI;KX{$z6kp=5wZlW7Ybt#+1>35nUM5sR& zW9BT1-XF&$uGn!V2=S<8#UeD^{Z~!a;tJD6H9nEDZk$$WnWeMmCLBZ~DH)gQTdpr^ zTDIa9Z~?*;EFI%!EQ&Dkv|w(3tbD0*ey1HYyg|@y9DAfVi~qJXtkfLN$=u=gU)qEI z{W(76b>_V2WDsAza#|sPrID+E?ZgOSaxJY&pqf5R@8H7&iMDvMW4|hz(4zDC#Qi{w zr+Eq5DE|5xx$oc~rXAaUexIbQhiH!8GofIT-=|A^C;6GtX}Ocd(O8pMk%UL& z4*rLMip8CcRgq65)$2LC!l8vK$P^`@O_D;cBq1}ycsdq*CZ45<;i?pH9NxV zf2yVWcF=?ayOjD%UTh^Q4Rl#EgCW@75>IWU9U{i-u3K29GOrNlPrTKv9gZfOJ$!bQ z(=ln(65`Lm!Vi50I+IY~Y=v%FUAm`p%;9j!9GsueWBM6Wi;f_liAPE0f!!_Ve*F0t zu|}P6r=9!FvMMU~bKaygu?gG_s@pkU_8Mv8SftFpzwf+wCsJWP8or>XofUGICAMwZ z=&dlpPq{-a*`g+hG(1SM7Tcn1jQnB64H?)li|>86I9|iEL?Lt1%<>;>S=4HthcG6S zXt5kfNGOv-YnSrxo|ZFzok6NO3h>m#IV)~o7n(7s--3hGZ&e=Bl z?4UXlmO-`mB*wF1Hzj-bzPGefJPppG?&J$e{mYQv%@y4{IYmP(p!x+K16QWPMZ_AV%G1H06WiyRF1cs@)S`bQ)?U7tDza>JLNVdl1D;{b-9|7H4_ z{jG4ncb*NVcX)N?cMUQjxOL+fQDsKs6B+V{p8!Lz%xc-8p2!tx}^IX@$KA|$N zBriO-3%=DJH{L{-zg}E=W;)?OZxfnE`8U2uM-8I3;z+BW@A=fr%yF;jj0IR!;>2qY zCLA1~_73q59gSQi_gO2V{`do`+0YL}oDx~u;^LFTwDU?o@g1@(yuVEd$( zDnGmOx=?uHxJ+m*w~7r)YpD6(^=-sm5mpm;BljQ1{tpcjN}FHcvMM0>kAdr;!?Hut zWkG;gLEdtfweHjBwP4O_KkshT0=~ZQC4PD!%9?@i)qYYncmJWo@c-};RulYPhsCsD zrbnzmu+_X^K{)Zr>pv7|RNsn>;&=M+W@+A!jVG-Z8{TW#gk;R!_Hga!@tKFPTF#I*F^BsMb z+(UNTUOoh>=-$jbWN!9(E5p-X>CNMFb36ZNlYhl{Gu2jrgTBqrP5xgN$I&JFymGHv zzs){&!nghGhAwH?sB~Twu&hx5VDt~X(Qm4;qZ+o_SStyYP1$Rt=SF@!&}&CyPUzRP zWFNq5$asNbJ4t@ktdDq>i-A^xExW&XU#wnt(oUbFRhyHK=shYbPYsNwHO|eOnjShp zRi%_60Y>{n_?dy@^JrVteoeOXxs7=(dRT|kHh@4}&)G$T7~Ot=nR+X$KO4nU1qFxgHvYTSbXqzFmbv~nr&AW#Vmte9%KwT;)rpZ0=4#}D? zhJRWcqV!)MxgDSRL0!a$^Nqo~fBp!5TJT4o_rIH0t&)*yRcYlb+t)9lPF73E;NALll{? zPIm6M33+e|=1FYC2TPw!mXtf+9Zf<(hdW<>uOn{WmBY0^X5rpkq3r4go%_rcto^|7 zkLS;hUR9Xbsv50vx$m8Z^4DpxfEh!bm(I6uLCWV7qK}8qA=@A6D5Bdi|pW zxqj~5L}Y|qP0|U^uP1*LdTR2&e0CU%J}7+ZecRzg2rk&I2|a@z83k+KhZhTdq*n{{ z@yf;TJcRq&7W3n9^$#%h8>=OR7|otyci6=uk5#zid>T@|uEH0@_DZ=p!U8HlXWXrI zq`Xh|QG}r{!(8u#=uOJmvRfIjxl&Pdl5Cy7xgWi}v>BX%|*m}7kFIB#%$wZLGn%xO!>`D;(46MEJJ*WZfRBZ&z=+KK|v zOmSN099g-ZZcbaJoyVZ_4SrhZL={NqqxMdKbi3(3)mRd+EBUJ)Ii1c7ze-lVYv1S7 zE+*fAeH`v&ANZ1g%7sa7=mN5n+u#iawKG0z5;1Ps>{o#bzO^xfVuk0Nxvvf*EY30K zoz^aGb{PIV_AISwGXAWr83M??XQd@SzlhzhH{qNvus{VH>SZ@`gU&lWuK4;K?0rj} zq3*V(6e%uCinjwa8SY9@ee;sbJlOJiiF0=ZUHr2ENd=xXbqW#X&_8B3rMCx5hC5gE z_EbGb)D*b~6wcaB0-9KkQveQbOF|-C#Z4lcA4i)gK)e^vr6l1}VbttO zZ6dwM%5{m|p#kJ%%-DAPwPA6ch&D^hnN>!?L6t@;v#6Oa`6;_dzoZl}wxjT*5o+!v zeVcd@bjEnpo=ipamUHf1^T~uXUE2oE0~NX6<)(xbJHx*AS+8Pxz1?^HGHnh2DtRKIFXWt)lRMQfnOlamQG7( zrx=*foHkxN+L)v7rPeAIODq6YF}9T3azY(bKW((Vq{_KEfZ7*|SJ7EN<97X8{b~;v zJ|m3R^=f^Vk0EE9?b(+iUv8QwlP?Dn@aGp_rIyH*9u!!*2e<1eA;*8~22KpL0|%^_ zceY$c=!ON}*s2n;5K4g61RLE6K847kq}w18G8-$u$)CN2z~r@ma4YE|Bj#UK2BQJ@ zvZv7Z&T*UINxtzHq+aE#GQP@SiF?PNN-pD~_qA?HE-)vZMgFpOdc@|VWowp){Fz|Q z&9e5OU`X?C{%58;sV@RU^AqYO#P+N|?Jt{_Bpo6M8&Sahit45tAx69Yf%vZ|`6j0p zxz6V0q=sWc!<1SGf_==pxg(iUCul=#SL7u?yrfKGiieP*`Z)kgoJ_e>o%lU~1>58v zrF9?F{)Yelwc8xyV=6CsAsjyUEk8lF%&= zK41MN!pNz>w$8BzWk*jI=v|i2-MnjCB@=_(5$*j9DUSl4d9dKPs)5eP(~t;hQ!XPq zQ9;Zn%ce?iBFDn@o+h3UzMbUl@YQpm?Ymxk&%tK+P44GEiW6GiQ=;AfEDkTb|KY)4 zNAu{iyJ7flu<({=ZSuhkxc#v1^qU8X0AE#5FWvMqVJBWe{O|1MBFON@5t#|d0@Wvm;HMBZS>JLmOqH*sqpfvWI) z2j{$QRTJl@&(e|n6N3#OgtC8`qjcExg5Vj3du=}G`r(ff0~yk0P&uI=Q+f8oHLAW% zq1jfE=MVVR4F>U#^<|=UOntT$F5mU7g620FYafXbIA?Te>O*_GZY z)v%v*!vnDg{IzMQnF~FvpB+MSI%`iOOG_Tv1-DJ+|H(=oCv9sOis(Na*^SR;E_YCB zc);HK>`jzp_d3P}uMMc)HgJ}cZ$aG#rxc{^g!kN9g>p8XO|RKzdK&fwj^UKm9U zH~7PKxR049u|K8Nvis1b+rvvf7(|^#bU7r3x=UVz`G!Kr!L_^=0!Hj$7)c30<9Cqb z=7EX?Ng2Yf+XL7VmAX_}Sy$ZoE@jE%4qe!EGd#;{L5?4=`Y;xg9MM7bFfsG&J%~8n z&Y|xqSmn&jMNgP;uF9cdIfoP;StP#A-S>mlOqiJqqCbh%(306z>$BPv3-(se_F}N_ zZ1Q-{y->bXaMF0rgRja_x!Kj-v)9y8`^YZKGwPIJ#aPWVrAl6}nG4S=vDFE6zt{Pg zY@y#w`OzP(k6c-qcDFmWzj8Ij^_6?x@7sIy-|Vi^t;DqT`0}X0)tWVaIfJu_2#^HE zC!`D;*{R!{Z<>m=uBOwG3Zpgo&&K>T@)u0>Wxa(aN0tM^cjfB`KNmnIJZqC+Y_zLOU` zqiL*q3I1LR=xkMkkVx{T%2j9NiBIl!i>^{pUj*j=d@AtUJD(U)NA1 z{5A3nonG&OJLWzzzDpqvZner>f;$h+2D-{-LYe0mTHN)m#j+po^%NINpsm)ZU-Peq z!rW!PQ9rjZ7UwJ_lL@UzrM7^J`<0Hw+}c0=v-Rg>6SZBHgVWBm0F+0jaRO)0L#;N3 z4w|gH3u~=NP5H-+Grt@<@frVDB&+CR{nuO6>K-^jH+2GeI7+nh1s+)=S{|1#SNEA@ z4`*c$Qu%VI^(#SPF52s&_pQ^Ho}>x(ciIf`@$WV_{KmJ#gQI+VVOhM$BcHL_fk+q} zrvncb!TiU)x*reCc~;5eCqK*|#$MSYdhKkoqhpPL3v-6@G`X@x`i<0^e+l)9eC$5k zk=wgE(G`G4GqRd5)iw#IsqyD@ldS96^xn+xdtlucE zoOj~F^T8O(udNUmoJY(2E5kpK7w8*+Q{&D%y78{Sw33*meDB2LwSJD8jw6vhw$EE` z574s7nhwg@q7Wj+dm`x@79D$RweC{{WwNN1rpSjl* zFP{aXF7wdgFZa=swu(c;Tx|YIcGaLM^y`MwiUzunpf!&&-iY3BfErgF;}2FjT2a9% z-=tF*4GgtEm^>Bpria{s^bewX4OMvF&b~4t4T)}#dh=>x)?i#9YT5s+!#x$Z)6y}L z*4u>t6yR*l=on~8c7>+}(S|^OwN6D5Ae!Z65GvV+W*o31%&TG3CnKV2>b}qfyN3=+r-$NjaZ~q-c``@)e%YeK_orOk z>4REG@*kaW`tDUQ`CZPf%F^`QVMsMHxO~dcc=KBR=V>_$Fg7-~l zadn(cOH(Q;J$n2wQVW|Zkb-j6AXT2Re|uKg;CDi+{uQ4vnqHf!e}+7$HND&_BLybn z>IIi)63e;NVY?r?j>vo=F2!pfou%6-^~(tv>Cx1-9KWxJ95u{Tz{%fAG~sllV)!xf z<4@}jYXUH)HSga!8~Jk==Hv&oSh12?L(|^jY#M#oAM&q+{C$vxVj^n*Vyo3x_MHZEer#5RUGsi7k|L0Z=_5ogzvJoC8b-kp z2UcI696GL{i25x*lXJStCc4^g?7mu`%%59y^IAlyIGnFy_jmo$$ZoGwk9NgVm*~}# zQb?0zC4FlJiAABU0ao^;%)S(bVS|IRY-xK@Ta*D942S;B*V4wXE|QUnBFGt_U8y+C z+j3nT0#=+vwfkJ`1`66wi)M;YaT+SQ4s^EgXd(()WM#62`z>x+N3wLR!?HCh{3K7n1mceJ2Lh)IYMSEa}+F7Kz4} z4XCMy(!-qdtEj8J3$FhK4qNvs0T66D5-LGt&K*Cc=9h;FzSo0B6FK0+)1n+CC-4p{ zy)iPV6tr#_oO2Tj4^7RY>f`}5&7!=;QPFa^!WE#eDJ($0lHso@lODa2fd~3v1!UdnjF&F%$hD%R$>ZdPB(7>GLA6JquXS zhPdR{vn(V<%>y&$WH(X!du$(Oe#-Tbs$SN*-E`c8gZmZ+K*QWKDL^bfWQB#->D zyEeu&T(t1I-(R-wDS8J*fK5C~C@n=U_QkrVcoSB z&Cp6YW3R1B=R#It6#O=Al`F%Dy~kW_uk{pNE2XMdC~ck$Bq=rdr4}hMFY*w`hwWxS z_oARy^K%u)O@3cu+L_5@>bZQi*OOA!r?yhnBcz2X(Wkmo^)B?YPKCzqeVHm4r5!_$ z3FVZ`R3@mJ-74fMh}h>bO89vi7mT@vMd$SJIj8f#C3t}JYP5+E3-?!}L1OSRQkZm=%qF(9NH0Rj} zBNw1JUXoXZ;h=IWMyEoM>NIY@9|)_kdVm)6mmM$wf|`$j&ovZX-)(kUaZSUAoVCvP z50b?LNL1(hQ}f%`i7RYO5T^jva{%nlAc(waPv%mVOm2||c5UTld=*O^59X#$P>vNS zpAP2GxTYC+Z5dps4PjaV6wj+V;6;noplScC(cT0LYYZ?c{+Hn2vF=}cPJyq$=y(*+B zFBtZ7OvBHmwhUC7Gqsh?Ha(7%Z>^|WKvl=fk`=%oI_Mv}SYrpYG5)3vZsDsWRUMH1 zC&T{_QzQ`9ZU?tmVBvH$Cg`>lYm15l3KRu{e~gNE-pR8d0!T&!wvGma$KDkHketx293y zeRNHaMD!yT^PxP>S;fsss!1MzI4*-+lgGAs5{oFkdBsv^PFUW~dch`-+T#Dj(ZXAu zEt*E>L81CA>QmYqf`z643_(3X8X>0`^#&M4X z=$!AeXj?R)aPvynhgfU}bruuJsNV7|V>qKN)Z4NU?G3c32vvBkr*VgLE` zI0kISc4pT^c)l^pgx77u;Dcw=sy$Xyak9)ly?%%TbBO|FGX%X(g8#TQBGw zh5`cCJ}nBzNB=3Yt;nu6ns4#a+E1oNbL0T0AIUu1+amfu|E2$8s`+b}SC8C+kKW!B zqwD)~Mt?{Q9FK`+)KCu4WhGIUo_~Hu>Qb&=i`ky4wkch#s;Oy?57p)ymgv4)VB0D``TC38Z7IX=cMXB8g`r#R2V@|#8J-O zEw>kEwsQ|w_s^io%*D#D?W92G%lIv~E_fJAt`x-o5j@^$P5U>g727d`S6;qR_HR&Y zK>L8qOY?+tXG4v0yw9L>cWbmWlhuA~fT7ml%wh}OQ+)gfVZ6^@QLqNw$ayJ@Dvw5? zBBTOv19uHy10nUZWz+HRt3{ZfQg@K~0$Y#4&o@9Lqqh|jsoQ&HdBH-fb)9qNZYLup zm*8tXLE#>qA^Hj}r@Y3wk%d(2;_dXfG})Gwq`7%oiRJI3mIQ^MlzPE4D?X4N?dVS< zdtz2=koeNZB4YTz8a=bPgw>m4(by58Bh&9kBFV&7Y4zOb~`9ZbmuS)AHgBVu&NlXG?l6s4ZDzlG;|Gpv8-6S}hTY8^PdJqD49R;G#!22_dDYGG-~8$;h{!oVk1GV_LIR+8Z{kuJiTh@dX1(3~TYsgdO zb>(J@GaEv~y59T@+T&jCn5Ej{4n`kVF2j6z_&D@C*^f`-(l&t8-nsg%BW%=1%Fun| z2i-KuZ7g2On(lc|eV=3A>Lyv|YZf)RqLd4rT@mPbTD<>oSEbYJU39L&$FYqsV*Vc8l`Iw zsd2kV?Qc&#iXhzhx@hRr#vL|WxqWk*7+{o|bmhuAanonrHSosyH%Pk8oNp%rOi~+r z1zsHZJ$#4svUjy*doWTJ(-d?(nO1$Tyb30v_6bVkOxYl+-Qxn*CR^^13Id;Rd8V&nMF6`AzrFLWQ@Wr72)k{yLv1**HU4P<-*ELKVPJQD(dj#uc z(!R_lrApHfjBqvw4fM1X#7_Sib+&M>hP7_fB^62WL43I$6$#_E`0(X(9K=<# zvvb3*Q7X5udDGa7DD}>D^6ijrUY=3|L_j0yR)wVB#1){v&dv(*vx zFm+JN8jA?Q155vrnSY^Ci%og;QGDjSgFXG}f(5ImY#edYUaS;8?cwU(b$FT? zi-d)=xt4COpUhvAVqdpOX+>I_Zn2u3$C92}!_meCHr!@d^a?8xMCkVFAb@1j?Agkc zL`+WYL&bWRn0!&JC}E*lPVscSY{PTIAVK4+aM(!F*!ZxHXiLJ;H=WuXkYEc?UNmjo>cB^>Shz_DkE!z2-o|MbRv$*yKFoYYv+oV;!2p zL#XW)!He)S%j6;Lh}QiaF2wx+e|%=M^_{-Hup)7ip0_^*OU77!&)O+BDd`ui z`MfO8&cKG`RX1w!qgC_2ZvvwME^F&p=ShMn*@`bu%@_XS)srK{QN^^Y;8c_mkB~>V z=Igf&rjgH7`H3yLYXoOm6`c)|;JLErm6-<4hF2(u^{KwOY#;2`NY*(WvFh^elG2M8 zh)FXOY=evzUDDZK575oW|75pdpnZAybSRDEb?Ql<$7<%UG?UzD`lis;rSYS^xME=b z)%xk}?`6O0$y(R-03eRZ=%#OU5VjAeZq!Akyw<6=Elh5Goriy%DsTH#?cSw}*0*|- zr^=ZoeO%+ek`02ntFWsu?>M`Eo^E-*vZOIv7ac&GZ;25uVRk&5O*McjC;J2MPDYh+ zGw15;LIV%WS-`J4{ops?_6G3QvE>=O^YV6tH);hy?1HugL-`*`f#;KYOs&b2o!lq$ z3$&w@duieUA_Bu!)3uXrRU&uRH-9gn{Iar;uQYiFI|Mob+=qkUS? zdmX!NRmqM%j`T-aW_-bG2sb+AI7ogwaKDWG{1C!t)B~wb5K$dE+5wpt+p)jR-qsRB zej2%iGUj4ta?>UlpV7ScS;4A^y_U`MP0N> z;+uIfpgUG}XMOT0-lH7JUs^)yCm~-OpVU5; zMxDS6#eVZh-9d_;yMYQ@=>dU$7R}e^DT`8a&im1!yD8vcn>#mQGU;;bGNHZaRm}u191k=-B&eFPdM=)0r!;s zo!Th%ukLR(N%~P+s!QdjdyT^!Ewp##89VK@WkP{g%AE9n@>D}0Sj@(bm;{&=&=M9#swO< zdNCP;FAHRYjF8OP%esK)<$iCsMr|cW`lp@bk;Ray6HUr)ttOgCiZrb=gp@{(;nChJpU) z_PzDoumOCbSVx$-*n71D0g^OWnJAV#t-4|Uc<|ub`^!~SPsl8rg2@3zT0dCE9pEd9 zkY$z?(LQVy0xFHioS>hMd*9Lc@YezYb{rGby>9LhYoCTq?s007QM<2MYqS&?>a!zQ z>VXTf*>8Jzl+9s&KJovLs<(iOqYK&wgD1g4a1Zbj7~Gw~-Q6V+g1a-gyIauU?(Xg~ zxXa+~gWK|b|L&gMbEfL_)UDfBx^7iZPv56_cjzXzT}%)0M<}0SlHPT|Mg(4}BVOx| z@DT4i(5ipJ4&y7zvKxy*>&3eEp3To|t2^d%&a}crI}yxn%Z9_#i+7Mrfe0v9Eoe(IPC#wN!-Y=b`Y|<4jnvyfT z$n$;&n~(cTzpo5Q#{6P_N}f@GxLz`b545=+muj{}(rLwDKhqj5!o9bke`Gq9Ts$kl z+b|I1e$geYC8X&5#Ysn8xMt1l$#W?wcL(ZAMsu!ueDZ~byYS(xvGNbwc)NeG6k93sJQD?#} z={$mIumXMoxXZrAIhi8U=*z8HiJ2m|;CeW*YDE@ZIX4GKx@=}%+q}>p=X1E84B8qU zG%%V=sL>>tlqW%Fx^lY~ZC-k#ygNRA`Ks1V&EM51B1%G)LN4airVlpXfRFkF?`16E@5r^HjM1~zYhGdv zi5*<1UKS}2gyu}!rz&mzUHuNWX$_!ly3Q2WvZVZk;?RMKH`9AJ0sXD%T{bXh=gvhc z8wpI3oizAVUp3l5zVHIa_J3L6v}=S4XnnJ5>1}VWUTTEn|GXknv{l}iut_K zY2{}UZ-n90r20~r8KT}nKs{-#9gh<&AiJ!-sZ&D>hyPY+;@p;gt>?L ztY3XEcocf`ZXXmK&1T$J_Etu5VGX9BkTGiJ+~?JJQ;Rdhcu@eMOaa8{+IL$TCSfd^eALc+YujQ(QojZZ?x8tIvm6#Gfor$E5Jq_ zBo{0O4_J=G9~j?1S0rA^j$8t)bEvXQ&2&a>JoDI^-d`;toAZNh^l5fx_f03;vFe_T z;-#t>c*C1GXVf(b1@)C_rct+IBaUB!o;!FKu?E<6B~E6=T(`ahdZS{HNEv}J4-efe z)q$ZuJf}E&7*!v{QbVz#M3I;E*1q%i+e|Ca#a2ZeU86FK?1yVP1gFvpeAk$d+Rm-T za7bv*xAO1&@-(!ad|ji-=o(=cc*<}WE_(Z~xPYYhfC*?2%6iRqS~Os1FP`|3I{=7% zRT2q?zl{vV-RyS3dD2RD?&rSx48)vsk{*ju;=q8S>uGM5Rl zXDf0OiX#7Y>vjq%dslslw>$Ea2R_|%xZ>ZOpfMP7U4~eUYkUkqHm1@w0!CEz^k+ik zcg=^PUICb)FAiKl3NfvclD%DdEwo05nS$h$*`%+vxy3(dcUXlgK7kPMV-#E|<$_D+ z_pp@U3Y1hj0Tv^g4aq1WrwkTjO;`BQV97*X+X95`{O_lXAJ1_{ou6)4B>5QWADnRe z^5L?#9wPe>nt?=D(Y;ry`OY+x3Q6pjIXiJi1eN@#jpo;6p20h;%I)+Z2rCikOm=@! zTPo_R)zY6n4#LLe>IpwEetY0@(XGglu;z=|?v7;=%a)2#u#op{A+0sVRTu z=1q$Pg53@~$Wq)57K7UbJguWPeB4E*(sezyXe>olqF(B>NPB@4n%Ty>dN+3$NZ#$Q zoHcRab4Z;_rm&pqP$!e5MLeDT)2C-q{34AL9_-WgTe-hgH^k;urX+Eo`rh%KA7=(# z5;9g&Yx|F1lev+>{Cvd)V~5A(a5)N;)^C z@_1ZweRL@Sz4a)=mUEWNxt~keAao)fK@4#|t!(-Q=4j7zA(R5@EzJzfm3&}n4hk6&dsw=Gf{!eCx z0@K|y`BsGmB|$TPnx=TK`ckdA_Hb1L06N1yb31T!>-4G%A@xGf5Jz{Ki=^W!_`*5;^C%x#<7y5tVb+V#DtM z%Ow*l%kn6OgO+8YRl<6T?j;LH!!W$f6LqM24HK;0GvYHOR42EKvDrYh6BTN7FX^5P ziSpSvkX-j7tBzJ(K2gH2Oq1n}XVhx(TX)EnpG-x`Xi}59-`!u!ibtH4Y`|uGy|lk` zPvO_I_{8wk7^bdj7mYMDE@SI|Q=pS;dW0_m{wFlRUlF=sWG z)f;S`i`Rda7fP{D9k);C(Nw1?CLVhyECxBmnK#%XAMl!pcW~!7ccSuVPI;V)k&XLn zKZ&fT3WbS75>qD*1+b6F+U!U-#EQIZJPFRocV>$>p4e7S_G2l_KoUp=?mrw;jXPef z5BTinjgfnnI%SAB6Hhr8xe#@XR;=x0Q>L>?wmf-z-b{(8=+f_1ok?bjJLQJvO}Q0@ z1@8L8wnhs=-UYub;K_BsoJmh3I$xU}pk{985NIwY(Uepjk_UXR)7AT}x^0M?v|@KS z*?)bf%3Vn@ulBwTyXf&M+=dMy4dLY>z@x|;IE*lxyECu193k^E??|(eo)@v<9gG$~ zC#>bJw9(*nwLPD#RU|!`HDjd87Jrs{WLtq5EmB(TqEm1tga8AdbJtSWEXqMKM+&?o zABAKiMM_8I-!qX*hIki@f@p(4U05ck$hK{>%~&&71Yt9Y!XC(FwLajX^VU&P&_ZY{ zmt|tgtcu3pX|^c}Y>O`C91h7d4Ti-(kf}_)f*PtOxEk zn$W`}!>4{{lC}nwf|J@D;T^ZqT$H6RGO{5j%G&1d4W2S59*dL>1obva%FWWdtBf9= z>a7cOzfPh+^~zmab;{DpCPUbq_Q^AY9f2v@vFoduL)%)qRHh?W$fIuQqfIM0Z)P$) z;vPHoRi*FbJ8XG(joKJU5yfgfG9K6$G@a)j)zPlaX*vhEE&8u8d7h;v&bLmCQMwa` zRmCe7MiT74>kQ*0d9}3uTr+oo_g*J3*JNRu&aZ z<9M9R63Pjs`YE6Xnz~(;I4%SRFcP^5@lMBtp6hBS7EJZSIT*r%R%_I zxFLB#tEEp_YpTwl7A zH~wt+*jMTsq8p9E^(KANXJMj;Q)qann!}8Un%Bhi>LMb*#{+Rg z8^QxWa_DQZ`lK?3+!8HFP>;ALc(r_;uoE}zCsPI|k6Hin6TWD(o~+B%mku#c_w4xQ z(q;RX#c+tT6T!byxp- z&h=_s=6Ry$;4?)M!kFWWg#9hwJ0QqZdMyG6z=q5}l6&aGW0~PZ0(shYM^0oOkfxlvQ-M*_yJK`7-Vkg?3Vcc3w(J-@b zwaRXt6f$G}b(YIKFRK))GVQHZCe-J1Aq@E#v&)d-I|MA=1po|7N6qbL@ho zw%nAL;s-qlPMqg^$IC20(On(dod9)s3oDiJTs4|ml%&ymT!Rm^v&jgQ$>2Rd2w63} zNATr5h`p7R)adJyOHSN1Bm0Qw|K7%{Ja(51QDkcH}xGLQC&!Y4xQS zTYIN7d}aw;!D*MB@USOsZoJ)s=#~cn1ArFWQg*kdAw7=HVHfxB+|A$Kv?X(-cg)ES z6e{sZXv7#+ls=!1xC6)t?JFdNT`s-OAZ1t%X^sPxLrt_n8OA}nX+arpx>u{=m1J0s zsjafFhKpdyz7gkFVTS?N6JUToAbs1wkL@5FLKUXk=Qxn1(AIk(9>OwJbw@e*xd3`$ zrO>{TB0M4aABic@#fW;VSmC>b9Upt^^zszyP4|X^eu|`sq(IuAci6JGp7#k!w`mU1kUKE*eaJ$bE*Y^H< zm^IXtaE>lPRo#++B*lAP23X=zJFI;hIAkt4 zSIkjZO&P>LE1N0JB**GmT=~-itB;#uQ#9((hyhc#?=c*eoARvT{&}n#C7LY2i-oOp zzT<q(l0ySF)YZW#T7;2dmIM05Ga&gu(DM*^5p{=k{*D^BPS7A6;azJm zOee(}#Z7cWG_g?=!6L!S^u0nh;#f9+Ntqebo686t48k=#QmeZ~Sg{Pz5u<}Vj<7^I zIQVgR_sn9P-1@}`AcJmc7EN+E#_A~x;U&8*e6}QCW~M201Nc~PBF45Gf#H19++tAzZ-t-ogvIsFmI7C zWjzSEg-aH7(J&v1R9O+T_2nvXzOD@HAb_fx7*R&HsIS<%Cf(AH>-Djfa%=G&2;@w^ zb!chU=|-Y#AE2b!MAAWj`>Ly9L(BM1hHI@3SGbO22UhCcu_head<7zpanw>w0c>R# zgxG~QtURx`<3Y(x9ZZf`I^tpr_6SX5dn;AxnMN_3dow8THl9{`BqEgMV)@S@gMmv$QctZNi#I@I> zW>NJHAMcweEv!%Mi;IxHlU}9{XC3!}GHBgRx&MZlgc)?zP`g}|BA-ll%Iz<8cAu0= z#xq}V%TlN(FAL{2Z`|_Zh%-?wW+Hr9lRWYu3GOO(8q=k@=%eSS`m#92A{col^t z8yMws1O1qXB89wH9^__qtji_Uf3uw#dJlgEalOMe|EXlJ1!Z>-%^aHdv21vi#)3Y1 zNPiT&}=J829c~PpoDdO5!(XEoVj~ewq2z^lDnRq>x4ww@@8GZ3e*gkRKtr!F6 zMsS^SSI&Pty1=zZ5hH30UA+}M|21i!$v9&!OSf%Vv1lGhzrCW9KU-`+FZ+dGp?UOm zUJT7SX{UVb9+Xt&5JBI>wNDo*Efm(Yq_VQI?U&Q8T=?!9}dO@;20Ah+g9_8*rXror?Ba3LG)2)NGNxb zV%+3D_F1}Usso<8cPH4PS6@2})=hV^qZ0OI#UVgv7^RGLEPFx(pL7k!d<+Q1eL*TbrD}8)DW6fh8u47FFJN zJb3XND=Wvt@xkVTwgDYx)H&Ty_r^`v~Laf=rSto~66GD#36n z8PH92n{KkWf{+SbqA?(OcLHN?MpL0qal<3wTqI>e}2wFF~y8D{vTKX)h&4FjW`wvF=mW~ z{+U6_(-bWIOW_>TGB00%^mD({hjBRUV(kJ%0tJ>S3d3T5w>AG)=C4ukRp0bAxqi#a zv4Dqfl@?3HG{|UJkvdp5$mp=(p{FRR6^rT_W*P|A zqAJ+sD%!;=+N~cvGJO_nG%$KrYcx1;+L$@)43xhwI7$@Y$W%U`=@QO>;h7Kl@k$3( zeC5L{dH+0k+~phQq2`vnctoNCwX9a1xAik`E&q+#;DoHH;p%^T`>8rdAJHl|Bp?;j zui{p;x5=Wci};ASEG-feD5snlOum*P^9w2d7SuG!BgN9B7d|wam2U{ zCEbNeXj7|}2MIej#%KMa_5*WVAvl1A%o3#=cy1TLJ zGAm%ytyLzd)CQm~RwM@Ns7nV_E0L^NVJ(>CRl{(6B^*tbZ0xV4oEEQ1YErV|_H-f0 zp4h8neLN)srkmzj64xhym3SYCKHhBr@IGcVwoQ}s@D@A&=CU#@44~^E^1d{e=#zGd zJ2U%==1>nG!nNYpN0b={HYUP4a6=m4hWVw&JUfkDaM?+LN#`UR2zI_}833jwIHf0C zMBM&Z5Xnr;(ro;%wgC4;p)PB}6p0(qAd=xELGf^k2jtBH%R}lu`jnP%&bcV%&Ktsi zlcBna!^Nw}UAyPih*fKn>4-biGW`f>o_GJYw)KLtcJ=~G=irS>;*M&Te^vcm|II4^_w3O^2wg4s-IR~_|Zm|~1S^;ltoC5}9a#xE7 zb*PV4n84Mvk1gjjf9dg0vq#=K))KRd))TX=IPdFiq`^#R?EWHATZ%i}bMRZCdZwKZv~ZKEU%r;&CIUtz?mB zuTcM_K3!%_u4BQS^Hv*oea=$PL8Z!h{zKsWA!u5gv;2a7tDP3&L7)CXDIp#epFX|| zWmy;&AHW`ql!we@9Okg4+$*N3@Fnh-l1MwIh0N%ViI`WOLOZ|B0&?ghjN&4-bI@*4>U9(Gd3wOo*86Pq&d(!uI1cWc_wFnrz!mk-#2w-!h`E_DUezJDy^I{DR@6QHlivQRCRj{|lX6;HUH z(oR&vw2M!gWA~Vvi>5xGSfvc;mZmgNt+qiZR_7iV7jf6NKyYhk ztLQk7m3~NGFb(|M#Z^Du)>2@yuA>kYo;MJ|kIDWAUW7dno%|5WP5aBz3!TeW#^Pv+ zwQFbCpm%G<8=tQ$FQWk@Th~;6FmF~&!vgpyw>}8sPiM|??{5o+x$j!l?eB6-1Mg&- z^FBnfHwK87kJh)b?{8eyon7opQvz64+u2_@?yF#Ro@4yZUc3A=Un@gC$}J2FyZD#J z1ipK&bit3``M{!G`yioRouE^^zpC|Mys1O*-kI#$1xPa>n<)DaRerNCY9}9MQ9Xa( zOuM@?!?;LK^T{!K#0%-cTLu{gN&#XNpjQ+46T)#aybdFLwvpiz+S)Vu=c`EWW%E;Rzw`{x>r&}p2T{%z9!i7nNlP;hI6+%1=W2QTSPt6a2SAz+A^PL zs@cdo`y2=WrPXFXB!C5IPpjfQmHw+Gq9QTkmg1YZMy(0nvl>2&y@~VjqTCycfzxL- zX{G6RSvn{af3pgCQB53Mwjs%8k5QZ8lAns)fxqEePvn z(yz+_YGv-kDuo|M6OltUYeQTrlTGPcM1QzGWdEbbE$egR)&>Bl#c#lkY{@RqCho{` zZzitFxi2J^jo%!kpN7+_(30Z(rxz_n9mMwh$ zRu#%}n#_J;?bx?ZcITVq%lhmt#`ahC`sZGXyLX%Wo0YGU4>)b86dXBZy6fr(mhIX+ zv_18%<9jLOpDLF40)2;PVW-M8smsWs107_bvTu`0ykk;J9E_WClbI@{;sZ0Hiw^#) z_T;6?+theRd(^4q~3_b>8^$C1jJFP)E64TMg!nG`;K$+s-i7Krh*5Tl7 zvg18dhQ~rSUtdHpWGYtzG#oxN-+$HM+~rcSXo&QTE;AwGWHND8iDozXxZZ!SBLR$p z(Fqo{<<>;2mV`rEg&Ag}u*2v)KiB^pl!YgWU|h2yMy>MB_r z1xrT3tpAVhjqJy2D3Sv-rfqey_x=5-eItwioN{D3%BNz(Zj!6u@Jc{xCP_aWi#kSF zt5Hh^{#&aNexxxH8+vTOYm7gn|J&Oe*^eO^m4C>fn_9wb@gH!DqeseLQHqViUX(WC z)09+wv=@l9kGy4q#OYv3>)-g+IODiiZR^a808v5$9ruABYOWV3- zOru7PMpILRYvX<6eI0s3OtnI_LIb$QpwXaChloLxh8qDDRKwAzT; z`fcb5vj%7pZ;`eVzw)tCc#&lB*CJpMe^G4FWDzxG+okyf$?-h;T=rh^9{D`%+;v@M zt!+KKt;_!X^lhH_IPCgA4;r@_K6Ljq_Z9aix2!9a`^dZTOS?so_&s_4U_^-^C$uB%Ypdbv zSPhZFz;SfIXD$3%Kt8o7svO!GUK$1u7j$4sBquurF=QUi^7{ht^s2h3*P%B##2RfC zqmlE}Y)RwSK`%p)9x~?Emo2$oonX_DF8nvOha@}pUTh`qT#x>d&|7R_a}UK*N>vgQQ7hO<_?g(R!qEQ1wL|pWCJ7%xdSg1~Njw8t zGg&Lyc%8`54zh zq=A$eg@_9b0id_Ir;z8b7uPGYFG^oZzD#^yq5Si&9rKpDu&9x)(P}?Q7~_B5 zsd%Z0v8vo9Ldp^Ol~NrESqf=c^~^__Gn`Ugln6;@`YuMxO`}=#I)!UE^+CqMIgf$O z)NETR@))$tHQzJadkiZ+$$sy@(!e#g>EfvV@@K>H^{*kPkE2~#6}#DO6A~k$D%(L)=*5p z63&yGS4>NSdn?L0{jDrtd>i0)k3nCpYyk-Fa||@2(Dy%ZD=+yOil#~CjHMz<#VqH9 zQx(CW3E&6(`2ppN18iWg4+u|-w1=dA6=SRsf({y9CoVsoGwk#j%#1QE>VOD*i%)(R#GGcMdnmII2?M3wdl=xgk1c2Ss#Go_y z{>vdFG`1>~`mr=L4pX!}gL-sSDmNp8oFrC7EG>i5Vt6^XFoV`s4-8@^h0FXAXk2mOxMI#=y{jQX*-{huEL@F;!0 z=j|~bhE^H=aZqcg^TDnfwKU3YXZSfrco^V=Ydf62E%z8QoZ=Jix@Tb2Ik)@0WUOF@ zTtl)=mzLO}&S}(ohQ3LrYYhOm2hHoA}1lc}a&uX_J08E31i9&;O2$ z|7o0b%pz4nHb%p4!d;L|S2dT6o#?@$K`qll)IHiDak<4`!Gz7IIt z1xbUn{yD|UBn?r%cC8_eCR~dYq_5@v9<7jeZIL@7Yog`flP^eFD}W}qB^B+Gn8dD? zp(GC_neK9qI$oFi>#7EijE&m4>$wZPq?%i%Q>>7Ypt_MYA!|KqHIB8fFh^#a2kGC@V z-ta1V3`SCV56iA{AZDoEVB6hnWwg-^xyZu#l=8sw@%SuQXSdo;=G7xGz<23M%l`2) z8i1{Sj7)-z(wFt<{XOZaBbM@s^tywO*PrKW3u=LD=g3fQ17>)R(l7Ph!9l1ROxNTC zwr+-3hp012vtcR3716k;yx@S(lkRpZnb|!hXtiBUX1ALg(~Uy?=(UI1=52ue1oN(q zLVJ1k?H9nCxt=>Bi}b1JloL6a0k(mSn*VS(3QMpbM^(+);m{%y0#P|cP$y4<_G zP%@1iHUkwIWgtUjuQyMNJI*|jwDk(Fb&rIr6C#{rn^N)R2E>XXqVi^Vi28(Q?Ab(# z_#exJHWURaUWc<$`GwaK4NOxRRiL8G6hP;=@e?gmq}|Q;SauJc`gHdy52I8BF-fez zol!&}TVm~DQh2gPN^8J;(oEjdZm@T?p>-MgH@5*Be;HR+Qs!pvT&DmoQSI^4ndSPE z8;~wNHLnpxC1N3j{P5+7SPBxzz*Eh_! z+}Jer6z(0KPPj^MhwWw5jFY`C(6w$VtpcpYrHwr7UoSfS&t2(*)(0NDE=qdKx7p?- zA3+gHRi1>UZ)eMc#+=(P zG;Q(E+9c-A>F8ui@hRf#ASLL;Wra^Ku~SvX8j=U%gCtQ3d6lg7Ju9~i`6FbG-O)$; z=xTn2{u_#Fr#Tvm)Sk1R=#!qYg4R%x*v>UIBLUSK z*`W@5p(d%k>%=`V*VIASAij+zu2abL96Dab^NQVe)OkN+i-ebr>Ap4i>v+&>iS463 z=>Y4$Nfj;~7q%$%Gu~M(ip=+nP8v$~x@L`huGI$|px#;^Z*%224Y=SP|LPefmx7Tn z%T_D})Y=Swbi87%p3~# zzMb&QGx1L;{~o9YEhD%5X@zu=Poggz3njBEtx?^h1ySbz zVdL^b3ep2Z5#tmDH~YQWIEz2G5~v~+dDlLrQksvVQPAxn04_~9` z{Ji@yW-l=Cb7}LlrRKt|*_W|CPuFP5eDq)I%{IHyldp%~*{80iXr4r?NXb+dcNZGE z;+2TtyF4B~qV_#JRDHZ>mZjp*QEI;`%Uz2I@-!Wi(84tt8PKtdWfZsI-u2J>rJMVN zH#x8rQF!mZqt^X{6AyGfgEgfk2_GmuTDxY^eh( zrlpg(Auq0sXC*8!w(H%L-H#N_gz3yxHAfNF;CJ+#Iw0FNN#|8Dc?7#yaf)Y91%wIQ zc=6wVx_7$`r4Ps1I9G_w+P#Iuzx~&*p)BBP!f@egT5&QJ;?Q^K97W*PwSe1HU2VV| zm57Y|h#v9Z`XOr_jU%Z}*wQQZcD%GWdKXMiquT1i#iUlQ{lzP~*UZHv3HWeN`X1EA za(_#k)pRk+w^G%7FSF!XYhaH?Nc(|EU$TjIDCNnNq}hc~14im!82_c!ulvVa#t8P= z=}e-0CRLL@?ExkGtlRVG2XhT)jWNnq49fP~ul|C)&}8yxQ+|UJG9zSp5zFYVE6aXT ziSJ!sf1K+JdfF0R(F31HNw$$~zbz(`O~BYFVk{b~E!CH^R8){Vbjl+ZF6sX z`_EpE(1?;C&r_Av*otyp^R=VT)Y@`nqdHbcC4YQyX)f)QJ}N0L>9p}leaSY_Ibf6M z=UDedzl6I@BcK04U&Wtd zZ*ZlDyj?@DYI|^VIQ9OE;@*rhp1FlY*m^_?T$n70lc&ISlejg@*5>wS-p*m{bX)Nv z+6vukYHO%xlCMx8JNwJ)e+PE9Bq?zEKPQX-WO&iEHEaAmrasb%+$eNHH!k0gBq?;V z8f?FM`O(U2+}IKoae;#PHYyN%To!29P9dncM)eE-+TCu!fsg+ z2|!8#IZF=TSY^6d>eA=9z#O9br@t8=l4@@oP$vN%ds6_4IUX$!PjDUQd#!p&nem-w2^Fe z7OWpY9p=y)tB+J7O#&vkF}j1)#*ykDtX?`V7_Yz_dNxRXw;7c7GL0&4Dz!<{v{kig z4l)tBTA#kS#>V*ZHidN)Rwq|K$F8aE_qD4E{8Rn}M|09Q{PHU;orcp>S5(=LpvJ!I zvUA@%!s5@_cD)XAu00OKs(}X0zgluYhL6OmqCbpk!_qxI(KQK*!INdkz2rRqdc;%} z#dlloH}LpI*ZUn_hRKRUX_^27vbvAN}Xv$PlftCP7VKX>Tkq{ zsExUp&C*UVP2p7C*15C~HHV1j80$R>VhYug&_dU&aA4>bND<>e3%prjRW~!dj@=TVnWZf1I^2j@30OxamIg}pB#5lE}b87 z9)dH(xB;dr@}n(~RR@y2r17Hm_?w;q2eQ3*U3i8#1c-7A){7tml0YJDk8sOZU3vj{ z*U@3p!S1jV5z*Q|$}f?{ro;2e<9M}~>Of3DV<|LzJh0!cpS z5(5l`8R2p}s0~EWVX!euGyF&pX~=cCk@;a&Mf0!eq14|hq#j8;P>Mq}_h6x1iWpa; z=u?=2^*{F{4yFE)kJ1Q;Fe1_9wmaZ^AShy}CDIzI?P)NnwIHgi*!Y@{%2l^sBh6#( zF_w~rCx#an6dPKLr4*C>BPUTUpE~gmcN47mPoYFDiI}LX(^R9fAMD zu3ae+J;H}I|Rj`>fiqfAkgGi#l!!h-RpjnMz}X^bFQr%a7x(85G^pdS4U#;?O;5+Cy4Fv2xWFK_61l zi=28m0Yx5PQkqOdM)+xlM24wF-*C+`J{T|J;?P@ZjYC2~F)P(pzx2fOkNmDw4-GSf zFH%Qv`pUK4W6}Z-@31u6X)~lx&WaeEiGGlaQNzo^Yr4~qb^Y0yntJ{~NR1fn_&DO9 z1o0PA#^TU#&TLS_Z|nxd$iXE$hF_4dF$y|S28*lwYmP;ky`VxBuffhX>uNY+uDoq4{L(4H@Oqu>i9%7^{Rk$7%3;au3cK8=EATB@=pWw4Q1-suV4$sFk*Bb=?A{r}zmfu55AXciXh>->)p1b7~i~z#bAKUtIc;VpXgAvCL9RcXK?uj8DK)g~gQXe!Z zG5d*pRH4JyLD}Hz&*QP4|GX$Qg$xiDW(43#XEXv(ZyO8=z4&LQa8yM>uN0SGyf9O9 zY+>4tSG%ch&kQ-es8UOOU|kmPefe({di0-w)lJ@?Jf#KT@1|pXUvI(PFi!^%!B==L zNr5kD3tjmci(QDgC#KydPg-^@Z}iQ=?vB1bhi^Nqgv@z!3FUmS(vwVRnP} zB#TaORKA?ee;$>a`PvolFg)}=ehd++%;-)3NS4R$@1#4y)77w5X>$DpN z4j_r^!1mzD;4>|J&ozP~F+b__cEiiSr~V1^@8Aj5pZ*Tl@iVk$^*d4rTIg~nB}}=k z6s(TcsGl_*wp}BA=##k=B1n_QkDp$xyNJF7LM_Ao5Q)hAQ@d1z6xoQVeh%KCW-fS7 z?OUDMSb$+=0STS0Zz`1zNiYyjl)i!O(}Ctpk1Ji2VKx#um_DipRz^iL*|)eO`Oj2} zA2osuvRzOCHXW@H)H|7DO2hB)p6;xhJsAxmE329wr}xhmMoB!G>Ypv#w53+7 ze;fUJH-GYZ^##IofR=|aBdk(%@&-gmhEx;H&rB$p?odJy`X|{Na*+I1O@uV9qJ`+c zsfie1N)PV!MpNy-PtJk3kKI5J#_TQ)l5u+?lH(vT$a)?n?`IgTx z5()g`%CTR%6?y=#6>4{8qmx}q1;#^I1#|Q20@lmi0?L}HB@9V*11$RTif{Jnil4y} zk8jr!&sMmGV5D3l1Ei{vs(aH)ug9{{2I8#adKp|n_0U$q={CE7)NV2c`(Awu_g;UC z^j?b!ALPYEeFmPv#Cld#Y!E=VxZCW1Q^wgS9%m{?%aL9@hjm>rPiL&%g3mgJv0gZugFr%*MlgcN=}osH2#EJ58$Eax z*B|3f%rL*>Q)De8Lf+X}58ksh(?aLh$U2|TgR2?=U+x+VbG`Uef4_gGv)qJFuCs+1 zTW#{gK3(kzzsoeNeZ^!N=tL_2{f<>`wTYx&L;9&~1>LXYjsgOA2k!oL2UhypCsZDD zO4Y4#M%DA>j=m|o<_*rsjkN!C?u`P9E(o2u z%PzrLX6&ma5T&m*@ax18U2S@oZs`5+MOIxfBsH7xF)K$$i>7y7-Nr5@d6P@bEm%Wm zJZ`-<2wl~yJqa#UZlmXjUG<=zs#D;l!JXh`ZU@Rk0zZ8FZ*(}H8VTRUQzZy0D3W2| z;)g{dKiU(0tc$SRr}ug)KcD3>zqCBqhfoT9tKDLF;Bhf*qg_6^s?4{%(maBt6(!=+ zY(f0v$AnJo-D)b*f zjK7ZQ(0>9^D;#ftzdB}szd7Eby5X1wUU$p}e|OBKy5X1y-g4wq-EhpOy5U#|dYy~F z0A~T{b1nt_&gEdBb0rw-Tm{BCKLq2QtHA{4S}@VM9!zq61eSGf0+XFvz!c{;u#$5- zSlPJ~tl|6wtm)hX)^dId)^_d#>o^a9^_+*mhnz>ihn=5+^_`!C4V)*at~yVG>CP{~ zhR(04-a5~KO`K=Jrp|A{$DH4T&72p&=FT6e_BwwA+c*3*-Qakq7kt<0 z0~a_0!6nWz;4)_j_@OflTw#Z69|pg6HULjM(-HOz zh&twM1b**q44!v31%Grl!`Yuej5V$npz3M`T3u~GyQ`h0j5sbTi4bv7R1v2|ODD0l zGZ}2_Ob6RL8;LXGX=h_F8)wfW2dao0Vy3H;xG9QURY1-Cw(F*_xaWX2_dB4&od>$y z?}8rp0x-b+9_V*327}y7z+m?>Fx0&Q40pc|M!G)$quqsIta}X@?_LL1c6Y&5s=A*L z4tdc%!0nJfxd(xl+|Rh(GQ|_`@W{HJ-|V3>!0YgaO260T4VTTmuUNumOYa1*wf8l! ztvAP#AVUMHhy)oOkPOBKq=WGRjljf!W}=*263|nWmlp&2fIkIfftLdMi3;-ffG*&z zfG5BJUt>{AzUQkVYRf`jvS=YU1Puf?1`P%`2R#dJ4H^o59P~W6BWO6dE9gaVcM$Du zvo~loSQIoC+#fU!JQ&nd43qB$CyP;X2RK!J7u*ayADj+e3~mGd6x;~B#AkmAZU+qZ=e~0HZ`DbtkP=quBm5^jm3uz2mLaKO#82Xu&}4v&l!>yE ztSRfurm~~#DTm21a;{t`SIBj8tK2KYl!{6_WtcKrc}1D5)HbLoM46}`1S+%nZtVB2h;?%v=&;NI++>n#&7H{fAkJ6{i9Z{Gml zINw{odA@gjU-*9T-S9Q=xA4#OFY_1ri~LmrYX$BIJQ#R9Fg>VGkgH5&nX+X%mwB?x zl`^-=xPr?EKNQ>~xNY#j;JLvIgO>-d4*os3R!GZ`K_RO{c7=Qw@^i@b5MO9mXnbg$ z&_N8gC98q+^!Xw1l%l`$X3M8)=w z-4M4a?q*z-_!jYP;~$S75`Qe-n($46EpdLLo-`t9V$$rSrAe-`waPXqJEZKcvWLr- zEvLx0f?BkdV#s!@aH;=?xi^85E4vB=UsP%#7fBUX3sDs1l)9!|B^RaAQVUg9$(5^= zu3S{g%v!KbI5OgA=C>l^hyIU{GVP`*V{8^N-@3n|Dz)Ar+>7F`_mHKwylT5{Z>i1=pSl0 z*Uq1PoBAWJ`Q64mJH+m9daE)2><=pB{utnIRI27C{B6PCHvGM#^5y28m3z%UfWNP; zdEBWxk>Ew0TeEf_ZOc$$VqwdGk$`W%JFI7tOa+ z*3J7W-)z3M@;>wa%D*!osQfWd<39#E`^V;kl|MD#QTdPNL-6;V@b_Kt_mAN3yW#J9 z;P1ng{gv;nj8wi4{=OgnexNc|`N7I-DnC>?TKQr4`$*+P<-do&kHX)NR2~Gn^`SOka(PWSZ!zaHSb2>$RA;-3)zuafW6^1UGGUXXMzP`Y=UXYV?7ANpUt zi|cV!(z|-sA5gsClX$-;@E;2NhXQ}a5Vy})3~~FsR^ZnPd_v$80{{IXF3-gwF8@V= zpB4C7g6}qyLs+i6&9r=Hhq#Th zzt0c7;WeKh`rg0y`JtbHzh8#G&%)oohrhpqzXQiUKlHA9K0ow5_dI#vZ}0t%yPqBU z=>vyf`#CdIz5CeH54;}!o&@;IN1h!zWG?SJY+l-T1ip8}UlrW1f$vfH`+ML%2H!7* z?{WBk8GP@7@0Y{hz3}%H@OPj2i@RP6-*NCe0pFA6ONRcwd9S%2-2WZ?odNt=_@0CB zdH6mC{*S}o6YzHt;5Wh_5snKNpQ_c)p0AxT7cND;seaZ=+7rEA8n5+xQFd`nJt^2@ zI|X~p277#`V2|5iPwW)z2^;Lmor0m~m8(lH%uUZ+tu0P0%+w}cn3$iNn4F)ffn#;1 z;1AH1+SJm*m5Hl>%KI)ZO+ymX6IWJBJg1iC=Vzu?=9U&~%S%@|L_OU&W9HA^q7Y}z zg^j3Jn`w7@+ZUTqZZkKPw7d1RzSfG~2GC5W-;Nw~y_L9`kZaL~9I3H&{A1&~5V>4>k7whe)`CPOO2y#v*?Rwl{ME$I3uAMbk zqby2qM9s4XTWP5a8Fc`tC0+cipT$-_Yx-#i+VSF(wc5?J-aTu&X#)TD&zh~XrWaw6 z)B5&Vb1mA&VC`CMHty70Er4n@XuV$Cn7|Noow&EM-Hn#xcSO&eJ!e+uI=%Df%u2#v z7-{U7KWAq9oyObFVLQ%svR=K@hya3;M@_Gt&zU(0upGC$t!Sa%75Hkj9;Fe)fVw5E z8_<|Jyi36g0cpQbZ}lT;b;vkLdr^~G6Jk%t6uh2pTdx3Rn?JzT&p{KPvrT-?Z{l;@ z#OKWVIc#DsA@|QYZ0>W^#^+26N&tv+X6u}5>2ui9&`jsCeXgX**0yaVLU~O@a7oSC z1M8Q^xhmv+5UvMR4?;jS&bu<6H`pdqNe9M%Zz97!dg3v{&9tI6;PPJF`{0;=%%$Qv zAD0kkpK!P*cydGEWjME=bUvQ*tB{&;KG6*s_%6AV7{Nph{3kxq3tv8ou%>0a* zMXGIPmscjPu8?zLd3k1Ga{gr^=VlTAzcjHjLv1#*G>f2Fh#P5=CF{M@%hy}WIJ?r* z3-wNYgF5Z>a`W2h>3E$7ecahNy?kYk;v*Hzy7fl1dUeipd;onX>zQ@qphWj`W?^;S ztS-XJW0tow7&NEnmdwoaI09b8Az-FwW+ztXS8(B(o2P{b*SVRiD=*6mr0bIni7S}H zu3lZVi=qt@ER|+UbbaK92|+KNxy2wI2YTsvVJv8?&a3va zxiY`HY`_oxy|iNHSIiYy%sRalGd=f$S$=-r*1CqZzH)VDcJ3u}11Dvzrp^0OyLFnE zFX{+!zL>_nNZb%YTz-@&jbRCW2hG^ia~MW3u$rF++97d(bc!qE53IQ^scBgK%@qBM zxsxMPhqoGO;y?{4Mj9d65YO2(Y3BlDInbp<@Z560+l6%nS4c#x!BCv(Y{VV*o{d{A zazJ}#5!8(%WmB8=l<{eVd;`>y!1<)!)T9b&8<;6^w~wU!YI2h>seIeDCIz_l^n#{1 zy#REvsV!vzT*xc{Zd~v!38k8Yh1B%@MN1UxU8yIIb?JQr5 zT2U|QWZ1Zv#?`1{uu9Bl5gIuqSZ({QUWUFC%^TRj7zn}L)k+6~TiP-hJRRu1Qm@6N zqrPjiahmnsl*AqAm==(8z+G#Y^-ja|)`8lVEr=7@ws@4Uiq4;1&=$0YIlPUq4BUBV zV{n3be@bU+v){SqaC04~3JfoYSpt6FVV1AO-IA;aXIc`N`)hC%-+v*w5v?TFtB}@Y z+_@ZW4NlAVhe}|O=>!Hw)-a73_-8tTe{c*=^;0BNJRF)Un<+L%6NX`{R*PZ$z}&S+ zNr>X%@>$k|6(|9;K}W^JP}9gX?mW7FTss_S?Xh#k7K8Nz|*!XlCFQ3Di)X z%g))ZMdCv4llEIUnrDHB$AG#s$7Mlq*mRT8I*eoXx*8#GXq&IhYpGL)#e^o-p`xYf zl=v)lN|4B!uL8p`9jyZc(1iW*WHb#e-<2FVv|=Rj5V_O|;kA`C-q-+sxM||dxqH^- z(w%7a2ot2MNKIE^>M@~T(wQFEbWRL-HM-u9HJAnFGV4s$fuW%VnzB){&Z$IOp;bq@62p<8D2@QMGgW-8qpN9C>%LGAFodv;zcG?zIy zMM7%Oskdya!qO^-f@v?rFOEX=GE}BnPnoyzye5D(#$-Jd4X4ex z)dYf#)GP3Kp$euS>UmlxT4}Xhqk3!A_qIuj(a_(T|T(l$wCBE z8kD2a`aQE1HTt#+NxR$E_O<{HHF0vGVWLMj?95XLr=Gf@5DsY9QtR$#&_T6M(gPex z%Zl_8*|bt>$sQrCWL%C?1}PNq0hMIbY`hhfvMjU=@lNYDIjA}2_wFDC9^rSIO7^Ox zGSkWWY2>HF7#GC%Yb&=)P#H()H&nI^jP+)kbaoS(X+;ntE23Z$U+Tv^Y-i)B#evu* z(pnwbjBM9XL^=;lGsA0_W8gwN3=rX`NymbSphVo8(6#ZvZ)*C7*d9B`piFoZEuWMcdYmE7(v_miSLcS!oDP5XQod zxQX58mx<`HD^?N3k#+AONa}cT*BUH@u!t1+s(i&4`>obQy3t3Hzmf#H9~0Xa1A-^Q zFIoRZ|6`VWKxj7{{9;tU<{;8f$yUV2p%lPjS^=a=42MaBxXVdD)dmqKaYq8E*fp+i zbYSkpjqEfH6!9hjgt&3qFcRe!o^V(CU7HB_CuPBStgAn8P-!pdd-aJkb>RfQ!h#M( zq1Y#Z4fhiCW(pmTod)dt<`nSCW>X!w65#ixEA`&y%vK}nVg`gFvY4hxYM}*mWa?-$ zOLik7Xgy8Z3mR}PgRuzH$s&a9^wHEDMKqDIdJ3}=xAS6c#R5L}DNZwq7 zsR+n6l#gJBUVIj9A2HEbw0%MPXacAE?e=zva&y8%;?^Y$vQkes0wgIwIMJv}76}T_ zw<%wYdnrx&4AnNQb2i2;J2`>QEOOTf#UW^-S?`J~<8RPbgo!h5c1cshdq8BF5H;6P1hGcmPEXL?0)`5@UWbjDVpxEH zuFSfoqee=sGJ{YmA7mXyMs8*X6vC|vuJH=XF2zT+EwOhv*{034+fg$H%1``=1h>&> zbA_DeRg}zOtFQxTI#iL}Ze1!JtDlJjD(&fT7T9kpnVLKRGm?0nu4xpg0Ks!hUSPp|+u&oI@u$5QS&MeGyVuNg0Brwtl zG+$JVgM!FN4tO%H+<3^t@%M|F}hLz>*oyc#(;%fYB;^`V{=7x`72 zr-P97>Dh#FS+ao^k{e!*G-jDYGkJYHlw1V*G3}Ba4cHu!9E$8!fpj(`%v!}Od})YM3i1hdH>R#c00q7{+Wj~uebk()+5@aeKy zTIygZh&Z*rVIwKqj9J)7j?AyaSQWJedS<OGW%EWkvK zyDeqjJw%pA03i+F-O_w-{+-4N&GST~eASsE?kUFIP6kRsnD0UdZGh3C%on;zj6<#l z3R=ijW)C_>Z3|7*BHU3xoLTldCVJY8>IwY zFF~dJg}tLqkf^2|;|^*$7s=8z{4BJe1yB=1giDcG88XcyR?=}!`& zi(Xg9H0=YRi3ytN_z?CIJ76*6nbxRxTt8XS6Alp%axy8CsQ%W*f~g=wQP{N2xXXP5 zYb__%OI?%5fX#y8n^}Ld)R95eux=*_(UhBgaYIXK=aCdfb3_uHbQA&GUXnQ52IpYc z`rHa6hgS8|QfKmqNZV}bCrUwFc_CoW*eFbaB{dLmABwYbm$|?W~bHoW#tYfDUW4awjtD=>- zZG}<78knz+(qtuB>O>+#hlNu1;pBo2U&Ak!(~3gaXpijPpmKRMvUNEWY}{QOx7`-p z()xOfz8(53!T>W15$ber#;|{CA-udL0t||O&d&3Uo>ro0Rkmf9>@`hjblXQ0}WLQ*|5&SQ<4ur+E~Qww%RFz zRPm(1ayubPz}Z-rF9Rn;C%PHHu@3}dUR&J|gIZl5R$^!qAniXD-ifpbCZVQ-U=L?Q zX4XlxnN%Vl(((j08`>BW zbi=ylGVOvTVqr*o;g1hs^IbV3SWr^MEW}wG&8)09tS{tF028G>8dt*H(;DNWLsNO91F`i(WLuku+6Q|ctJ2EG%QyQJz zD~VUm^~C06fmj{Xvt7wJVFxaPI&;uu+XiG(?zaljm{hwUM4$@Theb3IXf#NQEB@II zes#~S`beI4v>v-6wb;!BcO_9+xFFmm=y0)vml-+F3kO|)eLdb%95)glYU5r_d?;m| zJyFR_>AC|Zw&E<`W|<=}KEgH`gR!3LVbF2BI0@A$n}0RSfz1z!;=RFwaxjm?S`g{0 z1-uQ4HPj*YP`gHrs^o}-M|OGgdw2+a2{s)a4`rvUE0=Kf0ncydVI?JLfg+UohY{QD zvx{U~HXWrWIXbd!N3sRlwI1~y%Kgc;-jiX!_ICEELr;-wuu=VKdk*r#a~DsGdw1dY zV&-fWDK3wRX7j~O7_U&^oAgCGv)o_H$WWe5mdxBn2S3foE$?LT%tD-w02%!&t=EW} z{nYZ(0(GrR&vLvN_cm9v2t_)5i97{^N297+6dPRVI7>R}p)?bU)#>?2v1M0Ots#!7 zR#Z=?VA>-jsZ4EA?H=pe-REQaeV__ixGXaR4oPz0yFDFV!}o}>sibW^0m@11Ep&= zbY5?kV{Idt$W-}Ktk2>qPGkla?t5+=1S@I1lQBd(QU~vrz*tj!Te&L&+P-@jSPrfR7p9>ey)@oVM6au#8EBb1I+>z<|SlR?; z5N*&68f)An*Yo`ZM-}Z*m#-5b((;s+6tv^ER~taz0K?$H1(O?pFuPz*yY6t-MG9tz zUyS;_wBE9Usd?D*^n(!7(OQ3F14&R&5UZqdSWm|imO0!yIX|ens9d~)ifCvh?v+?&^qBzzyRe@OKU(dqFxxt0uGC-StkY# zvZRK%gK5{(YtD-eEoRZ^t zLw&gdI8mgrSnfDdCjur zL$j^=M&^$xBs_Iq{#x}du5?gDIbTy~<|{0M4*JDw6R|ah#neaB7CuC|(a_x{>tU~S z^UGMk7BZA&lQx(J1sq;QK|7LsPt&njhg=Uq4zn0-g-I=6>pNIBx*;J(%MC9|PNH6% zvR-4MiCYc_$pfA9de@2B%kbWyFY}%P!ngrUP2hLU2lN!5KibiBFT}ad0`9-F9dy3t z;ibuPYYN%{eO6bmQDBPJ5jRaM7#oI&b$ou$mmvs5D1Kf8oHghlh%R{4zA#~jsj=gClhG12~642Iv!wb z#mGzeC?4G?p@V%UB0Q)1bx}T}z7`nV3$XZYL4f&s)>HQiaEYYXF-x$CYONbvh?GEF z`(e?LwJLKL?HUuA&^EZ`L=K}3*955%ygAy5`T?ONTs*Kq7jY*1AA2W^HJ3X)xh4S*tN z6I4}uNF1rm{wanzIUj?qF%`uvuLi>EoR)^8nS(r=s z!U9Tflp=9U)pMTxR9&;8um}1gb?F9R4Q83^7`gpMF#g(XktMg{>~JBDHF0sE-$@cl zP}fmYqHV)$1d_;=gpNgc#azi;<*Z5pEo8Dt+-$C^;ir2|C#_?aCBX1>#{sYqGX{6_ ztr$;g;lUr705hm>iFZdUN>)5FPmvU$3_UkN?Ys?Vv438;(Dd`kfQBazIej@nInO81 zRKON&I*^xmN*i`M^%kI(QHcV}k#2O*S%<%Nwo!JDjAnzGf%OubW)gMpXh1{a-8yRC z7zLTlz^aN)x(3Cp(Z6gDffq+58+0_8SRUfR*|h^>WaNl44+u1vHp?yem;OQVdK$qu zmG6~4{)0n9=LixX#&EhfLLV7f#qGHXn61 zFobhDYAA@>mBywxFQLgMxmx_0=`=GW{SvF5_84T|y9=%k9r$JUl^E5qG472}cAK9!HOTcC~B(SYOU29*NBJV4GNn$rq-vS4!Q?}4r9Ug1^*2X8bGgI zGsLiwt#C%L91v7X+es{h+3NDQU0b8?l_==u9#6BXp+?w0psp$*4175ImjnQqg#f=dxK4FwdL%4ks!GSb(T8p32brH7TT9P0ueRhwjc{< zAjFU4wd^DbLfS+&K+lIM2%*%u;cQG5)eJ#C#K+{0mqiQle#e4ju7leZS10S|UrLB< zgp*!NfVoVyw8)#&mB?s%g&X`v)KU_!w}3Pq%IE8SZ~w@3E`k_iFxIV>IS;0lK*>mi zL8F90I>zpNtX!EzYUjJel+xpRa~?qDm5NQOhP64-V^5@a zHd&0!09lCBVG-^2)gHKEL*{q@!oV<`Xtm5WX#c2n{@m$itF>F!0fUmUA~rs*W%NZe zWbDUDWQ&CLCa1fplZ6GuFOi+g9xn03ak#e_G*~f;f4gCDvEgp(%i5FEz$w%1I-Opc z>?&?>4=vs+Ot+Ge<5GATCgGq*)XxqoLfke-=O7tbxD-*6Y_LF1-n?+}_|^m|M6hWf zWM0g~r9&dXX|~l_w$N#^I_JGxXwU}+J1199ufb*#56^L{;3}+fr5a*4Kv-O%V8Q2q z=^vn9YGWb>fatP1J=oL%NUR$=E~!1G5+Fp1gj)QGG;3H&6!J=Ynp--Jx=M!lP8-;d!#}h%0NLjYeb518oxVWYrXxI6 z!ysLZ9dFPbeuMz}FDx&C?HXQ@VA8hiuG&IpP*Tm;T6gFpx2K_oL0sY8p&qhuZ>ad8 zRzjRfw|0qUM!K@e;5>|La-&cmSk?~nGNk9_O(2@Zs>GK8;wTzyFw6E6?DXzcS>}yb z#vVx2+0~NhbJ12L1pv*rT@@r50+}t~n=LgLr3)xH#-| z<|2WqH7*&}!yZF2z0EYaxzzDP+Q?)VED*9=Hg0IsDR@52gseRt>c&xzR?<>uSdlC= zAFcPCS7xshHe!X>Z&Pe>ak6MGjamu%hsN@12L_T@joXV*m<*!_^eas3nB0lyj!<@e zgWXh63(?*)A{CyPEU>6Sfkj+n@a6$Us3ow&5Yxkl19796^n1>aq&htOskhWEW5lb3 z`snFy0f~zHv0!_u;JP!LKn({^b1VYQJ@p~-zJbHv!|>IKqzm)Xri1xG5osy*D-dFE zxd;#o^|vPuh&v8w*KUXl1;i65W64Cv0ywe17d@Kla%6Gcle#juFz;DGnvV~wR363q z&j5wH#sI+!sfSoDLFCfZllUH5%^~x6QexSZ)*BODHlpOVEWN@@kN8aVfy8ur8k(o$ zPQF%~kJl6u1EqtZ+y~7R%kazY>U5PT=@sf0j_plz7S**@DuU3Xk%nmn(hqyEif0h) zS@?WafKN+sOvQLkv+dAK2bjf7{fX)EERc-53PmxHtPeUf*Tuv$boCF4$Vqp-YRj5B zvJsCfigF#7TFIK-1`OOE=nyKq1}x{7y8?`T<&vfR6-lfwY4FH$x~sy=lUC)JH*2KOm>do z7)4p$ea z0~;+RY0wP5ratTuW@G%oW#W_5-X(3P)m|ffS!fp#dEk^rru!L_n;r%kL$4u ztizb$N=5vO^OtR|U!W|6vjB2ji-%lEmKzD`K=U4%vIJql3%JR8lUCr_B+WIAyXsnM zGaaMOJ50|H5kMq(b08h)>bOq!#l)!%)3okPzHaZMrwMtB2J~%dJwOS2Z*j!hkdiXt zM68d~&!K)H?YlI>L#Hz=b0|5asy>(U=Ty}re^gcRGFt?qO+m-=!qwAZ=-^L?63M(T z57FzT!+<=HZV`w&#moLmk}-fyWdWE~>O=(!ZRtCl$;@SYW1^W_T5y2J5CupF;JyM^ zs=&MC;{U)OYZa+ps1^9)eZ)ws?AZY4g%R`sVGh6SHd=nc^jg~>b9*Cf&da+7*CA!u z=c8FcGS2SCp>@4m>i3q`>GrrF%B`=FbHTkE&Fy7aL1Ke%#44|?-hbOFEfdQk1D}%P z-+_N_6JPL`l!K#`E`YU1l>>NXQE9lBc_8=YwK{41l72=Ugu{ndfij~^0{UWyA+r(= za1@ZEnYBY+Z!SuIpb-Iw$9=8f4EugcGjtuP( zu5d+ISy=A?dwEjK=kJh>4uHWS@|``n7+STmAizA#wV}qdw8;p^o1;S{4)CS}^B_)A zQ8pNLf`v;86ICV)#kQ?yrAfhjDlM6EpU#uW??Tj0((T+xZuHZ*7b0_H&NfppHofx( zYLxAxnuSvdxS6(Y;9^PCN6b|_Zm`Qecz2rB7q=1wNhsYo>49X=*x)k01SD%hl9y5G zy%UBsK_z&(GR3>1!q{6bNNEHz$+%HxL4T2tO`8U%;&3Qj44k ze|C8FD26RB-ZyD)-(w9KVpbCT*WKBO&@zA6E7;>M47Q4sgWefy z?itG{A478L9Gb3fAQy8ki||543BY#H_;~ z@kC2q*lu25>N<#5SHKWKY~pLqa^E-KcOtO8jT^vb)HPyL3oe$zx>JNAeDx5yV}?QU zc@Mn=-@~HF)(>T3g8)tA^U^8ZOkrv_;2*Ik zLoS4F;KMIbJsR9>EyzyN%%B=bV7g^coKRlbgD_&wT4YE>AC{XCJWMken$`AJwoeI? zxSrh8YaW2M)E-E3As^OrDkNMr#RU>54=*OD8|YKvR4x1@WEZrg7YtX z7L}EzC=&Q6r%+8z=4mu$bjyj4{{&mhgsunvWSiku+<1ZN$aopYb!(3 zh-jmZ2$kU}GAly@7u)a3j&(MXa2?7olS9L)0TM6d#~Deh(J9Tzm>twabzs5jEk@;6;NZ-16^OCYPU5JXa>F}y#^+9? zmF`fo694Nh?dDVS=w%4cMcabt zI`$nwdy`urQovHsIcf`%3ADH|2@Cj|EJ2YfN!;G$IC)}En<#PsmyB=idh9En4N67* z$&)cW#ziAX-o0aMP1r3q#HA-z1Oz5UTwB(K=6m9#kG$5A2+lKJVBSXXHzg~m$x?@= zgzPNX&ASJ7#{IJqxVc^l-IU0>zY+9;`TVZ2codiWQ}gg(6h(#cVhAj$!q2dhy9P_BdQ zhcY^J(_l7&s+i43J*|)4#750$R}G8p6fi7J#^Hqh)XMn?4SP8ZUdu64~hQM?Hs z`tm$FA&7#wG>S@N<~&$yZ9yK!KEl~4``8_B{&Y{`Tv)ky`jUMkXAkjqY3sP0fBNh; zv*RmhZZ|TloV$qXMacyYk2}zzs-P!x7+2$*M=J#9ren&wo_flh;&}w1;z59-0*Ic4 z5T_Gi>BYdlHHO7?=?O=L^sY#`kk0rg)h$vA1+LQ#{+B*O_a^!R0YsK0`{@tfkI2@UtJ5W`oHi0y5*I8Sr;RBFP{E>PL zFlfAMG88lNJ`)));4{KA9HoahfaueKe&$!mm06dk2yzILLNT}o%pkig4JA3z<@yc5 zUy^6Y)R*X-aP{>2~f=hESzf$Ez@IVpuc^G-3 z$_vh_BE>96Jr8PmPQAqsDURS&aURLVgq~Ns<~{!EmF&C+Zc5qD$8$y?SdQ#`7L@$7$vmyDWdL3Yi8Z zU3reV;H~$kT7RD*%;a_xWcn0C8d4xT(3L=Zj+)Qu1&S6p9xZ3GTy%#M`>3wTE z?<;#-24ui8K&l#cI^$Q%PU1KcNk?XlLYAz(hKeRx2vinA4&SqP${*A;b^2XWA7*S? zjd9s_Oilh24Dx> z4U;5}C-d(zp`)etp4<}DtiHy`_|;CU#D@g)p=2}f;htg3SWSSAW#CxFNj2to)iQlx z&F`9RMubn1$>JAm{mI${rnG21iVp{6R)&B_V)y}|Os+GCd-@VkM(-Lqh`7*ngMqp_ zf+uP+;~s(uI4Ji5N+ufT0$Kz(VvDH39E_4LH9Yk3{$nK>KU|Ee4+H#f7TB<7f!#X$ zDUA)WdJRz!v4CvX)(W__2_y%ZL%4?<@;=TY-ZJ{y$l}gCcis2bB_Ok={~n4TGw~3Y z^gd4y*T^I4ytjOosg?Hj|EGD<^-CPDQ<*(Xwl$l?xvcwx` z+1i}7h%7zFLZuTp@E?;>vgzhiY?vX13nLIF4r_HD!s~-5IzP%_(VW%?82SJ`$ zFsZ%7%rfnZ{WgKME`6|`sCrVMoFi+xFuE3&>FqR;K}tLIAE2>Q@1nXc^zn6dp^vYq zD=UoC!j%*y?^)E(5kAztIlOj00Wil>>A{7#L+-YGS%AC6IQdG)lb#_n7cQQ!)h=9o ztXAu7#u>{kChJ-3Xv)$$zE5Sgkg+67S0Hcv(VcFl7q-z_i5SJg;EHa@Ra-*q*$b^n z@teQE^EBQqRp6rK2rkJ}h%XTr->E9VWYXLgCvOi?lf6B?Mkf?xSwm^^G>o3E=Tk6vZ9Mcsv8#3 z7G6ud(QnmLXJ4ILkW>=s5an#N^Dj1BPB{Y$qvtMXpycEl@{p~T>a#k6lDo;e3>Kce zQjg%314SlXS0q^EEQ{~2d>P(1iv8P}qDu&gkG+y$*e-t1M3|R>M0U&Qp!r(Q$UV`8 zfACS6R=rCD#qKj!ovPJ2L& zuKLCanO^nD1_b`fsu)fz_vVw;+$#?{*uUh(D9^X+C4?+=YIy{rjkt}t5pSS!LHbGr z@4|&zi2KO9XUBOhb)36yU0WInpQJYS*dc?<{RTF&d7<8kTdlgZd0tpqd`s8&ESyU6 zJ-O@c)7ZWjicCBZW&#ca53|G3(lBDzgK&rFUyCP{t)+#Lg9!f6QIuSxN~%P~DM1mC zjUyF8!&P;oy_5)#EH06+TW{!$46SYCgjK~8D6!!rZ=ojR9?gWyv6OY9fv0#f-7gWI zjIhaNEdyOk*qCB8t12$kG$_ie09st2P(;0I9nyeN=PE9h?$+%=vLL) zw7$Xcx^>A0w$D(L9<_}eqHbOChHUP#72?8hFm92wk?c7_g2-|P;dja0>|?g-TnL4ReIq_5$JZ`qsZnM*x0-!sCpKzqwe!~YH zqs_JwLFIL6?1Rb;axh)!O|S9r!z-`E6`H9D(tkBm!_h8aqSMS>1rm4*fLyaU?W2>S z%ngUX;E7*_nIIq^zw!{iQI87Z-D)EEl|=JfZ}0+Bqj{ldxOprOrT!nMUaHhOfAIDXs2Val!x z5z2IWsH}*xvQ0V_t8|Kvdr!1*Z@BHDJ&e67g@ACUE;}R3=6xccbC@J(H&l+ zj6)5$O7Wv`3A@>%Tmb5eXdNgK{j)9u9$!r}^mdx8^>kk;esyU#bGVS36&UFFO}aJY z;Nk}POvf7>BHCgn3A1TcH*seZC}xk0O-w9vlSB__m{0l1`oLRjRe3t)C-bMg_EWE@ zdyZ~57eFqpCpYRIEenCS3bp!pr-VEJG}jRi_ZX-k?5pYmqxK5V%+_1{pmbtW>_r5BtoQjGF4JR%&t_5jQzw(b?sP?pPz6r z?O7GLlNXIN4P;B86PDI(qVyD>LiV~u@6KH#kJYBVpp*ed&Iu|AY^FL3cU;RDrn@c_ z6=^cEG0|gY{^ct>?J)-3SRiA8NxG+eN%8IU-WHk zb7E^^+qP|MVmp~kY}>ZYiH(W*#kTq7=J$WN_vO~D`_QXS_3qwvdUyBfu3dYtb-Q>< zu-ZqNlYd;AB#{?|k)Ev6tWWA&Y^#Lb>`z(w;fw<- z=ICFa51zV7dSlv~{@?9)voPQ;)B^RQ_~`k0E~p5z(+OT2`6Uydw6H zQVT%eY#z576}mJg76dXEO z7Br7)7x$B^rTbJalo@leT1M?zwbxvtH#nQOZ0CoD-0SAY+Ml9SY4RG@nUV8+)=ZV{ z>o%l|n~!VzVzk--pKYpQIACq)DWQL{>wfPlwTlY?9dCjS+C6Ja(QJzO>J4Bx|BOa1 zM$ndZdeLZx|Jw^wp;TUIu?yb9@}d$xBA`RW&kMowI|Oqjng}bdQTrD{Tm%h0@yZF= zLy%Qi{bL25;!b_URi>tXwN4)px$)WB16-SiH>N*DWyXP(*vp~ z#7u!59$U2@=-h!Pv$87uQ)th`-P;E>_1F5kZkj=SsAg?(sxYZ=Zk^$@tCVH)=Q1PR zzH2O;Fne%*7YpiN#h(^IQv+$LH$RFd*?kel>HHwrf_^_F{@9L+(j}0<{FA6Mr%?pB za~HZ$ue^R#Fs3fm?hhAkDF|g_T-IF?>#{fYg_kp?LQm=8=3cr=4dnLejukRWKRKt3 z(^905(GcPRhmS(*QM-bOH1JB2^zo45A^$aSQ^dKA68P#UB1AS8G^(G|`=d4F!jau^ z&rLH3pFv5|v1;pXVqMnvHzi6udZEU1f&28iif_H-K15XB_t)>u^EW--zpztj7w2i6 z^Ikg|Fd5Nl+zPE`QzhR}mH1)@-eE~)ST~P@Fk0dae~-Uzep!7j=>o6>4!uhv;lIW_czSoOD|}1VRiNt}JI1>@s~)pRh5ITza3^DiDj1(73OKyS_p|1w zQDUM&{Jqiw8DKQVTQT2DkR=PcdPmb(rSE-lRsyRsnlsw#bFn2iR{ot2?pYE2m z6%1NET>=mfM1Ow(2ii3EW)7{YK29;8_L!F-G%fVaBnB1OltWnH@);|cxaNI*3=Qtt z-LlaxFpSG(7r~0voTTYT@WmMN*FZeNlBqA2lkm595wE*L3rzQ%>gtX=A>}!C4&W4^ zUy=KSyzD8h7i4q93k?WCe-Aen`%{5ih=>q9syJO2N2Cm-PRjh!(XT7@MG=4eXbrDM z>Q#3~GgI>4n|}V`HEM7W1JgY4)Ie^5s4UmF2D#8Uzu{cjiQ%zA9W@x&MCW$iMM|v? z$>OG0SavtIwhYd-tuH6$W?Zs&ZMJC&9mD5O;%~R1yNGzj<;p~wF@WrD{@v+^o}b1& zf)jN0B%P9J;n%8zUg6J-1X_<8HD;!B+EH-Wz*0x&MO$DM zVw+#t;lbCJ10;?^Q)*rg3Ndar3r$FDW^v8B4U9a>9R-^L+2sE4n@-RI; zU;GZ^U_l8>I!3WFcqUXF$s0eBk1e7fJh8#vH<@oNF-7k$Jl(SEI;jQvrZ`PA`O_#C zbAtBq4*wLxKz;m1XjG2safx`lhq2bKl%{V|sf=>*KM->44)Cmxh?&;cGiv$O;rY%Q zGhKr{QYxE;n@&Y4=TP=kaZsSO{k*e|BQi30h3CgZb*0)hF=E%&Eao&}yt|cR_nvXq zOhp?%9bJM(Of`h8|bdWcg7Kmpj?w)j=2Rcduny^F; z3`W@z8%^WCXtoefU9}{OKQ{%^&ilj%>8?ism8 z2-gGh4j>yuSc+rEBz-B1?O+=!nwFc|XH55@_xTi#@XiIj(QijPrdqPjdO zfZw_32#maXkP_q1_vxT`HA&G_@|XWyeQI?pJ=WK5`)_%ICteplxXG27#XARc1l!{D)sjsY(eKvEO<*+G_|H51p$>U-H`0FBG5d@L z7h_Jw8>3*4#>dw=OEKPoM01MIKOWjexpGOR&m9SA*3cgQ`Pbh~@r%tLz#!PKN)bCk z|8BG~=<3v3`9=Im%mrL#?M1uw^ZTAb23kH8JgpC}VTAcD6gvFuhl~L1aUzoir=P4b z`c~D#AwmMNI{101L5#p>sSUFu)Fx}v1s47LZ>?2-c#E~{(7xm8?u_36YnQ=nc1yX# zTx;|!w-<5BkiJ-JkWFU15i#225!eM*C46TJlq-mKRmZJBNBPLdlt7=kZgiD*oflFJ zQCJ0`pRhyx!lya;i+F)+Ak-Y!Amy+nPYFC6yUp&PF_M`av5Upgin=u=?1St>N^?J$>|{HMm}xwUWxajemGn2-6J33%0HU zy38{hLck2RXs7hQGT^XIc7Ea`v8%|!g+>L5JNTZhpX1$A1*B7R}1j|#E~QTv;H&*rgo4^j;|nhH;#*Zj@Y0#$XVa}<0T~lf{or+ zCIfR?rGN3fWzdkJ^HidLe^9A)v9Q>ITC7x7u-Ig)Kmlt*1lfZFpr{lPAXo5t(1Nu<8vAsSDLPb(R?B5>5~Tl}gXMzxC|C|lR*Lm1Z*dNw?sx6Q?hck0nb zsjNbT2sslGb?G1d*wm*jPLwI+gty-{H!J)8aHV9mRE{@TMG=D?vNFLv+r1j><+^OF zu}xc=MwXSk*yViLYoeoU_gz!l3hZi#e4Xmn-flY~A>Hehbg_>o3gwGDD zKBQ`|!nD)b*KCNrO!u8gfXQ`;L7B*PX*dr3kUlP378)zXopPJ34VM>7#iFPXPkT+4 z8ohmLGDmCKm1klq=W$IbHEMDe?_u`=YIm7~G)fA{DFZRSVMpv+;n6vAf?jWoF0-xp zKWyjN24fAOabMVk+G~Nh@;{tg;z;V%1lQ&nkIa&)dzYMkn`#*-l%UaxR0L#*HZ?pg z#%U8{(MSi)XHUmSG!uYiel@Ih721_H!~d5`K-v4& zEm?u=s~TtFpzR$shp=>O!gUv~phE==T8x-gHpWW^3P~%d;wI6ECm!}~Rf!N^!o6j3 zZ%d@Xae%v4z_!HakMpU*-FgG(b7kfy>C@3A z=Hb%S^ajoF<@fkN{a=>oHJgPXZcut~+>gx!jZg*9C)*e=qXZE{c5zd5Dt+cSMVvC5 zg+}^xB}1LLc|ks|OOaI{tndPNl>y9o*(}v2k&KDGX*@MXJ+jkCFW0ho*?*C48{nlp z#ypF(V`KYVOwWhRvTOn0QR6&1fiUucIuy1o#tr-zqadtpiZ+#Lx`2Vc?@_MqNSK*q zzRI+vJs6ocw3$p}s(|G*nd~4ditpBq84KM=$K@(60d?s65NS+SIHn-((ilEj!uxB| zZIg$S{Gv=o zVTv#mY(=q883oYthbNE=smvoX_Hz5e-~yuz>5@_Yl3w8cG3BSEe|-AYo&*DTtGx0i z$|t0W&|Zy@^+zeClkZ5CAutS35P5$qO=~^sw$QvYUl>+C&+|b^ocVd_?ZwSknsgwo zM&fQGY`BKy%RwuquNX(E-K#j=gT%Gqi4+mByy8b(5e@{*ibTv5YM3Nb9II`-D+qma znMH_nyZpHOE8OePPrT`b*k)nEa&gWCv=ZozTWEHq_r#Jpl!Ks^T#on}d>|6}5|w&> zgS!-rC_1JNJHounQ8Lg{3?)in`x&Ow8jG^8m1ZIK%aY7Ej?FA4QE61S`KQTDCojo| zUk+H!IXb~nBcyRv#++5L#UJiYiK;&`d)yea)$C{N1JP$M;Ll98xcIR?ZNfE@={~H3 zSen#E-hawj&vNGKoavIkEb#Y(qUE?hocTq#S)czN)@~YNRVrYJO=@u)Ac%5Dhc)Pk zQE=#WTwN&$GXh=i1*+b$ ziY@HD*40$+3vm+>${wYw2;@yr0^&dpZKIr&?HtntT#1G4%@#z zS^`)6eZtEiq?L;duKh~z3XR&GhozFn$JhZ#;o;|2z~r&et;LO zWF%L+A4O6ku%=zkJX`o>73M{+q`Q7G>BxMD(991h)POaCt}L+6lKe*l*+62@tRES7 zitj95gT)sO+`de0Pw=m~pNmF>SZ{^bqK)ObcY}yMggTwpYIJx9s?5+KbLzb0bJEs# z`z!e4gE-93GGdOeP5y(+>=P0Tx?DfQYR-w#L0!fyIi~)y>%b{%_9J=tNlXI9YXQxQ*C6kznBQ8CpTlaZqjPAe-6dVH+M*&2jKG?69)Su`B8!&k>wq+(Z_EFTku_v7Fmnq z%!heAA-5WKG_y@LvUHB#muw!Hmo*z$7FfLgNXy?`<$Qfp2;+Bh@DgwsdCj_q$9n&4 z7G4z;Y2KZlD;nJ4f#^dY3RO(63w;0>`wxHAz8X$p2eJTLxOKg%of}w`JM_F%4~aB> zE@}S!YP`#sFjNCp-sRDLl{kOY$~;c!6LpW1~Yoq&rH z;k=#9IUxJFpLl@Y`-t{&KD^(&i@toKe*9bt5PS$gR)31Q1!DHEyy|!u1J*5^<4wDg8cCj6yU#;hOAcE=e*N~?EBQ;$A80n^ZpSe2s#DaEep*H z0>}f@5CeQ)%0dI6{8P?m5d)lGp2NP3UI2(+w>O3eUsV0y z?Ke2wEY8nk^9f-R27=BO#VY)q&i)6t2~-ljHU||6X_DJu>2)}-nF+4NoOihi&oSLZ z{_%HX(2@ddcMS<~aUY9gv(X=PMgq)t;|Yep0YrZtzD`!HO1#Y;uI7u1kYjrNAEr(^ z=I;Z&OdcxcEq9(%=i6eJCC&rAW>4Cp{f!PMsx+Dbo-g*LGf%DfypMU3xa6eB@ z;-dY3J?sa*j?XJb13ylvB%kAAVh9Mke5zIardLHx>xg&-pI%l~O&##6z>oM%0X$DZ z4Gu)_u?=xCe!dr$p!X3Cim{(0A3&>%xX~vfTwb*bLIKz3f)#x4leu$bezz05u(QAl zd;z}~gpU~lfq<8_LDn$ZB@Y7N+aLg>&w=klKCBP&J9h8LeP1^ogutsoB7qOlFhS>+ zqQKYrK|${qqQUF^uz-&nLGF*Fz}JdFLAMu6q_2zJ?@-j?12K$p`JGS4HWOaPkO7}{ zSHO!c!}cx}_M5IM9Er8V@;Cn&zD@f+r`PLa zdfy?$(C))_)DY*32=v}%zmE$zdGp?Ks~Ge3_RPX7jn6O$}vS^Ql(&A4~;sH+@}b=CVf# zzKI@D3A}a4JX+s3|IN@2CYn)DU3#r(YEt=sA^J$@lwwX!O6ANq3Q?H(pI!Xvocvf^ z)2=xC|3ug(p`)@H1u5-soRLvK{=cDum3l@V4{uQ7*#CA4d-~rP_Audlj_4Cb_o^0D zO630?M5~_jzp>zoMbOP%qmt+U;KhF)8tzpsErT3)bclC7uG+h0X4SdCZ|6Xbgx4vxO z1tA5q!{*#s(DV2mANx0uhM1l^DVlB-kw3z~zi#^t@n5pQQ+5lC4cHkG7!d>oyTNEJ z!I{nn$8Wkq0d~h$C1-U7T#`Y#NMCz5jK~2tFPx!*{2#i5d7x9rp@LMj=U)OJRLzas z?9MCUeVrmvKKIy`jL|g-@MPGMl#&cFdW2r~W}r+wMJvV_tj){7@v%JcQWhRI9#0L!A30!CCG(R-voQ?Oy-aVUHT_KXMzM8qltqSuZ}yqz zDV2R#`+8x@=QYDzE5?fhzrGIV4e>r7=N03CM<WF+em0`xVbpIxZe6PZMPZbS@MDGu) z4zYd~7ak-2*i4AZv|pj z6ASGkLNjnBCh*jHo>o_sV|>WXKF3cIBtRGYXM9D zuWR7k$Nbm5M+&qA-BWP~AfM|KvEC`RF)O6`tR8Pu-k{+$`OWr27>FMb^Mq3q^y&kYl$~&GF2vnPN|&A947cA7pY4N|tmjdqUwb3ns!QJ!Q~pJG0$ z2d+tJV(U`3SO4r=@bhJQNt!-ON#@r_zgrDXD#DWVCf)+7RT<3F^Jn6HLu>erZSJ4p z>;qmbHiH~9DB-P2FW6-6+KD%$meQJezw^TC+KBn~JZFP7ZC2x-z0v0DItghrW16^;0|p-WMG8y^N9zujHb zki!kDb`MRU!h=b>W6?0Nerm2z)=qmDilu|5X{lp(28lj3&MmFtk7k`~=h z5O1ETl~6TU(G+ou(HJdmdSBVMMdVVl9P9DGyEU1~q2#iIfBkS(Q(W`%c4=gsSgG zGz+M?e=FQkc#5f|rv$Ci@{oCs5Gif(~?h*>(Y?X z?(@=;(n>}Ft1;*`g)~MyGz2tau`uI~q{p}gkDy2DK*BkhJpG`BTo=@YfXfmRDGsw}&Ez@lQr z>$SBqDBrYZ*0jmQ=34e-9zvKhTtqKG06bhTP8CaAGl)(>mE>?L>M|#k3wKDKIBr&$ zR8W>6E<(pBE4jT${Bv;1S!6oISpwM-YzHofALgzct`Cg}06X*P-DOe+tpjo(D@&Xb z7#o>o-^ijPyea|s$zvmQr&NO3UXi+74kKkc^Ax*)$V&%8#<+1xx7E>}My=<&$|HuX zalI&p#|WzRL^oYz(f0kE;QiDsC*xci#o1F{51E7xIl!z9ANG@uLX5V~gpZSeLssGG zHY`i6@g)-x%%y6dn^njzc&|z!=Vql?wxl(%%zjG-e*-_;L`R?+D)=a-ZKBO{c}j5I zWIMxwCJ(om(qZDjo^&B;@AZWWtn!+O#0uq6)d14sOZjjKtrEP()KXLSob^S8^!}hm zr@zm3y6P20sVd9?b7db>lK;8FtBY{oro?w=X+Vnux$|3jk@Urc*cO9pd%Iz4S{Mhk z=$BTMIfwe;c=9z`+@T z_5komY`cHa^Y1q-v(XSMzum{*2Ki%+>n10v&*zFn7>Ppk4{%=iVQX2Bs&4M$H97HW zABuj*^eCvIX;TmUjaEOJz1BmUrYfE3|50W==AfkYXE52gt2+Rm*MwB=netO%5a7iK z8S90m$M}~#2f5mPih2WXSHx7~x;eRAj4`?SjCM_$>(+w9$rBd}`a1){p_oB+vM$Twa~Irr zp@YBrZ!`Fh9-|4u`Z<>a+-rCCNMP;{^L-fSI8z_4LzmUWIJBnA60R#igNBL6r;w-U zP&HHc!U!NcvuH*7qTjE7MI^)2pPsJEiB0geU`Vn~#U|lbJ`EtayTcN1N2_}K&d&U5 zaIn9(l3%Hr2zJswmUh=3m85Z!1-8>OxT3@K)TlZ-EK7zzsF2fVN8=n9)>>_>)ofE9 z*5V`@vl;TGNUC>*&PAcdO$t(13@q;cSHSv#n6sp3v7lYCdahw>A)E*Dh7p`HA9(q* zICTRj1{-N`tVwec4QaNQz4xOZW!AvnZWfg8I2Y3ckw*lW9%Xy(ci=S*9@#%)+yK}L;!Kf zNQ|MWO?{Y1#t4Koo_tP+v4=}0l1HnROa+GbjoHnsFTJQln6w&Dx})~UWp1(VU#)YQ z>KAYE+muZ#K+Hc^Ubf{DE1FRD-wVAgmuDqe#sydHTX=1gi4^bI)f@Bk%UucQ23I@L zp_T*3thY}KG(`+FiP)i0QfXnv26r(p&&@BPL`5O$-k_)KQcuO+;fvd7XkVJ$eDGn< zvA^^mN5qVp7AN#`Pzz=iT*6o`v_h2IV3)VeUi~}5VJqMck*$(nAS#|zry_P|F5V1`6h^c6c$3n`3-2J`o~`e(I;7WT2QTs@ z&SyNfwND2jsmHsF&R8B^{pNX-)`(k-0wqE$;4GBc9nFM z^O8>++jy;locpWwXa=)x=-EtzC72rbTQGOpjJB3Advkck7PC-K{{y&HwB zKHfvt8A!{yX*?Wdp*Ub=9i=#Ym|zahMq(Ox$<5*42GlsG?=CRySx14?hPMWsWF8d> zNDf>I-~kWFh0uq65Die~gH#zwoVrNwWoJL0qsw(h=buAk?z1CKawFt(FrPz#nuvHI z^OP5!Ct(}vEO4D^su>{NGQV2It<4F?j+JoFl&0c+9@{xIj_s2%pM}?Tj*O%7fIF{)t=bu+ z1I;)g$ZN3SRR}8aIZ6&lzGsk zJq7z&m&wh^wu*8t#&*o&NIXnI#1V-5Hx!eLUjo19{xnF~AMn~~F$Hr*61Up94B^VD z+K^Uu3eq8}s_@Zto2-t3YdrgC#AJdT+3#^(`C7zS+8hr%J_qdGvbZR6g;G|VO!4*K zM~7rq$}qwl5&A~xAV_Xh8lz7S-I${MMeR>wz=wx$8u|5iFH>b>XL%C)_Eg_Vqfmel z4#ZDp=BU2li%xogKl0`Vo{~*>3TlNWZ8>_ZVvC;liV%;G23(a#UBK3tBqf=#jmPTq z)gWJ~epI5-c(y4hFQ81(-i$B%`j~IYMTGmlSfwx?Z3iym%;4E`8Dk5KiPkGKY|@@o ztH5cLp3S!URq2~0pLL`48N8F@9A2%hcHKKq6c9aDQK;(+o6LHN$*K)%GDcH^WDk8LXp-7`)>Z?zj}{s zOF`;V-wooQY`zTcC~3yI_!wm0wH`eIUkco?^gV3UQ-rpUANbR9J(mrZCOAo*$a@WC zn(1L05GC)UVP4NW5=6Qc$u;E0^aF#UK9$3t;%~*>P+_JN30b?tkCXuT*z@O?3(2Tw zv(7ui(jGO83-AH2V?fkFNGG7f%>t9VCccg#I%B^e;I$@IYBvQwhpEG-f-r;S?EyJ$ zz);XzP2iViDfp4V;X-=hR{nz}qM?ylZsz1I`-Bs9UIjOXeZP04SEa8uCA=;4{ch|A z8}gZy`%wW2^2}zlm!ndY<6A1aUt@Nv^<*PmhnT=kGTv)2S2yV9>E~59*x_cS|5vD}f@TXa5kcu|mNDnH*J++#)u1&qF;lL58# z`jfB5)1Urpi%QgVJ=*$A)qe9H;;#lfNX9RjHM9>78P;AMrz_GduQ3Qjvir?>EtwcvN3Riap&D>c^9u<2#Tfs zJ>7-bV(ncMf2(qE?SD;i|YTZL`xRqGr)UBzG;EJW&M7>ae@H=~o$n z!ASiEz0} zyL0_n*R4p)EUIp)dthSxisP=iFsd)(k3JhX=Z zdw1Lb6*R7b;=?`dAmI7TV$3I^wQW*H4tU$Wz|B)~+5r!x;IbQ-<~Hii_-{8dYXW_{ zZJ_`%34v#%9-U&b4b@e>n{J^@j-}?5d8sgLK&#We4=e}a(@ zNGu?uyyj7;@|yU0qxkrP2YFx6gMjNPvrWU`9&_gl6FRQv`)3B~Ij#ShKV_x+eG)0R z{aiLSv&aGfd!K0s<5}puh~NKm{WkVBy4?jb;-(%}Xep7Gkx`f)}|UtFu7KwuzRx zNlCFg@~u2_3LoD*SK8B&>>=$_Fzg50{kV2Kl>x|LealWzT`Tf?TI*|hTDPt1d2%3- zO7i;gPl{neutx&Eoj_(!M3alJQB1rxUWdsjh4EgRD*5=P`c5$*)HmMejZiA0`p)ZUtBTAn$J> zl%POLMp08w{o2mJzQF+Jk}9VZ#><;ozK}lHuc`Ef03?vj2w{7xpW$NO&bV|l?;O~} zJ}$4mtjJ0lUmZ}9!tOdGH9>{<3&w>_Ko^XQ>%CD0|A)JxI3nIuP;UhrQYk8Kf*_4D zXt=}W+O&KD#Pk8!`0O!%C1a~ez0w@0zJ_{(;J&)0Lk!=agnHMf?D7zB9pXBt&hK5s zFabTloSOh>;Pppx_8R zYkQU0FLM6>0?=U3AM+l*i6g0;sR#BeJ$T03BKMtFl~35!061X<8W`Ibm6Mo_dMJ=E z(O-&GL4WwLQsC10eSnqtpq^Sq~h;oCHY9%u7@4~AmT5hnut-q4@e^SojYu{>#H zAOTlUu--?QCrb8=ttT}3`ub!K(Aa7~e*mtPzNa@{36E8P1MMv)>`zJ#S2oTONH9># zqBc|(`IlLe)18dFJeRJs)nMi%#jXku0e!$p9wiC;RzKK{b>8G*p6~Ky=un1F{+9?; z^q4OZuQ%}=F?UX2j#%TrbDINK1DWs_MgQE%S3b=3y+V$hZn>ZZfl9Ce_x24ifhqpi z8jdO6SCf9hSG%->Kck0%lBHz<-k8M*&5)ZAGn_3Y;+4T>Fr6`QZcxOnpjy^<$};!m zg7-<@X$zMUUI%uL+#9%?H!F1P@pMCioT1CYRs_Yjov20Dd0q4B*Y2tuWnHizKv=-R z7d-m_PZy|ifW_G5tlqEt?>w=KU?L`y?^Hk{E_AMg2m3o~+dC`DTYVGa+~kAEfI+~> zJk%%K0{rDU4g^XNA-M6uZ1Wox5hyt`xhUD+gRFzm0Y4m~*R1ir z$W0EyUmM+Xs;t*HmfNSZzwRtMnJtfWETTQ`OwmK^NF!@@^Uw4DDd2Y~f;n&~t!+37 zJ-?Mwmb(+e^hcWU84TPyA>@4g{KGMRa@%TStO(*nJ&rEq?U)1X>iDe)0?)r5ZCv+8 zWeBG6PUw-uBLvYEF?l$7ahK!p*y^=qfb2-!4ff1)Ln68Xf+scf6AAF@ZIlCov_-wv zZNCQluNO1ar~-+n*x`*__RJa|lbXLRd@q$opeb#gbB=t8q-lPYcB!ZuLFvrm%=1|_ z2~?og8!(0ZnLz-Q%L}+0RZCmRPqe4pT1d7rZ>j>l8DXF#V+9M!dlJf+W9|mEA4*Ys z4r?L*v3RzdI#c}sB4sotS$|rvMFqG~1SYo^EiGKwJUCK0Jmz)H9PY}zQ`LdQYJOyF z{K?`zn$3Q&+|G-lqO&LSfLd>@0o7TISTr88EGIHCu&E6zeq6(>Db^hLcpc$oacTZh-5iANfZcq+>rC3|#Z- zR=+B7PrR!KdL^18+mH{07?xB96_4KBb>6dO?yY6+on`L5rNQ^zzOgj8vov_N^gqk{ z&7gao2bKZxd!MivCNYBg_Zp)o`9FZ~f`_-1v!%ek;OGTN^)je7^&0=`2XPrH&KGz5 zPrChGxNs;T zsal^Olty9g=OCeuOwf8xiv=>ELSysD+;6&iF{==v>k7SM83q(+eF%gYUhxn1D3hxZ zc;wIzhS-IuMnhJPJZ)$?V4WC1G4uX&k@;IDA&Jmnq`|vD$%yxaSr+8>mIL}R_h(*l zr~Jd)Ipr`Ndg4B`(SbNG?fUaV+^jSIx~`eQjK5*dWFUi~0Y5=5X?SqEJh1zS#m6?&N;hg}(Z`8sB8}XM) zd6}UCl4iSx@R;Dp2Nhr%XNEJO7uRWg?GwcqA%tRoQYF*d9*sW|3?=y9O8`q%!hEscXX|!+d6t;ou;@@O?^}ym% z{B}@tAb$CjG8gu>qC;ClpR?4hZvwmF;Y0#)Ta5xo`F+Z=0wzN|QaT%y#$tvm-S9x_ zU|tLPlMGKEUd`@4*tI)D9MCeRl-5S(#b`~$N;1`ct z$WYWe5Ddw}JJxxsh&H*;2L~ra0M~v^g3ZBOE=et8YzA&%^f-D7f$ei^ek002zTpbv zUwjVHEdtx+OkeMEB>wdfAMggDC?GQST4&`_e~R++AOjn83>##7e>xGJsNCDU_Jx~O z32Sgus}sHwk+Cj3_X%#CRLU6#9^`D_6ep^h)zex{W ziJ2rn28|2cz_LjUosXEdICR(UOh@Rfpg&WCYIL?ObH+QUo z+R4TITzw~R>2+F&N~Lvje^d(ca#sB6qoxbs>I?RjkLk!pX;1QNrc2xvNATuhUiavY zE7YZ+3BV~TsG{*zmNwBQQ#73}sRx1$Mtq?Y-eIsPCH z{M#PIUP^>gVV|=I_b2R2iZh%N6M_;HSaHdAk8E^w;UCbtCAbulh{}u1f+z=r_Xn+Q zg0lslf|dauBA;y8l=PaVdS-EY{SEnr3jsX}SGg5x;z-mBrbJk`y#qfE=s!U5Zkan4 zQ~;aPDksd!w9^ZMq&pW!jL&6i(WiNzGrS$Gp6-uQxszveV@Y(c=+&(x+JMG-pR7xp z-V^06TCD=SJ==e3fUjGmq@YW}bQXQkHiJ66X?U3+c$81{D2a)Hv&z14>?m zGQrdlif#A=TU`h<8StXWz*_7PaWIK+n$>V_fQ5Rl$5sv553gkH1l0}dJ1UsjiUl&F+qd(Q2W$bwIUuMe}`!{w=d#@yz>V#JVGrL z3@JX{6XrNN5&ZD`9ew@$5Pjn5%M($!jT2E&9uo$BZ*Vv}L?H-DV<=zLX5k_VH{TYe zvCEI5_>DB%D5_#r#lDMqKQKS4X-vo8`j!VY$Z=Eo3Qupgkzkm*^%rn&w&ntoTo3@H#eJ0z43_WmFEbNnqu<~!$Ed;9$ zt_sWU{eaUW!~M$&%2r(qvpvaJc_3;%M=am=v!3n%1 z-TrYl+&*jTOF{3UH>qd@tnh~v^P}pILuW5aPX_K!+`{mQdGd3P^73ysG3%Kf&j6sk zX!echK2pSpeuXtYD054;?|6VcH}N>Dh(wSTC_9dBa4@=eAWYuCG{NQRGGFszP;sd? z{EH_N=z7EI%dK>IS)wMN6#XCAjEgx^Tu1ZY&e6xt(Jrx0%Y)4*n%lMW=LV=Ld-7Em z+IG58?s70#f>wi2nK}HlM!)wfS3byHbqMB|&$1xGr5pUpTsE7R<0Me)+%vL3r2Z(1j?tY|q%jqF{1v z)d`(struGSivI8S+l8g|fr1v31&U( zJ^PSg$x_pGe9?RF2fpdXB#$|betdUsdG9M%D^{ul7-&S7g}NVM+-kkn+ylF%yY_GI z>yA{uA{u&VNfKqcwW8wVr^O*7lT0Nx;+=ZTbDW&nb9gm!dZ6AxGj+&PY1ukp97 zrLr|%uXkVugG6?_#uF>e8s7ApJGKfzr?w(#`2=+?C)9|m2viMz7~4W1xjYdIo||Wt z@b$fuZ;!9=Jq$#cr@UW*Y0C-W`ov)VT&yd6{fT+Q?2{F}HLY}_N# zztd6$aY?wjGF;kkUXj~T&~^@4+WLWrIsoB_*HBfd70&oT)|z(ZNZXtn$32$n!HC#4 zZ9qZL>-b}>hT2q*K^uBWep(vT-4FaUr!BX)yE}86k#}P#Q8<_@#iGhtSvv!d9G{j+ zvPD&$o?P#-0Hh`C^^sRt+QDu*MOu&rhrK69yk@o;dj9rOzDFkcVnVxqb6cHX8E-$Q z#R)ye-L6`pIL)yua$S=spPC0Z$oYCJ7;TLe?6Pdmv>ESsAR<;QI${l4_5vqP6#V-X zQZsk!q-ja(5i~j5Vf0Fa$itJGLN+a&v&InTek0c)AIQ|9j~N_cZdYL6N}Ap-MzOi_ zUF4m*{qs*fvV#x~huA+%8chIr63*}KUAo#?qiGVASNU#q#CkuHH6!e$=4=+#xv+yz zZk>xCJ~L5?y4Xm)FY@pb?vCc|(aUEBBk%HLV1%JUGc@>1R?fkuq`cC}Hy}BP zy&Tc1T`<4^Jv(dUF6AVkjL6qJ(5w}qQy7};*)F)#ITN0(8_a&MW}j>Z^Ii8Wf}L|S zdwCE7CafjL%o-Yn&HDby3jN6n9^JZ8l-9Yqbb;~Joeqfs0eFQj@C7VlHAIWnwST}0 zH?KSzrP+FUHD}wCL1jpy62@7iIhBwFOBs@_16I?=!Y&!o8rDIWRwz4(2mVaL?>V@1 zMCzgfaD*L%@4z&e7FE;i>Ahal@N{#y;-0Jt;rhQReb33iIz}kZcy&+^aPzer4Xep= zi)v7R^!hQJ;Xs8HZXZ6hXGzx#p+oXn?QYTt{Y=Jkmcefwh{>2O>U^g#Q2FJ$BAtlm z=JgCGZOC3+(kpGy=W;?DlRZ%|%xxrdy5qTDSj5Hc21GmP-Co+8tv#SgOJDmt>mhJ3 z#GRX^Uw~GJ5oN!|tRnXZNx?v4$>mt~Y&Q%VFZ0nY#hdw6gwfjkab^UBe4LM=i_Z?U z<}ki5en9NVrJTira6rwq9VFfU?v6$DpE;Yhso?Lb0IFP2PYnM<88aXz?Q1_*Gc#Wc zWSZ5Zi*@F#-zoO>OZoM1X_ih`2}8xgjV6FxTE!2U#}YsyEsx&^x%sr01#6Xz>(Dy( zs=-oCnLJDd`quA(@e#B2@V@|oKz_gK#s@-d=C3XAYma8)E|;Iba(|jG)WoESxPs9s zX?61MrlY`n=nhu5RR0Ln>c*&qAFCRZ_!By8{r?aY+bJCfcMtsUgyPW>NT=1S7<}pC zBlC4H3!l668-nHR0uOuGR3%&z^GOQLgiro;^FomGO8rvz9tOpo z0OLLV9QeEE6MXT-a^unA;=0#M*j*jyIMKoPdN(+0w1dsLOC5}U{c?zHWc=z~m>fSl zR^Nb5BRZ|<$ly4C{`2~u|GZV&VC7@5{^D=F`ino0YDg89Vuh&;L7Xc09aKG4E@++k zmuA}EKZViPpxywWsVp}qIF8W66-@vW+U~4Qxrx~3VbiC;J(D9?Q0-crUtU_ls zI@h4H2AylsS&Pow&*Qoxm+Ww--#$q zq9ZxbaiUX?jvJj;bYx`A!@%2o^*KsZ#EY5QG4c(3hwmtXiqp*Fi+bZ$ZCI&?Omvk{&3=-iFY&*5MF&(L`j zoj1_=|Iqn&bgrQDQ*{0foqt8=C+PegI^Rd2nUq%zA@0`(W># zKl5NKOIbr$XKo&LZF%dkt4kY)^%q+kTV2}N*xK?|WH(qbBD=wgt+I}4OqG>PT+UKi zXLY8dVc7%Jaz$z5{UDaB$>!`+%-N1a?vAfZ_spPG* zvy{BLw4vnA>g?yOD@>kmKCj)X)#aOJZ*;lcs?Fs!1}ldA)>pRUx3;{5 zZ!NU^+*)Y(x!Gv<*_&_nx!Gv-xwATBfxG8!E3k?p%9*3jgpS-g= zV}%>6*eYCK*;L`0LOoaqV8tl(Y)5<99fmKZRz&R$UA zLgVZO(S^3zZ?tZjy`ZE*%k1q|4YRjfwaXqbGZEQ0TMLnWvo#P|Fiq6j;YRC5;@6h9 z5r2a<5HyQ;#=Tv&Xr0cIG(yW^0XeePv^u zH(0a9*>2So=Q?w1`d!r;(+`+g_FP@s(EjSucJ@1}F|!{qvl%K^G8wvWek_LWoU6gm zb>`m+C=qS^R6s{H)<##B;*hoFEs(A(Wq@>TdHbU!*Vb~PW_4-nqw6ahA6;MB_Gr7+ zk0bO{|7`?kqo=OX-(1(|6V^KXUE;Y@JbT5nPds-(`knCC2Y)+ok9`ez+C7b$nFrjQ zzqqV1XK|vgvCUiG=$rX5q>JG3wsuT1iRblkkACuDbe=%xQFOiv=>rXoZNBpo=6VCe z@cidw7M*7??+_jbmGO|=PV~{Kfot)#4Sm;Px@XY2AHvSNp)CL8^XP3xrxl%*82t#Q zmeE;>nSJQ2(oZE!Ucro+UPOi9OkTkR9q4p98ygY1*RiZM=mao$0LwZ^+4?b1ChvZ7 zFJiz3O!XS3dH|h!fg)$oa|$DgEDsX6z0SruAVUL$%yb~=H!&`X#9N7_VdbGto<{8& zCz1gZW*nHG@d6}UFvlrOdl{VUer&FObjXL5%3#D)Un5&;!O-uqAB#LchLMOx_EK}B z;jR~^yNC&}obw3a{6Tb(0OzrF&YwW%c1(8(v%{-z`lZ&!f=f2JBOotp2ZRHf$B9{9 z#}a-FzAQ3BwjLcfI?Y%rQ9gveF?XZ5ZNS(&F%XHA4G?G2#RN>9LW)da3B7TuXB|L@i&w2QYoj;51ntcrsA>%wvjkXukZW?csZ#dPrUx^90yX{d;uK~aspCvY8Cn(LlhrC=K?xN-I?3bK}MPh zq4Onlu#GY^=zCDmK6h@awXxu=R6&Z#%UYAuc`0vW-Z?3x)`;-0Sb9RDc9}yyV-7zPHH@XltQPK(R$g@ z0I3_A+)a2|S@`PQWI}-NGWaH6;RjyXceHTKW%M_5_&=b(5uGM+_hFI>XE)11S;{u) z#@e@`2j1QAcO{TQuZw)AB=(`bTSK}Ct9TXHZKs61T@%kCqfsBenBGfpd%YBZDTb)&$(?+j>GnL{U7dUk zewYU!aqwegpJyilLoD!wq6dP79VGT-TC|WS!Nd1lE|RT)$;X&F04zYneG_9mX!^vb z`&OY(+`ZXC?ZftZCLg5(_mf{m$q1Z8rVSk40KGlx4bUZkN7;JF1K4193qLlH<_Fd! zz?6;*O1+5>fX|Or0le$N#v&sA2-o@&qIfFIL}%=Ul_K%k_TIQdKP9d_tKQ-9a1m$<(BqdH$QaQ@y=0bN5803KefU^mLUhJ z9GT0JIpKbhaKD>nK%1AFQV32?bWtR_NCj-*0ygkSa!~~MGcWPu$J7%uA9Ew&&-ybz z6`m?{+*g9q));f=yNHyWs^t7~<8qz3eWk9ylfJPJJIt)o$(0RheMcs3&# z-p7wsjQ^XA(PN}OLYs1XvYv8*W5FDomF< zr`XOZ-;Zjh*q6!u9=SgxTRJlx(5tBrlSxCThVK*$%BhuYWIG2ud{J!WGR<-c4DTo) zr(`z~ZVJZxfFPU@r&I$}0&rmDdcVr;_B@X~&o@D*(=8(57&nE`Q5@i9UwAmV2Xl-5_5|uA)2(<>ncnwn@B5j4r-(Qyo->?u z@hEf>6X8YZ+XGmcPe~%+X?$(c^712O|!Wk20y35TR(h5PX&K9}O z0EBF$pphgFZW9H1D7Z~r*FsB6*wzuW<3v3cOK(5|g{cdXc_+S#ds)~5WQ$J}0^_Me z*p#|PYGj*CzRVSnr*GnQx;Ebw-Y%k{+lk>wv(L8)ZQ!e{I7I0&)xZxAKU#ponD~kl z1gmz9P59Xs6DOGR2@i#^s{Eu!sz)m*DD~I|5#3<*<2W?c=bMrJ*#|^NVGaWng~zc{ za_IJz*s6n67&vtun-W0kDIVD&u0=OfA~c-TwnAF2zwpg^5{B9RBn-3rY3!N)l7ITa z<pD0 zejg~bN2A&1(fll61HS2(SdBqmc8adT@HHVdxsdp@}CyCvaG;{ zc+?7U%oua>8q!6wV;&x?&@PP376HI3Mlh#a1UacvW0VLhI@XHz(kT*`wM3=S07EW* zzb5>%q_Fz3%}^79DKjE6W!iuS)RC{r0ti$9lbjzTH-a2ZX8q2mK#FT#-_!)nCg6=H z8P}3Ba6ZNLOcCiOc-)&{SQq%wO7x@wID3J#q9<7M`7*bJL@RTzu}#7al%Sr>er7L# zP{KJ6OxvfTx|WXi_)zhrATHuHW-HKBpQOG^K6e`p+-xyr@=01^gwQ6MSU!nHS%^zW zXPO~yn|`fX7Oeq9sb5BIjy6hgwF~&872X2C(r9xI z4V~ZvdYooRW+!2)zn*|smh-P0-xj{f+DVKqHz!WUUff*~|6(Ec`frfEUNIpQSan>}S3F;6=5mz$)NeG(jaSY-lE= zkkXITOCUZ-5xZYp_7Z`(@yx>fv3FQ z05S1XZF0TA_?s94+(KjmCy*rs%_JO|xnh|~W){e@dGL&BCHq>Fw!%8ShR~XTFk(}(flez}&OpG6tL;jF#4z#Q4$^Tz6rfyY8&mA_>LDkD z0P>x`KuTS9e~U~}!e9opq2UefdwJU$++;S;f6~cD2A!zS`cDE~X~EmXZC2;+LlK}jo>t9<`OOf)j?pJ7sK2X2Co$P zSeusu9)kcktB-BCs!z5Ha8aV(ArwVkN}_o1dudJJGMNvBSCU_=NPb;%bve=cmV;** zZC+f4A|{@B441-{z_Kok4=YypWF+a@&dhliC@0N*+P0i zhyzaP0jIdQQ=CYT4GB#d!Z^Y0{K5(F1vL}j%n3b)lZkgO`yx$6XD-s{Gjnm7>?W%j z_>YY(^K^0MK^Jw4wtzO)&OFs53|?rqFL=j|n-J{;kXb~B_LzBs?d==V&`Xn~Pt=;F zI)|nT(k@wB!0ScB=f0^eIQsy-8#nu4Rz|Z1H1u)};Oo^*OOWRxT5?z|yNbdgc!k`U z9}Ho*Fq9Wo5RiFPEMa0m-W!(KB<9DsQz|V+egt4}H!M`n(?cydm@jJ@f@b=o5PA6FMr{b`t#?bm^PjAe1iJ6>TM{ z&VJI;a#ETUt?7C^Z+8U9@ls5-v7I)v=;c|;GDQC88{27<21{l4d_B2t zjKF0fd}$`PmE4t-?-43vB>?mQW^G)i^*T{c`!tW*b6q4jDc`s1p{pe019RCbK&iKe(MX_&E%IC>_irnYO zeTLju$$f#`H^_a7+}FwdDU~ddTTd=ga;lkPUnci^;L~nc@X`DMD3wfTw&S`F=DF-{*CzPF1|Z%8i6EeR!Gm2P3^i8MA&?pT;jc{uM!52lmAKRR9+~8 zK8*riW`u{S!9fk72SJ!3wwt+x-Gh1ZF+!G6zCiAm$i1l13r4>7+{o9ijeLk-FFHHX z=|g7+I{oMbr~}Wu-s&zed5taS@VGT2)9$7;-?c%`8 z^6+n+Lvlz%&eiWrDC39YvAt)5>Ub&~j}46_;&&x6os-hFIixk6hxZQci6_)u<+RVQxl>gwt3!hgMe^w`dCU0qwddf3D9TY9!^ z?(N>(jVUR(oBw*Y^=#X`RS9iXw~TDx(zkV33HF4xZ0=T-;oxQ^7~HybYp`dePYw2M z+diUf?;YtI**4s@xo2CbXJn*D4Q=V!+}qnX(ziLdIkY9XB^2rjjRdz12e)qzZs~#I zdV<|OTe`cq4UcRI4y!%AJ;U2Wz1`ckbZy(*Gu$&Ag8FUk-5%VkjtuvyTekFUg%Y=p zghJh$p)On0U}zY!_H=jkbwQ$FND1}z_4JM?%628#1+`Ivn}fqjkD@>YH*eXxZ5Y5S z+eXx$EnUN#yGE4YaA<2!s8J$)nHBU{zpV4oy4V3VQ?|1wk1 zFn3#Mn8A_YQhO{+dt{=}2BW3g0DOC6>F5%<=at;2fZV@yWcY(>FtzvWcmxDiVu`}@ zN?|KP<)}IuPNqQChd6FYsLXF0WT6c{Qf(U?JFwIW^V$m2&U?(<6bB+xxtiSA3xKEFi&9U%IJvP4H`a7>Lv zSoE+oQij8kaB8A+AP&tifgK@~6H`lVH2-b%1!$ws&2t+q$**~DrVupK2L_{YYL&xF zOGFDp<&OZB&stojn|Jz;bZ;N&27+x5cK7!6DBHFThtyDauuD~d6rt@~wnNrXaP!D^ zwQHnT2?d9TH;0DR&3#=X!7bZ{fuemq+qZUgE6V1cEkO02?LFIu`?ihr^mYd!b@%q| zTb1GMP}44@8>s~C+&kPoqV{zIfqO#GO4M!;w7q9!8<4h7?F|KcptY5eZe?V9s5_)= z+uXfn8?;$yduVg82hhPbfzYj8y_>gnZ`}rPdPWqrSJ~Pf>Io{~?;h#e+S>(rfODW- z6~KLa@0LEmV0)LMc5mw$>4ByP)QSGL1O1N+F5i`0T9KPy?mh|B9ZbQDYiY4_zDfJb zK-yzKS|t*R4}WlpxbsR}k_v)vL+bbvb?1}1-43avnh{TuWQX)NlWi193OJ-|N+yWL zC8^0FHK?&o#|9;7twUO+r<3=@6XWrOg1erQbge^LnTr~{?V!wMNYXnU(uVv@o${_o zL{5Z9$5Kf-p(Zh5s8f;-Ii&ri%8lm5xFEnP@2ynHFtM) zZt3cTk+`R`n`_d)clWXPNYW99^j?cZJgO?8BeBRte>jLGD~X9yJ@48vs;2G$eoo#J zy5o**l60FxIymR@jw_M0N+oWWBoI)?=TaiJteQ}UBPtiZH#(l0z_Ni5#~ji?m1Q3U z+Mnt+E!E?Y>JOyUC@}*XxW^6h7HI1DU5C<9r7M1 zI-O8&j;U$r6A^=;9g3e;V>g538`(0lZKS(9w53bgth76%>yIT>xjz*eNW_C`G6`_x z@kD%FO{6B|a17un*cGL%b&~X#-~7?naX0)^@E6f=QIqj>0&?m;HS0oAEmL^%=aowg(@`=4?Kp<#Uj6!uHa!3tE6sAj3-n8i!N-RP zPpIoYjKc9gQspgmah>+VZ>0BHj-|Wbq(h0-H(| z&@`dNQ;9Md6;@=&ySW}^n12^3jWw=H4vB((YL5Gmk^n8V#<=H@Fz>pYZc%VfAu2_P z7m>X}JAhm3DhU*-;-5pxc#Y8(7?^VoB%--t?Qzx7m@CH&;NdFL@K$<~N~uNSO7%CU zt+wie(Rfk*ynxaZ)IIT7N(sl*gzdQHAeZ6p-I4gP?N~9;cUQ>^>EUEB5vChZ78$~j zql#Wplvg_%Tur^p7E&BjnrHUMlPNwM9u8Ksw6Vb0=c84Isrpq&JrS*L{9Itf4LFsR zqQ?&%h$T}>Y%vksh?6yOTBL1p&s%h?RDf3*UJ|J+i%{F~FCk(}N+T}?qif6aE z?UnxF!C-tGH^w;_Hq`kQkM31N>^;Y_IMVqau)Y|O6m+{6rkDf z|14ZJ%k2kMQLj1d4J}-~%I_7KRbo+cVx>K#N{wZy4QIQrw1CwvxzAKZoo2h|v~X1_ zvjo=FZtc9&$*}bi@H7uG36jyn+J6#J` z)sj13rBI*U{?`KQk=EqLEceA0TGggovz9G_TYO7N_zHStT6>>u6h?tuG+f zItC^vTAqyb=V_>S9 z)mqOfkDj#&@Pdz`c?!&I=eP?^MS;Y-s~zlXK5mw8{wijw3yx(Gd8;`IntxItMHZ&2 zn0t#H)lRxaHtm@=-QK4RC&Iz|Tvosx(qn-FNC&lVQ>(VGuW-)-xAAS`F zEYmq9x1FV(N={le*3l7>GylLz4zAf;G8PJ3;qrM!O^0e(1>o$1m6t^36;B}u$S!m~HtLCco z0%C7O!^(hOwC}O!&|Yg3QnPQ}yRQ=hMvKAdEAvTAEBG^E66 zMKysc+`Q2^sof|?lw|7Wjj2Rh-B|WcZ*WYFDvPRe_?Ew>KsXkeu_ze8hbvDLYg>&J zqF8CT!Sff3yBa~lu^OWyB_{QiXHd1RB%x@!5-&R1QFUZ-*TjHmew&#H^6NHj!fZ0I zBQ77u6XmbamOON-=i@cnYA@01*{dDc^o%)QffiMam)V>zA{NgrOj>M2pAj-+&Rjw? z(7m`&M~tf4hRCb+-m_{jZBTx#skF8?PH8mfuiA^g!n3dHLC{%_jYr~2XeeCOp13^~ z%}3ArhEv{)CS(u9K-U(guo16tP)$}8wZ;37dLddFRZy)&?rP~*q6lMH!MGFhFaiCR@lU|ObjrS_sq2j;J>Xkzaw zXy9U8%g_P@Q$$V4da~OKX-FpbbJ4{G7w1ThDG8O0>MK!IK5|Gd=AjN*i6rB4Iw=wX zb{+Dt8dNX@v!?Ef%VWy;xEjMx5)>4s6|5 z36O9pHE~tcE)UxZ)hvC;$x37?rasOe7h1#=%EQxywXIiuZ|qDs5sx7%N7WG(#=feK zx7e*^m%w(mWDt6aK~~(J$9kluI%T z)dC$Z76L&rVSN#>==y{xK`X%0mP>IqOHEKZTZ!QOeW=nnnw)0TGvscX%sqncFHrZE8?* z;$PifOa74;)yk=)LH=5HwIA3pIbU>3=`S!Hj;F#S;b6fA4rM+(*jXx;_wg4BebERN zZo3%|9RZrgqu(3l(C{5GP_c5yk?_;U8)ZIgG>}k7!e?*Z$Zr(0K$ST>n14>H{DmYn z5{CQ}d&ZPlOg~Ts)hdXvm+%$w+?5zjV*zFH)e_i(x5>qr;+oKbm0Ȫc)2kW&; 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

I1(m6ZK4#3h;}Jmx+?+C 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

-77ucLyfg5DQhG6&zs2s>yYz95RC=m1GQL7#2g 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