From 37c579ea188e025949b73639c45cd901c2e0a026 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Fri, 8 Mar 2024 22:44:30 -0300 Subject: [PATCH 01/36] Add CassandraDb HealthCheck support --- .github/codecov.yml | 2 + .github/labeler.yml | 3 + .../workflows/healthchecks_cassandradb_cd.yml | 16 ++++ .../healthchecks_cassandradb_cd_preview.yml | 17 ++++ .../workflows/healthchecks_cassandradb_ci.yml | 71 +++++++++++++++ AspNetCore.Diagnostics.HealthChecks.sln | 14 +++ build/versions.props | 1 + .../CassandraDbHealthCheck.cs | 43 +++++++++ .../CassandraDbOptions.cs | 14 +++ ...CassandraDbHealthCheckBuilderExtensions.cs | 91 +++++++++++++++++++ .../HealthChecks.CassandraDb.csproj | 12 +++ ...sandraHealthCheckBuilderExtensionsTests.cs | 61 +++++++++++++ .../Functional/CassandraDbHealthCheckTests.cs | 77 ++++++++++++++++ .../HealthChecks.CassandraDb.Tests.csproj | 5 + 14 files changed, 427 insertions(+) create mode 100644 .github/workflows/healthchecks_cassandradb_cd.yml create mode 100644 .github/workflows/healthchecks_cassandradb_cd_preview.yml create mode 100644 .github/workflows/healthchecks_cassandradb_ci.yml create mode 100644 src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs create mode 100644 src/HealthChecks.CassandraDb/CassandraDbOptions.cs create mode 100644 src/HealthChecks.CassandraDb/DependencyInjection/CassandraDbHealthCheckBuilderExtensions.cs create mode 100644 src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj create mode 100644 test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs create mode 100644 test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs create mode 100644 test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj diff --git a/.github/codecov.yml b/.github/codecov.yml index 8ef912e73d..5cdde27582 100644 --- a/.github/codecov.yml +++ b/.github/codecov.yml @@ -35,6 +35,8 @@ flags: carryforward: true CosmosDb: carryforward: true + CassandraDb: + carryforward: true DocumentDb: carryforward: true DynamoDb: diff --git a/.github/labeler.yml b/.github/labeler.yml index 87db1be728..81b82d0491 100644 --- a/.github/labeler.yml +++ b/.github/labeler.yml @@ -35,6 +35,9 @@ consul: cosmosdb: - src/HealthChecks.CosmosDb/**/* +cassandradb: + - src/HealthChecks.CassandraDb/**/* + dapr: - src/HealthChecks.Dapr/**/* diff --git a/.github/workflows/healthchecks_cassandradb_cd.yml b/.github/workflows/healthchecks_cassandradb_cd.yml new file mode 100644 index 0000000000..dd87a3322e --- /dev/null +++ b/.github/workflows/healthchecks_cassandradb_cd.yml @@ -0,0 +1,16 @@ +name: HealthChecks CassandraDb CD + +on: + push: + tags: + - release-cassandradb-* + - release-all-* + +jobs: + build: + uses: ./.github/workflows/reusable_cd_workflow.yml + secrets: inherit + with: + BUILD_CONFIG: Release + PROJECT_PATH: ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj + PACKAGE_NAME: AspNetCore.HealthChecks.CassandraDb diff --git a/.github/workflows/healthchecks_cassandradb_cd_preview.yml b/.github/workflows/healthchecks_cassandradb_cd_preview.yml new file mode 100644 index 0000000000..4abfe26d5c --- /dev/null +++ b/.github/workflows/healthchecks_cassandradb_cd_preview.yml @@ -0,0 +1,17 @@ +name: HealthChecks CassandraDb Preview CD + +on: + push: + tags: + - preview-cassandradb-* + - preview-all-* + +jobs: + build: + uses: ./.github/workflows/reusable_cd_preview_workflow.yml + secrets: inherit + with: + BUILD_CONFIG: Release + VERSION_SUFFIX_PREFIX: rc1 + PROJECT_PATH: ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj + PACKAGE_NAME: AspNetCore.HealthChecks.CassandraDb diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml new file mode 100644 index 0000000000..24291a451f --- /dev/null +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -0,0 +1,71 @@ +name: HealthChecks CassandraDbDB CI + +on: + workflow_dispatch: + push: + branches: [ master ] + paths: + - src/HealthChecks.CassandraDb/** + - test/HealthChecks.CassandraDb.Tests/** + - test/_SHARED/** + - .github/workflows/healthchecks_cassandradb_ci.yml + - Directory.Build.props + - Directory.Build.targets + tags-ignore: + - release-* + - preview-* + + pull_request: + branches: [ master ] + paths: + - src/HealthChecks.CassandraDb/** + - test/HealthChecks.CassandraDb.Tests/** + - test/_SHARED/** + - .github/workflows/healthchecks_cassandradb_ci.yml + - Directory.Build.props + - Directory.Build.targets + +jobs: + build: + runs-on: ubuntu-latest + services: + CassandraDb: + image: CassandraDb:latest + ports: + - 9042:9042 + steps: + - uses: actions/checkout@v3 + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: | + 6.0.x + 7.0.x + 8.0.x + - name: Restore + run: | + dotnet restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && + dotnet restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj + - name: Check formatting + run: | + dotnet format --no-restore --verify-no-changes --severity warn ./src/HealthChecks.CassandraDbDb/HealthChecks.CassandraDb.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) && + dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDbDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" and exit 1) + - name: Build + run: | + dotnet build --no-restore ./src/HealthChecks.CassandraDbDb/HealthChecks.CassandraDbDb.csproj && + dotnet build --no-restore ./test/HealthChecks.CassandraDbDb.Tests/HealthChecks.CassandraDbDb.Tests.csproj + - name: Test + run: > + dotnet test + ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDbDb.Tests.csproj + --no-restore + --no-build + --collect "XPlat Code Coverage" + --results-directory .coverage + -- + DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=opencover + - name: Upload Coverage + uses: codecov/codecov-action@v3 + with: + flags: CassandraDb + directory: .coverage diff --git a/AspNetCore.Diagnostics.HealthChecks.sln b/AspNetCore.Diagnostics.HealthChecks.sln index c782d00ea9..6f011a5249 100644 --- a/AspNetCore.Diagnostics.HealthChecks.sln +++ b/AspNetCore.Diagnostics.HealthChecks.sln @@ -306,6 +306,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HealthChecks.Azure.Messagin EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HealthChecks.AzureServiceBus.Tests", "test\HealthChecks.AzureServiceBus.Tests\HealthChecks.AzureServiceBus.Tests.csproj", "{3B812989-2C4E-4FCE-B3A0-EF9C00A9B3A5}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HealthChecks.CassandraDb", "src\HealthChecks.CassandraDb\HealthChecks.CassandraDb.csproj", "{BCBC3C44-A140-452C-9C18-C670C2F7FCEF}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HealthChecks.CassandraDb.Tests", "test\HealthChecks.CassandraDb.Tests\HealthChecks.CassandraDb.Tests.csproj", "{3FDC5E82-4AFB-4C79-A253-2C704DCAC400}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -856,6 +860,14 @@ Global {3B812989-2C4E-4FCE-B3A0-EF9C00A9B3A5}.Debug|Any CPU.Build.0 = Debug|Any CPU {3B812989-2C4E-4FCE-B3A0-EF9C00A9B3A5}.Release|Any CPU.ActiveCfg = Release|Any CPU {3B812989-2C4E-4FCE-B3A0-EF9C00A9B3A5}.Release|Any CPU.Build.0 = Release|Any CPU + {BCBC3C44-A140-452C-9C18-C670C2F7FCEF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BCBC3C44-A140-452C-9C18-C670C2F7FCEF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BCBC3C44-A140-452C-9C18-C670C2F7FCEF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BCBC3C44-A140-452C-9C18-C670C2F7FCEF}.Release|Any CPU.Build.0 = Release|Any CPU + {3FDC5E82-4AFB-4C79-A253-2C704DCAC400}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3FDC5E82-4AFB-4C79-A253-2C704DCAC400}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3FDC5E82-4AFB-4C79-A253-2C704DCAC400}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3FDC5E82-4AFB-4C79-A253-2C704DCAC400}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -997,6 +1009,8 @@ Global {2C02BEDF-FFFA-4747-920A-A1ED6CFFC21A} = {FF4414C2-8863-4ADA-8A1D-4B9F25C361FE} {09160C0F-BB5E-4DF2-AF44-E859E8EDE6BD} = {FF4414C2-8863-4ADA-8A1D-4B9F25C361FE} {3B812989-2C4E-4FCE-B3A0-EF9C00A9B3A5} = {FF4414C2-8863-4ADA-8A1D-4B9F25C361FE} + {BCBC3C44-A140-452C-9C18-C670C2F7FCEF} = {2A3FD988-2BB8-43CF-B3A2-B70E648259D4} + {3FDC5E82-4AFB-4C79-A253-2C704DCAC400} = {FF4414C2-8863-4ADA-8A1D-4B9F25C361FE} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {2B8C62A1-11B6-469F-874C-A02443256568} diff --git a/build/versions.props b/build/versions.props index 659fa667b4..a4ae3385b5 100644 --- a/build/versions.props +++ b/build/versions.props @@ -21,6 +21,7 @@ 8.0.0 8.0.0 8.0.0 + 8.0.0 8.0.0 8.0.0 8.0.0 diff --git a/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs b/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs new file mode 100644 index 0000000000..e3bdbe0c8b --- /dev/null +++ b/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs @@ -0,0 +1,43 @@ +using Cassandra; +using Microsoft.Extensions.Diagnostics.HealthChecks; + +namespace HealthChecks.CassandraDb; + +public class CassandraDbHealthCheck : IHealthCheck +{ + private readonly CassandraDbOptions _options; + + public CassandraDbHealthCheck(CassandraDbOptions options) + { + _options = Guard.ThrowIfNull(options); + + if (_options.ContactPoint is null && _options.Keyspace is null) + { + throw new ArgumentException("A connection or connection string must be set!", nameof(options)); + } + } + + public async Task CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) + { + try + { + var builder = Cluster.Builder().AddContactPoint(_options.ContactPoint); + _options.ConfigureClusterBuilder?.Invoke(builder); + + var cluster = builder.Build(); + + ISession session = await cluster.ConnectAsync(_options.Keyspace).ConfigureAwait(false); + + + RowSet rows = await session.ExecuteAsync(new SimpleStatement(_options.Query)).ConfigureAwait(false); + var result = rows.FirstOrDefault(); + + return HealthCheckResult.Healthy(); + } + catch (Exception ex) + { + + return HealthCheckResult.Unhealthy(ex.Message); + } + } +} diff --git a/src/HealthChecks.CassandraDb/CassandraDbOptions.cs b/src/HealthChecks.CassandraDb/CassandraDbOptions.cs new file mode 100644 index 0000000000..57bfa49567 --- /dev/null +++ b/src/HealthChecks.CassandraDb/CassandraDbOptions.cs @@ -0,0 +1,14 @@ +using Cassandra; + +namespace HealthChecks.CassandraDb; + +/// +/// Options for CassandraHealthCheck. +/// +public class CassandraDbOptions +{ + public string ContactPoint { get; set; } = null!; + public string Keyspace { get; set; } = null!; + public string Query { get; set; } = "SELECT now() FROM system.local;"; + public Action ConfigureClusterBuilder { get; set; } = null!; +} diff --git a/src/HealthChecks.CassandraDb/DependencyInjection/CassandraDbHealthCheckBuilderExtensions.cs b/src/HealthChecks.CassandraDb/DependencyInjection/CassandraDbHealthCheckBuilderExtensions.cs new file mode 100644 index 0000000000..24a8fa4645 --- /dev/null +++ b/src/HealthChecks.CassandraDb/DependencyInjection/CassandraDbHealthCheckBuilderExtensions.cs @@ -0,0 +1,91 @@ +using Cassandra; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Diagnostics.HealthChecks; + +namespace HealthChecks.CassandraDb.DependencyInjection; + +/// +/// Extension methods to configure . +/// +public static class CassandraDbHealthCheckBuilderExtensions +{ + private const string NAME = "cassandra"; + + /// + /// Add a health check for Cassandra databases. + /// + /// The . + /// The Cassandra contact point to be used. + /// The Cassandra keyspace to be used. + /// The query to be executed. Default is 'SELECT now() FROM system.local;'. + /// An action to allow additional Cassandra specific configuration. It cannot be null. + /// The health check name. Optional. If null the type name 'cassandra' will be used for the name. + /// + /// The that should be reported when the health check fails. Optional. If null then + /// the default status of will be reported. + /// + /// A list of tags that can be used to filter sets of health checks. Optional. + /// An optional representing the timeout of the check. + /// The specified . + public static IHealthChecksBuilder AddCassandra( + this IHealthChecksBuilder builder, + string contactPoint, + string keyspace, + string query = "SELECT now() FROM system.local;", + Action? configureClusterBuilder = null, // Note: The caller must ensure this is not null + string? name = default, + HealthStatus? failureStatus = default, + IEnumerable? tags = default, + TimeSpan? timeout = default) + { + // Define a default configuration action if none is provided + var defaultConfigurationAction = new Action(b => + // Default minimal configuration + b.AddContactPoint(contactPoint).Build()); + + var options = new CassandraDbOptions + { + ContactPoint = contactPoint, + Keyspace = keyspace, + Query = query, + ConfigureClusterBuilder = configureClusterBuilder ?? defaultConfigurationAction // Use provided configuration or default + }; + + return builder.AddCassandra(options, name, failureStatus, tags, timeout); + } + + /// + /// Add a health check for Cassandra databases using . + /// + /// The . + /// Options for the Cassandra health check. + /// The health check name. Optional. If null the type name 'cassandra' will be used for the name. + /// + /// The that should be reported when the health check fails. Optional. If null then + /// the default status of will be reported. + /// + /// A list of tags that can be used to filter sets of health checks. Optional. + /// An optional representing the timeout of the check. + /// The specified . + public static IHealthChecksBuilder AddCassandra( + this IHealthChecksBuilder builder, + CassandraDbOptions options, + string? name = default, + HealthStatus? failureStatus = default, + IEnumerable? tags = default, + TimeSpan? timeout = default) + { + // Ensure options.ConfigureClusterBuilder is never null + if (options.ConfigureClusterBuilder == null) + { + throw new ArgumentNullException(nameof(options.ConfigureClusterBuilder), "ConfigureClusterBuilder action cannot be null."); + } + + return builder.Add(new HealthCheckRegistration( + name ?? NAME, + sp => new CassandraDbHealthCheck(options), + failureStatus, + tags, + timeout)); + } +} diff --git a/src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj b/src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj new file mode 100644 index 0000000000..20bc6b2245 --- /dev/null +++ b/src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj @@ -0,0 +1,12 @@ + + + + netstandard2.0 + + + + + + + + diff --git a/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs b/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs new file mode 100644 index 0000000000..87b392350d --- /dev/null +++ b/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs @@ -0,0 +1,61 @@ +using HealthChecks.CassandraDb.DependencyInjection; + +namespace HealthChecks.CassandraDb.Tests.DependencyInjection; + +public class CassandraHealthCheckBuilderExtensionsTests +{ + [Fact] + public void AddHealthCheckWhenProperlyConfigured() + { + var services = new ServiceCollection() + .AddHealthChecks() + .AddCassandra(new CassandraDbOptions + { + ContactPoint = "127.0.0.1", + Keyspace = "myKeyspace", + Query = "SELECT now() FROM system.local;", + ConfigureClusterBuilder = builder => builder.WithPort(9042) + }, name: "cassandra") + .Services; + + var serviceProvider = services.BuildServiceProvider(); + var options = serviceProvider.GetService>(); + var healthCheckRegistration = options?.Value.Registrations.First(); + var registration = healthCheckRegistration; + + registration?.Name.ShouldBe("cassandra"); + } + + [Fact] + public void AddNamedHealthCheckWhenProperlyConfigured() + { + var services = new ServiceCollection() + .AddHealthChecks() + .AddCassandra(new CassandraDbOptions + { + ContactPoint = "127.0.0.1", + Keyspace = "testKeyspace", + Query = "SELECT now() FROM system.local;", + ConfigureClusterBuilder = builder => builder.WithPort(9042) + }, name: "my-cassandra-1") + .Services; + + var serviceProvider = services.BuildServiceProvider(); + var options = serviceProvider.GetService>(); + var registration = options?.Value.Registrations.First(r => r.Name == "my-cassandra-1"); + + registration?.Name.ShouldBe("my-cassandra-1"); + } + + [Fact] + public void ThrowsExceptionWhenConfigureClusterBuilderIsNullAndRequired() + { + var services = new ServiceCollection(); + + Assert.Throws(() => services.AddHealthChecks().AddCassandra(new CassandraDbOptions + { + ContactPoint = "127.0.0.1", + Keyspace = "myKeyspace", + })); + } +} diff --git a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs new file mode 100644 index 0000000000..aa5feaae63 --- /dev/null +++ b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs @@ -0,0 +1,77 @@ +using System.Net; +using HealthChecks.CassandraDb.DependencyInjection; + +namespace HealthChecks.CassandraDb.Tests.Functional; + +public class CassandraDbHealthCheckTests +{ + [Fact] + public async Task be_healthy_if_cassandra_is_available() + { + var webHostBuilder = new WebHostBuilder() + .ConfigureServices(services => + { + services.AddHealthChecks() + .AddCassandra(contactPoint: "localhost", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + }) + .Configure(app => + { + app.UseHealthChecks("/health", new HealthCheckOptions + { + Predicate = r => r.Tags.Contains("cassandra") + }); + }); + + using var server = new TestServer(webHostBuilder); + using var response = await server.CreateRequest("/health").GetAsync(); + + response.StatusCode.ShouldBe(HttpStatusCode.OK); + } + + [Fact] + public async Task be_unhealthy_if_cassandra_is_not_available() + { + var webHostBuilder = new WebHostBuilder() + .ConfigureServices(services => + { + services.AddHealthChecks() + .AddCassandra(contactPoint: "invalid-host", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + }) + .Configure(app => + { + app.UseHealthChecks("/health", new HealthCheckOptions + { + Predicate = r => r.Tags.Contains("cassandra") + }); + }); + + using var server = new TestServer(webHostBuilder); + using var response = await server.CreateRequest("/health").GetAsync(); + + response.StatusCode.ShouldBe(HttpStatusCode.ServiceUnavailable); + } + + [Fact] + public async Task be_unhealthy_if_cassandra_query_is_not_valid() + { + var webHostBuilder = new WebHostBuilder() + .ConfigureServices(services => + { + services.AddHealthChecks() + .AddCassandra(contactPoint: "localhost", keyspace: "system", query: "SELECT invalid_query FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + }) + .Configure(app => + { + app.UseHealthChecks("/health", new HealthCheckOptions + { + Predicate = r => r.Tags.Contains("cassandra") + }); + }); + + using var server = new TestServer(webHostBuilder); + using var response = await server.CreateRequest("/health").GetAsync(); + + response.StatusCode.ShouldBe(HttpStatusCode.ServiceUnavailable); + } + +} diff --git a/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj b/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj new file mode 100644 index 0000000000..acff354b06 --- /dev/null +++ b/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj @@ -0,0 +1,5 @@ + + + + + From 9565dc45cb18a273c6317c31388cbdd20f74fd58 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Fri, 8 Mar 2024 23:41:02 -0300 Subject: [PATCH 02/36] Update healthchecks_cassandradb_ci.yaml --- .github/workflows/healthchecks_cassandradb_ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 24291a451f..ffeb6efab5 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -30,7 +30,7 @@ jobs: runs-on: ubuntu-latest services: CassandraDb: - image: CassandraDb:latest + image: cassandra:latest ports: - 9042:9042 steps: From 5661506a7cd7cc48666d0196564d94bf94f9343c Mon Sep 17 00:00:00 2001 From: djesusnet Date: Fri, 8 Mar 2024 23:47:54 -0300 Subject: [PATCH 03/36] Update ymal --- .github/workflows/healthchecks_cassandradb_ci.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index ffeb6efab5..6099d12808 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -1,4 +1,4 @@ -name: HealthChecks CassandraDbDB CI +name: HealthChecks CassandraDb CI on: workflow_dispatch: @@ -48,16 +48,16 @@ jobs: dotnet restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - name: Check formatting run: | - dotnet format --no-restore --verify-no-changes --severity warn ./src/HealthChecks.CassandraDbDb/HealthChecks.CassandraDb.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) && - dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDbDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" and exit 1) + dotnet format --no-restore --verify-no-changes --severity warn ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) && + dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" and exit 1) - name: Build run: | - dotnet build --no-restore ./src/HealthChecks.CassandraDbDb/HealthChecks.CassandraDbDb.csproj && - dotnet build --no-restore ./test/HealthChecks.CassandraDbDb.Tests/HealthChecks.CassandraDbDb.Tests.csproj + dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && + dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - name: Test run: > dotnet test - ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDbDb.Tests.csproj + ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj --no-restore --no-build --collect "XPlat Code Coverage" From 0dc5f148e293b894d351f9a74a7ca3b4c590d0fe Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 00:10:28 -0300 Subject: [PATCH 04/36] Update CassandraDbHealthCheckTests --- .../Functional/CassandraDbHealthCheckTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs index aa5feaae63..a498de2aa8 100644 --- a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs +++ b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs @@ -12,7 +12,7 @@ public async Task be_healthy_if_cassandra_is_available() .ConfigureServices(services => { services.AddHealthChecks() - .AddCassandra(contactPoint: "localhost", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + .AddCassandra(contactPoint: "127.0.0.1", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); }) .Configure(app => { From 17ae1a8e0df57659b7d47b7fe79f864f24752420 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 00:22:36 -0300 Subject: [PATCH 05/36] update CassandraDbHealthCheckTests --- .../Functional/CassandraDbHealthCheckTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs index a498de2aa8..aa5feaae63 100644 --- a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs +++ b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs @@ -12,7 +12,7 @@ public async Task be_healthy_if_cassandra_is_available() .ConfigureServices(services => { services.AddHealthChecks() - .AddCassandra(contactPoint: "127.0.0.1", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + .AddCassandra(contactPoint: "localhost", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); }) .Configure(app => { From 2d161ffa4fdb1f876f48460eef4ad366c9b48012 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 00:29:19 -0300 Subject: [PATCH 06/36] updates yml and CassandraDbHealthCheckTests --- .github/workflows/healthchecks_cassandradb_ci.yml | 9 +++++++-- .../Functional/CassandraDbHealthCheckTests.cs | 2 +- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 6099d12808..ab3cb33d8f 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -29,10 +29,15 @@ jobs: build: runs-on: ubuntu-latest services: - CassandraDb: + cassandradb: image: cassandra:latest ports: - 9042:9042 + options: >- + --health-cmd "cqlsh -e 'DESC KEYSPACES'" + --health-interval 10s + --health-timeout 5s + --health-retries 5 steps: - uses: actions/checkout@v3 - name: Setup .NET @@ -55,7 +60,7 @@ jobs: dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - name: Test - run: > + run: | dotnet test ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj --no-restore diff --git a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs index aa5feaae63..a498de2aa8 100644 --- a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs +++ b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs @@ -12,7 +12,7 @@ public async Task be_healthy_if_cassandra_is_available() .ConfigureServices(services => { services.AddHealthChecks() - .AddCassandra(contactPoint: "localhost", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + .AddCassandra(contactPoint: "127.0.0.1", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); }) .Configure(app => { From 02797c960a006cef986452c3087637b1c7b2e797 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 00:36:08 -0300 Subject: [PATCH 07/36] Update unit tests --- .../CassandraHealthCheckBuilderExtensionsTests.cs | 6 +++--- .../Functional/CassandraDbHealthCheckTests.cs | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs b/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs index 87b392350d..b4bc07c708 100644 --- a/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs +++ b/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs @@ -11,7 +11,7 @@ public void AddHealthCheckWhenProperlyConfigured() .AddHealthChecks() .AddCassandra(new CassandraDbOptions { - ContactPoint = "127.0.0.1", + ContactPoint = "cassandradb", Keyspace = "myKeyspace", Query = "SELECT now() FROM system.local;", ConfigureClusterBuilder = builder => builder.WithPort(9042) @@ -33,7 +33,7 @@ public void AddNamedHealthCheckWhenProperlyConfigured() .AddHealthChecks() .AddCassandra(new CassandraDbOptions { - ContactPoint = "127.0.0.1", + ContactPoint = "cassandradb", Keyspace = "testKeyspace", Query = "SELECT now() FROM system.local;", ConfigureClusterBuilder = builder => builder.WithPort(9042) @@ -54,7 +54,7 @@ public void ThrowsExceptionWhenConfigureClusterBuilderIsNullAndRequired() Assert.Throws(() => services.AddHealthChecks().AddCassandra(new CassandraDbOptions { - ContactPoint = "127.0.0.1", + ContactPoint = "cassandradb", Keyspace = "myKeyspace", })); } diff --git a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs index a498de2aa8..f50d28f8b0 100644 --- a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs +++ b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs @@ -12,7 +12,7 @@ public async Task be_healthy_if_cassandra_is_available() .ConfigureServices(services => { services.AddHealthChecks() - .AddCassandra(contactPoint: "127.0.0.1", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + .AddCassandra(contactPoint: "cassandradb", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); }) .Configure(app => { @@ -58,7 +58,7 @@ public async Task be_unhealthy_if_cassandra_query_is_not_valid() .ConfigureServices(services => { services.AddHealthChecks() - .AddCassandra(contactPoint: "localhost", keyspace: "system", query: "SELECT invalid_query FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + .AddCassandra(contactPoint: "cassandradb", keyspace: "system", query: "SELECT invalid_query FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); }) .Configure(app => { From 9a2abdc99091fc915a21ae7e388bb641bf3300e5 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 00:43:32 -0300 Subject: [PATCH 08/36] Update yml --- .github/workflows/healthchecks_cassandradb_ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index ab3cb33d8f..b935421fef 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -35,8 +35,8 @@ jobs: - 9042:9042 options: >- --health-cmd "cqlsh -e 'DESC KEYSPACES'" - --health-interval 10s - --health-timeout 5s + --health-interval 20s + --health-timeout 10s --health-retries 5 steps: - uses: actions/checkout@v3 From 1e7b60a052edca38222b0b0acc8a285021e5a975 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 00:56:54 -0300 Subject: [PATCH 09/36] Update HealthChecks CassandraDb CIi.yml --- .../workflows/healthchecks_cassandradb_ci.yml | 25 +++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index b935421fef..3b921706cf 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -35,11 +35,13 @@ jobs: - 9042:9042 options: >- --health-cmd "cqlsh -e 'DESC KEYSPACES'" - --health-interval 20s - --health-timeout 10s + --health-interval 10s + --health-timeout 5s --health-retries 5 + steps: - uses: actions/checkout@v3 + - name: Setup .NET uses: actions/setup-dotnet@v4 with: @@ -47,18 +49,36 @@ jobs: 6.0.x 7.0.x 8.0.x + - name: Restore run: | dotnet restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj + - name: Check formatting run: | dotnet format --no-restore --verify-no-changes --severity warn ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) && dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" and exit 1) + - name: Build run: | dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj + + - name: Wait for Cassandra to be ready + run: | + echo "Waiting for Cassandra to be ready..." + timeout=60 + while ! nc -z localhost 9042; do + timeout=$((timeout-1)) + if [ $timeout -eq 0 ]; then + echo "Timeout waiting for Cassandra to start" + exit 1 + fi + sleep 1 + done + echo "Cassandra is up and running!" + - name: Test run: | dotnet test @@ -69,6 +89,7 @@ jobs: --results-directory .coverage -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=opencover + - name: Upload Coverage uses: codecov/codecov-action@v3 with: From 50a4995bf99bb68b155bb9ddc1f602766376663a Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 00:59:13 -0300 Subject: [PATCH 10/36] Update Ci.yml --- .../workflows/healthchecks_cassandradb_ci.yml | 30 ++----------------- 1 file changed, 2 insertions(+), 28 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 3b921706cf..6099d12808 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -29,19 +29,12 @@ jobs: build: runs-on: ubuntu-latest services: - cassandradb: + CassandraDb: image: cassandra:latest ports: - 9042:9042 - options: >- - --health-cmd "cqlsh -e 'DESC KEYSPACES'" - --health-interval 10s - --health-timeout 5s - --health-retries 5 - steps: - uses: actions/checkout@v3 - - name: Setup .NET uses: actions/setup-dotnet@v4 with: @@ -49,38 +42,20 @@ jobs: 6.0.x 7.0.x 8.0.x - - name: Restore run: | dotnet restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - - name: Check formatting run: | dotnet format --no-restore --verify-no-changes --severity warn ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) && dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" and exit 1) - - name: Build run: | dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - - - name: Wait for Cassandra to be ready - run: | - echo "Waiting for Cassandra to be ready..." - timeout=60 - while ! nc -z localhost 9042; do - timeout=$((timeout-1)) - if [ $timeout -eq 0 ]; then - echo "Timeout waiting for Cassandra to start" - exit 1 - fi - sleep 1 - done - echo "Cassandra is up and running!" - - name: Test - run: | + run: > dotnet test ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj --no-restore @@ -89,7 +64,6 @@ jobs: --results-directory .coverage -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=opencover - - name: Upload Coverage uses: codecov/codecov-action@v3 with: From d92a38059fcda61e0cbbd006d55088c174e85a73 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 06:08:37 -0300 Subject: [PATCH 11/36] Updates unit tests --- .github/workflows/healthchecks_cassandradb_ci.yml | 4 ++-- .../CassandraHealthCheckBuilderExtensionsTests.cs | 4 ++-- .../Functional/CassandraDbHealthCheckTests.cs | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 6099d12808..224f9df061 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -30,7 +30,7 @@ jobs: runs-on: ubuntu-latest services: CassandraDb: - image: cassandra:latest + image: cassandra ports: - 9042:9042 steps: @@ -67,5 +67,5 @@ jobs: - name: Upload Coverage uses: codecov/codecov-action@v3 with: - flags: CassandraDb + flags: cassandra directory: .coverage diff --git a/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs b/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs index b4bc07c708..d45cc02f64 100644 --- a/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs +++ b/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs @@ -37,14 +37,14 @@ public void AddNamedHealthCheckWhenProperlyConfigured() Keyspace = "testKeyspace", Query = "SELECT now() FROM system.local;", ConfigureClusterBuilder = builder => builder.WithPort(9042) - }, name: "my-cassandra-1") + }, name: "cassandra") .Services; var serviceProvider = services.BuildServiceProvider(); var options = serviceProvider.GetService>(); var registration = options?.Value.Registrations.First(r => r.Name == "my-cassandra-1"); - registration?.Name.ShouldBe("my-cassandra-1"); + registration?.Name.ShouldBe("cassandra"); } [Fact] diff --git a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs index f50d28f8b0..aa5feaae63 100644 --- a/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs +++ b/test/HealthChecks.CassandraDb.Tests/Functional/CassandraDbHealthCheckTests.cs @@ -12,7 +12,7 @@ public async Task be_healthy_if_cassandra_is_available() .ConfigureServices(services => { services.AddHealthChecks() - .AddCassandra(contactPoint: "cassandradb", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + .AddCassandra(contactPoint: "localhost", keyspace: "system", query: "SELECT now() FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); }) .Configure(app => { @@ -58,7 +58,7 @@ public async Task be_unhealthy_if_cassandra_query_is_not_valid() .ConfigureServices(services => { services.AddHealthChecks() - .AddCassandra(contactPoint: "cassandradb", keyspace: "system", query: "SELECT invalid_query FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); + .AddCassandra(contactPoint: "localhost", keyspace: "system", query: "SELECT invalid_query FROM system.local", configureClusterBuilder: builder => builder.WithPort(9042), tags: new string[] { "cassandra" }); }) .Configure(app => { From 2dcd46660141c2781fdc0c7314722b6c0467b21a Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 06:23:07 -0300 Subject: [PATCH 12/36] update dockercompose --- .github/workflows/healthchecks_cassandradb_ci.yml | 4 ++-- docker-compose.yml | 9 +++++++++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 224f9df061..6099d12808 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -30,7 +30,7 @@ jobs: runs-on: ubuntu-latest services: CassandraDb: - image: cassandra + image: cassandra:latest ports: - 9042:9042 steps: @@ -67,5 +67,5 @@ jobs: - name: Upload Coverage uses: codecov/codecov-action@v3 with: - flags: cassandra + flags: CassandraDb directory: .coverage diff --git a/docker-compose.yml b/docker-compose.yml index ee3a4c86ee..c5570e5c2c 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -8,6 +8,15 @@ services: environment: - ACCEPT_EULA=Y - SA_PASSWORD=Password12! + cassandra: + image: cassandra:latest + ports: + - "9042:9042" + environment: + - CASSANDRA_CLUSTER_NAME=MyCluster + - CASSANDRA_DC=DataCenter1 + - CASSANDRA_RACK=Rack1 + - CASSANDRA_ENDPOINT_SNITCH=GossipingPropertyFileSnitch redis: image: redis:alpine ports: From 49261bb124470eba2205cdffe3b47c369ccfc145 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 06:31:24 -0300 Subject: [PATCH 13/36] Update DockerCompose --- docker-compose.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/docker-compose.yml b/docker-compose.yml index c5570e5c2c..78ca158a39 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -12,11 +12,6 @@ services: image: cassandra:latest ports: - "9042:9042" - environment: - - CASSANDRA_CLUSTER_NAME=MyCluster - - CASSANDRA_DC=DataCenter1 - - CASSANDRA_RACK=Rack1 - - CASSANDRA_ENDPOINT_SNITCH=GossipingPropertyFileSnitch redis: image: redis:alpine ports: From 4ee4e47b91b01d5cc422f26f5677ca69ac33b29e Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 06:43:57 -0300 Subject: [PATCH 14/36] update docker-compose --- docker-compose.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docker-compose.yml b/docker-compose.yml index 78ca158a39..568831d54e 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -12,6 +12,10 @@ services: image: cassandra:latest ports: - "9042:9042" + volumes: + - ./build/docker-services/cassandra:/var/lib/cassandra + environment: + - CASSANDRA_CLUSTER_NAME=cloudinfra redis: image: redis:alpine ports: From 5f23cb0e8bf33cf6f5ca4730b31a927777d261a2 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 06:46:46 -0300 Subject: [PATCH 15/36] Update CI --- .github/workflows/healthchecks_cassandradb_ci.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 6099d12808..02d8349fcc 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -33,6 +33,10 @@ jobs: image: cassandra:latest ports: - 9042:9042 + volumes: + - ./build/docker-services/cassandra:/var/lib/cassandra + environment: + - CASSANDRA_CLUSTER_NAME=cloudinfra steps: - uses: actions/checkout@v3 - name: Setup .NET From 96d5f4ad800604d39b4bc08d2a69e233a317bf98 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 06:52:14 -0300 Subject: [PATCH 16/36] Update CI --- .github/workflows/healthchecks_cassandradb_ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 02d8349fcc..5f812a6ed8 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -33,8 +33,6 @@ jobs: image: cassandra:latest ports: - 9042:9042 - volumes: - - ./build/docker-services/cassandra:/var/lib/cassandra environment: - CASSANDRA_CLUSTER_NAME=cloudinfra steps: @@ -58,6 +56,8 @@ jobs: run: | dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj + - name: Wait for Cassandra + run: sleep 30 # Ajuste conforme necessário - name: Test run: > dotnet test From 68a11d952239dc3b97e911b96ad7906edea0877e Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:04:58 -0300 Subject: [PATCH 17/36] update CI --- .github/workflows/healthchecks_cassandradb_ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 5f812a6ed8..a9a22fda00 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -57,7 +57,7 @@ jobs: dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - name: Wait for Cassandra - run: sleep 30 # Ajuste conforme necessário + run: sleep 60 - name: Test run: > dotnet test From cefe9134978394ca0e44a7b6db06bf466b9d281a Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:06:50 -0300 Subject: [PATCH 18/36] update ci --- .github/workflows/healthchecks_cassandradb_ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index a9a22fda00..21ebd3c06a 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -57,7 +57,7 @@ jobs: dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - name: Wait for Cassandra - run: sleep 60 + run: sleep 45 - name: Test run: > dotnet test From 9c627ce090f68051b8472923cab8b01285faae4a Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:07:41 -0300 Subject: [PATCH 19/36] update CI --- .github/workflows/healthchecks_cassandradb_ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 21ebd3c06a..02d8349fcc 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -33,6 +33,8 @@ jobs: image: cassandra:latest ports: - 9042:9042 + volumes: + - ./build/docker-services/cassandra:/var/lib/cassandra environment: - CASSANDRA_CLUSTER_NAME=cloudinfra steps: @@ -56,8 +58,6 @@ jobs: run: | dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - - name: Wait for Cassandra - run: sleep 45 - name: Test run: > dotnet test From 88be2d83f9b0b58fea30722185ea80e7b226bf29 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:08:57 -0300 Subject: [PATCH 20/36] Update ci --- .github/workflows/healthchecks_cassandradb_ci.yml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 02d8349fcc..6099d12808 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -33,10 +33,6 @@ jobs: image: cassandra:latest ports: - 9042:9042 - volumes: - - ./build/docker-services/cassandra:/var/lib/cassandra - environment: - - CASSANDRA_CLUSTER_NAME=cloudinfra steps: - uses: actions/checkout@v3 - name: Setup .NET From eba5c54919b6c1021931937d9af1e0e8477d8312 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:12:45 -0300 Subject: [PATCH 21/36] Ajuste CI --- .github/workflows/healthchecks_cassandradb_ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 6099d12808..6f36ccb777 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -69,3 +69,4 @@ jobs: with: flags: CassandraDb directory: .coverage + From db136c57ca305b3c88fb00d950977080adba48f4 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:22:04 -0300 Subject: [PATCH 22/36] update Ci --- .github/workflows/healthchecks_cassandradb_ci.yml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 6f36ccb777..cc7eeb0ab4 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -54,6 +54,13 @@ jobs: run: | dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj + - name: Wait for Cassandra to be ready + run: | + for i in {1..30}; do + nc -zv localhost 9042 && echo "Cassandra is up" && break + echo "Waiting for Cassandra..." + sleep 10 + done - name: Test run: > dotnet test @@ -69,4 +76,3 @@ jobs: with: flags: CassandraDb directory: .coverage - From 19173553d3f13d6bb1f25b557abfa35bda9fc871 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:31:03 -0300 Subject: [PATCH 23/36] Ajuste no CI --- .github/workflows/healthchecks_cassandradb_ci.yml | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index cc7eeb0ab4..b4a86f3ed8 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -42,6 +42,13 @@ jobs: 6.0.x 7.0.x 8.0.x + - name: Wait for Cassandra to be ready + run: | + for i in {1..30}; do + nc -zv localhost 9042 && echo "Cassandra is up" && break + echo "Waiting for Cassandra..." + sleep 10 + done - name: Restore run: | dotnet restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && @@ -54,13 +61,7 @@ jobs: run: | dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - - name: Wait for Cassandra to be ready - run: | - for i in {1..30}; do - nc -zv localhost 9042 && echo "Cassandra is up" && break - echo "Waiting for Cassandra..." - sleep 10 - done + - name: Test run: > dotnet test From 5f595a3e44c15b0356b3cff3331b9e132eaf7729 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:32:48 -0300 Subject: [PATCH 24/36] Ajuste Ci --- .github/workflows/healthchecks_cassandradb_ci.yml | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index b4a86f3ed8..97791f8ae8 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -42,13 +42,6 @@ jobs: 6.0.x 7.0.x 8.0.x - - name: Wait for Cassandra to be ready - run: | - for i in {1..30}; do - nc -zv localhost 9042 && echo "Cassandra is up" && break - echo "Waiting for Cassandra..." - sleep 10 - done - name: Restore run: | dotnet restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && @@ -57,11 +50,17 @@ jobs: run: | dotnet format --no-restore --verify-no-changes --severity warn ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) && dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" and exit 1) + - name: Wait for Cassandra to be ready + run: | + for i in {1..30}; do + nc -zv localhost 9042 && echo "Cassandra is up" && break + echo "Waiting for Cassandra..." + sleep 10 + done - name: Build run: | dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - - name: Test run: > dotnet test From 67fac24a85b9bcb84c8a6faab1e015a7156f98f6 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:36:29 -0300 Subject: [PATCH 25/36] update CI - CassandraDb --- .github/workflows/healthchecks_cassandradb_ci.yml | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 97791f8ae8..3b6cc56a1d 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -50,6 +50,10 @@ jobs: run: | dotnet format --no-restore --verify-no-changes --severity warn ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) && dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" and exit 1) + - name: Build + run: | + dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && + dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj - name: Wait for Cassandra to be ready run: | for i in {1..30}; do @@ -57,10 +61,9 @@ jobs: echo "Waiting for Cassandra..." sleep 10 done - - name: Build + - name: Validate SELECT on Cassandra run: | - dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && - dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj + docker run --network host -e CQLSH_HOST=localhost -e CQLSH_PORT=9042 cassandra:latest cqlsh -e "SELECT now() FROM system.local;" - name: Test run: > dotnet test From 6f776eff9218dcc989e6391c1c43457699307299 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:42:38 -0300 Subject: [PATCH 26/36] Update unit test --- src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs b/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs index e3bdbe0c8b..bd0fdaf6fa 100644 --- a/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs +++ b/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs @@ -30,7 +30,7 @@ public async Task CheckHealthAsync(HealthCheckContext context RowSet rows = await session.ExecuteAsync(new SimpleStatement(_options.Query)).ConfigureAwait(false); - var result = rows.FirstOrDefault(); + var result = rows.SingleOrDefault(); return HealthCheckResult.Healthy(); } From 488cf5e4caa26939e371bc1cbedec461f9580b45 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:51:15 -0300 Subject: [PATCH 27/36] update CI --- .github/workflows/healthchecks_cassandradb_ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 3b6cc56a1d..7dec6a982f 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -33,6 +33,7 @@ jobs: image: cassandra:latest ports: - 9042:9042 + options: --health-cmd="cqlsh -e 'DESCRIBE KEYSPACES'" --health-interval=10s --health-timeout=5s --health-retries=6 steps: - uses: actions/checkout@v3 - name: Setup .NET From 281575ab6998b85e1dd6795b4ceb0b2d9a737a9b Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 07:52:42 -0300 Subject: [PATCH 28/36] update Ci --- .github/workflows/healthchecks_cassandradb_ci.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index 7dec6a982f..f53f508e80 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -62,9 +62,6 @@ jobs: echo "Waiting for Cassandra..." sleep 10 done - - name: Validate SELECT on Cassandra - run: | - docker run --network host -e CQLSH_HOST=localhost -e CQLSH_PORT=9042 cassandra:latest cqlsh -e "SELECT now() FROM system.local;" - name: Test run: > dotnet test From 025ad2774cd768837873c439d9ec12e43974175b Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 08:07:19 -0300 Subject: [PATCH 29/36] Ajuste no CI --- .../workflows/healthchecks_cassandradb_ci.yml | 20 ++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index f53f508e80..ba3895920d 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -34,8 +34,10 @@ jobs: ports: - 9042:9042 options: --health-cmd="cqlsh -e 'DESCRIBE KEYSPACES'" --health-interval=10s --health-timeout=5s --health-retries=6 + steps: - uses: actions/checkout@v3 + - name: Setup .NET uses: actions/setup-dotnet@v4 with: @@ -43,25 +45,36 @@ jobs: 6.0.x 7.0.x 8.0.x + + - name: Cache NuGet Packages + uses: actions/cache@v2 + with: + path: ~/.nuget/packages + key: ${{ runner.os }}-nuget-${{ hashFiles('**/.*csproj') }} + restore-keys: ${{ runner.os }}-nuget- + - name: Restore run: | dotnet restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj + - name: Check formatting run: | dotnet format --no-restore --verify-no-changes --severity warn ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) && - dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" and exit 1) + dotnet format --no-restore --verify-no-changes --severity warn ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj || (echo "Run 'dotnet format' to fix issues" && exit 1) + - name: Build run: | dotnet build --no-restore ./src/HealthChecks.CassandraDb/HealthChecks.CassandraDb.csproj && dotnet build --no-restore ./test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.Tests.csproj + - name: Wait for Cassandra to be ready run: | - for i in {1..30}; do - nc -zv localhost 9042 && echo "Cassandra is up" && break + until docker run --network host -e CQLSH_HOST=localhost -e CQLSH_PORT=9042 cassandra:latest cqlsh -e "SELECT now() FROM system.local;"; do echo "Waiting for Cassandra..." sleep 10 done + - name: Test run: > dotnet test @@ -72,6 +85,7 @@ jobs: --results-directory .coverage -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=opencover + - name: Upload Coverage uses: codecov/codecov-action@v3 with: From 3a665daf6fa13812562c21101523e301991842df Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 08:09:53 -0300 Subject: [PATCH 30/36] Update CassandraDbHealthCheck --- src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs b/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs index bd0fdaf6fa..e3bdbe0c8b 100644 --- a/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs +++ b/src/HealthChecks.CassandraDb/CassandraDbHealthCheck.cs @@ -30,7 +30,7 @@ public async Task CheckHealthAsync(HealthCheckContext context RowSet rows = await session.ExecuteAsync(new SimpleStatement(_options.Query)).ConfigureAwait(false); - var result = rows.SingleOrDefault(); + var result = rows.FirstOrDefault(); return HealthCheckResult.Healthy(); } From 338713ec700d88ae847dbf2b1388c0fe7d069403 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 08:17:37 -0300 Subject: [PATCH 31/36] Update tests --- src/HealthChecks.UI/assets/1ae4e3706fe3f478fcc1.woff2 | 1 + .../CassandraHealthCheckBuilderExtensionsTests.cs | 10 +++++----- 2 files changed, 6 insertions(+), 5 deletions(-) create mode 100644 src/HealthChecks.UI/assets/1ae4e3706fe3f478fcc1.woff2 diff --git a/src/HealthChecks.UI/assets/1ae4e3706fe3f478fcc1.woff2 b/src/HealthChecks.UI/assets/1ae4e3706fe3f478fcc1.woff2 new file mode 100644 index 0000000000..8d4eb5b1a2 --- /dev/null +++ b/src/HealthChecks.UI/assets/1ae4e3706fe3f478fcc1.woff2 @@ -0,0 +1 @@ +export default "data:font/woff2;base64,d09GMgABAAAAAUJQAA8AAAADjSQAAUH2AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhwbEByCzyoGYACwGggEEQgKisooiIBCC7BYAAE2AiQDmDAEIAWCegcgW+HOcgZ1sqToUKDf7ZQw2b5yOK3itxsVcE6WpzcjVJG/DQ0OyLwW4gfnAbgHVfOX/f///9lJJcYsqZi0vYGooE7H//8gmLMqqEaOosJXFRVlVs5Y0N2X9VpcmHncFrpjo/0aaHs8s4r6/LRFwhhjFO7z+SncdePXijy770dv8g7zSyuEi4IhS9rfDlMS59MtlNg3fB7I6IeOQB1KoRRKeH7WBaMxbmujm6/RH94jRcfL+Pp7oqfe/r1n2lG48w866ElacU/XE2R4TP6fPyz+ZZ1+nV5BkjhZp2+nCDXNHs7vbxKkVGBZoezINuvIZxYsZJoMQYGUGVqhFFhWlHZkmxIaaZREpobogCMrlAJJhyP/mmcliwWRoJGidccj12HO2ZSry8gHZ9FChpbGTIWR4kuohwDbGIv1EwmpOHjsXvQRPnXQcnj+mu/+IfC6C0tYIhbIbXFpUEvS0pQH1XZ31Q1MPoarKrMd7Q5WyAQIS5HOcGryonb6Zmcv4nLfXPjpZXZ3cDG5XIGE6autsNWfSAEQKCJQgL6vav+dN7wEQBCiIIqSaVv2aMKb9H4Iqd4tym2rLYp6iz7yfP/7wW+fuXfed2nqkFS8EkmioZH4qxMqIZmHItaAnv6Q3Nf+NTqgSwMLQYhLp2googHPeKiDNJIMT7r5L5CEbHJJ7khCxmUAyV0YU4bKBcJKYOfCUAEZQRIHIoI7cYLagQpUqLbV1lrC7xS1Chas1Q6wE+g8tN+2rhK7bLchKs+9yXMmEg5wgYpW94q/ULn3wd7Z0qIfsQ0u+1tPRTeIpfDugP3pSzDNBDyITg4eTfoRG0RTQQfqv6Jb0RTehbKk9XCCbWk4odz5rNosZRjmDtPQfWofMUcu+YByZEVWfp7Pzf9fVCuTDCfkBAhDQhgkewccIKiAyQFCgAQF8ezDpIIyaE4UbRXB8ZzbWg22802o0Fa0MztW71Bv+8XboB3uq9Lq7SW5U6Nt7wg+Yzv/9t3rmX+d2v+rdOMH2bpjQxmnQxJc6yWN+p6W1V7tVeIkLsiWLCOF0EnxDPxDO+W/CjpP8wHIxGYy+Ae39rbB57pDR+9qJgWlVHo2NJtpKXDoJgqDPGNdBwgMELhp6rAYT2nDlLnOQ5Y5U+lCLk0Y8egLcj/E8YhHCKW9a5nS5uw0c9o+pfuaEEb4SjNCGGP8vUwZhi051dm+d2SXrMghl106uWRFDugKBNPPDz0/r9dg2lb/jiIFKPr99uT2tfbFEG+USoqExJAq0yndknqCq1z/a1TeVmbB34KnG9Hbr59GfXrA992onaA+jdjNNqhngl09e8QkCeq7BSeOUIF4WtsPG98RyXEFsxSG0I9G5X9vTQ2mOJVT34GIggDbBCqhkiOhVWsiPsSuhOI1nE4vaYXt/ef71rKq+6z6bRkBJjLajUQQT5yNeFUXS/8s9CX989v92/3yN7KEnEMyAn6yMgLsya7PQMmJc+LGsIYCaqvd+/9/U+t/b+k+2rvqoSFJ450JlKpshxoCUqnhQrgF5+xtu35iVyf181v6lX4LbCswYHPDzNwQDPUQ2tZ904+z3mqrpuXOH5vRQudIM0oAukq6tUpO560rEeqm3dQhsxwQ+c/I2f/e1HpTvsUajOzwO8/vRxvJxhpqJ5Id7kSSzxQrGly810fo1xctoquHnwQaqCFM1wyXO98avG6OqtEcqQjubBXQwKiAJvYXyZnvM4XWfOMzmci4CWWTXJmU+jhVkCreSEGY6e9L1bqiScGWJ9Ib5ZtnN9/Gezh5tPl0ThH9fkL/37+b+A2AZDfBAJAUBYgSCZCiDEoadADZaFBWnLHCBEr2TNlZYVIyaE6g7Akp1X33NCGE0972ctvjHndva9X0P+nN/5k5RHiAML9R73Y9zfXOhSzLORfXOq4OIEduaEKg579UtSuGtLSkK5Rnv6ftUqqUquS93Le3U6572nff9/7/MwBm/mBAzB8MBAwICgRICQBFGgOQMjAUJRIEaYhW8kCIVKiSPFlOlZMsozTZacBAVACQdABStJrtlSjbKaVJslxTej3mmGPennK9bGnH+x6Oy4P+Pa/eY/8JFpcUQPqWwW0qJVxmxPOfY8X/I9xpVjqkkglRf9lWeNy+cl5k44/utpUhvUQkhPnqfe7ErHAKyd5dCluGEkoIRhhhjBBGCCGE8Q2ld7/f+f7zL933vlP/51ExRlRVbRVRMcZYxoj6Xvjxf9v7Wei+32+tEXlRtaqqqsYYIyLiGN3GtAuzdmbIUlER+R/G1P4fJrm0vWVjeqYjTRwoGFGQLeBo39v/38uc/7Rr/V/borVWkS2IAxECWZfLkXrEnP1/L5pcrjQvwZwxViyJBZSywLY2LLx/DoApAKUAFUh/uYUd2LBjD83gCnkuUAbX33s7u7Lx0uMdawEqFQBEx9U3XmptGZ1ibyuV61L7v8Bn94C1nOibGCQngyEWbxlVeOVvdpTn7rC8Z8r+xcf06jZZWaafmDdUH/BI9Z3ZfrPrZPwdaXJUl20rX139T/3ZbwGIkV3ZnyNttInt7GxfhzvR2S4uEY0BImCZwAop9RyhgkqrVQgUloK/0ImrhVbwFRrBW6gFT6ES3IVScBUWy5wW//ShwrYZaAETt6xtSpqPK9n8EYlHxB8Re0SUZQ4tlf5lqvRm9uVQjh18VgREZCRBJQwjvnJ0jnz1uotsp7OYsk2uLbQGJ00B+aCixyMQ9dKyn2DHqnBIU95tJcx6j9akQj6kvpraA6pf5P5hhCRBUAEqktispvmg1nA1OK+mw7qI87VX03/IoKD37PxaNcm8u4IEHCLKdNk5vnm0ciFXS5SCi/rhk2zVdrWbVG+4vzls3P9ytDlyPwzjIxZoYYUAAygKdSIbRgpu6FHSEFiLuOlbgwx1FKgoqZn78oVvnhls/Ock7VTSJ+lyiRcvg5nqHzOc//nprrsOu6uqq13attWu1tnJ0tXrvvawvfzJoy945ImH7+8Fz1w9dXjVhXMuOHr2gn/5f/7+d371X36ZnreO1hoiYXAAMUo6E4mRCOAB5tHr84BAuGL0B+KwFSl6y6efvEQOgy3aV/3UHZQdHVLR9q4KPbTV/ZoAsG0phaMloS1qJvcYOVfIWh198HRGg9lEaL4HPmrQp6vqx9O6wDT8tSMUZ+g8ka4W0duAisQQrbauLfHjkkT0ipSkPJElbAVS79TfYaNCa5DpXIN1nv6XduqTIIgBMURRtrjWHO821sJQqvgzvZa1LyommWuousBojs5y1YswG1EkaCp8r2UD1SdifxUhn6rBR4FEUXsD+YwiT2COjhxWXrbQu0Nk0VLFyF1EZCx3P9KADTvSspReBOYMlGRvM0rQiKfmhqzfDV0TxCBv4z4qRrOe7V0PzDF3XJQOA51odBWFn6oleZSUZj2CIaKsyPIDxxUtfaVIPIhydXTdHl8edi2sxd0JbI92jfmiRVbxYvOiFGBhV0vI0INiCYDF4eAoKs2WksdCIweihObnjzlMBQig/0JVuCA+qKPggbN8DYwM9FeZdNemheBKIBzXsGbwBW3EOsI8UsAzQQwkki2E9wZRdGgkRS1K5aJY9OH0UKBfDBbmIzPcYHJIsJjtN51Ew5IZVJMUPk6NaR3jAHjLEKCDMOdxtH+HSGh4Xd7WIAYHdYWt7eANQhNXzsZuYIsnp8i493gTQxLHjnh6GTHVHgx0JTmf2FO6mnVhFLa8drvFVtswkCNaajBbUwRXWLi2dTpj61ubIOBATVHE7d7DoQH65nBpCHo6hxpHlDq1/PHuUAHDWga9Q5RzwsKpz+RQAr3DvwseCrC5xzB+MbtR0VDdcRHXxh4NU030bYnpMjWChyN6/46UQERE1e6m5KYgMIZYHdGK6cQwuFIoEXor8/cV17oHRpoQZfoF+ZtcIjal+phGUhtjlfSY6u8azsC81ETLL6uCkU506fhwOWhOIOvesp+Vmgaw5dnFatOKXVitTB+MuAbXBRP8+LB4w/Iqk6Mg3PxupkvDW0mZFsJpw03a7NXIhFnMOIu6QGJfmsactn3d0VcF3R4oKHiSx8SkwnW9lxMt+iMPcNB5Hxuo76MenmAzKq6nXkAzlyNMBmP9TjRjMtOd3c5EX/PqZiAmpk8I6iq408KOv83Zkf8O63nbQBDHRusMJppA6kOEryy8RKOQA/8GwXm6rSDlSvU1wmaawSyToFF7pSZ9wAsiUnpd7KksxwjiHzPGNLdp0f0DG6ng7lBjkkgvJtHYsgqCbC4TZi3+gIjmkLYiH7aY8H6M6NUIAdCS38IGpBs9Yc5sYLCf3YL3CUt52WCXVgFl98G/5oK+3tmQmKJvvVd/8zxx7LB5DHc9Ofh9E1hDindfneZfaZT5CKGg2eVcBK0KFtvcCDCQ5CiBjriX+sJcNkMLhx+rbBcJgGNQvZrtidKAR2QLV+TkXCGU/J1NZGkJ7bz2xI/8hdD95nLgz/VGA0rdFH+i9MfthoDf+v9vnuZyj3vFF9QlKhM0kRzAB2CD8WrnzpYzmeifZWtNp1rNYmE/qddhv/Pw1dHp59VjUHQ8A+HhYAGJBZjOlIaOjHV6vCanJZD1IlZSoImeJYX6E4pd8K+ejJLvDDl3gtx2rVBm9KhnE/Opo+7CA2+PUz+cU+2z6UWDI72o72MlPErUPZ8uLusAPK91TUuWiKcvuvgdUJPSZlBeia4ctIIOvCDkSUkyWjjF3f++pmhdDF8tokT/SwFCAKGUtvdjzok4O3zqE05wQHnbEh8tCDDG0eXtCLY61Ogfrac0TbPMJHkpXSYupc34pTQZu5Q6o5dSZSQo56II7VADUmBSUmt8HigB7AlWo0L2nHb3WR+kMGY4Cka07p2RvCVn6ep5yekJIraziQ6TLImLHyKZZBmBj0uUtFWCFj5MUtXUgfbpIkkiVicfJomdFS62zQ6XOLliAehFYoih+Q+R6C0o6albIp1VHW7zkwCjhpeRYldyV2VGC3Kiqs2d/SeFVNU45HkqSq85P3YsScPWiqcb3vUagluluEMNklUeIr9dDFiU4BxVGcHPBQVGw12QJK5WdIRh3WGT/q8mLUwu01EzUfC/g0gy1V6HD42jPCl9XIriMv+LuI2x6xgelKY2o4goKdgU3R6bZr+09tf0WPW9O6g8HundOBbVuN4cbakaNra+vQ0wZs2xStDepUQKkF2SClj9P9Ljk39zlq9gwAOQsX8TTj2qmmDCiaC0bMkpln8aVwzxqnrwqFvrHwziYvfdB8FaK/CA9RUVKK/PwbQkDQYU4URhaLPgV7waWRq9LhzOw0nmYGr3M2c931EBY9IDmGAiKGapOUaV1WTwIbQRSPvlbc9j1KpiZRgDnWT38J39AHok9yEPp4GmohAYHvcw2lgkGf+2SrIF+25kjlR5aRxNhNXT2dH19NPB7PZ2pRYEfD45uVGFhgeNJyAFNaJieNOOmvdQl13vgvyPtyqpjwKNVFrlyYOTVj7ZWBqzzHcwq7RyiEqaIDz3M0xsyFgjZzXBuIGh3teXtFxdUtm02HrbqpUVi5vfaPU+rUpnrOPreNeJ5TOBchotkaZgy9WnDEfpSdAnliDqOuKd0aSPNK1s7poCuPVB/LAVIvKVTb0Y6j1ibEldGp/3DlrdclBvs14KbPJNEu0PbLIq6tEqK8dulrr62j6vQSU3Ef3sJgN2XShZgeQXW7pWKWS2Y3/kEzwfTsxKb0vZJLrrOFF0lzeFoxx5x2e2a48bUHxZb7XzBe1NZtEMlk2SRli2t+8aQE++oHhj3iaxtKfarEeJNFWw0wnVj+8CKuegK04DPkZozeUs86OUUpcPngBXCWZOYr+Sgq3epbd6oOL049htjIMl2/bAvoNH0VJXHspzMoAkiySJXRPTQPNrt0B+lIU/ud6OaaFJShjiwNM396e2v2lbiasGnem2/Uz7IhgoRS4ge0q7w6YjqKWNshZOvL2uy7Vk0xXmeMzAwHIYolhDdUmCyU+gFgXGL3rruFO7E9anJNhLGl5jjxdITwuXc60muwGax0WdsDWvQWsaSsVw0A6FqKMj9YpUdaIHrNAZJVBre0ryQUiIEiqekAYAasahDF3UihVL+Ak4JCsGMxVfktGnmiasqCgrtWurfhg7Sg5A9RXwSacUslkRp6Km3ANaG04QZ6ACDIQVupljgxuRDoa67fERruxOgPiV9GK6AkTWZYUTbpvwTUKPez+6iJm8PmJjuB+YRm36P8n/Oo7jV1vaQEc1nBLFyQEsBzIs8Xp/jq5OLH0K7a99PPcHZphLnm66ZgCsx7Hhto03UhrmpL2rutzkDLg1zIWh3DvyWiDatKoXDpsk0FXUzjLl2IeXG3ZdbegGrgxu0jQiFWD5o4+b/GxS07gBUP749NRjimG0RMXFYMEtv+hY1ksFfChJZY46nNnKLqYXGs8oWrTsvgMBZ8iZO6fdjySlwMjrOh/Kr6MuoXcStQL+cgmYx55QqWJFtDHpKAUwtX6fUhXC2RlrzW3IC8yjkRPhe9qZJ6UrfGJ7zbiYV6CaDpCHMjBeMmFeMk6rr60m1bLdZfwC4rGplYa6RFi2OOyEASCyNTqsv1z2BONjGXurVgWxUcfgbkfq+ZrauIWWEiK9rFk9JxqDifLItHpGKRM6PkdTQxI/61nG+FuaMHXuvGYxQ/FVTEp6QjyoPNaA7Y3wRut6zDCqqmbiulEIH0iAWN8QvMFAVxyMY9h6WKyU190V15Kq0WswpeFzDHgcymrEtR4Ls2xO4zEgt0sCxA9JMUU5bNQrZbVcCUxefr9k/HGdZhl++uzTuAAGrhZNAdEl9Mb103vQa97zGaGam3dvXFggiPXLJ+lm1ziz7NBI4ZvSa6Kjmh5h3RF9dI5Qva+dP1ks0lmnTwcxQx0LCGi4yEh0X367GTucsE7DH5I8OPXpSJ3UVqrMRTYra/vyvmiKDAF5vayqhXP5457kWkJqeMZbpGAR7ut1sXedGLtKzbQpd9uTswB7ddb8nihzYCqP+TpZWiOMJVzyEtFD+Og6muq1ixlE1/6wJ4vNegZxNvjWmSN8lFLuX5W7Rj15EgYCTu3qn+QpLdV8/SW9hGCmkvTzQ+fzpOUd16HD+U6xlZEAClR3jES2TCEp9zdMQFGbjORK08O3j1MRrXdLNXEKasaXENdVJsBDWvpCwNrle9ETKBqXsiI15mPBu0rGKdLXdJiFWdA7Km+pwNv21ArvbsppMbWHsV5j16fk5kXGghj12Ir2UyQQGtHeG7oIpckEqmihfjStWUmTtOToBVm6nh2DAWaGY3WXwQ4qBzGkc8ksaHu5gpQ62tcUVmNPEtFdsrPFvyxn4zZsfwl1uGP3f7eTQKNuxe6KdQk8h4nZtnst/fmUtmEsT3MR20nJHg1+W7ZeJcw8wlY4DXUFqEd5BytPEhhtBXxX8ES8lXUC60HtgwTK34fg2ZI/JxLQ0OvqTNhGYs858ROMdQCFl6Uu59WKeVur6wd1pDRWKcEIHKUMiRFMwh69fkFOTb6MTq99DTKQpK4MPMIej90inJLlk7wOJsqEvjHDxp/4GWVtFGOh/Bgtmo8ymLmaC2ukObfCEsa3eMVxbMd8NHSd4Sc0QFs+c2sGmoW5pJAxA3jgjMEIceCEmRjyi6e1zas01A6dTgELEuYbhmDVaA98IQlB7UkeSn7tPa2E/i6Jm5SRcBxSyI0Bqun1GjpYRc7uF+RgHuhUN3rGN0HAuKMT38TnUSrTnZch5H+1EHvJlFEFVmzdq9pqr9UiDghODeceRuP6yBmjPvGfPEUITIvpP9Nm5Wyd45PYpEiRNmrvTulHXdqdPdVf+mJpUbTDEtnCYg427xxtMlutEfzL2eGSedqQaITWy0Dz1gncTyiDF4Evtdp5qziG9lWzDODg5FvCsVjX+ArbdSUF216xYmjjFgLFe+2SEHPJ+G5NTEWr4DLALRQA4gi7OtVijqAW/Qr/AwMh77C1dUEg6YCfEZDREfBcQrjkePaslAJqPTYsx6JpxnE1P6yOtsf6MM7+QKRmZ3BvP2JbCqiNaSPyqlVjSjTdqEGztRDv7hThTY/GvrUjFR3sSQf86V7uvDn/1WyUj7AXmg8QN1yc3kUbNUZAxhButnBcaFr+i4ZV+j/1ekM7xzYxewB8cVdh61iVuX5csLWU1kEv6RAeGmzZURkl2AQg9GDN0vLQ4FmrWktywNEIcclfHEfTeBWp0ZYawzYfquq1P2+sSSTp7Jfp1pM5NK013FqqUy0Np05Cz2p05uPAW4YaXhPtY2aqEiwdylMT+vR5KijPTjhPEVPWM5Z+yZsSQkJ9hNsTrNE7W3KWuFaEU9S5MBwNU8ChLS11FdxhOTqmFrpYogmQZzOD5U+gvgBuuyN6Ka5MAds8i+K+vvF3XCRiFu9kpjidmcu7EAoFCZR7FdZUfaqDwYfQcB6Zo3N8GHtzmhYzehbP8flh/m/TSu3d97qyR/tLny3DIrGoLY5L9JK7jC5zy+ZyBpuUN4FEcVFxRaKKlMh1VzaTZ657Y25rMKUlzyadTMLSjo1MMkLrvA+Nm/TUB0eMHbvd3Jt2Vd5+oz632UXNXhfWbm47u1u+sH80U8xRiAf9doTbJRisAqMUvhPaMOf3t29AWyoLoHRnhr2wpAi0Z5nK8wgi9Qe687gdYk9rXY3L02sLV/0tyos/I9Sfwm3p48lZMwXOCpOLJSGaWhH+BeR5mVr+F6dgbbTxIAPj636hrEz2PGJ/YpSxgbGjlweAtaqhP9+UYUSqlN+S5cWouoY+4GWUIWjpiMjxcJgMSA6G+WRSsEViazNNN0uJBoX3R8FK31B9W9KrQn8yANdMXW1BvFgEzbdZSjpfziZAv2RypG1Oq0ZX/QbRqntGQFqV9DLTxZoKQkd9bV9IGioPuDpVkvohwDtjVmqNMoNMKaodocQyS0jlXJdOHBhRLVZe4ioQzppKicpWILuMYe4lS5GsMqOQ/kyiVEnhK7rfd36jvTh/+/dhWwiG0SWW6gT6uQjlMMdVtrF5SmJMoKHdOJZIspK+Y143ecqPQ/dxeLQGph63pzRmjcKOS9lw39WE0iId07gBOrXT0Rmo2ciH+2Q9YMrAVint0feEQQxjxk481dMpREEqNtY8QQXWkWO8IkLpHs2QBDDjX48eyHwaNFR/RUX2EILttgBLt+FM8hCyGEBXv9bp91TK42AbAgqMaEnvBIKM0JJBmuGQxcyGMsF6Gi5aNzD4SohSV3Y4tGmeuMbGYphnHYwdSQcu5uvQCljelbM+RjEXHyicNrLvtHlS4/uEdzzonCkbRpnjUdM88VOEm9ce/thaGFt/8hqE7FnZZZeTkEk/JE7SbGt/3QL36Q7T/xtwWd+eIOYZXAYeTdq/lOiNbY7+Qvqw/CnWWuX3Wsv8WqvLz7Xa/Firybe16hDXqrJVK/P5D8nXjTakgRPQyqOU6aSFdVNXc8SZMYPprrOK5q8RjQCOvseBLhttBYd5JhU4HXkAqlCTKYm7lAhBibsjlY9hbyAjjjr/zlq4KrtrEMiBnJVk/UgleYltkyvmMfVDYBNMmY94RloMtMwHqwxm0tD1XmwGJ68jKHFIq+SumswYrrA2c82lGTWGMazvw2pRNwpYmLE3vb+MGVehJ/2nliXLfTUFCMLp4sBSlXv4/i6DjlUIxnSnYyrkfngTcOZha0nsbqxA7Z+XZV+OtoXdHex0l7vTo17zkZ/8nyWMOXIximeCE5305KYyrRldQIFSnO8awDjjzQoxMz45BAY6AvOFAqjs18OFSghnMjQoSBYaOMElslXZm8VuSjsoarD8FQS0vdwFtuuCfbTBz1xgoQJb53ArZ2XZqXJFAKJIBIjfETkgH/gpQuotPRCQgY5G6fePRmD54OSUxhPQQwDmX5xP+kDGETMrDOXx2W0V+7cdHNdnsjFuNYiDLOFXGcMfmSMCWdrsydWt/GyOdam7veAdaiocYINs4P3RZGT7ZrVzo2FkXuGHUcOwRc3itfIqFxX3l/oGbbXZLYZxQm3bFTzbZR6veiJ1QfAW/JL34M5ah9fIYeQ3mLImn/25OIcu6jXVrF5nOLI7Z3ajVRUesqYQ8uMp0vCucuMhrQq6iHBKnpO6xkP6bEe5wpwL6NqZ+8Zd279Cx5RD1MXJED/Fi1jB0XOQWCcGMY44aDrjiibk6PYRCkbhMXZnr5VmLCQSHHXrRWpgLMpvMTTcATW3a2qQRzWA1cSn9UzH7EiFFamZi5tAdeMqq06oT3k5y7EuuasaTtjHloaGyPZGKdif/pMg0JMM4GfFDUkPjnpgQ0hT43TiAvKLWsZbx3uzrqhSuBkX1Bvbj4b1jdw+aF+qLuII84dxlHqbktGFOWULqW0EaHUaglRtw8GyMGNTHUOgJui6bRhoVtxrYKUtqQCDiQJ47wMvNyP6GuIWnrW/tiyE13nZ9fUEWvC/l+0czvG2crirPe61QDBsxKKXwNxJe+ZzVFDspVBaFVlJVV3j9WUg4OxDbwSP+CIFC8g4T2QEzVotfp+3Mb1kGGVG8zj90xSWviVN58fW4I+IrvoObs/DYiNnro3g7r4mXPxW4Nzhga68jrKjGc4DSp+VLSExhTsvGyVrc6UBA8xtfQ4Gb8Jmzbk0q/37iPDIvCzFZM72zivMmDEFEu073IOQBa17u/hyfLDZi09FtmTUaA1vQHby2YReMMeWNO9OpPPQpP251vKXl42pcrgLAAqGf115agYv7SI246+R6DQebm96q3ON5lwUwm5ll6VlTisGyN/h3DRyr9OUsyYBsNwCfZ2mZxSo8sftOsQhFUFf3XZOtLeLPemLoGACMYhv0lKa9kzm/rGD2Xndl75Gs7DuaVUARbd+N8PI5OuhmlLZ1M/CeqAcRGIdqkc8otFVnAA7wp3yYsxH5ClHyuY7RPnKFTPNPNpcce3HrKLnQqzxhFqTT+GchfKh2dPJuAPrvP6TUk7dfn97rvaMz/yWYmN3rqoOwBA4EuSZKhGKCZHtG7v5wqCl8qXWta71na/crCCbG+3n+9nDN4tnobzf3miHEyR+AIzYp0dWr5qdG7BIxbeVkv+X/dujEosKNFMgLVfs3cbW1IGphRO7Tszx5OHwQDA07bjw5NLjfEunjdsHBhrU7ahu9hKusjhjj93MT2nby+gGZi3IxirJpeBzwLRkKxgztym15ImZ0XSlNNuzRmvSeFe024vborm4KarX10UNqmL9SuKosVabPyhdUS9hF9+PT4oGoegD/BjOD5dV3sedhIB1SSngjsXOaebMl1bA9mc/k5D0TH1GNZy5jJtyio59C0qTjdFG+YEAWZk3cPkGxgs/5RjDk8bXRQL4DG9rzDsBMdcAcHyPEqa7SU2wcNZxEgsQaL3cUfK+6+ySz8WxCs0pUHIeBlYKnwjeseQrHYMBNOYdTYhNww7HWbSiVtY9mxUpJqbw/fK4nB1hMLTycGOJ8MNwXRpZg2FZOGnex9ChyYp5DjvkeEwilYNw48FGmqnbViLSlAw76CpVbbPyHChSARIU0GXnBwRo6kWcAT5Vq6Ikg/5tWlbQqLDGsP2+oiqnmggxPO/FlZg5UwBvdA3bd2HRNaOD42/VHHihfUypLEpQn1WDzcwvGfS+DzpE5DngmeWFmYqMD3o+EJulYXukfeg7h3l2R+wJZzdWGi9JDdvjUnitST3s1ndBeVaStZ6OtqwNWMa7IOzuJBgUtb5586oczCDaQA/zYFgM/yT4OaStvm58HhS+fIC+mn9CtGYX8ouQJCTsXpifmMIbCL3gFVZ5l6lspBd5TzQ/djjkgZCP1Nsg2ZzDaJdJypivkizoZmrhiYey4jumBGU0zZuXTtFqkyKMvb8D1Cqb4bCgi2o53kfyTWFRUwYT3zU5aCl14uz+ksktKBrPrrhUZ2IAvcwZu/BkLUEXSyX4Hg4AJpMHIwqnoUKEs1WAGeR55StEgs+aWTc9ozye9xNocxuK6cxck4FuyrmWgJ5VKDOqB4r1Aa26cbaMNstUY1ei909NClhtJV8yAJS43/5Ul7rXW8TWNFIG0o6Xa2ViDropzEB/BvLNOt5UDp99nYY9FeWKB0WRWEnn6Ps3r54tlt9+OzmJgMUNOSIEpA9yB/GF4PGv1Urggg4lA3Iiz+ryk1hMQlpXqia3SiIyhCo4HE7t7VqA3cvlCDkUOsRckeY9yTKGwRDaAlHqWJbsLlP4BNsd5Z8a3CYuNc4sYUCgBrQi3E3GjgZsBr8RfCbR6nCNZvlqg8wCLSNafAeIIbduhgLSavawk61DqJjGD9jljHHjHFCx/qqj3aryQiILfhx2w+BfMwFq8gqq3fiIxYGAFC246/IPyhdagsLicLjLR5QAmM3G4lOgp0J34gH6ascvwbO3OM7xNhcEaF0JpeF5cFD6pjfmBsdcYa6rvViBZxOtaXog/C/W3Kzg0q78pZedGEVW4bXF6CthyEYQQmmIgQNiqgRwEMqephGINv3mgxEs1SLuDHVtRoKWEuiSFYEBREzY1vML2HaAPLLST0cbDyi39qLNecFdi3iUJzDa6egXKuJV4wQPF8WQY+pyA+2yHImYqwOyiI0dTHOt2xxE+w67/WsXUeW+AUD32B7BFOEyh+WeeyAL+6ZO5dbhMogJ36YTHzxLSGVJq1/DlNR9npPI7QYieWJqEDdamSILdtwBho6K+OJMi9cDHcIFZ4RLbEgO03336Dilb6eS7fPralhJTG4dCx8GYpeGbiLUZkNMVoQbcAal2k34IhZ0FqIQBmR2GMI/brAE7nlBMnJqWpqdHSiymA42gKF+zHkz9efj0T+9mEAOgrdVcCfqk+C1dFWRZ8D9glb+R7Ufd3e8q71AzYglxI0hfzQxvBG4Foxa9o2836ypFmqH+3S+XP3qMJqXTmau59N+unxzsAstbHYybLH8roGd2bnBGHeNGQPmKWvT8ponZ9ggBw/hPcSQARXcj8z/C4YUcBEdC4UECBba/HQoAE9c2NsN6YpMUOxiQQIy6F3/jaNj66sNRRiAT2Ai4QvVReOhIJndAxIXdKmeGxRow0N2f0ByBkeKEte4bqog3dh9Zh8KcfR3r9hJhJYzzxneXeK5AH3BHS5nt4mzX6oB/rKpUtRQtzvczI8kUd6yRMCqq8z7ndx96XkLLvccPEiOEuNFUT9ylgm/tg8CLJMBqxV+7TLg5/eXPseV8Uf9f9H4wENtt4ap0a53waUtpgqVf+A7kcJwVDOdI0YPjryVl2p+pqSH5Z6e7zvErkhgKZBJ9xocR5toC3+X8yNUiuQBHwOGJafAJwdH0EfDOVp6ClngiZasJgO5D6+Q41fiaGmP5ROc9Y8xaD4PE81y2LUrSzJN1RFGD0XfNdgjnIy7GFT8ogQBfJPccL6ZMVowlqrJ6BXES2TGSGbMpP7qLHfrVN9/todzqp0d71zXetArvgspjCkq8NFTHviGWWB9MZHOnvA0yZG3HAYKQCH0++yrENL521DEh7/HC0gsehMFmjeyTjExsg7oQxWFiSapNn/Krh7ikUnBQyGiIp4DDPsZ5o/guqY/UzHyUMET7gEd5/tHe8zgIDOrQa/BH67Kr6bFO7ZGaEuvnisc9BTczvXEow3mPwzhljgcYEYVxCZA2yVPCtF7me1/oWDdOm9mw1v+zWPlVvGS4DE+e7Fo9fjbi1/XxsQLIqq4wcHwRM0DFU8MCFxQa5XWSlxaVE19KPJUXiy2vHNgcOIkw/QUm3Ki8GDs6evLyBSmPDhsYCYd5rfG9nsrdNYs1vHnkS9vep2dbXNXGzwx6PDb4+/y1Pu//Tan7nX6vg6Pfh3TBAzdipit6p26ekiAgVmZKWicDxObR0Ew5igIw7Xgd1TOM8GoifaacUzruRxNgb+b10QsZqbtukinBO8xw6YP3xo2WtTXY+yC5i2O8dbo+nIBeVF5tcJfacYAydL8j6koZfoUc/k0bidNtTetMdhx68L0vI8EaIZG20haNcZ2z784qtMGaAhAg8vg10L1OtyqJNgoMjBUIv7fgF63SRUOn9y5R9ORSzZsOW8sbOU11GEnqQF1JhVORmNCYXz5q08CB9u2uKv0WKof/a7LjHurdLwKOcUJVLCRj8sCyAMPk1tHRx9/yPHasGfM+OTjVInpdiqVC8mtYzELw9lfLfFchSF+Tzqnco5xv1GIfXf050fDl32nNLTonNL2iXqW9+6uyPUxEnghtNLoXNLnUzcIKOl3mKIKi74aOVPV+e8qkNYxVXgIIZmeIRMF8vStLQUi5Jlay2LQ9G8x3bDmQ56RBlTLmNKmfhauRp0oxYOIFlu1ImDW/0fwxk+zxWNFVmknj9Dcqqn5KsnMs5w/yET0MXvCK0XO8pblqpxN0CT2fcUs1HH7vvyTcs1EnKsyNIZeoanZ9h30Mmlijw56aTCryGGVDkljaiYWN4TzyQko4i6sORpsTw2HGzlPADLIlUbsRnz1mTxioFbhgEfmTWMssFj6cywY7rBK1mAGenrcwg2d/AUNeHdVWosX5U6RzYIVRltglVTS9U/RUnFHfQr11plVgInyJIlyTKatg8xRsnsqu4xJer6n0MgokZ2jJtzE/FBo1xxtewyErwulJsbDK0pjJMbKpywR2SNCA5bMTKhBTfhJnu062zDhy/XBJDGD4Sq8K6KSiIeq09LCcZMRVXO8yrXaumGiI8ApbBx0Jky0FL2APJPrCgsgh1n3hEkw8qb3rfxugsVKsQvIs4mXWORFy91qR2K0YNHHPtKIGRzSCCWoidqKm5sI/EHqxRwrEjhvhctpsUxfdF0XKHhu1stPYuKEpPU2NdvtDZIXcoxBcBN1SutoTbTnZ/MobuqGAixrg2SGYQbvAUKe8xut6hjlgs43CN17zFL6jM1FzshZnoUktpOWuegdcRLivIZZzpumCp10i1zxh6GhhjlPtdwdiffbm4PguNkZ+WbHB1c2XJsZcB+bYPJYg03rj4OkQaTq/4xZBZUXtQ6JZROqFeqGHFRJHRsidMWV+OVXBnbnfMe61qOIHAFtyXXH9zwJh0D88UbmORoR7YHtV/Gnv80oSQqgFH1mUVje/nYC6k3ISYQzjN/miRzlJ2N+AnVapVY+MG8nnS2whlWPFMrCtUt9Iij15W/bL3mHTsedrLpNSO+PY5zscvd6wVs+8gs1GH33giVHRJGYBySlcnOvkyhdWBQcWaahl2Z61NHsl3lJJcs7Bd+9sdc/PflmpQyNJ1RgxAGYgC3XXnAG6y+BvNFjme77c+r8cBqdTHh+zb+KkeXW87ejqTnbAgw76weUV/duo69JvBECmOhlp6nkudLUFW8KUP2ibIsWQgGeWifu44yF9Wh5E7U7KmRFYpq3ID0FvUUJY2VUMvYSemLuNlWOI42qzvpkEvlZSDrYQ7cadwDrr9fFyfJyBM8l/0p3r2yJA1iPqWjpTTdmbE4qMGUuI7g8RgaARCvhOm39EyE6twXBEb4luRR9SOG5y+QHmOv1JgQJKIS50x2Vs66HAX0oHlKTxnrXk23oHKR2jcfhmOMXmEFrMfoNnmh+HeUNYFSbX+PSdm8YXjfZmI/fEYpOtu6AktNqC7d/iPIHnM63e529CagmrUP9PeE0TOc3AREjp/I/allVrD84OnJsqH733PttzgKoSKqlVua3++dVwcR2eQu5r8JGnCegzpc6KDyL7ba+aqRuqiKZ7itMNvplvtZf7hZY1kDH9I6k3ody04Zi3OZLgNsak9WCeqHNz3+4Ruroq4dvpR4beyiGo2FHcApL6QI9QIZ4wnVRgK8bYEI02Y5lCqS3zkUHKXxMpCFn9RXWjX4AFqf5XiejMQwjafZdeXE4GULyWIxkpJC9oQzNrJxtp+PChDTfC854DgrtdFzU0/zMtN/kZG5yEcieKoYzxpOpBPbtrs0LGlV8oJpN1XTFIJd63ywLBSeG3fx9+h0TXnLsBLvukXrL1jwbRFzym8jIfi01UJsL36vRRmVp7kOEOqsb79zySf8354wZpj1DaIZ5BfOVc/SQ3o8MGzWLKQ8fnK+ByWp57XPzhrKWG5U2qmu2sH31+uXb38uajd7ymfd4q/d1y2vu91q3uOrJs+ce/9tPv/vjv/FX/8kP/+LXEW4chIuFq4SP+BTfExOUC/lD6aJVrAJEd1JEiKxE6TAKA/6NwYpTxU5xGqYYM4j5hNnEorCsEpNkqcQu8ZTES7KxD7CN2DfYPXp2OB+OhlPoH9GX0w/Tz9MT6Q9oVsMRLWJCiOAWmWzxMqDYAQVke6b8siX3MRVrsv12dS+87w9g5FSe3UO/Z2RUS91pBXxi+cY7kNj+H7jcOaBiKA1p70mU/uLeGQOGUXFkMhvF+Zku0mavxXZvcc9KKJvNhgtBY9sSZLKyaNUcxa7ZhMIigEnj2wdz9qRGLEy8mIDGFCDnFXUYwzRKrJe/t8eIAlxKrNSgsTcCvZ0G9YqaSCMVuWMZ5MAIVDHiqZqKqCDFayU0gKW2P00Cwettda5m+616v6BWyD4X0XwvKRbrb9kzV9BXL/WbBOSv7QGLd2C2EEjeS5DtGbvfJMaJbIqpHN85W4YeiIXkLAG7SLm2H2HOhhUlJEjjiV3KWZSv0vWVfV2tIlw9QosOnWEgEMF4CshGeqnjRF1xa17yvASvV9zPe/MBhlsivFH+G+cAyt4bWnmteGjgLDfME5UXGf0PiM44To2P6S21AC80l8X2kzrICxZlflXKFyBuFM+Pl8UOL00tR7NDsIBeKmpZ8p7Hq4+OkN/SPHkwPEsIvWyRD60iICQNbuXU3iv+XxL8LB4yuqBg70/8wlmpikAz0phGXpA+YHDJ3EgdUPbNxbaHbRRRdh4YG2S8wt0Kn4XtozUq/IIvx/Yag44X4xMzuT3q5Dr3cQKnvHZjwSd20DksTnooVUrpOKxdayloMfz43CEJ2Hts8eJO4ijsx3A75mDfMKS1r2YQNpDSxshsptaTldq699TOQRrjpFcSXwXuB99LfCy2nydqqVmU6xZVYLsp3NcKMPY8ZmAYGvZ8ThUal73fuaerp3j+cNXRVQWMmVOtMPTkhELA2MbWnj73+wV8MsLfNvCcwFB4Vph4TrnQccHWFayIuqxalwG6xnfA6G32X9Ktfja/DT36XO0Zw6DnZEpSVd7BbzF3QgLKWEvOG4+0391znja44Ah+/g5OQr+80kMGpFNfVzQxbRERNX7rfgoszwDQGqEHIcL2rY5ooT7rErHpAGg1PdKZHZyJaGh1duVOGj1Zsy3q19t1Xdtr9uPOUTVkbNmbjT9jH+t+WEScDOc2GQ6mYlEcNyW8vU3xDy9qYs8wwMVm9UrFyu6EjZJo/3qTFSs394CfcmGx2EUY26tIzTY8o+xPptts6QKEgFeZmpkezL38uT2VPbJYPgX0MXXZlMkTa2Ab6fvGVjKGpdcLis3YGQLR9Tk+tUZ3a/YdByKIdaFUMV0mL5USbebfozdJuV2VCkiqcHkn5SBpN4nfEw09ulv0KndbRpnoNDJhAtlXDMwgtnNa1DNVUT3mpVQSw5Sl+1Ol5FMiSLV832IGGV8URQxQZCzlPD+FRh6OqPLKkXMWT4Emc/S9EBZOvoVE6kAqdK3NBn9+8sTsAWFT55oP1BdqnAl0PNkFVe/jkuUkRx7RSitFspjHUSyuSmnjqi22s3lOHqmSWDfCEXlomswuvANRfT40Dw4QCLNU65rPyX04+ptI4NEOw2IwstFNsr9jBeNiGrMRvfeakpkXYxej5/wQvNMUI4F1fMdXSOlRYSJG4icmCdvLZGT4Pa7ypRtnqhk34qpzGyO05QSe34kY1iVxEcUK+0RmqvRv454rHb4NWH+jp8yV0QaO19ha9di3sMdK1Z2y+3VVCdqqgmx18nHWNlJjfRKV4Mg9nuiIyVLPMNpQ22/TE6ISuNpEs36a19GWNGPYSJqfHBD9WWbEiMli7tA0KwaKQ/0QJ3oM9HGdkidi6SG22TyjUOYxxGNDAh737wSrdtXSZjcw9tK/Lyd3Id1WCF0eRVWhSU8kVQpmZ7eFNCSXJvax8ksGqfdn6Zsy8ZweZi4kx2Zeb8ep9m+q28Rvw0nOd7tHPe0jv3WQ+9NhVh1khWBGEc2P05vVV9EokQlq780bafxQinIWrj7tc2dVm+R9dT+Zt3Ge3VpPj1eE2IJRxwxd85U6ABIO6YkVLQmBAQkDGuYyxHmHjGjyXXm/GHBNNw5464ruF9tsZp0RdsMhq5nJzTCiPSuZqa/xwL4G2WVO6Ki+2V6GKNOxQnGcn0F5NHNNyV3NcNuSwzNAA7iUm36EkgxdoqQSywz8HfoDJBTnWG6jWedamgqAq1ztTzqFa9SfAPmIcw7E8+ucZQFT7LxFQJA6yp+um9qwt8/gvoAmLswmgqGqQuVvPdD7GgO3QtKDAN1ex3TWbQQ2vItvNoYd9tLD9U/cTrfezT0FcBpm1/K6zI+WYNaymvR4XTLa93cuLUpO9biSXcbSdUJL68ZysLBUn/+ZofOAhWtYTxesPdyMOjEOPmyWzMgfao0ohxlsehbkGp0wbKaaYPnoxSawogIwj9OBa2mnkTarrC6L/WQkqOFs+AzyYktp3C2fsvuS92+LOHBrlJLRrIelBWRUpu+Hcd8yjQA7K1cXP5qOK5LtjqnApgzLPh4lUPuBh6pCofEionwl3yX9rsEh+VFWo9IAbZG6Ebfb+IyjvkYj390nzuD9GfRFQVGDwIRvEURQfep0i42aJYeGymFMQ99bGfo8VCM2odwE8Kg0CB7RuPyRep45uI+zASMe2gcCvdEnBhK3vp+2T0mr1nCh073eqv+qe7fSp3cwJ9vVwc52s6e95wu/Z+0u4cy8SyDh/fcA03jlq6pgxTMHgxl2cWGY0T2e47fjIw2bZIeBQ06lhgBQzb1JaVWG4T3YM6LnVpfvgfpU/xCNaVaW7eHg9XVjmP+r2Y1L7elI13vYK74h2lABBIt+yf/l26Sgwj2VcmuXc1FurP2lWvgoiQRt4rmg+nbz48XdR/48QaBQUwUvExKp7V52ubp2ZBGjzQQRlbNCcCkSuO5yjFyCU2SysYvJ0+qTfwgXPZHbmi9FTTyifSRItJ8BRSJYxwxOXEnFi1RzyxpLXszzGKZjXajBwB3Iz+IiiTkiGmaOpAm0oGa2SSnZqku9JswsJnm7m66VMrOEPD+q8tzI9OcQcr7Se7NRQVHLF0wxld9dYZpkPIV9jTessja08fJI86xsSW5K8mR1bgatZjJJWBxky2diTaolAcC6aTP+GViFNBHQ9zYQgCvVaD4YWAAMV/UBZhqMOJu4ENwDHGcu4wJIhtsQk5ioWut8xkQCcMYeTiZAgkbPl6n9+N0LJjwMAzxyvYZunVAsk1mKTPx13sGSTDzaOk9uqsTsI6NaumldjQIT47ykPctMxPdsRllvYdMIzxsB0m+/M+fb0fFo1fvKv6HqvOsoHC0CnokAHOj05uq3xmDSnCBKbDoyUEfhqSGSVT3VJlFKRv1H0Pm+uWEmo/ZbAZ1jMAG+3CvzRFA5/ea70/pBqoeDrvpJuYrAdOF1i9VPkTOfh9EiGzUWQNLZLyiA3tziQ9X1RNLLlBe/9dPAcKhaUFiNGFSeD6EtEPDqEhSD7n7QJ06rqjIafwA5J4wGflHk93CYR2Htw31XmkSZmV3TQUPpaNth0ILAR+6mfQPKWuPHQtZVGUHf3202yHLA1mX6/L3qtxneh6IpNTkKcd62BqQ1FrcbntwHiaNrB996c0tXEeaOug5dq2M0exUggjurpgNwVE8VtlBNsD5AG/yuh8EN7H2pLme50/11Uzgi5WQWZ+c31fuVFhxAlqCnFo7qbAt4ZYvsbHTGLIouGlNSmQe3pYq+d0Gi0Hu7e0Ei8TH3L3gnNpRjEexKM1Uk2vkg0H9bL+LYI/v6vk+ZqlDDnhLyBpJhXgsJ9fi+25RKveLE1TtDAf98MzsQKQtsfMQpYDfFVwf0/37VvqVc8ySkGuCXnxy2WQEQvmmK9f9FGOL7mYCTXf63gDu8r3WSd7LeeDx3Yfl/j7DCVwd7JKAgcbkNXGFcF4/AcXB8HISjx13BceF4cSI4SZwizhoXjYvFjeImcDO4//j9+Dx8KX4a/xy/jP+MJxAgwmrCDOEFYX6DdEO6obSB2/i7idkU29TYkttK3MITOYmGRGeiB9GXGEMcJM4S14lfiXhPn5Tf+M/NIpRNyllPFP0sIkiZx6hrosmmedu7PjTHXPMttMQya6yz0Wbb7LbXAcecRsPCJ6GgoWcEdk5edAaLb6nNrc5aQ+Y55FZA0SWMY8Y1zvzir+F+X2rCkpPGdGY2VtzkabPlQwWMVCQghLODNNLJ4h5DjPASl5CYnJGFkz/LTbOr06jJGONcZMYvuMGkwI3Zg9/IcTxcKE6Cu4JjwfHgBHBiOGmcMs4WF4PrwI3jpnFzeF38I3wpvgb/HL+A/4DH4S8IBYRRwhxhfoNkg7Mh3yjbIGxsb7KbEluiW4pb00Rqoo7oTHQjeu3teTOftt7TMcsISlmLNTEMsoxkq1gK+udni+JHqkTnSr/DTq6YOIQP1WJ7/kP751ZKufK4jLLIMffCixnLClexdafwpeAsrWfyPJ+Ynrud1OXblKyMM4+/klExi1uURx+UGyV+NsH0XwWD4ycicI8KRLJoPv7/+mFRMSpCQzmpOak4KTkp+Mo5VjiWORY45jni1Z5qZ7Wd2kptptZXa6sF1Az2fvY+9h72BFW8Kk5Fr5KoRCpIJVTqldqPtl+P2rFV23H8bGVym5Xtdtr5ZxA9LzfB1R8pksBdujDQ98xTj/3B791z5lTPuDGjhgzq16dHl04d2g6+OrVqVCpXqkSRAvlyPfHYQw/clyUzLEXH/L7omN+BjvmFPBR0zHeguPLJNhQd/RetAD+jXSSL+gosknhVfdFhv6rdosM+AgX2CegAwP5QhhID0GE+yETxXNEBgPlddAAAgHlqlY9N/Fr6p4bM73LxbeV/krC7YhdHR98H3Yo5isV0tYhG0Z4PQCs82O6VXT5qwTFmxhd29gQ6h0uQ+5VHnmE/5m69kX8VyBtfof/gAfb/HdWLKVOhSs1S3ip6XXejIGzIPDTZidJsCFoJYeZqOXMUj8q1YYS/UUCXwo4azVZfPw3Tsh3MWLHjwIkbP0kyFOkwYMyKLScevPnwEyBchFiJkqV6LFeefAWKlCpTrlqNOm06dOoyaNiSVW989gXBD789kOOhBZXwfqpynwB7H6irUM9BGHGWorVyJWHFa9c0CBIiUDAGjPhcJUWDFj1G0tySLkOWV776ThvOsmzStsySM25MN6TfTR/JszGt3x9zGq2ZsW5Ai0lwH0Gi3nnvidsy+RKi4I677nnmuRe++eWTCSlMvMSihz4xPMz0ckEUyUK7/y6n7jbstk2HRrykpFCJYkVCh1AqF66azQX1RwCYDzzhBY6LNwqzJUouX5wyMeKXSS2+T6rxpDU2oy5kOK4gCBVFaWhaOZZl+jYCCy4xHrwqAkTU3/mVRIc0RQPKrA3ZijYSE7GAgNERowCYsXETJqbNmJqb/y/H3ei2k7BmLh7J81Wq1E+Naf95zlpmLFjG4oPPOOAQ8MQFsIXuVXvbDRbCRs2INOeFGzPPF5sM2JFcUqQgxyQNMyWPlcHpRvDXwdn+tccA4OB26SHmKgka1Z6D6JWDJUWJnEzDn8o9UnM5MYGHodVxZnUOt+PRxK4XfNGJEUPWoEGeZmIWcMfWrTv11Vdng2/JnePEmkAAJ8HVCf2D8l2cv3uGSVziTBHUgMdAY8RIhhJ2pizxsRZFSIx+xgYtuh/LwAVELQAXCMpbpGh8gqaNMLptRQ99iRgkS2YqTRoz2W4zd9ddlh56yEqOHNZy5bKRL5+tQoXsFCtxTZkyDqrUcFSnjotGjVw1a+amTRt3nbp56NXLW78BPoaN8TMZUwAJM01SEOAyuwrGc0tCrHgjxjsfJVi3LhEOXpJNm1IQEaX64Yc0v/1xyz//ZNixK9O+A9mOHbvjzJm7c8FH954ruBDuI8PrkasUtY4SCTYArspNrFWoRIQqVZrUqLGjTl0UjTAEaHKMSDQDcDVehmDCBJopUyXMmBEec/BcLY5D0kvg6rjUwokT5x8ar12oJJ4rV1TcuOHiHgEAvREu2peJYdlArFgj4sTxFy/e6CTwATw3lssBJQIExBEkqJBymAC0wYz52d+XAu/DcI+EEmWnVKi6GLW2QFCnCUWLFkratDHRoYOZLl2s9BhgZ8gQNyNG+BkzJsmECRmmTCkyY0aHOXMGLFgwZsmS1TcFW9asObFhw4MtO96uucaPPXsBHDgK58RJLGfOErlwkcyVq1Ru3Dzmzksub96K+PBTyl+AaoEC1QkSpE2wUB3ChBkULtywCBGWRIq0KkqUN6JF+yxGjC9ixSKIE+eHePF+a9AgdH6T4AXg7bycIEyYeTlyuGvU6KlOnabMmqVryZIYK1Y8sGpVjjVrmhAQvPXLLw/99tuCffuuOHGi0qlTeGfO/HTuXJULF+7PJSmPkIcV2xZ5HyK+U8qlpulOiwWHViBBoh4pUg7IkAlDjpw4ChQsUaIUjQqVVtSouaJBQwIa2go6dF7DwtrEgIEbFiy8JEp0TZIkDVKlIZcuHUyWLKZuuy3IHXeEuOuuQPfcE6xEKQZlyvGpUEFKpUoaqlTRUq2anho1jNRqkKZRoyxNmrzSrNlXLVp816qVtjZtcNq1W9ahQ7ZOnaR16bKlW7dZPXrI6dVrXJ8+Y9NPs2UGSCCBz2AT6yHqwk0jRhQbN+6jCRPkTZpk46mnpk2Z0t/TFP6YMWPOrFmNPUdhbZ7RxPo5lax74YUBL73UYt68SQsWwC1a9MiSJYKWLRO1YtU7b7zxxFtv3fbOO5k++MDQZ5/5WrNGyFdfKcAhuGODnz6G55kAKwn6T376acI//yTZti3Fjh0mdu16ac8eFvv29ThwQN+hQ2KOHOGZMxKLwBcsZoCB6QWBuICDI0JAiISEZAEFpR0lSn8xYvQfEyaHmDHbw4LFAVZsjrBj9w8HDts4cTrFhcsubtz28eCxM/x0uDktQCUoggQhCRNGRoQI0hFjOYcECRctRflIWppKQMtQySVZsmDkyCFveSqBjxKJM3yVJz5IQICNl+/+6fA/HpG/wBzH/wZEw26q/Ez/JX8nweBo7bfAPfCLgTlempAMieRZBOhdLD1igudVMLRQJ2z8XABFA70QOaEb62tdE0O1FejNEvEBvlaxOSueSE6UCwN8khhFsReyAZIdn6ZwAgSvpRk8G1cxWJ8o4CYAwM7fFXjKZ6qNVIDYiwlyYhWqAPyIPrMvbAfUbJgPasJW5x5DW8PzH9vwbwEeVzRb+YY670OUenm1eHQKCQKTYSkRUYBokYl3PlCITKh3RVAdKZvQjqMdsA6nsqAzpQ0frVoAIIMmQ1Lw5eH50LwPHxJPbUJnd+cDqePRwbyBVBaYPrpmNDw+Gxb9dCQ7cOeswBu54dm5pAjGMqrp+5HMVqEE2zuBtiYyF/8TLxG1qfpxOpfb0cL0yHn+sciwkQBatEpHbqylojNKhCYcncMQcVqi/lhMcAx4EH2ahLuz7/UyRxIzEPub6Ec6Dhsz4SUhajFZD1fHJj+uRqsxqXC12pB6dLonxG5yBTHpkN5IcR6sKxupEJllNSQsqBOb7JIRmGyo5aVyQxXRnTmLMrQqw5fPMGspoJ4PKpmLlme0byv1Ml7lcYrO9V2ENKvNps+K8TUrZ1IGxCUzpbcbl+cDduYbqSYj6adGEB8Idg4FkhVglhh8+Lk0VSK07ecZehH2pMpqrNAm9PVOwcturSv/iAvjjxKiacSNOYdEa5Cav5Q05bB83ogjYhsx5reHMXiSQ1rmVhda2R+5KTnAyyYZb1/2kcSutgC6IfPEiUNdSLfkhEUDlzHjNzJmiJTXuSpmQI7GhVs3khWC9u6Y6rK0nrUxYjx/fgGGRHFEzNWePBNQxuA1cnrpB5ZQsOIM4bdiOsY8gUkvxjJtzxwldl6V4ojPA864k6FYLgOPTAtRtRQJOMPwKy1HzpB9GuyVEhc8+QCXMrfX7+9ZasSE4FsvB4/5X/zHQWAGELGsNPr7BCAUHjFYIwaaLHOW3h2LzAMVwXGFJzTzcfSIwU5Cx8SlDnzFVJrY9qExqAUiCEEoAVYXdFBGs1SRBmBYnoyNuTkEKDGxz8UE2OD1mwsRBTc2oqt2qCmvQULood1xa23/Y5/2zK5mhurrZmiF1YFq6gFA9BupTAo8EKqfh+wANGPiKOwKc5zM0ReKNRvOxXNrFBZlQxxJl9uUkIXjlbVc8qUDl7kDGSSOIC8D88gjTCvmNskUV2Ixvjw4IGiIFSkCO1yF+WK9R1WySe0ma4ezdPmFywUvIbq0WEZk+T9c9sPt0mIo4mmBKEnQpplywkhqJKNUNXvDLsHAzcaUpoKeIkQuIqtGuDzK6Wd1h5OxjpwHQxx5GdJFPv5gdhRFB8EoHqicyI1wqquowvN3Uc95SZXDiKLgkZBI0oR21X6azKHAaJ0QffSTiLV7cs8L0Ki1tqCFUJB4cgqVXR4EgNMln60QFfiAra9JF79I5xUk+r0S9Ch+miQxFchKVxCAD+tRUZuF54xziD7jEDg2brJmwpdyH8tqfZXUR6eeA/bH18srwN+iEX/Rhr8sgiJiQhoTJpMgkRCeKOO1EGVFKdnOPMQu8EgEnkd5oIRCsoQ744pETygaGbIfwRrKthlYigggdLht8fZz/QcRVoYVzKi+0bJb4sineRaaeXZbb4RQqSuqSDXOxcJ6LBENK/gY2uCI+q+crqh3ulIChctwRnIjAhFM/8/o+xEldiVGHD7MnFyMpirMQ0SLQQ8R9SSSdJ8XxO1oUo42yF2KUDQafB2tHPC7ndUl9pCAWfQLR0OdvEffgREslyLmwkZnbEFaoEExeLQOKbJE9V8iXZCYTf2WDFKT+NhszIJaQlEaMhh/yJSeaJmHszXeYxjUYNBoYTXwsjubPa7NTWlp4o/lufRQNNUN14hjKMB1j95ynoFpPtw23GfwnOtjYmEo2uVbANK1VpgSWwdrkSDeBcNMnX2FGBGC4siviCVhhHprKeSRSC+RaLSXzGkB5NiJ6Jbk6Gbq1ZuDfHEx29qxVLkSsQPRRds19WbRo7V0SYoQSlA1gfJjdANGiqcY4aE5SSdt2iRdIjJEUbN9yV89mewEGYBDjBj8JOlAXD+K1nQI81hgKlBHT9EjT+gN8820tfJbm6hDeEpmabB9KrPp8FFkjg7qoIUpRpkQJ5MSGzmN5iIrjbgr/Ke4N7fK1wMk/0mW0e1oIhb4rhfK41qqupyzmiGrvBEJ3mQTcwK+h7Oo0QozytWofLmIRL2QQ1AqSWsMr/clVQZU6ULQQSaknaqjREcBi9knZ7FJ40QqE+ugNJK3kUY7mKGJlCPk9iTeXVGobGiYSCTK84UsgbXJmwUu2BzHphAkJFOgBgIG1Ap/MgJizj0kHETA4TJW8FqMgg/40kcndAM6tEZBC42yDg8P8sDmavn1Yc94AC4H5hc7vsmRCIlh+CIRB9OumUvJ72V14SYpy2LNbN0sHaztOpeAQ0BDWxTbpVHeuKuKf1wL958MA59K+FAxxApOlxjJILl8qi5bN19DytrDBru4FxLRR9yYCzxbxMisSDe9pbTyflEZamF5y5NFV/csTM/23cMUS7BSFmT2rtRC7qhLSONO9qgmUaqbTyLeyF8NDiFURVnuGc5o2fGYncypKUSTAFHl1oKyshwMlHsceY6eYwY+O2wCIZCU42MNhrVtGoAy0nPYLu7oichnyqssx+U6OS1eI9Ii+tEUYqATz32pX7GC0THHqCr08FOXO9sYRyGJlAQkzYhRPnWN7zJJ7cHKEEmzAJPiIQmxR1tM/tQGEO7oWFO8AySDlANeNFL6ynCCMgxauQcCHWViaGiW737yg8iPMVEEk5eF0qewybId0OhH84uHdy3ijuOV3x4Vt6LugDZ0zRKOsonraqcgKoaHyyd5jpG4DeHWxhQ9UsPhgN7B9dtpfRvklDnnmEmdtOUl2cbgSDa8PnlHg4sBJxIfwlpqTQ6QZHCzQgKimMI6qSuMdUWHBgb1LlZk/76dj+wnY2VstJ7hF28WwoEewgA9pNna8HBm/4hOjBj3LprpWeLXtJN8/NrjuYnyciw14PaS+PjsUSLD2sZycMGvVlbJWSqzBTlgEfh1DoyxnKwN4pmg8kI22iBdXcx80HDKyM5yMItWqZb4ZVtb08urtZWoTWZ4AAmE5pnc0IjFcdQu9PfaShUwQC3Ugl6pivKwnQwli5UrYm4CHYGta1XMKW1INYmWLDqyorFeJXE7J+tM3/L2YLOrc8UgmSSX7muivGT1RtNC9BZW07xIDEtJqIjm9krKd+EbEqfgJqlSRyRvMcUw0BCoOavPGk8gLsQD0yXMJIfpUpkZFoWBq/B2EEDBY0rO0M7yHvfqysGJsMtJMwtY1NWz2hM27TZg2bZ9JIlKoCQDJsDBIejWqSkXGhmzDLDZM0FwWpV5Spq06+TRwtOrypVZVfUiDbh35je5baK5F5dJA4MRHNPGWYuhTYxxT8CtUEBH5Jm0WydIQ1POLIyTrolT1SjZZwzukWKUZZLJNR/uxnaWxYZaZRybiaZWaZ9LznwdQSNwKuecszxhuYHhRDSJ/PjxoCkNBU0miKyyQ+QlzhvDL1owhNyPoJ9TgeamGcowBJGJcFruC5x8tlqRVEMmbfdRoPgI/XW3T/onyfQi4LTvTnr9uAHVZfQgg/GrNf2Lzxzh4B5U3YqC794lTyPK3w/VHTBraJ102xWTEeJRcHUrtxKTv3LRZ0yJn9lpHH0EaYengLlE1IjfrRNN1hZ+ICj/TPei5EhSFFmd8mSKh/2PE9ppMNi8UgpalVl1VK3CDtfF7WG2ppoVrXsDRqu0zgUzZSNjfh1Poa3PzJehlogP87ZqHnHKomMx/KPZByA1Gbhza3zlafqRFXqkN0eS46cTLbSZgTaGG+0BJkYPFg42JXt1KyGMP9pP9jF7NbsM3w44R7ug3VqOxBPG8FVxsCRCmllsvinwYT6pHusw2ntvFkfs+3qRl5W/tsAytW89DjPFmI8r2gZotBxDmQI4o+teIn0mckdGrH71yO33RZ+M9uSpHIz64geiq//hYFWbjk/Ho8MMc/zBfraGcl7Rx8gX80PPbw6/rWW42WyY8WRbyG2ONu42BLHQzsKi41pO9dyGxdpBzhamlNJk2hvCjHI/evWBV0mtpHK5bO7ps4mWZmZOu7mN+Sg5NjdpaPYD/mYNsZENZQqGZHpyqJaIOEovA9jp51OW9wB83JkARWRg+0EOeacqe1hjKmqs4tYIZvF9zc6rLxFtxqvZt2qYINT9fEycwtTFr2iOP9pgSIWx0dztcFfVaXYcFrOzLCXUIZImoZD6IzMPCENvy6qdHS/vo9nu+9OJLblHfLdXbmNcsGmZw3fmyqf/kT3Z3MXu3Ku4GRa7jUS0LebkYsgZzU2tgPzP6Xayr+0sfMAZCE+jn0jGY1SW3a139luije6tSBp5GesRf/pB8xkc+bphOBrNtCxll3lwRkOg0k9MBJ5nGBPcWB3MwZcHrsg8asJNKEYCi+n/FouARzJUsQplxIO/nIcYAwEzw7hNNLdISBlHzGgb4GATe2oGe624AfhKgMxpPWqyfhPeBVZnSC5luH/d73ElKEfVkMeX4UXUD9TtpbCWiVUBDA6Hr84JgqH15BlQxApCvguUlivvY6+KvF8GpBUcgxokzoCbQ1mlddAAKa2jpt+Ek14Lj5xzGGIbTtoKpAaTw+hZQ1WrWiFR+PId020DzbdbhHGrg/x1x8Do0UfOn4LPvP2QzQ1aMNI+ovHklRXryfgXECoWIPp6d4Gl5bnHw7dzuYcMR4iMBUYe1AihOyJgYu9f1YLWIDtGJmpLlzu4AwEc9YcvhRJZPVL+NhD+QsJg1NeVR11ovV7cAaTZhvOpAV0uW3rVqCxKLXNveLI6uavDKoQZKhoVK8WiNHfSyK2aDsuSxBMpCSS90lZceJWJdMAmWgkrOhkLt1e9QKwHjbgFEVoVz2zLGiP0TKKdrqjasjXxS7Y08n52bvCoIEBU3pt8rhBVuVJTI5oFQ5K0qwsG3V5tZI2q7GsLK8xZ7ZHSCBKhBSzgoMUqsAIq9UjbUTfsYenX0egPSPbG6IAbf+3/J+6F3agdrMVvGEahPGzHKGBEnWxotIpW1qo9anhe5UrEFerVz7kDooBA6KI1GBMSnmd7FQlVgUdygiXrnYhtE6gpyhB+6ifGk4B+WCkMmasRMhjFs5R2abWpNyWBMb5GbsUZKELvbsgMsaFF2aba8q/QetLyngMX983E4HMv9rte8/8EzitKiVacoQplpxUEqKFZOQ8qQMRbLhZEZwGEU49NxFoRitNruHb0+s5HEMoNL3w0iRu2gBCyLPTkNO7p3YKZ4fup1mnL+tsFASf4UKWFrdm/AX3VRLOB5MJgKAENTNm6kc6LylKDsm/9OssMWzpFJ8hyK6IuQv01UnUqLaT8O96rjVMsc7KEVoRVRG0sA+QLqc8hDmWjqBo913dzWHxQz11GNgWZ8DC+z6ansKER3ObyGMSu7LIN/OFbFYOyRyHPIgD1rjcBMiCiVnixWlZu49KAPMBRVro+agZG9BYDHRhA1GCgZQ/sjpK1c2Ki27Tla0adbqoeDFfG/J+BtAglIzJ9ou27GZJYYs6qYKtORdi0jDKoc6xgr4nEdstpntkgSkbIypXzDVqeKGudjEMLSQkep+POGGyYwOX+lDZWBdcauZ90wQEs1I/qfl2hqLlm2bjtUWRbtsgS8ig0Qzn/K2e+raDy/1wKZW0l2l7aOf+NHAHE6SaVwa5vteCgm9SMBHbRVPfZyxq/2wnEBYAe6+Fip+ICvXS2ngVa8v9mRPvlB/8u7q0Gj6dgXTq3x7yfvqCfDdFQpfXerP/HFXv1d8QxBJPKWAYspRwwkHbLyLekKCsUoxwM2O7ibuVy7wgcQJy+cVKO3V+YJQ7vQvWjj6mOu3xDqkrcB5v9im+EoULx8mePZV7QjpxGnXaJbTZ2GQ2bu6zUQ6WxWdUhLGoAzFozEHher1xxqhyPFipFoVgOR2hyONfqe7Spu7vuu/3Jt6ytFrPI6BShOfqa5oHWegxuz8NbtF+4DITGV4rUEkxVnJPAyhL2XzOLY3g7qVHLiutJC5mh0/K7CTpgHeftXGGG5w4uOAZdEGAIDEpxRdgEchviKwTQ0lg4OfVvwMGeifJO1HZ4N/q5mNsB18WMkKsO7BDJHOhIR3Ap0iR1bsksHeA3W//cBKXpP121j0bAjohL0jJyUx1iXgKenJCqmosxSwMdPCxWYk5SdMVX+1yMCqB8BjzSn9Nxr/MMUXYlxEm6E/x/fwcG5nxHSrPmbYIl0zZ6sdpbHVKDk7tHPVlqa2NFU0oJkZbAaj8hO4+wBJDIBkTzL3ErbEb1QJrTVn6aOADZlyt9ebfpeLaHWnUqzfdrhxtemBm4UCcG6RJ2ZQ24ofFAoa09qt12C40J/S3hEnBuavscwvZ9YLDW/UZ2eiu0/Vm/zcaX/C8LShqWEBeIWriR8dK9lTDNx8PV02+DH53lmjNGcpa2g07c68fwPDpQXGh25Rpe/STaNwKrdKuMr4pB5Yd6oDYKlkApaP8EV2ygDk6UvL9En/oj8jJe8rajYuKAuyjhNmCt19QqVfhnuhscGK0lSPvRBbRhlAAS1al3GQ8A05AMSpxXsoEUfofqAk/xlaMhqJk3gLIcsMjbkJEP85TBfYujPdTXdJ8IenaKNshaRxvrifFV2taLsPddtA3gO7fdxn/DEiBPy934Nmi1++3jB9JsKyj6O5Y+Dxb9ndBq2Lba1vmricvRVEaOZuhAyngfbi/I4YzMFCYNekbGhMcLerzER0r6mk38eAcHc3ysxNO5hrxUT2v8GZeRWgJysuXwAeI1+C3W2mCukpZnz0Coa3g27AlW4eQpPr32T111FtAIVC2sArvkZ7hj+I/IjtrC3wnYlyvhpnPD6ziZ+mZ4I83KeYEs0qQEsrUtUWB19UAy0WzdK5Gl1jTBb0VsKm4apA+Qtj9XsjajC4mgJz73FjiAlP7iaMp+RZblff2q/rXXWlftsF9rtT3Dv91O0NYkPKein4GE9P6ypUgt5ybECrKOViFwZQzhRyOjphu65aP4ga5BOrUdrFJd/hp/plln9oaTvIqejvDn8QTfmhQLwnibUyTEAibp9jXJdPQ2wjOn4iqHFI6teJ4/SjVc6I0KOgxcaYATwa9VpuFD5Wf/4L3Xkd+meSwcIcdz7b7ZKU3jMxh4bjGR6ztzCp8Z51iIeXzEUfRY/I5xPGtqaukelRId4rJQdeDjlHnupEdJfYHIZ8Lpvvr2q4jtBZwKLU11NeFuHEZc5wSVxtIbQNLKzVLP8BJL73YyJH6SnqZee6p8HZWDSlwzvK4Ytg4fmWRSl2YZ6+08uKHWkKqYhfC2bEHtGkMXFl1wLDKIVt2bpFQ5mj7NP2E8OMis7gIrTliaO1i3gaOfDS1tYqV3Jn6GdTbMQLt9xC6EWiniGSOSzXJdu/cU4icHW1vmjlF46AA7h35W2zSDQdBHjqxm0AcNMvy/IaROaEOnKXgEqWR4FGgAtM/900hheQ76oyOC0UoOUqPGPUHnPuaT2xjrUB1lL26Z3bjAtWBI8BpdMhYBsr4BM2dUB7jlhkCblfqaMpkBcqrCPBDmGHAAeQCjIdBfacv2kl4Lp48xXsQFnmiiwaNGhs0UKVuaMe8/r8lA0H/4kURctIT2rx7P0yyfZoNQ6dQmvtGZgaU+CL1jzWpkNwULVcVrt6olA+9F2IXSqZfEQGYeq3WAU6lm/iLhZxmIsm5q8sFBDrjWe6wC1IJo4I1CxemvpR8McGC7hdQ3MH8kRpoh4GlzRjp5EO7k8KPSTLjaBgLTDHGvYIFC1Y/aNX/jAAqVHHHxFupJfbumBBYkYAueYNyd2R1oI1sm2GVwm57xGCm1b4TVmH3SmbuqmBGFKvXiKkFDa/vaWg1Im9DdKz0JqMEL0sybkCI0VYy17du+h11uUN0NqflNPLeGU39+HTH76NdeZIPC01wmrE+zAayf11v/XgFMss4beiNvNu4Zy0AFFesM3suDAdiu6bRFqBDY2XuxLjFJK0uGCxnYA4JCd7cwJUFB2kt5IoFL+lcdjvtERVuQBFl5XDgLYvA8GlS1ICKZHbss/L6IXbzEGgUBl/gOoCW7a1JCw5p5ZySXblxCC9IyB2Hb0JKPFUIVmmysIRxNrg05adRDk5U1ptyMm2HwQzKGLYRqwBo/rOwHY38IfN3/Mhw33WVgImYhw2+xWgPrOpMoiqtGNmq/jgcuSArWJnj5jKOd6xkuWN2fBnXAs6/uekBVxeDn/AOOvr2+a/zd1dIWr7RRPdGase2Vi6ExXmgJnSq4N4GtDAp/CqATfrmQRlmFYYTDSpX8zocn2RfmXfx9tTINXwnZ87Zgqp4sHYJPUi736Kvghhc+K3SHJ+kwJ38r8RHOI8KsvzFTvi0CwIWXTZUri1WG9YZgm9hJknEjPVNGMU2WNAQsv7mwBubdZYgCriSHBeqVAgxckAscyWPE+GHCvS0KBhcR+7F15oelFpBY860kQGMhjI3w4ZMk/CEKRrhGZ8fMRkSZuqy/w+CNwFO3CAVv6kZgx/rS4e8Kz+oaUIJn9GxeaKyGgeYvoSpGb8DsuDkfi3oyOWifQ9+TM0GfM71Q0Zh1vA+MVvYK/CVWJ8kTi+HzSYWngSrs8sMm+5lu2Uk+da++PY5KXBGdH8U0BjM/Wda+x9Rvdsa/Su0cXdHHPygQ+3TiynTBxwJ3lv/XF91k/ulCuGDkIVawAmFfGQk+Cv3IOf506qQ6EgpBhhsjqZkFxmkduL3ot5ut/T7A1EZfU1ME9DV+beapmjKxVYmJ9fS0eIIXZPCiBcyZJV8MEmzZDKgTZZpqDyvInKUiTx/P4fNY+PhSNR3X1xNXrBupM8SRUw0Ni7CfCFpRoknWPq5QwuvkcjLvM+soIOAmiwUfZEoH8SUc1nYaDWB7EggfdEf4NlYL4t39gd+FDPdH6A5qPJX+VKg871Ycw8RhKJBFUwwN8+vGigaFRNgMi7Qk2VQmISYkcv4TSniVfGlLyiJ/0o2LN+B/gv84gagSQ6htk5RnaTun0QVzLufbo6mkxJpDpXe8Mp4xf5g5bVQMLI9DVyX7yxLra0S7qFkpt9Y/Pgbuc73KFQ3Dw7orI/JgZQJor8WSyI1HcFLrgwzQS1+q2Tjh10jOkQczqsw/0rE0BZLTeEy8tLWNm81JC9gTzI3YDToMA2m2LiQASQxIWqxvMzxhAuj9rzAQcBBCN7iUcE4TiLSKtkg/7kb1SBGty+OJq0Af+KJnUEfe/vR9ZDAIWq9HJnyLOv80fsMTQyqiJZ8bmX0H5iKLV2wh2zzcCaJ7TudRkHDdV2Uh1UTzM8FYTvHcJ6Mz5j/Bf2S8tUiepfRk17hNa9YAuvKFR6eSkhJtzJcFrfmBXfP1Xf4/MxS4zi1ZEfBLM7yObbp5CgkQiyTQlhKzCO+DPw4RCm3SL2gvksGlLlCFqjQzR+oB7d8VG3QKKF43US1HXUuF6XdRH28USTYFah94t/pA1hxwUAURuTBUKFhzbYvvfhZhO04NCDA61S0JDgWCR6D+Xypi4HsE4uy00DYIsIgZV4xNyJSwAEzFj34Eaz6QiYCL8oz4QwUuoj0PoprvV82jO7pAaUVfBpJV9c4+yD+BpYeYyIB6rlOvCu9C2BoztQUOq6mSdSz6Nmcz1yJuR6xMJeh0z4WJBmMQWenv45v9RI+07MOp7Wt+ede3BhXP8UgBusFfl/51VJHmkMR5Bm8ZdZ+qKlz4QVimRDZzZNKs1ReDhqfnN28VCGs33RQtTTiqrCpWkocjybBWqq+UchLWxyMI5xcwUv0wf+9dJJC4XfoVyOSgEfouBSbV2G69RSIjggaEw1li0REYlN9Sxn/EpGvolVU2GKlJyVemPvlnL82P9tCIAbUiFGRgAD6Ba/iQP/qYPgCfwkBUIz4jzQT4a2+eKwWmejIDPIIq0JHFhw7K6QS4evWNbNfaSf/+AJRFo+I4M1+iG3gMuIvbTkxEYnsNq9zd4uhoT53Gqq90wRIkNwhaqVYWwniz/lPQg0gN4mmudm8p/3goVuiG/koshoHhhN8R9ynmAQtRQyfkNyknxcuD0fAbew+j+1hkSKDvhAgOoFr6/mRc+FTHT4ghAl3Ib9nGeyUV6EfyfTSJHygCFytGBFwCko7x4cX6WAbxifcFh9pI/KnIKLV/EfZUYlhzENs6CUbk0w4tQ7jtIcEgIC9sdNOfiMzn8w0JAF5T+1Ce8jQrZQ6NwvgI8qTn2+eaqcEKzyKWvrleZ8JtfLWeJODACuAFuFnOdO4q1lyKI6fHXaoZbEb5Ct1GtXSMXG2Qr3D9q1V3FNcUAydYi0o2GBS9JZsEvEGkCTuuOtZfQgS2t0kvBhNUpZpBYmQjUE+toqs8VN2vBAipFkNKWkdra13Vw35yT+sfWBva03FYyRrV4X6BBFVu7v13yQgG9xsXnNDt7YOlbdSg3ytvG7Ho72C98wJx0X+JtRRH/cv55vZ58a3IQsrJvoRm4bcKDuPwHIj0aFRM5k77QWUXKtlTbEoKC0DuthGIlSaxSNZAfJN7VFx5M/wNil0HNVYtx5plfxXc2OzeYSAIpksh3FYkjFfY7Xp2gJK3EYi7epryoiFh7h7bPQs/Rwz3OYrrzRO5Yj0LVptkAgJK6DGn+NB3y2ALWATCbQgbxRqwlOFVMI0Wf5+lBh5zaKX4ft7DfRBb9/sWjKwvoSZMAlCchbLZsqgJIRX0/XEEYdG+Daz5jf1rciwgXpuKGGOtJUYrLoWE29FbfYSIFXKvSObq5YGFzikhUpTrfpJ6hgMDB1lPIj9eTCRRyEiKkVSecQWjFpLk+CDaD7GCjIFLkAtXkgcSDpl50CqQhCw4zQ11phjBfK9MBwFiKJfF1UJ6ka9B204OnsG44Hay7f22B1tmx8fclEbiXzYXVIpGEUHEoJZF4M85UlQNNIrLlQhJ/5eGaCGkWkT5sD2Gy5JeThAeiyBlMpq9eCXn+GrJRVnq5Fsp/xIKHrielWypZSB3PycR5397K7z/dOGm/CjvbGiqX9+YvX8WnE6uMf12e9ryWIL21LXVKnTo7BKVFpCAcx19if/TLCcRlwfis8lKNWE3OaLD5olkllYg1PoykBdlQkkfCzImOworN2Kgp+aGvCX3hGTHhZarMMC1hv+Lm0+MoXKc8QMmo3bkTBospNE/GaQV5IHmpLUNsYNiBt1AMJxsGR2yZSBnOTqIFBOni8dKkxUiZjehkiNjkmmZxD1kbev0EWDHN/OBdr8X09DEuWYanq8Lc/2gcZRaeE5lq3DVvUyEXOkGIhMPkl6Zq+aRVEzBb9J91AfwiCNuXWMteShYf7IL/IniuQeIFZp4VTK0xgNszR1yS0b49cIElM3dW9IPbYDC+hfY6O4iKg9qUI1m3XmLmQdJ9jImhAiwNzrtp/pYT3gBla+fyjq0hd6oO+kSwlhBBKHWZywfs5ueXtI2i2E7jI1I6zxu46YKpWV3pdLcuEsl5mVa0ksVF7r4YLQlQJrLsdJDaKaH9fIygNJipmWW4qfbhocaH7EiLPaXMq7X5DhiMTR0n9ptZHji+OiLoT9Zdl0XKiTyI1+oxogFlVzYwE3fDARt5AnYjWECrUd0W9soH4bMogdDqnFJmXzRt7Y3YSeGbFIekrydGBuciotkpRBC9llINjVWILuW7DRVilEy/LWQ3Hbb51P3ncX7Mm8klR8sJa+6USUxVJ5v8lCbWEfteTkxTLVffwL2cKH2u7f1ywwv8cS+kNdBKO3XWbgzHvzkefGeTOOaIBbutLNqYk+xSulp1m3hDeX62hm4QpzPwYEXzULvuvkI0eqpmaPr5/AN1lwBcc/eOgPqeY9q1uoaNLz9Q6M/e2rdbwoQGi8MnusTluOW3tSk3eqwYVOffCDIRqBo0HWZkY+MKTtM5+6ZKrMkJ5y9+xSqUPAdoFLO/wXenSkCrCo7aCAlTFdn2MulHAIGmJl3DH0SNYtS57F/Bie6XXPiRlUhWz5vQoRNO+HCRkRIX5kMkUJpg9eZ2MGHz0NcBcQeBcfyd8IEKrbwz60MQJMrkN/yXDE7TTMUN6PxK8iJjAVvcggTWFVgby+vesekqwGlUgbNeSpmZA0nucQvm54xn0/vxSjCwCxwGBact2qdkwU2nGMIrf/xzjSnKXRFuAsqAIO0gWPamECNRGT0Sg8n+uFyMJUrK4NLGN6tCnraziV/zE/O2nDjytcIG3WwDW54HUWtfJL2fxzTsTtRle0TeQ62NU2EJRQ2qNuOhIk7aMGlEEcRvdoBoT+KhSur7igI0I2RgoDswobVchSf7iFpAwcjbCM8a1ZslALqTXxFDhaucL0KErCAkSJtrTDHS5GYojBGGLyxexRNbgx6xapnIe3fmjEEA9AUJnsX+F+aJ/e0VrDGJm53iCAUsg11NbIPq8+DhtfLQB7zEH8AUopoHKGm6zWHYul7MStf2q0GHBgNU+Xn9oz2gOs5EDV9CHMUNoM6nAdALZ1heuTgNEwOHJ5GnKOHGn/Arx3bi8h3guf3Yvb98IVtMNr2/j8SuHyxgttXSqJz7ICrsv4RY3ySGpjdGoYWeShUuOhiAoxD5XLawcYEk8nRXflfxBn9vyMCXvwT4nywhvWodxIeWy9QEgUeEKuC1sjgMz37yZsNtnLwwFlOel+M6GaC7k7EO2m+NWo27NqjSaUVK/jcMXiPc/3aL7qvcIPjnTXgXVQQTxW0AKdwJxxTcZPNqe+Mkdiisczu6J8W3xQPYu0Z784i6+nfGjCklcFW6ckqGP2qTMHouVjWm2yKprurjNeSn66n6um2V42j4FB7Fi0rDjzspQRqtQoMb42bsVluOb17BMeo2uellZ5PwM2xOpkhjrs3ih0sL+Nmf20UxnrJzZTtTWsgevliQ2Wx6oWkvw2SJe9c72jAbUJ+dAdyH1jcjLoVNT3HCk2UwPVnXF8iu+DG1QkssvhWC0BcO2ZKQZ6kGrg6WBiSxAXp3fjVHd2iuqsXbrU17yfAOUw45kjkqHOHUlyaBHZoHwU2CoTAhSFWS91rfbX6c+7iLtzOEjK5LAG3OqydXtJtU8VNFCPDvucXmR3CXAM53yHIhDoQowkjd8SJ6JAmiv1zJwqxG3RjNuJjceIz95aFn7FVtovXMJyJoJKebJ0dLuDlXGSzA/RFB8xpGUFhM8wJK+LqYK+6XhicFeu7DDVCW5TccWbcx2JCCbQGcQwAUOPLyahCuw4x0GHRBDTY3EYaiOiB5I7i6J0WyVlbHHOOIoQERtlYRomlcgmstgQWqslv1uaDhneDYz2CkKNa3RfsNliuv8Ga87S0x3rfk0FtNbD9MrJkAwZyUNfrovSv/PUpGJp4Frp5Bzt5+Ufmixxlcx0wy28TcGdD/vZa1zb3rd+f5Py5makzZ6fN5UunTly4eDLqOUsf8keT709y8cKJU5cun7Yz584fnz57ZnpLKkAV96gEXtjgGc4Vmm9OjDzFosKQ+K5Dx9IvI5xQtY8QGelah5j1bmqvGcLhR/1S0B44C/iyU0kRvhl8scd6supscWVC+qFqI4laSpxXCkKVF6jFjCfwUNRdBFfrnqyR9WFLcAkQZG3PrBDxNXEiY5wudxBHJJDyLjf6KjW2cOov+/8aQV6xXFA+kvZEBnOaHxknLZoPbJrd77brCkUe8myQ7Yy5EuQaXFCLnxYFkUQZznWHI2sJQ/3lZ4NCs3Fu/hFD7DG38JiN+0iFijtzarCcOwYOBkbKmBOJFputXaUstndnWRvAGH77J9j6r8ysONPvb4HxfdkpnOzNE2KfR+ic+R7jrsq6bSdghZxX+4g/p2eNnL+UhD6Wrfp1v2+wLGx+KJ/M+UEtvWggiYVYDtVYMfLkKMRiALmX0VHQcEYA6HeoiTDJpX2Xm45rOE9X0EXj/ToKLCy++C6gaRWb0mCwc/Lz7uK7RQYQ8okH8aOeFZlmmtFN1LF7cc8lavGhXeCaO0upLBjfmP0rpFdYtyOR+l5ySkwqFWtirTTsK42s3qV9yZSWHBS+xf8vzAiCREoQAfKjQA76AOkOx1wCMRMGr5Ri9yue5lh6q5kl5FNjKQ5w1s+Yp4VcjyMPJ4tSM9gbUSrX84ehWG6vWy2D/H8cTlS8HNm/GIq485k6F8oZIJEKYajtiaSWy2ivw0RWtQ/UHdleZy5Es1TQE2KeUJMHhPfv7igYSwu7565eNMONqVLuyaAxexjOYzo7f9pGcubaCA7+3+PL1bxvkuw01cOj50j3I71yYu+oDi9u/pbIdmhbWYLKVvdiBPx/Tn58wMknxtBXqz0krV9W0RH2iox4YusvDtCmJDmrVse2ueqhQKR+VTUjZuz+xWKqVUeDOnduTMxEoxaRsykY11NZTFM+OlWcU5DRLM+/dg+pTqylERaaGUVLRUQeCeE0pPoSLMWC/T8wluMIVNcKOCjCoMeRoxveyZMc3jddUNJ2Ftiy9BtY70I2oBkLr29QecvqOxhzrxpWcvqHOPXffJuAssLq2ydlDrG890rD98py9TWjvoHRupWzJII6eJTWSLrhPiQRFZAlbg9D2O7WWoJsnSsVnMHpqYKnZzxIT/X4xDk5xOyDKAV253yCqpZE6VHJFJiFJ8LLXLCP/BErJypDAFAcjT7atIOPAgdcY/QHvbX7AiSn2lMzT2PCQN/1sYYjlv9BuzVuGs4b3TkKqU6N58aDP/zB22A/S3dRrL25ub7vqZUA973Ega8EaGrVw9SoUxuI6858GoIeJDJUYQgLvsDJyO4SPEd1WGFzOUqCiTVL8dJqNVUD1rfrhkXJf7u6A3D1APU8x0iGGX4BfST8+Ot5mzAS0FJvdAevOC3sehsf3jXuyOZbwCdTaA2+RyPTCROOxSIlbIogKsXkNQwbyh3p9JQS4ga6lHPjOvY+337/W9UGNIi0ErC4ZLrcv18UnkzJvOAXfO3MrTqhWzEE6dbOC7eVZPruzAEgiQz8mf7W8oiNKu2z6gUb6V11iMszpb6wPYVPcOWzchbRP+wrRyQMJmYXuTy4ADBFy57Es/3gIDz5DK7TXycqEJGgiCEC2bX6BSuqDSrD3wFX4OaU1KyO8GmbqqsGc7MVqpqIOMtp9bURZ1EN6koQbwP689C0YtO3Fp209yIBUbSRsXXRqGlNqGSJ5JHDfm/uusUnYdDeiHPd2qf6X+2638VGHD8zuAC5TpMjN3O+POxcGkb0fLeK+H0YMA/TaVPGWLJGXitmAQtEF7xAxMx71APpe24sn2AKF7hqPjHzRM1QgkJsRBGLJniu+O06I+k7w04CuQheb04EPow4EAw/wmai25lsI7frjRbhNlg5zGPu8vRgADrfEseYd1q/f+zHmLY+Fs+7itzw2AB5GaI2D2asNUe1dqM4qH9JRF8pzBsk+9Qu1GWxtTU7emzUFR71q1ksTVkC+Kk2gbrbuzVopvkbBWjG0dafAfcVby5m3er3qxW4x7/Ivxgxh0N10NlXeGecqwTreQ1ibDAs8dtqFq6wj5E9etauazIYI2kUmDiAOayUDCgY5wApoNpJTrF5qbIEc5oHn3wJwfLQsraJaG1bMhQkHCU3Bsd9O+u27uIdo+AH3uv4bQFp3S55a+F1KbErXl9Uu9YBskInOcgGNXj5Tc2ISaBiEC8fsMfKnQ2n/AxLxQiDYavPaQDWxXWqbuSx4jrqnXmw41lPqH8nJaB7+ZYJn9d09vkK3PvY2p22HxG2y7fxevPHrd/o+Y/qXlyrS/t8ldNbD3DqfwxsPiT/tGnU5mOunkft15mXC86skfp/E4VMWh03iUHfeeupy2AeVYdxMSK2vuGmU/IJCCFR4o3LdEvXkTQYfnYE+tf4s/r2w+h+sbETl1oy+prW9yPC1nkCTDQlUUUB9XL0ZvWv9MTqfY0L49trpeaL9922ouT8VdETv+CL8QCMIYPDQfLRW10I717KAfFqyl6nv/T87PNUIQwS0zBIR9YcWkxvwQYFRocY1QD+YcBa3fxdhq6lOwskxqT3kSeEvXcgIzJi8LvI3fvMk7EEO8iUwNox2za9w7dFaEptfE2qs66QOEiQa6VMTSVkMDnYv595n/DlSvirxfDlwoInX7H6PumMhF+2dV9ngj/qmHc5qe4JSlLZl6HyfqlepP1AvFP9OQP+nsSq5F9IOclPXUj+KkAKrfDNTyh9b9yY0DfoPuKnvlLO0DUQKzxhgvXmihHWs78ogUUvkxywW1gFd7KFa1h2UNvqhNymkY8/zA+tGeidK54AbNybL6N/KafwTBV1W/A/hFjoefcfxJNyWeNS39gJrfIM4w740Xri9+uU99bgBYDdtoTppaXiJ8N0V7mfhfmoNjOI9T/Nw955dApQ8bD66+hJWTN5clDDSxvWtsRnXrhNxe4Er+ZPw2Avmy/dkVawRxc3+RCN6keXDZj/RDwmrG+3U80N8peMbiaWdHAJYVBu/aGeMxdqT+cib3R9IdFr/3ZSIZ3ks7uTghKbhcn8alc4IM4BqDkae++36hWBPZFXsz6oTLm3PKaOgBrLwqG4e0h8d1lfK4T/oIUX3W4REcJd5utEk9SfHUu4MbeqmwGxdtRIrOrg3Yokv4nAmVVJExGX0EbL5IFmN5J6q5HPyM+BHffPAsCW6xHH/M7mnxvazxbwrlGvXjKra+sZkFosWCpqZ50gPrXcwpbeXD9/pbl2KCgGL5UvolG6K2K9lBjfehw9jZF31T0ehKYAaZs31Uyt6AE5YdS/TcXzmTyoU/OaiVu8gciSyUGi290BUFhgSgTO0uzhMqN+v3PW9MBxTFkhb8lsygyZeN6O5GKO7WWGcqaEUx1NUOkuRI5mDXh3MlTimHxXv+jKNDnTNgGGKPjE504RZUmVa0FiiRW8FFkhpVeA4U6ecvui2jBmyeYVrsKu8FA6K2myhAgXGZ3u52Bvhvz5WC6SPDLP8rcDPXCewFA/tg3/O+370qkc9o/NsZku1pqLkQwb7gnb93zAPhpMP3vuKcbj+85hxjtx733pO1La4h36PRj2Tgp+UdNrG1i5oKxoeyoFyl/xf09NKlKRPssip1/llATTGJGMtl4kBgsoxUcYtgG3xryu0msVPab8mjBiovwoh0MmGOsf7cdU8Lq2NngRfNPxhrXkcyDXZwFhg0oJVMdU0vsC+tWOaB0qXW2fkCIuJe03UkWjWdrQTwHlwLrO0Nzhm4+jpxYhF4Ncz2S9h3YYNMpYb9bqW0kq451qZYbck9a2nLBdeSpKW2JIXfeh9tlqzltH5J6llOvoHK6gR3NOZFw0RDMeHE2obiZT74eejagukKaIg+4OHVjgcsgRjkJzNGGez36t6lbGfZbr7bOlZ5IbImJgngLWs7aMcLSygcI8NyhM7Tna44UM5oxayW7ddwm5E1gTqzHVLbOiMX3GjcNfzIFFRAiz1yfe4JhQW4wyTnaVLZPjuyQD1bf816GkjBqY/4euPCYa8ksvcf6GPolf9i5h267LWwlauYPYBu4NOkvjYoEjD3n7Q8/fv5A7RBAoUDDoaSo70OR5j2ybpbIKS0sOPkL0Lj+06sitLazLDN9y+v0h+r7CelDiK1BOaosGvM+jHyLSpJqq5sJMyHyEaoFaqgogJ+YDLpe9bw5e2V6GX30W1qyGS3qlaJN8liZnFJ/GUdt9ia+DjKqIUb/cFzVOWcFzvGE96MyEcK9CkQqujIK97BRTnHfVhHb0IpMcwWQGUehMeqMYDhalHQ7cWJ2J1YzqlqppevLsz8e85C/hF5pYMgSzxQOeSlI8vw0PwxQtB2TjWZpuOa/e8aUgab/M0G3n7sTq4wQsP8l9MSK8Eqazb5R9NsR36MrT/OfD+wlN/Xmfeg7NVqj4WiyOWwBXViVZoNCGLYfdzFhLeQGoeLfDzrN4bhk2JWHORKE/+jzq9m/S4TB04RKw1nx8TpAQgK7MIWfE1Ok+hS3OqJETy4w9rjixuc2OgQaHgArsiYPOsNAmFlAwJW2ioF8mBIbiwk4KhIHC/UNxN7PsIJaoDSBrJraOvQJGvhAYwcPzjhO90QTkQNqZA1SrPqBOiSmEghR9tEkd3Ye50pIs01dijdZ1HhIDtSzEe8VlpLoI5PhdR2SSNoMWkkZUZtV+NjZKqJ/9yq5t8rBN3BIStqPKD/fiGNXP+4ZPqrXg929WfK8jhqnphfThmX0jI+c+phzB8DSpouBi4hSQyquMT5bfG7vFtZaw2kGK0RTvEc6M6imAQdkMTjxD/sHHDrVxP9O9WCPXTGZcWtXeFte+08a31vMXMkMKs1mEZliYWuoXN8xvX7tZ/e/XcpfXhn29xTy4Co2gNE4V2juF8WZxalZ7PdPe4z1OZEC9lgW6N7nDydx8P9ffyE/Omm+V5rv8Hp0uDb9M2X8559s91gWF+wuVY1H/XBpH4nRLGqsIzvgHS9APkIMaQ80D8nzrFKassdwgRrIQXUGMPSNqpeBSsHWZrT7qOqXTAlQ5PCudl2veOkAmHqP/FNivNiZFab3JYsLU9/V/wAGgupY8LnzIAl+LxbhJ/6rNYEafrsMJinaQ/GqEa5p9M37wkcC1+OoV+ZBUPa33mgP393aRYb5gy98Nn3Setyq378QBBeU/UNyJbmmNGzHdTHvC6MOjAC9vHx9BecA8tO50ABgb/MASRk/3YxputLE1uPP2SM2vxJ5d5cQTS4pBUZwvsuxZNY2wQK0r+eE4QKWFyW74OPBIluGxOTMopjQP152hxIKBAVX2dYPcrwBU0Z8jYsFNZSJNy68pOT+QmlfYJlSynyBTXLAYvkJP06djCzbKMfGjHgbQz4y/MYS19ZUnPB2aNee1zeUs7orn9UOM4Fk1czWkWCciJu5Lyyg/yR3icZ6Jl6DJ5XwBiL9YEnv43i9Mma7uflrpf6px+WUAebZDomE4uMjSavtrp4xTwj3hRdH/s3lxPOAyvdU2AISswAqer0Pc3djPm8epmOV0616umim+y/IXr/DnpZ+9KqBpXOLFsbgr7FzRdv2+TScMHSVBVKYaM/i2emdJSijGpNmsLGHjDMfTthL7psk853XndcHZBcArfCYb8cXZRCF/IzkQ6AvMo4/IMLZrUlJ5JMXs7jyivQ53G3UO39cehDhUMBVBbnFhwAo+qjO8Zxdd2s+GD/EJ5wcfYp1rjUn4MFONPQ5iLH19vCa5gMsH748p+JC0INoaEWMU1ew+oiXqQBcvgSiEYBjlyDqv++wCw/t7evLihV2jSe/reAAG8xd6B10EcxZy3VtDM6xzF9eBm73OvVVwkemPpTf2ZK8SZpm7qB3LQJGjBhG+wppPWrzvvIdHTlp819p8U8u2jesuON9s3tR2iXmncI6dVXnfarlEKZdTEuROcJoVEhKAFpmc9jpYiS4jnNbuFHtwM2yWuTThNHuK+IujiFcI4aK9wG8NtA9IcUhRVdzMokxCr6IneG/w6MHytmwqEVWDNQHV6FID3rBt3IFIc+GIFAOuWpNLW1O5ljnZfrIWV/RQRrT+4JVmjvSN7VSLpaNG8GFkbLlUNtbWTeaXC7+N3/v1GJPyDhhfzD+Rs49GM69v/AbxWlbdG/wtFnrbXte2RFE13RutRcEF9eVbOsodMcuMFsoDfKMFccWBGPoaIr5y8tqV09f4dEC1IJi1bnPNt4V1DWCy7XjYkEBkdoZwx48a1eUJS5x3NlmcHXsQ0hOVGVjdVd481l2ndzfHkOu151oC+L2R0ptIQxxPHEqlCY7RjoGTpHE5fqgyUmJH77Qnqai4bal3QFpcYfFGerGzkh/+zupusJfD1lUaM5TpH9s6DSmHzNhz7p+Q7yC/WCZjHiFIYOnsrcd+NY3w6La2x9zesphn7M/ATzc5NwWwvpLG+a93vryp3ZrMJPI+Nx6MrBy07LJn7hRKjE1laGatlHfURUkySnPpFWGUdYvnvVVP7O8Fn4Y/C5frnwfFcBimdhWF1ORzxgfC0AJAXEsea/NJ5NuW+osEsLzDJUO29sg+XqJHIxVzm1nLf8PqGlbbZPxvsOiSYfJae9zsZDPIOSGvxcOMWrv8hFm7z5Gl7gu5uHkYHHUexI/slzDST/8Uff6X8IsdFYtSNw4ECfAvUdEP9SzZSSyWJcOjCW/wWqPRpXxFAI5E3+JfnJd4XedvYYKBskB3Ry4Lr9qrIrfEQv13Fq0n9oPQitWTtS8zBveopgh4CY3geskJtr0+MlBD+xT/wzrJbhSZkMMu4fChtu51lhBBU/CJMHYl0Kr7SMSXfOCwvGvEcAmLlp/whUi54FmTY8PHHIjlMPTPsJCRqQTxxd+0adRrzUYQNv16aATkVANmmr7xc6Jwu9/9d9/ai6tM4eHe7DBnAePu8337qajVYspDnlphjHSzmRQNh6DMKagS6IhRt7xyX7+fVnr9vbdUoNN7CWPcu8wkIrJghg+lvWgu9YHX1KkKD5IcSSJFseQoLaggqOlATWxreFdzp7ewfrunbw+mvhb0SBHZjnao47e9rdYbNO8pnHFBUtoh1sC+8XP5lqUZmiKNKZDABtLW88Y/Lmd8TcA3vvqmKzPWO2emvR1c0HetmPadQxu3oIZbDpH4ysj1AU7wqWPWeFpNtcjZ/1QxFTrAYUi+Z2COBEAKLUGLWIRHg5vYa+V4owGw49e9EMO5cCdISB5sMKW5zwvBK63gBOkdgwkufBXloDIrk7VOpoerInw7w7OBoEoJrJ7AVKmYV4wdjB3t6bJak5TTHSuaURQoVrOgs46aQzb4zV1QFMEbCFmyC8IIW4WX6PGjZlJ4aN+HqdbEqKAWNW/UxTc7lFvsGeki07T1tjWDQqVr5IwYWmxN0pjcGY6xxRDGumJrmS8Zj4QH1Vv12lq1EbbAcHeXECKy9Q4nd82gBvz/UekaYcCtYHXWBktMqhcYB23NBmyvaPkNYsfFbEFnxImiNZYirYp/hKD/cX4gtJqH1LBkX6Eka/AMQf/DWcy9yP9+3JBhSHllG9bTUAlNtuq2+lzABIQiX21hC0XRla6svWKFIl1TPVtbhH7eh2NaDVFIvFQJWtCGZKx9e4NZHPnHndGqxH6EQLT3o/2G/QMY2mgcHgKG+84ztAm2p22D8ErdYhACsVaDyAxDOJnMAoSTGl71j4sD2Ro6Thw7NUU+m0ldw2pQlsGGs5PmrKE+tNIilIaJQMdVrgogEG6VXasGkchmStmOCKxuVbbxw60+6VYSvu29womEkG8JsWp/IIPTauwbM17vOqk93HZtmtiGnEU7XBNng2CbJyijs4GePAgosk7W2iVbDgOhmhTGsxrKHJSiHNK7rjh+k6UhhWayQLe5CTYD7AlKk2W4TooZV+W08t7VvOpQT9iRQko4Mm04nv6pvzrrjXKVWnZ8Xf4AYZMb0LKU+3I5fQ/uq6unAE/PZBx6eqQnE/IvaSqvJy/r1jRzW4IvaAOtm2pECqbncxuV1dCpPhhbw1laAiWcJFaw12x+sCWo9fRwcyFXndDmJuc3y6cPbWiJlaoMi+ob8Jw8STgyCRw8H0QIhPX4ZkzKaRgDFlUTNdVggJ48QAcaNA19ckWN+X9q4MB73wwcGZOUmZALUlncUKEJ9bps3ywAvTaWRZRFzPR8bZjDYAmb9SNOr/acYQZ0jR2VZlsbXOjJ1+ktixuUu0GBVs7y2/RtjsgIm1FqkSjJzHItVqVbfFK15mXapvJwi9deYtlPofHuqOBaQcpoAk7jylpVUbERTchFJxloN4D1zURYsXZw+NhWz/MNAdYa34CQhqkmx8Qi2t4WA4AI8Fw2Q2KgZWIzt7qF7xpww0QDO+FrxHyVFOf5Yy0Aw6KffEO5wtIfHa3g1SvJ0fFcrrhJlv0B51K+UuRH78eG+S8qFi/nTp+M6P7qQNm7zp6H+wRkM17CWvkl2xJLhLty3XT3/S77tlMWTAlle2Tv2TrJVwI8iT3HvUe8TDZqptQbG4VYy/2ddFiYd62QOv2ZTr65GnliBBSC6EmiJoTB9RjmP3vA+BX8d4FnMsyfPbggC9RB11+mQ0SCRqu1JpPrPM6TD0UaTdP97NgYZNqv5UvAs1zOKzv+he6uWEByPv88XBmvoD4UCP8WDiry0oTJwCHH01ryTEHJWfa1tnjGoiW8AittJVLx67P4k2yzMQz+LMRSbB6tXLyJ16ICDnBMlDy0M8BgN/J+h3I9pD/WFOuIUf6pAio6O8soBCYwUpvrJT9eFkwHFxWWB5cnprTdJvZsnbE+3/i0ljSwMg2MZxabvLLJ2LKZPdJ0EF80HRWRO/Okaawbc7+EGEe1/YCj9Dzt0871rnvb0gjGzSbX/B1lahVfnTchwTj/d25++mobvwnU3JYRLzYIGzzvjuuyF9/9c2TXtOuYrhqSqVHZGy0bMH4ygxU3UZ3gjBI3nVSyur4FuYFiIpIPdaBjil83IGu6W3AoWmkjLJ8/B/l7/vasJYCR2VGzNdkThvylNpqWt7a+N7XX3bPKz/OmLwNNl9pqxGc1EjK58HPL4RshoGhblVYkgSoJkI52VdHMqGFJHYrmAA1OGBLvtXCL06oZEGUi02NiJHIwtsWSRAHBQF5XpbsqFlB7Z0VuxV/40nNIT+bP2BtgvhL2j/cBsARvcMSgCi7A2QPXkOs03yy1EWMjRrVYDM0DTZ5xbPnKiFH+OUpz5cMQi3edtb1my4q6WuAZt2qE7C+jZBd6LZL+PLs7DnVdwUKqYoIRoBAleRzvj+EDXrOnz/Hpk3zmZCjDdtXFDiGwcdkl0+Hdb1Wy6Wb9FjQyCv8WtgzRd2xeWG6Wxvu3i2P1nTuxnbHo1TKgVbkYbtRW791hJuN2u4LJiPqP7+Z4/5Q21cIrpubwexmkpNP32m/eiW7Vd4O9xm3NeIxKPVVVVBB9k63jQQ7WEWfx6fJTPDW0x/d3Au3IQ3Dw9tZQshFhy6oMZzJQMjcZQOsZ5zAuvwHad98d6L/eeTAbKflBctlZ+0DWE0vs/jAD3S6OHbRX51kpN4x7v8gU++nhXSz9yOSOOtg2rzwTbDl7uBI8jvGj35+5ab52dD09xDEcJw9SybeeNly1+kDCCLJmDao/xdJrWRdMeBnrG1YeMj5ZGgWteYb73hZ0YQQW4nna2LgsgvU9JilApZxUsli3gRFwEiNpCDtQ7kBpOvY91QsZ+trP98Egd6loYbcYGK9kfeNLiB8bZWg7ioXk6VeaaPb/gQ5mnmXodplidXUVCR6SE8CYdl1/cqmdhQEAPBVSD4o1SFOevTlRD8cawCetnpQAQUxEdv0hLCHO6wuNv7C7aqZ8fjDr0tpRjL8zun5+44sXeOmU3RalTZ5FubO0rgBMuDa3NaHvT6yd0eG9wufPf5PZaySwnnjGwGCL/V2cfvI4in9IW08sLLdRkxOSo/Ve1GAZ9s2DTjKRh7+r/AxQ6nHU7nIiI0Xsvd9Xfx7oEOPapSba8LkkG1FauirqG5nkQ45C6gLPMsjRZI9xBNtyy1S2EEgrjtupDLV4oZZzKHGAtyu1FugyMgnYUG+Veiv5e7yKEGlX1IZ5+SMbCcrsP+zoNbvmjdguJyNnlwyV/Ve2y7YEX3zGEa1tqV57qbC8lxBVePiwqV1TMda+dogOHFyLnUCOHk7LQFGKVh8nDh5RZLDHXlt5mu9cBW2Li/WZAxC3aKLORn05cas/2WeBdCmzFic/Ew39pS+4J36odhfRtbcSMnXVbFt6BTdmDJgvICp3A8pBLZNQec6Gxv5A6foLzpXgi6FwMmxwuyz/oGZ8LWtbuTCsrdkv/QK+Q1bLe/S5sECcZ5lzeu4EPlUv5MTZz8Tc3dZvGj+q/7LpPse7+ssTrQYQ+mB8PdWrVuFDU1N0YT5TNNPDwqLMQcWRVf2wlmlXjiq2j2ad8L3bQgyT1IFwx/7WZnbd+uXE8Z0pW7Lr3Zdq5Z+XeBpvO/99tbBLto/DEw/pg4/I/Nf8mMwRTmPrqJV2yV3Y1gYsNUGiIyuw+yoy9GFe7RyvG0JSZceLaT0IMyhMZCjzWqPT4nTgWn5vNV5vjIX1iWY42TArZjX5wAtGzqcLG6750acFZdQIgh80JJqBzDC3Jn0613FeQYsHpXXS86BgJ+6AH6V5Ud/VkxkTyy8iVmejYOqfBEbeTk30wq3a1lardbeQ3TwqPQYWGWTrUXrYNbLuNblaVqfZnIh95NltzHFGLbJjKSbRJ1+nNx2gBt8ysHI4DolcvqvD+hMxA17MpwNo5vIvLuBt5Aev2NKh8IfGdoaXklubCfrHmKVqv5miqaYQBRXo9UTCnPLJg6uJGf0Sj4ctjQmPgQvLgVITHdezkBYpQDgi2lfxftreeNAYi8geQ/D3L504FXN/ij5/qkI5/9f4s0ec/SR4/YEM1cZ9EfDJn4au1oXj+rg8LZTlXAl/1ShZRXILLae53LY8kqGTNJOhLMiGpDAMMkWnC5IVHZeuZO4ugTSyFlnmcqwr5mfD52yZffP15BAiuh5d4b+4s5SN3rtUzi7dB3O4d2hTyTRrKh5JQZe+Qc1YkpXC+XKHloKf9RvLzerJicIMqvdOL5wr096p5d2owpgPaGsxUgn0tyzsLsv6UkOu2f3fJixUO+YGutIFDHGkXymE8imTfEV1ZPZqkDOzKXOuD4hh2Q0qh6EHxS5pZOzmjaSZbrluEHCA8rkhaMkzymBYfmKUlVX4mIBvrzGFplm37sQDiKATDrAeHO+uAVaS8D02w/X99LBV2OiAeD9eQfu2CuiAuOedTVFQZBn3ryx79AA6BzWpeQnvkeztrGMlFKvm9MW9mw0ya5bHm8y1HKrva6vIBqbj9SlyHFWOQD8PyR5HA9dzvteagb9ba0vlOE2La/YtY+uwfaQ2MVowTSm/BoS/kWvk9XRBlcn2eBiSMjTCoLEFLBrfmj66DS98r5G6L+lfmQjGU2PK1wc17rWwdN5PIwvA5jkMLbsJRAeXAgPa1d4VXDxafh8ZRgFI75K9O9GtQLXhJrnAGuWvGTfPeVM10vVuXh0UqKm3Y3htD9jOGrFaVI3NyMo0kEQNWZDt2pWsvXfg3WjHTLjhtL34ontuoIX0WJv/BeKVwz8MXnqPbq8e/hxYrL2c1GF4OKpXSs6StneTciDvL4OeemBATSF/5FkhwjPjTgYTtPMA/OzyRHEML12Njt0mtMR1IXUDy2A726y1nE7QsK5xEiDYJQNu2JEvh8RuQ8gSWMbbIIPWDPBFCQv5aY7vep4M9boq/jc+4HGq4ge1LdyhVtwttp5p1AP4VKV2xt8WGLxBe2R3k7/Iaw/FZ2bcmfnBIa2/hF/08ArtgbjzaUgj1M+uFXDLzzKMjxYTsfQkE2TElgUHVsvzEmSGkfmNAKw30HX2qYz4UE9MLOtr+Im31M42Hr98Pt8eWe+mitAc9gpf2n+MP9oaXusk8+Df3jkZgFhqCwQJhRRxFNSC/Ci76eEaD/6QuFaveX7dxx9UMX7gNwdqzdo9NFZrtNRcYuD+A0eEmRXgqkjn8f3HQ2M0ObReZCZ5bKlkn7+WE6OkuWATUlPQ17wzmoh4zqfOeIEEiPwfh5NWzw5XfxvZ4EHJdlLtgdajbLaOXLqiyohFgV9DN/YNjxq/EtQZqRWtTsT98DosldZo6tfFj7JDxHtl7ezFu0Cmkw2sGO8y6VhUO8RJrA7f2r8NrDGspWVLuDnbGX00+sX8XWXv3RiIN37m3/pIsppdz+9LX/pCxA1xiEsblC8RBUrXA6+ug0QGNcfmXoY2H8gi49BRY1O+mzpkomFY6K0/V/W/Hyi43zbuXcv3X1sxt/S8ZqxM943C7OFnnSTp5KV6/A0uwxeo5xR0vWWfMiMlK9MpO8nUVqnKhnsCR7nTMTrdxIaLwwhjqDLk8yximmRBqcXZunIOJCEx7t17hOVtIeb5IlqlBATj7zYyVsWS4ZV9iC0a85WJENqdu1gSRvBlZeEJa1mYHpE0ULifrGRQ0VEMpMIfhM+eTJU+LdYg9p4t9QcVkFaHrMZ1iNroHGdd03RRL/aLpOf7mn8TIPOUUeCUafSDCTMe1MpcbrnaeFWIh/Xx+b2A6B2xJXqLuZzYXFO//zc/cezOgwMTr60z9NDBsUP3Lh0ZO7oEUhsfGz98+/5r4wfWWPn00OTBh1ePTh4ZQjjErPZCspIv041uCS+vBCmvCKPv57Yshpcj7xcOzGL41kqAMg0VBvFy2wa9DDRg7GUg3DIty/XXX3DipAzcThIcRGLUEDeWBoPYLHSph4dXTZdONZ7oE+ujUbQrQ7rzhGG597N70CShDPWWfWTUFGhKA0OTfcoBlnHe5mS1PzmenDxdeJ7bnW9fe/Iq89DMb7A6OQLpw81H0b3+zH/SFaUeNrHRFdM2zY6xXa23VVombFntJMkNn5uxKeClPtH81pit5RnJ6jdWWOcgyBhBpr2n6hdZ5DWCMiMAaygMFB/FYxDTlcMFOeRyWzuQZsEY8rmtl+EjcDjDtUH2COs/WHttYMItiOicoCQ54GyBQTpFRZDvUoX1jaauE85itvGW9GoJJDcFXjLkd8rfJaxgE/l6qcFJpwnSxvox4qTbKkHl1/rTvrMZH9wOfmlz5lzIc9lDVjWGjXeKLQ5aBmJqR9jVZI30J6h1LlinGagPMrK+FbQK9ox0QU6wAFzW2VUZteR0sBBhWn0eUf0wGCe3IroVRrXSUWgb8d+VwZUOnIxlJ0mNdsU2V8knj8C1/Rg6B3A+n7XShPJaiqT23/H2KdawCdLKQCKwwbXo4qnTFy6dPLEA43LIVy9MPFNkTQF+HLTzHNUyQzom7DZayZrMomrdJXqDPh8wIp6NudIGkhjQxUrXPD9A9sUR1kGpun2IuP9ltSiSynqPYaeDoOz30zwXowZHoEtY5r5hP26llkHo895PXHQUkUrJdItl53GgpAbGXVER3MEItQQvmbzjwA1dlxR/6P+gP4nx8vcOqeeEDkR9zGpYBakVWLJDFBdP0cuJyYMsOPHMfjDXeeWrG01zbEPzlfY06emDo8pCliJkHBJ7M/Dr+6EZPmZQplRfceFJeoMzC7nrLFeH8bXTE4jahPTDMBXuyfdPZTheKlgqkNAUKTCAtuJCocnK+TxwazWgBdC2qkzXDdDV7XzzRP/lraYWeuPYwfcPHZPDh945eNgUWr1aKqXFV85KG/ZZGaw9Sx/Jy/JVVqFRJmkD0zTEq6WxagQ1VbeojPLrAuSfR1ntke1XfDvobByU8lXO5ukyOCUEtUDgrPygQorZ5o6hbhRW9b3Oh7h0aTEimSUXDskGKLdxOV66pqhAPX7V2F6NQFlXbhqbpXEtW1cEX2vvehgwuhUCfhx+DmzdUIJyxLlk6cvIbCBkdq4PoWAVDRqXSu6HFIQV8O+LWOFqLLhRzkdXwsT6oAI4PUE5OmIyi3R2YWdZU6foU7VdA+oPGv4wvNZINF6CYfhElLOjLg1TtZnVT9UiWRO5p5UH0oHYzlBOm5/rlJnGDDwX3BBf1ynm69zhq2Hp/cpLF5Djpq1Lk7PCIS2/WxSZmujtxPVw0m8WvQ4yNRqzk1ibbJjGB5VCW2xprhQda3OyjuvYSVMruRIVVGjgqsFqw62HXZuTptSlyKK6+RLUUu+qzQs+bZYZItLsZeAxrxbUrDQjoYjpMA/VbdRFi6j6ZFC8CGlAzeZo1wanat0GAY9qElgv7nwokVDpkkLTwBHDnLoMzxAGsw7es2eoEnGugeeMEri7dNuOg77rmrlxiaV5nmbPmRnQ0dNgqhd0xF3FosFBS788y03mmjjOViK+fFuGann632/zWc8TC1z0hMHNG77WQiOadHbMbjE7OOz8ZNRtu0GeuZueJSiKRdi5UKpp+KhgVxlWKNUSl8/EqPJEleaJIS1JGbbe/3m0ycQ2P0ljtx6Pb3FjPDlck984kimYuoRsRgwIok0mS9eFkpPgd6A0BH27ooEf971IwNHM1zfxrAOuqWlC0CStVew3bAq45OcIJa1wa5YOMUa9VmqjxPrxIUirJzV5B4+CSzeWAjQK5Xl+hEDpTVZxsWJ+ag5ywfXbk6Qoa0PIaEzY7kv8OpHUwZLNZWU72/vNPCSfK2AIC1oRGNWr0KEbqVYxrnehFjCX9sKxBCBCpg/4crwsP5rDzcs1iVBBG7dbyT8DXCfbPQmtrRLZJuzQlVFsNeCWVkttJ45/2WK9yonhBDLjRn3fwLxGcM2VROcpWMoGYCMpqUvoCclWptJxYbRRcliD+KgaQG6s2XatsONcrd/pDILK9bsNR72eUmYgyGRJDhV4r5Ep3X21eDwDKR7L8MH8i1EqnXeS89GPpsb6JjigTcyJr6m0H+ykkzeNp4gbK8a/Dk70uL6O/3YIe1m/ptSrJS5BWVFaLTQztloBJs5XPdjiaXnj4kfJUKbKhz6K1BNeYIhVlLTiImXGvYKAiU+dRiy/5gzek/LpoA+8qE7lOjFezcAf/09gok0mPTRz7tLlSQwvqEnbuBYdM7vn5RO2+qGEdxovbztBTWsJNjL6BPnUXA+d0KGIC1nom+otMGCX4PsOVQfv9JrUblUHwv2oZqkB4aSMjz/vNcgApCSYpdWG5JO6XJRXN6olaABVLte36jXCINPcTY2H1O8IO1A92OWdhcOtZEEE/0sEwMebJypdhCOv7savnoKdoNatmXnCIUZwpsX+XH9i6Rb7o1zTDO9KAyYR4xs8lrZEsOuA7DeEUiY1QVxjK3Rs0Yn5EGxcRnJwI2mdQFOob2G8S32vbSxeuaZX7c58uvTJRC5jDPXT0dzGy+BDetxdOHf37HvH7Qbl3vBBuvNxekvF0DvX8TCvCLXA5rl6/s1IQaPMO0Q8nDDjrHq0BDsty9YjxqOv8QNEjQZvzoDbjxHfngs5bIF8DCAmN1Kqoda5ix6Gb0Fzra16I3l+YaPPVhqXjih/2CRAfnRtbSf9leWdfF1D6iNbUjDVm14js7CbxdRmAbcUeOMVfkLz6UadL8v0dWq2KwY+Mh52gHCsuQxtVKWTxyvoveG4DQO1qoacqTK2g06qk9Q3DLR5bbbOIqUlFaOVwlJtzpRS5vaDlN7LFsdFy5B340CU0BOX4eQ6kr/B6nxtbJOhiG7+XRNu0Mk2oyDH06u3cEOi25HzK/Lx9TuwJvKd6JllYWrtNq6n8F5sekM8v31ham3p3NKnPHy2xJ0dfkFmeufiuaWnM5vnzg6FM1vnj6/LBDaQmGSZoE5h5RX9ZTmOiOkgs03GKEqONX57dpqouVVTRHSgwY7WAYKLbSrE7dooBnfj8lkqE3IyOZQrPD7nUdfc4p9fn1Je+INLnpblvoe4KAoZxytEbwzJXBJnthWeoKDvtVevaC9qO2jbm206Z87UWdgUqHPD8FR6LOBRLtGctjN7gDyS5IXj7Y1uYt56/703X3/n3YR24Vw/HOD3b4FKinNWuYMm8Yl1zSmLRb8ZBjbRxDvXVyvdEZC0kMM9xcESmxftV1KvONPQao8UJt3IX5lpvkt7OZyXdIa/ayC35CIk26++KA2UeWhzyofTnhgvIAVZecVn3pHNRiS18XJk683U/YW9034dLdJZYnmK95jRA1MPFw404Gqtk5EK+0W+KX0ZWd6I5DZRPcnawFSNLh1u8cPXXA0fJ8lVrnryJVLvSIvcs5JUuhMpi6S3zJhcs2Cht/vUq7NTwV1GZITreu0WhMdrapk8g5kJ+3WZ1YjRte6jDzXg7i4KI1AiwlDMGIEP3/FCBagsLzKNri6pL5E6lLnpkLdkaNYpnnpoFzcObSVXiR3EqWJN8tPlhb1xxWbgwHems0sBMQr7vszGXoaWBnN/zzDCd3atzHvlpRJ4PHuew4DK9OfsQGqbx6zBkGXB1qgNBH9YFtpWCIUk8A+OrCalFhIBxZ4UFc57ZjJcjjFQoSr+sLrKgOGoVg1NGUpLV2SqPk75zR00c4rWgnM4RULycBHkxSjUeNTPjA94EQneT600lYqvFS7wF1sbyw44RVRnHUGK7YkQTb2vyidySkvh8FHk2G9gZjca5KCuOBiF3MelPOo+O9rbPXWscwaLRKPUVN+R1OHfmM5pCqLRycfLzA58pxgQRBkmuSCwXZRWuNpOu6Zxm5I0mzgH72ueD1ZqvE99O5QSUr/mgYu+eIswbmtMVfAUwh5CSwYykev547iO/Z1IVI6xJL7pNTYbq6ZO7YZsuS/P1zKrpDb4tLbaeapHzwcNaeWcP8xXBTXETsxmLe5XuyW3scR5p0LQJYixmY3+LrVpnyN6Uy7kxYqa4gYG4zSZO5SNTse/u7/0m/EN3qQUD0KbAO7cFMhYGF8Kynhs6ogMeJ6gC9knV2YEhWZpHsBElQXojkAulnjiPH1vyjBEauzNJu95sJaFSsOUPvlY4UZ73NGhaDxfauKEfhqJWb3B10HtHfzgZkrXIeu92L2z/uGnt2ZCYCVL0yEPPko43AKz63IFn0MxuJOB73RwQwQiF4xwk+ZCcJBxRoLxRftj8eyYwLUpD3zaCMRUAJdDvZxsFEzqriSNpWAgC9dOwmFDdpsSYJBf/96X4Yzr7p0dAm7gn8rGqIb3VYxlK5l2GXDYR7dOcOOmD0rQsGifrTRTcpwbLBrbj9YEkR/2ZJfmM63CnDKpvyQIONGXGadmte8FyFgsKzkXAOscC0EQXtF1NrJxvsReGjhXNT2Zz9r4ptdWeTG6weSXbK4ivljm50vYUNlYPPkBQn17Ug0JY1TTCldtIBGwCQuAURl7kFly4URB58ivXFsesqk/oYoczxZ+vQ6dSbmexFWM2GxyNi5IS4Nsgvjj50ObIB86pARu3bRY21lstI3AN3deUQq2515aQdVSqpXNG1VQXFVF/aKumipH8gEEWJRFlWkTNurokmUzkgzYmrIfuKPcQAYmVWWwHu/ugvWaHjugKDLSZUGkVOWaw9nS2aSPHk27L7pUMASVlBV9usASc1Zw0mPqF3MIuYRgmj5I8eczoJCBlM0DCBL1p5OHD+yC4sEj999zZObYa7RMOnT0wdw7XXxhUqp1qbjeUKxg/B2uHtfp+UVuHtJseHoEcJrC74TCKmlN/IGc8osLjXnyk6kSi9tR75YXr8WxVyNwVTzTynDFH6BYS+CyCEbk4t4vfQXQvbvdAtY+3wXuHL/f05CE64PAzYyf1SqvlqlcLQEuosT1JV8lAN5ey7viEO4MRTnV9qXWIUgFuTxzoXBQ4/eINv36etFDoVcrDergvs2lqYsZIuAcX5i+vIWFLrIvHr9U0j7YqWvDPTteoAh3x4q1sinW0XN+vXaTZU44w0ReuJquZBkefxfxYpzh5/qucwtCRc1f36pTUfORcRMFAe90yMbLl0H4Oe8/iFec9XWnih/+TEy42rtQrOVp2e/irVWuIWjlRnUptFesyAWroDYJBe/1jaYt887SkIc8+EkdG5OcPguraIShDv0VKI/TBDFHvYAmHxX+TBl3kS4Vj9b7+cz/NjFWMKu+0am6JqMvkvrHbW4ZhzgFv0LFBNBDVKhyIiWYBWx7cIP7INPZkGERvYLDaJoGR3Lk+WfXsh1kwi/oMWVAmTq8I9DKfgyGp3dzOE8JOSUSfI25OS/cPCZ/au2LYTAXUopno4vEVIKwM/0IyLq3AUMtQEbsh6Fh3VyDgUyUj0Bxo0EVB1Rj0SdT4TQi6ts3rJMLlflup/PCFGODUPokKpVGOOgBYM2qLk4rc1ZhS1qltLoIepcE3jKgdV7heaDbqEt7ls/BLPtphPKlPVsEfL0b6EK9HxAhLuJToM5OAeND2bxM+HjmACEBu7Ag9BYLEJ8UzTNvRCRAMT3pggMgWzo9y1c0d/j7dJkKZhgKTnzpwamaUN40DcGZE33Rcb/M5DJTZVqhbvlB+K2O127Vuu2gIwQsuxFL3NaqbXhhXXhw4UazVof4NYXcUfRtkek+/2157R+Dmm9a6ni5VGCr4PEyq7h4GoghwNSE6bqHP4g1j2WH/4SgjieCIA9P7AypXIYDb5Vs3/xPf/cfY5oY1snx+5ydDvGw0v7ZGUwasBonx8EGi63OWLs13m1PdrrRIWvYn1gzrJgztUk28wllrATaHaRcE05x5glKzinBz2cFnbtYii9hz1txqlwhxG0T3Rv29QKOrx+KwQE3+s8XbP+oP+CKcNRjeHwrgCgNhQVHjct0eciOVNckEXGEExx3ZwXaYaGzzU23qlERjiY57JXfvxWgOcAEWqtg7yoFnZRXUV87dvTQgcNHZlXSuH4BQAJQa/OOiGSNJHbxLr/EeQS3PmZhfPoqTMqoC2jH+w/FvqlSZSQhcJDaIHZGRm8FKhtthYo0FomeVPN4xUByOu73Q/7YpJjBPdLzr+hgL6u/AZBeEHgiIROoAn4/BVkmMOjjVkyLNpmtY2ho644q9KOg0CKCWrGKaEPNl+I1l/pKAlfpCsHQGl5m600iZTiUrF9Y5oq7cYgrnQJhhbT9J6FsWZQMCdnEsR+PzDQqy7UM3O9tBzctMA7nGrr7sz4PpylfpQsrm4nT9z8QIvenLp1cXecu3f2fXF7eiJ948JGe2tjiL956b1JS6i1Q7Ji2FjXHvFLpQus5SxIj33Tbld2HiIP1RuTpIrO8ceL2bvwWW+WKZ422fy4T7iaMA8kJfulyiYQHvMRKrt5RN798XdYqAImKUM5xCEwE+Rba9vkFgQ1bJkUGxSQMeqm91tvpB9PHCQKSJVQF/Bp5utjg7z4mS5B78tiYD4JD7j148nkP2qTRRXW41Y+vob2xRkxIh/NIwZQSkOcyQ5loRUgljj7eRnSFSBeoKzVPyvZaQKOqae1LF1AGkwKb3J6NfT6bezybyskDPQdbyGvKMu3qaRLfTK4Gnszl/L3NInPkmEFzbBKkRVdslKfiTjsD8KBabfM5nfT1oqCttcg9QKuy6iWlAgslCYRtUEOyb8+adpJRzam6llMCawMD8uFrlO+EFawAxoXZAccxbtYsa620GJzBKB2FQUH1ZRfCLtm3WQVi8HaybxosvyyTbwcUG6KpyLdAUZsLKDZxIq/W7PmkKJrZPbHnIWv7dwpUfzIfb5bkDgYHOF1BiGFV7RJ0WXlnhevFco308vyjrxMtxla/0YW0mfOdNiTpDuul02kV1xkeviEe6jQSck7266EHfRtKKNOOqI4oVaFVzgaOhBae2HOEu1TvJeJi16ATcPnuYmwbv2GAnUglzWhbq3sY4jcMUn392+Tv+bWvl8tiT1upQ3ofPHL4wKGjxwR5gINH+NUME8PqOse2cYHaft8Cvffaux9WTQiBRfbmjXyC8g0MmmTqLS4VTkk1KKNDWmEnlSWtQBDaE1nX2Rt79FL5z4HBK7S8k8v0h6t9DdCdKwGzSqZPQzV4RS+BmM0opbggrQ6Qj2VdmB57NVvLVjhiJIVguC+Wq9jb3qztbREG+TAOAzMGE4Yb43P4kxl8WoT+sM7zV73sM4n2UaGRlsWvT2/P+ir4DvV6+0zdKuujaMZaGx+uqh8Zc065tsJzVAJDLBfjtFFLRykr2UJfLnJbJzI1KhTFkaMQBsJE7SUIGldrIEO7xLUAU2WEAjKSUmm6vJOLJs8rRBuCNeBx/XjSD7j1sOjlg5gaCgrPowzjeZdVn26MJRADTDi19WqkCFtK2gjQMA+XIG9gAKGE6APg7BWgkIH4zCG4+MOM8R5PcpazCysaOuuQY3MiecgBn0cbmMV/wkUkyB9ud5PthGtCXKQdI6iqPEEigT9XG3yv/a6AV3hd7Am+Ll7baCr64bcrhD0LQo5ZaXVKuq2TCiS6yjTODb9j+LAilKBR9wMr6N6eo+HFaxkpHFr6ONeBlRo4w0k9Ep9VWNynGw+2Jw+XOyr4WUcm3lOQ+KOVDxyUMgeiilud7TnGCTVD7GAnjBISGk8RwMwtgeDh4lKxQTe+Btx2TnKjb0XC7990diu7KdXgiIaWhRTMi/IJY2rmhU1DMi0jAgwL7dva3P8gaQgIvAuZlmpNtLaI3FBx06Cm2sMAQhVe3p7TtoyyJFdF4B/OzC4yvoYMuWH4em/hppAamzEapnB90m3dupFpWPu9KYi7JzrAYc9yQvt8AFNbvM8Z9JofLP+6ggTtyZryZuak60dsdsQOh+vKZyw44BqAv9m76KJjs6DKl/N1qEz0KHzGOk0JODjHVYoHuxsu0+ZTseSbhKK0AwwKIEbIE3L2ztLZVt/QUg4vTgtn0YyOvoj72v/mLNQoKO2OEAkac53V/Vw1Ziuv+Y6USM5WspamL9MSVxs6EidOUiBFtP/XgIiH7EvuL+kvhiUeT6ejjGQjwQhXW39x6ND+IeBN91hvb0aL9qoqoEIywiYBdBCQYOSDL2id90IkuCuY45Cl79+kDjfPpMqpM4eWVW2YT0pMzCxJDOVkNpdcmuWZEcMIiFEdVwnMyQWzJCJGHiHko6zAUnHFioarSQmiTFVC6AcJDSvghhZNRb+q2t48lBn9bxtFvJHmrnH5G+Up1kPZ5l27Th+OqLm7cVVUb294z4MxyRZBOCQIllUNG1qN6JbqEi8xpQLUmtgxNhc7xRaI40JPjT4e53D8Rs25IBSZslTv9zNjDODeSOVRwdE5K9wW4ESeHwmCANZiOSRjggkieFIq1Rs0g8YLyj4N4IbrIvH7b3PBBDsoDypdXYqSiE795Vy1Tg3X+5rumfwm/oFLQ6eHwjbbFfuV/4+nmBEG5zK5Kd/v0fS9/3jpdmQVyBFCrLjoo45wkT7xq/TDZ95374Hsag5zPwmdCybr9frk+p7si5dRMzbrZT3G+MP53nyUBDme5wln7+21r3g9Mp9jdjhK0TfenBsP83RemaO5zt5m62JEWd7S6sqN3E1ILiVaWUvuU8i/eyd+cTQuwo1b4MLahvewjxKnofdd4Ht7aVvbpoX7yYvTDxgeWCQn2mRJUp6RjiwsWZKX8vXjD6cCMsHMCCOAAp/GSDizGCHCGfBDc0AaExIQA4ynDA9dTtjNEB5jhBOfQDEQoCCSKJbxLI+DeL6c0+GLllcjMvgXlUYZpt1p9omuCr21K5cili8qbkxeUlOfTb4l1Y1Mtaa8YlHRhbGmMTkMT+ysrKR0KG22ePtyK929e57JSDJf0hBBxI8IAssUU4TMVGMR1hkjeITor+g9W2gGpjmzBEK51DVa0169d02+NT2kgOEo1kgQEbDwFMXzGJKyHSQ6qwBFzE1/E6L9xjGfYfnIj3gJRz4WIhBIJvFC3y56LJlE46/5w3n7T6pNKmixRCVQDuikEl6hpiq90sRokh98v2Amwk3SzkNSe81tNSKtZ8QIA5CAZJDcMTwXejkbQHs90WteZgktyiFU19Njr+vteYwfpA6bHQ7RbRZEFQ8P/aG6emrfvqkgav4pC8bHU9z4HdXhgYEw9Ed9DjIIFXKvWARDUnmN5YLG9rVYXtLY5ggcElpdjbCM7b+nd+0+he5zeZ2nt7Scv6rbsv48VAGIoJTigEM4yGMBo4mTvaxQiRcE0AY1xjD2yL60mawuSplpr4mQ0jLb4ftzGYDtZ0L4etbc3KpEKmRhpLRh2GI78/w8zzsZ2zTFDjF5w0Fh/35aU7NhUUZC8pjX9vdI5GghzglgiSgKXIborBUdZzu+BrKCSzxUA8IdM0NVvb10Kv6q6diWjo6nauxy3+4o+JdLytfeMXEJFdttS9u/pI2xwYlLOz4H89ae9Wgfl2C60+X6+2DpE5UNZ89lXcENdIFxWphWi+Q2mT9mI6iTjGVUHF3yHiXDJMkgUsoCVINund8cfcjwm4zDvzls+GVGz882GAcSdF3fLEncWbLkbUMPs8Ldx4D3lAohAiXKwcDB1m31Svp4Qdu3s31DjkSfLw4S3kJPLzj3ebog4X3tfMxDzXQotcgkN1YI0y1NfcFL5Gwa45Vhrv352NycUKfxZLdeY2OesAUdScZWFxtWOZKF5XFnwSZfQbZrqY2iZ9thoCU53HiIgUVDwfe2IeIhIWIDFQI9ERQ4eQiGle0rYBGh7HszlARTCASk8zadPIMMbT/2uYBSixTtPiud05U2gSOiogH//PkJGN06s/No+DYHQTDOIBCk3M5x8jzVfMBtV+jIXvX9gKbo1VQI9JViiApzVTzUuLaL/dPv93V4geNwhg80GD0g5NakqG3l54YCgbdzMIGiC8Gin+/230Ys9Xmb8D8U/L1suNrHWaDc7Dd7AF0mU82ZIC2G+qBEoXzvT5p7GDem2K06HgTcYj7BJkKJNlmP07V6U+GvzPmSnq1X1+vzpCodl6hJsMnOBI36joIIcnrcdBOYw2orZjFkglvbnebMcKZ1Z7hjp9gkdqyvLYPIJMOcapbENHOvrHWaHVoKlDkS71l2aimzCYIJLisdRlDyI38QksqopFLVXmk63/SmJDNjjF8wsvwYmsIUh/YxKVFEwb05gkUCHDpc17mPlzlsMi23O8aayDsFc+TDpUQb/dkeN+ZGtXxpRI1kJPHKL8hpfnAs2R5Vxv2MhxFg9duRfxb/LgJjJAELUJFQ+nzdXQpnRSyiiMw6MiIY1gE/5oSDo/rpUV7lUVFMZcgxmOKiM9Hmqjnyqg4jX965vzka/xfplkn3v3Bz9EJbuOI7/GR1hnli3bs3H9rcePjNzRhlVH/zZM53GVThP9DLkQi3DAiDKGhE2CfUS2AvZzhLHRluA7PjmKyXkWPI94QTRfNnB4ToTgzqXnqQp+UAg2DqUXMyJ51xATSNAgRPY4lm76X4pn1SAIRtet/gd4x2EjDXXmUi5dDTCKRSF7S3nufleUmNawboFSW/a5le1i/r6tDpWU7/yHZb4LJO3grRP3CCF0XIL6iqLkvdvDm17N+LmxEuBCbuXY+SbqnD6Rkhu3E6Rjzn5QA9xhjxCCMyGfS7URQtRkhBdFgoGfkjQegSJnkCa65QLVWCROUg8OuxU2xHOusLBn1sumN1ZEt+Xel5uKird1ksGcsQVoDY0pvVSaOPjhMVscG1vcdgTK9F+Zw3E6t14CkYRI//8EMYQo9DuetSuZ0eSQrveXBIis6vC0M18DSEAwGvdyv2+/HWffuAN7RZUZUKIDDMm/cmerG3F0qqZBl+1ARQyCdiCfuxG0PSeH0HP+Z5+cVFgLWRp9ioEMSUdYr1qHJBmefxzQqaFQdA+rT6LBvHpOmP/KVwapvtgDB+h/1YwJCInLlRztbRmdnRl8OKMv6y0hMxt7RsiPTHBMdXLLml0WgcHIcxqwSDxoCB9NQQ5Na4oSaGS3J63ynrWPrFwr4Lpt61VYA/MX3MNlYjAthhKtIeMXXRgP/x8CCx19hBO8Ecu4i8VTVzPH9bdcLsNDjyPQOjyOsFr9RRDmRbUrh43fAwYcTN42N/2NbX9zTWbFDI/2q30bF/VGbZM8cya7PSu76mFCHI6VGSmauyq3IRQ0j8zPiJnHjMcCJtfCYIT/LMSQYzYwxRFKLyqLBtqfpfidXumhpaZ/9hzdC4UFZiK+B063Xxydtj++Uvo/tTv7LUqH6SLxUEy7JcW+PaRKkmAlcSpsgjifFNrzfSZTfh2rOff1lzSMtQZzOKaGTl8G7vGPKSFBmvJY44uXfP1PCFmNA2/u7Qlvv+2v6KGVhvE9jQdunGjUsjY29WFEqBvfDX5o0HBlXU9vbSidNRy5gxZgH0M/Xyk7ZpJKcucuk8PyUmuthp4aY2pFvfHJ+h49l+1ZKqbduqFv//kZ5gblNT3FfaYLYO0rHjtFXyie+NloOVocPUoftrSKm5YLqgUQ79FW0DKyv1pZV6JTwYsAfy3WZL0uCzKE+vyNTrhaq0z/XXX8jffwPPbQUFwnmbbU23C3N9XvNhqVW2/6vJ9ReuZ5tfpeklDy0+lA6sG/GObJth17gw5zr4A6neTU5loLBryUx46NQqgjZu59iRqTuRjsiMN28IHQkyHkZmTjIhUDIBuHZe8Ag1woyygwmpi8wTzpfL2Jlcn/Q5GJ80Y59AWt43AmhTSD9lYwMcz13kLX4LtVy0zGHLVIRLsPjnW2tq2GdbrlnuUVTQVrMcn+8+j5fD2qBzU44YXqwIC5gQsumKfXm+earG5isvUHQIVDCRwzgoBDHmAuHHFjQ4G+p5Wz1vq5KHCq1fHKtduhjtjAtwnXGh3I1xP/mz5BE5qmkqtmrOXcAUBOOE0EbwMcHMjBmhqdLSFbVpqVVVg+695OOma4BX2GepfR82iIJsc/5AQjm9zVeIDRrH8JCms4s1h6NfUEYiRVBI5droYU2xDgjA4waFQEIe3PC8R0YijSU/DEti7GEUrQiCGIqfIUSEec4kmyTiq1UMvvj7WKzK+l2meUmBrnFi5ULnwmDhI2sO/vOOsu/9zY+T5oVp552O8+dBNBUFogSji7qC8ymfriBNNIfi7YnIzkni208wJFOqYVUwcGCD/RJA/nfxzL01f3v5ZTr28E6VQ6pQyl/hnaz0zsFBHVlXlBwt3DXApPafFMjADNjh4TNn9u0bhW4Zrxdcn7aDB9vWWNraLBdGrlwZqXzg1KkHPk+hhWOFNEVN4YLXp3KpkV8cOtSm0/t1SySlLfK4oUmXoNPmJqjtfl/Y7kbuttWO93ezCzXFKe3r4/Q11hpLOxHjDo+Y4w4jQFdtzHVFijs3LYt43q2Ae124vx9kC5wJRPJLgkk2gXaYYn7ysWVFnRspnb0O5G2gALoQ/I14MAWlx85pTRHTfcwjNA3RxJMWP/+GY8oC6VzlWPExZWqm+RKFtm2gbKcv/KvwRcPThr5ywvPQI+14fTp3ZOtI7vQrm9d3AqPVWgOQH1KdCJDfUidjTvZGIslLZRnJcvnLUvRFVkf0WEhHzEhIR0pK1c/LggAZwzSQ2XTSi9FbNRD47ZRCiKfl9fGn/GRK+OckqB5/x58STkHwQRg91M57y9ljbBnrL/+/Ygu/hpXZ+bkHUGyWOTwUQESCkFWana33zRvtjrnFrYw5Vem5CTCLCsxQ0nnvXgcWsAM9+VxSHHpfXOjTVyoWQhDQy85GYsOWbfS1jXAtb0IwQU79yYNnqe0TNYhbzeu89ou7d98doCn6+UdbniC0OB4ifFwXyOJ5POemkeHicMCTeiUZbI1Le471+qjOodFoHrlgOJl3EnL6P0/5hpMXhcCc18sMqH8KRvtL1f9kmH++mRDICYgLcUh4QVpmV0nx0ElGgIDSStu3/oD+aIA3C/ubmvqJijBEJd26fVsDiWsGia/sPN/vvEcXBM1AMJheMb0bTkAFYERgrFfGsncWCxjuwuHg6P5hH3JPgziBijdTwU8BVf4oQa/s+30qLpw4yn4uzseBiVarzvfXWOSRkuHJmtM0oX1csslJDJ11LtbOcK6MvFYSpInPG3JWpXz64oZqIQ59aA36ZAvW1HhyVSAfxEFhaRgrUoBY1awaViEUBQDTzbabJsEoZPSX9WekWJeEKIqKfW0QslMO11IHR1PW0dk4Pb228QdL4uaaL3VwzV7SQIAiQkgSH+cQUklgNa7qEApBsNsS22Smo3HHqVavzgb6nSRZnSiTjZaXVbGdGmjV1BC37pMP06EHWEuC5MCsSXwqWszzoCEub2U0UhpyIkVLiZF/pii6BINRyRRhNKvOhJdCeAphQlVi5J9ECWVraL1RwRIkQZMgCC/ssCIK+wIBsHJQI0oQy9PhHEvE5o35FlPvvJ79JsuH7RS6JRJ8wx6iqdEtqOJWWX4oapyedjb+E0YXF+1gC3ewRdLwgG7qbU58R77FG90ScIYn4yJO4Fzi4DM6aAEmdV6w6Fe5G88lP7jKo4oTPndFicX8qB9WlDgkrHYSFeKtcPtW+DavMdqVRWJOMsUFEmuCW7KkguKzdpdhjHH7Q7zbsynOIY4BQwhMTi0hVB1EZqmCKE8Z0aP0IZ9MMAFz5sHm5tVO5Cwcah4qjMcUBcennVvS508ntyCigEF2O9yy3OGXg6MNbh9yUzCHaG8vJTxQPr6flIRCR9KwV8LFOJ8Ie/XFb6ZCiCJtchWjefyvTg9jthfsPRCRqIMwalLEvdXhNi1sHg6TWJb5nml9j+SoA+x2bHidqMd67OKKMNRUMDGuoAKBAmPdobmYhKnmMJzl9E6Wu2ucU+5zAMrll112QggtIMolNVwnsjNkWG5DQ3hqx87wB4X2HLvBrrJLzyvTVLC3uCypFJp+TMZyk10uoiLHj9l61/ayXyQ6ndtdDseRqIBDdVyFuVK5ohrHHchhHIcRo8qTD6agrOTnGdXzyeWfOhUTykIpB5NziwsPHt48lDFHMjKvXJ4b+erf1rzq3May5XmLlpctP2vgp/DoY+GdA5fCpjdnQWNIuPWfbKlaq7NyRRXviFE94N8QMHACN+/DMp5Xmp1kqtKcXzFvJqGkN6GvbGlVzMlk+MDpjemg0FXtbn75j00VcvXWB1K33pSQNKyllch9Nf0BfkVs4xq5asvWZrA3180fCFs3BCAh7u5a9dO6GnkZ21KNBW1LM+rCeRzjq8pupk1N9MD+pvN6h7pBrZ8YnCxFR5pELRVRjfrVV9claLWGBOCZlg6u90yKg77dN1IRdHAjN1ySYytaDBrVLQ7lHRPo84NGuUhAEB0/gfexLW69tW4rjWCfwB1/8cOsBOsx6fen1lNSkmpIZhLrjYXGLcbQiQ8/O7w+pmx4TafutH+YfXHLlq4cpLPwRRbIUDpe1BloFGfHJwa9Ymj4THjlyjCMKbiNe+yxQEztuJu93YnjwipokcPvWlnxtZ7P11Qu7CloayAEdrdJPwl3sNEWQKwxztk8D9Taa3kROALTe+579+20teSFHxxKRHQvIlzM+0jQwRhjoQIjbMoEWuZeEFS+RkQ/GGshq0ZfsNsq7FC7i20YGG6OJlobNqyyCELLdg3qqA3LNLuf02L3SNKUERHL1QQha3N4i/aHq2t+8wE8XDtY73p/EJqX3VQBgUbJqBiInWIH2ZfYMnvGx11js+h2iMOEmFKHjIGEZ5WMvMDVhuaROgDCwkevkQnTUeADqOXMe+KGFhMyDfT0/HM0/HPTgQX5L3A4Bym8BgqevHFjWs3CLH62KjaKyY+Zeq8vXEgz/nlLTxe2/0fh7Aj/1NlUuXtozMHaPoUMxn4JJGVdDRakSYqo9DOnCoZOTsIrrSBTTZGgBowe5u9ZBsP0pZKIvgPcss70/jE6vXMZM8L4qBPZiNS3q8HF0VE0OntHJd+1B/mkW5h0kkOyyoaSdd3rVh6MCeGDyd8Po3Fok7953dDQutG9iRrEFHDBaEo1cX4kkjwSO0X36KI6nndcpVkY38WGUIhXgI20ELgxlKTKj6I5kNKEMK0iviE+1JLNJ48ZGUk8YiUgxC98J8T9NtLcfKP3mePRW/U2h0t84mTG2PFjI9oxRRlLWDy477gn01MSvjY89NVXQ8ORMJTfcy1qXIPrWtLxbkWRiBdOgdrd7l/U8WVBlTVO7OneJTHhCVnEcGdNF2AFCexEppJoj2EUI6sl8IXQQFI1dMZqLdGmLVy/0Fqc6S2PQiKmiAb4+CT9CMgE4aayc37kh+ZuaAiUSrplSaUyMK187Trf0Nbx8X3dHc3rzp0Dcs8fSafFScitSLWu+D3ZXvHeioOPlFrfiXmnNf3RwRXvVdjPlwmjp/cXoow/D+pgXWeRrGmWGxwZTjAaRsX4ETDo/Jhcllfgy80td/6RxLkyMl2zofebr983sbkETiOMeKtABd6n6iao0xj4HQUWiMCKf/m5qhcyU/yF/pTMF6q4+CaYXshQXyy4qM58zMRRbCVWgimHWAi8FSR23Jglst3gSHg16DUR0z0k2WUKm9Y4tir8Ll6/i1/lbIaj/heHDraXr9oab+8vXlds7+l5oqfHvrRoLeTYvZ1vy0XTtpPLtWQMKMmwypan4gwnIeSI4NfuGwrzs6UR+XySUV8UCZFkhNk3mkwaOy66xP/q3ErTnbY7ppXnaP91dsGO84cP07GTzc3U/Ae91fJA7409lx0qmz4e7L9x/eP2p8bGqE03mLw843yHYx/B3PKCQ2DlXtgxjPGg0Yd6uAIWSzxHp80V6W7uh7gpdIo9JRpjVy0PTAHE97iD/7Qip36jQdT74BgihjksjF2coX4xVB9oRMzKo7+LEbEhOC/WoNsesPVvg+2AtKIxlOpMy1k92kreAw9IHNRd21TiEaNA+cPSu7Z9mmWlNQcqCsksM1dsnjQR9THyN0NPsV9HsPQhlki+s41o+KC0ug+oR0jHMzAZG3CjR21CO5IpNyaw8g6kzA9eO/7gCSc8KEl/49BD2/bEE+UpkI3DzbZYovdtiSp9IZ2D6DKdCuURPNy0ZJ3RPaCdmaJ/FKoK36dIc/rSJInaVKaD2Lqp6XafWFpKYU1AXlT5vu6VNN1BYYmdLRDbav3sLvjmOJVxLvva6YjOeBwboWFvQ7RJ9iWIdDcNVT7H2CaPmiirzrJs0cuy2Y6mEi0O7tMQ1DppsFVYqzbb3W2xrNHUjegTe7IbeE9t/UAd4sZnu4xZrbw5LXuoH1M07GRsCy2O328V9WCeIQ/hFLg5KavfU7C+KE/Tjki7t9Ry7Q6GNXyPwiI8Ynbg2/FJnCyuLGJ02L8F4W/0Lv4LoGDnzKaDrQebHsMz5nbvjQKeRTUzSdoPtU/h+/S0fICEE9s0JVO3EseO2BOTfJs2oUVE4pYjR0BKpRQlXlFAg9r9EC/nabnpurP5YMmg/GhHR9dWzcaOHgG/Z80a7QKYu3nRIl93Sez9ZCZrz+bmYs+Ems6dT7PeOJW7BZyS/oR9+VgHFrdunyeuw7QySCmIEVu00nOGsDOq2too5j1pQCD21N4o1uZX6weueNURcW/+kiDoJnB4zpmCUamqA4866uijDlQAwAedQxJSFXKhk688gONQDQZb77DtDpAH50+9QDECY22mnsiQk3w3G3/mZmyG6NJ6Let4iBuaodkQkLmqZkgfhLJ4W1rsLoEGjgRljgJDqXDb55EFTsMokEkVsAXpZtGwB1a5ykJjUFpkVdHtJ71bAjVa24Yqh6VP8VVIC2LRK8C06tKUFZuuRrcAkIDjJ3zX8ulsRaHl11e/vuzxgVvpKiZeLVMwUDrQdnQswZIOO7ovW4/oef/mvt4G3gOCtldcftl0uQoBhA821WL007v9evboig56JK9+Jn2exhTmOP8rEBntb3DpzoEhXBxNnQ+O1i8yU33UGMdhztYcsCupYORZGjZapwKP+nyYFvReKKpqWyQEtKROSQA6fT+7VGZZnpf8UXSUefl913EZb4jSw8QWa6pVtenJX5RZdqx4Y6ioJO+V/JjQv49nG6ISoral5v94O8n8l9tGcCBgQaE84QkXREFwWkCCMsnzPM8JSHAZZ25wvukiIkmgqzwGY0XByzjwmAxEJCS0VVqYf6xsJb2rX9Q3UxeKV+b/wdHQklZRX/9rfUowElKfkqU/dNBt4DwWKIjXB/50bVXG+rwdzrnc+kB2XcDQNdeyrR5HKPSeNt637SaEZfnlmKBw4Uz4o8qi8MzNByXEITHghiIRZRHKsznOUN51y/V6bJq3EAsuhnBItr/hbZOI5bigqOHcd189HVdVL05Z0645nJH0vLQoFaWdQ6vR+9UZq9rYx3ISmjLNK1FhdSK2etC2dkVgxA1CjlpUAqbdtzlmTOxjRhjON/sYRbp9guTKjefc824AjQUabLaA71RwGY3wfAFhviW4sLPgYiygJTgO0WjkrnPgWfn5zOkFB4+qgaJZkvgOmz+6ST82C/qy5LIbdZOs587nnR+2z+1FNVbwM4G7vTmtgokzxeFYwISgEOKDeBRDfqyQK4aMlahy3w3u9xzYiGQkwbQGIOYjM2tln+Wq7EzuBc09U0BzGr8Yy8aeh06amTGf6aYsF3XX8LXlsL/vQ88jU8TEsu9JllY7/m53Li0q2+iECVxZ3eJ1qtyM71x6IXST+6jKZ0ugxx4LD+ycCjMN8c8WiBwRCCeKz08Geg6Z/OIpN5KSZF0y+dOVqrSuIScHNc9k5fVIVIGWaPXx8TU1yzOfv7d96QMhLIjJJ1B46+Wk+JuVmX3QRE500dPECcID3kJiFBrEea+uIzKz2MITmdyFITD115y+BoW9wqAQJMqqKmQKRJqUV0tfTdH0UcOY4aTZkrU9Qnqg8mUSirZyAFj8TGqzZWRkC27evasJW1oFCzZFTFhLtByVtLoOmeP9t+D9ipXIm/h0JTE0bNnc9bdc4suGgNsBHgy+vbcPjbr6EJJDkqIz6eqbYCk74bOUXQSendh3DRJvViGEX+JEE5lIQTfqSiLhiGR1C27FKOIJs+IQJFiJzjkOAeMt1SBwPkiDkxlyGBRFKxE1MMWhFtEvxNO7djeNlsTrJ9hZBIDo5zbyaNM6KnS1MvaxZD2mJs5NQOjyuhoJppj1LQz1Y4DKZ2U8TAiCcOWBA0P1WDRVWBp6YMyG6zHw2oFVFx14rZPXqNjZ+Ai0AZCwJsyEyh8G0Tyh1jmM8ASEriti5IsjeBeG+ikA8r7VRtO2vLKtMQeQlHRgHsn5yue/9mopWgrzZIiHYc2ma5xAUq0ZIvtsTNDKCiyoE+0chRuAQ3b1Zc0L8yyhxaBEC+ap+XpHPJvdkGyRCRCeZZUsSuAFfQ1wjqkkUsPvH+LlydEqoUvQE4HYC7gCA/+qtVWjMBfxZ3i8sCqJaolWgNlD1v6t07iFF1hUg2c1dzUiBP/VIECQcnRBmoWBmFGyi7Y/5M/7xz+S65qbEWYoc6BOJ+k55wdV6dQGtod16zGCH2O1eIggE5A38yDBZNkjMLCr3gY/9jEu3h2/7GE49YhlRqDlgyUft/zYi/9MGIxebDG+418gsSZy+85n1qcQCLNrlwPewIvrt0dn+S55qw4AeIKJYqeSCCKIjwJBHmFFZ7XaCimOzoXo9ynZBtkukJ8CKUfbIv+jRY3Kk+dR8SPOduNZYfJeAYBEgjio8qjIxAWTYrpripiu2xm7ym6w998xnMw7rmKO5xXXJPcnlyT3Jf86mfieQjIQglEOvIWfKpqiSdReIGXk/WNYT2cp2QYeJjYjP0PGqgt/1EQ0oxDwlR6ILLPZumtty257f8RWa/LbSfAEGWdgNlwef0vKzV/7sno/ZSO3/HVmlqMEgInbXcW3E1uVOhHC2wokE4SflQpsXJfHjWFSPWCX5MM+8OgnftesJqxvWLMsiuVlXe9ap1md72//3ApWRlaEKyoiycgspSIr0uMBqSS5H2K9ONgqCui/bC5TY9L/pNnKkr7GJ3g9H7iaicSPV963hE8tWy+JhHnLg3mhpIoMjVSf/UpLOiW4/Tufz0ftIrVYjrz7XmIBai8/ZfKtmrLb59WmujsLrM27djf9fPt2C7IIrYOIZNv29BlJ17x04Ot9tXUJQWlt9TK9VsqjyZYiiV1Cd+/jyO2okuZ8JDY2EYauUXXJtbB5UxyXM+wEt9lxJw1JVkMerBDsUIEkKZ770jNWNaW6pJpR/d/VhVa5wPotkOyNj4tEoqGFu9Yqxq8cuZkjXuhINxcX53PLHiHraRXikXgOEkvW7Jq0V8Yy+hYhGeFUguTcuGaiav79PdGOaFzG3wdQQCLx9WXQXnAXKZBdjdQbZ7ZmSq41NzH65jQA4KX2ktQQVcZwh79GcKETi2hNx8Wm5ig6+69jlohdKJzS6hbztQm8n6umMvSfvAzHNr/8TRwSsl13x/RUuHQykSP/5lRHpVsCeunhbWje2YbYxOFeJfZ+PpneBFZdw17omNt2Sx9lS2O2M/qySeb/F4ccVYD6nAnnkgARQn7jVHwSsuQXNRu50AP4TXgcca1ssXpbyX89c8IwejDIL6hwOcwb6Ld56ltsA+ZoeiUaS6F9Ftle/n/c1K17OSb+H+BD23Jcm+FPVSktu58AENP+hLL9H1jrT3yi8IlE/zsfoHaDihW2YsPAaM/dzHr3LrPY2uaue0BkdQ3feDBUaiuyfWu8mWH3CtBsytjKeSBdEoemHsMMVsTlirq1ijKjSlg4pGdyl8wyl7X0OC6CLlbKY7RoxR6jBCbRqdWnw3EIu8a7a0amTNhWHs5SL7MnBCWFNvJOm83wwaqh/61A4TPyue0zobLnqKJgEYmYW2w+SA0jnXvMoM34QJBZXR7DyfdIDkmhiY+GImw7XGvgYxHCRtNPNPITNeUEVeT0gJJgjT6IIp1ZlhkDghY7QDDPf11KCJ5Fy/Is+Zaf91aHF2oCCV2Obv69FebeSt4KBlEbezoBauUhVWhZ947WqRVmvTBD2pSFJllQTWXTttUH432jaXdPnemOKT9RlMD9lVIAJbpn33TYDn6/x+9f903EX13tCYff+W1f32/fCYc91dVERYCUkBzitEtiRUyscpJcVu20IK4eDCKfUAvPTGr1kItvWrK8aWnxnrqeA6zeU7ylqN5Y+AueedQDiCmixtkXAXmMOFHb17SqFqyUF+JX+NA3HwTb4ZrzF1aHUMhoVFyICHnXYHPHKiDPAwR686TKPEVMdV3I8xfO8rbgmpQ2dBv2/Ze1d36185lXqjM2iWgCX1eFkMcgtrwE9pk8iElTTLkPHERB/KxEA1FDoWFj6I/DIFgom5EeDUasx7dFlxoZjWpF79ZP7qIWkTy3HvI26piZA78IMLYwJwnO9ejfRKvqoatuIV8yqIiJj9F39eBBGRlWiSC9IZnjBIx4nG1CZo0Vn8GgoWlyzF5LI8+2UOErxyQw5ZNSkPoORmj+MJeLpH+dsdzoAaa34bnk/kaksT/5OUNa6hONXPi51/NsdzM7qsz8VoWJlrHjxsxDgYczN7bQ4Vbw+IiZl6D5EhrP5vyJjKC6OfkhYtkeGuM/B0DEJTToYoeIkoSZPIkDWxYTTJD5rVmfoE0YnNhIiC1SJQXLVqWU7QvEstvZc7vc8XSoOopEGfVXgYNodluiiCwjAe/AaJBUCElrgwkCI9DgbXMciNFIqOwa7RFPCZKhqoFEatDmNwSBmPaQB1UNDW2x/Bxofrxtozn+hE0+7KjKng7VkIoq8RCdkjH9KQjhEXwmC+kilEVi5Q3OzZhjWW+eOOetaaDG/6h8spf28FLvpA8uWJ53a8yeY+R9QS51ueVEqc2E+/7vfiW3ZUVhPDo4pzjZ3dDyO7ZgInujrReEHRAFXt/+wGBACQXaJaVVNNc0LywtGKaY/3j8PzLuFP7jAfHdddj4Qe49vTNZrvDui6G1D3T9Ohy3PBl2/iMW7c7ohR+4MzvqZ57AxYYbuq5TyT0t+oePnurS3TAU46xFOjQ9jXIXKQNC+Uvt2rTsb36FRlfGg6hlJD8vh1F8pcg6H/4dQZZbmKvPPCLyW+f6gqdecbDAyAimj12RtrbBFjDO2+aNtgAO8gHiVaYZwMSMjhaHyOTH3nVNtLWt8aFprsklAoUtEXzrV5K1pHVKk4hpzKwUQiGpblhJ1ZnugTOjfwSoiOZ6hD4on2m+PaxYTw7BiCYqGPPRzRoyXvrzAzh74SMeHuMfqDB4uBc0ZYBFszBzBU+5twFNnbREK+MxgHO6yCnHlEMwSp8uIglo0Nm7u6XEn5I+fJ9SB+NhHJTPznmg8/EFcVw3ZQiC5wF2lB/z68iMys/+qUGnll2xZat5xb4zZ+obFNfg/UpiOvZ+741RDAnaBKPSFQNjFgV3p8sZl4JTC0x6lAa6mkOcsYs4Apda5Z8w6vwvWmObFafaGAqmUBwPyA97xiJE7ZJj12/kdptgCPv8lhflF3XXbpg8Qrc3Nq7N2i8P2OrVCyHyi1gag7xrLxr8yvSW8Hx/cn/nRhLLITe4JTWryMaNFi6+DSSO7Ws7z93AGzphTcro1Z4ZIU+564CGqRatnCVG90ggt95tbKgUY+xvfbTpPeu3da99z3tiLIXMhnTB1tva4o5du5qRtLJBXsby+hnDkPo7M/FSX1UVQ7PR4h6JNS3SvjSg1d1/xc4gA2LV03detuE8fZtoq1op4Cx72vrIEyuQ4cXW1mzKoMXgaJCQFNtZr/OWsFAa6FHrf9lEKFEAkTc0w6atVg7ilWLwTdRUTRPe8kbpgdbW7WPbfDSygKUQ7p12LxNBMqigy/vUy8TsMNmALvLTN0QDca9K7YW2PHl+wFBIwNjvzcWhcb/D40slWeWpk78UnBr/y7cJm0O3vU3OACdaFX3aES4qyBwq35c58skXLDlZOtRSENCrJ662Q+64sI5RvKyEcnO0cJpcthP00Q2yCbFKfmU9MVtaWw8JrZaVjQRm60yVVgWxLWXdo38Dh4jICjZyuwos5w/Nwd+AW27kgCNIl6OiIWeunxmUYoEAN1uWIHKDbfc58wTpAl5QfJ32Gg+PD1rId64obEVVedidsrDqMRKsd3fCyl9TYGLLai/dJQ7pE2vrruk+C7nAyzy0PFRbDpn3gb1c++0zjnsgf4zk3227OzNeys35OhHAyFmZZXOZCyMldSN9Rms+83hQFN2By3ldTYKAiXsdoU4A3mdFYOQGjBJeFENRFCkh+CJBsjdZIHKlIHwtPznHwinL2f9p7lJSalp/kwsn/8hHZcs0jEeOw8Tj9NEOR4ZPPeOpDM8jEEwPhwXWlVFocRZa4mwpiz/9aE0t+zLxmYTj0NjSnGp80Jocmub2paL6xfvjD+wH+thtR90uv8xt/PPFubUvj88r6mvr67ev99fP4A9THy/8gxpdQdTK0vHlV8GMV5lF+IrR9fBMvT/j4ZFLeBFz4Uplzm2hIpmAZ7M5Wbvka3W57ISI7Ey33vtzuz7PjE41YmVBd8Hr6iJr/oaASmadiuDwbj9/jCjn8NZaWwNRdd+/cJzYxeLWWpOLfr+xLnHbJLAZq25M8aZ8ZXVNVHJHq7cV6BD3KrAWdC2wk4idtBFPBOANNvki4hP7119LxpHeWTTIFFoYxOeXpF5gdRf3OWpXOJ1n19uvCgpUmLIDtS6yutqLgBYXUvS9a8M47WuSkqVSesDkWRa/JXdNhTFqWZpxbXnF2vAkVZggouztnRHtX3RYC7gRb50RpTFtHKOgTqgJY1aVzxrK2s+bwiKPn4F0cZlyDBa/cS6tSc8EydMPwWAXfjiXxktpqID/el5TTb049WIDv/5hG8y/nl0cLv0qlujfeE553BSxvtH6vRaXnH4fwspj5BoZuk/CjYyUH4lgY9G/0IWRR/LdKmKwUYbUouha0AAIndLwXFnp/L/L740IcTzs/DQDF5U0NRVvXOqo3Elu2eIj1angdz5pzNu+q1UqrACbb9CbtVHzfVk0afTb/kg3t2OpQfwodpEiR1oKDgVY3Yesy3xN70GW/npj6STSp4afzEQ8+tfWLZEsvVFQVF4rhwULv1yLSBzVM2TlRRqx/SBIda4xCi3EglHWKp2a61nbYotIT2AU4TqhCqsmTfk7RcViWPEQi2biakU9nzhxdS05H6kS75ybCTTBdikKMiq0UF/EYsekgb4KfM+FNQFc45QQF90fhQP5up9RjoI0x/qS5XU9vY/ZFetalianH9MdMzwbjAnStalrKQZzKW+th7krPyVh9Ycc5sSHp425oGW1ucbpbfJ8AHM4eE8ds/5PixAW4LGFTpRL48wGl86S052LLB/6lISzHMKTINH3h1OuA8Ph+gULLH63v8n85h9j8cSk1V1xHwhpMgI60MjTBwvBmo5S286uPhyM5SQ8ZRWxXdC1lSNnEjHaasJ2CaMZtCRo/ClQfh8Nx6WQ2c0O06QNvQRLxiqRllApFCAheTYjavJcia/hG5AFYyS8gU/0OERGD1nFby+aUmVh6iYJ1+SGSbhqEeUID+9HViRvXotHO2YizZ0GHmYoFk//0AZdkcng8GC4XiUfQdbn3eqvNTcvaNv84VfDglVucFjVPTNrLCtTVrfdaeWbgqPigDsKfDZR5voK259Z3cUyjfQyPLhk1VD5vlVQ+XoBfzMMgYr/x1PwZhv6GYdNPtFWNRA4ZMVgflfDTPXKKxUViOtNn6R0nE7CEIjHiZvgJtB57jyW5aFdu/HxyclG0VgRZ6wbTXOSyjSeJqr2pGBNu7lm05tTfzknAENFPQJPJK8fztpPX92zzFmB48r/WLFjU1Y0DV5x9YVasS8rRpKz7krldlNLDJ7UPbwHOdvODovI0fboYLnITsgGV1tyygCQKrTyE5M8R0/LXSjHfQdkzhRBtjVFTHdNiulYZlVVuLrqCW3htmaES9E6/gIAjbva4V7kc8vth7jPe78bYzBgm9wlkzy+t5fu35/P60UsmpiAwHN0+MwZpzNshB6Darbo7B7yFLFq+cBe0YCKw+wGsOMQJ7yUSFTkbt+Pkw2Lci0XLVMWvyVzpCPc8WnHTIdt02dHkWireEujmpo6qEm57VFM2DoDp+tZqJs7mzXEfaTAJ9D5P4aTkmwPQO2GojOSgCm/oZpGvBgsac15ldtLgpkbCv5kxa2hGsex9wMUbADQSNc1/ylGKodU01DhZSz5y1gzkaHVLLcfl/j0+XRAJJLxrUewesnjUfcLvn+ph2D1y5zMcc09r9t7Ur7lDQ3dTJYT1Xv5oqN7OvYcLYoqPihuFA8WFaCtciTyO6KFDDGZXhKv6S7qlHhoqPgJrpUAGhFgjk8Vj5Duv5nYarjzVwwlnw1yije6sl+FqaiAXpTx6avXZ+uQ5d31f2cXnAgeKO7F9Zu76iX+AQzE0xDkGnKnMXd+rYOn/aMVEmWtvPCxp3ZvDHgD3o1P7jr1/AH0nQ/BoPjEk7Sp2bWewInfUR6+HOYD3mZub/c++fIbr71261V15KE7GzTLssn+mGoDH6vBiGi4gTjZNGgxFzy2RyPUrm5fiG6gaToW5q7WCM5ltNYwwpBzH+lm05mfhRg4CFfaE/NoQDS3s2J2YJl2SYj6MhCcWI05cLEgl6vKlXMNuUGAWJ+Eq/KIHGKm9sIrykhjL0F4WciasVS5+tLm6bqMWkMC+9+E/d+y/CpVpmqeUanyiwBO3CxWRMPpdkIcp0Gsg/H8z1o5DRUEgWo4DsETLobUx5A75kqJNuXHX7625mGtVCOjo7q9yaHkvTrISttOQMr929qcSCRHo2iS7tI1+9BdzcK/qCP6pe0eAv3PQtKea+EXQkV6/sadoImhiWr2wmJjsiwgxrtkMb88knotbLtbfzpEug/Rx0qxO7Zhqtjx3Ys1EU1e1kwf5KMBKasSDdhXV8aOs6MMzpEL6ROG+xiMP4SB2CCu4L3GM3gAAU0dGARC3rO55gXsVOtfRoXr2+WsOBO6YPKIt0yqhhBgPGFNxdCwJy+XsUNb91u7c7x1d5Nj9/yuZicV2DW/G87GtjsmzEkNYNPRUcMmmU+vagWk38EIEbYFtDYhwyfpa6tSg2O8xPLihRmAfNR79k7lTfl8NhAITKkc2sKqKWirwZPbmVrBSkmbZ8LJRAZn/kdowPwcOUig5+csSlIRVWo1QJKzxhsYcmcm9BDS/bORD5jBLjKp+0noip5AquGEboOITreQuTnNG47k+JT+TcTDDfyHnwkzpE91rl9/K8njd8ZQrMaIR3lN297usXt8XtpWnl9c/XW1njWbu1pPzKx1zFh59020yreSu/3c6lioD+ZqxjI2p8MPy+wNS3B8Zf661rzF+LGY7EOebOIxRVY3990AVRkqqG4CC/+VTP/9bQmXmxWzfqhw/asPYP2g25VGSnj8kchTVlIiADpskstoh4jMqCaiydi699tvbz5vPwhcO2DArtwBD9Ju8zPPDO0j+/pjFnT164BvjgOQFL5nG3QWodWCTTdN7iqtoJ1jJS27GkFRyaxx4rgntFNDiXeJTyI54jGq/rZcOs+Td9x0Qw9DWTcP1NIWa4VCVfqq9HGVP5Bd+VYal13xVnrsFJtCk/5WRTaX9lblCM6CZhHWrH+ZpMFXk72ZB7arc84ONKDegeIFJ4LZv1ddseK62esfnsbyh/VX+d1phozaGa5lMtGKPjKeJyXMAjoUiTQ12e0R3hld1Ey8Y/D+tMSufPrplSxIGGqvpLxe+npKuD6Y5/k9su3VuyTIMvxQ89HH6/weTtd8uu7j2ZmDw2yuDFEzLXOJPuQz3GCmzdPMDYNGL8SEwMh7sZufwNccCPwxdA51d7uOacNQWTlz21rH/6srKoPRdfYyLmde2uV4DSYBPPnzgqp0S4UtveDnqdB6SYxeqVT0MV2pcHPR+aKaojSaVhS7nz/94kVv0B18Bhk3z6g8ixnif3thJBXSSPSQm7iNvHgJ43u7SjJtIGTW4vH148uImQkzft1UCxDcIffGrlhvCW8mZr6vvS/AwWPrx5bFQb3fpI4aa7LPJPXrQ3q78jlnIVjer9xUlEf/IuMzU9c/qENZi2/Hv5Qe27CrqBfVdXXX45c5aH2+rfau7zqIlrYLN7goELgdP/Og3bATdcLdqDuKmVcfIX3TIjjRb6d1e/XLutFudl8Gttrv988WebEv1Di5NzAPLa6qH0hzseELTOfOFl7w8nh4Y35BPsq76RNM4M53fzQpcmsCjI5c8NuL7BHY8cZVq8zMvS6j3mFpbbWsamhprc7YUEBsIB0Snj7B6E2kYENGsKTVsGGhcKGJg6Pwi0MWU4699FGTK5KweNt6zdb1mkOLQ9+4Xc7zPKmtiisvyzPBni/b28NOx7ZIyvaCgbaBgi8HSLO38iDX532SPu3dBlnEIc7KVy2vqtqUVJsEfu59tgrnhvgouuNHMpdHfrFebEWt7tzNmTkJOkiZvEFMMRvpo51jXK62tkMH21td4tTPf2NXVc7Bvp5g0YHbG13Mghs6DL6iBI6u2C65jGBEcIqm2paSmmDrvmNcTvVaiBrXvuLK76LJIkh3A6am8x76YCWuWVofseEMPQi8EV57By/4l6Gg+vzNfCbb5Syqj/z003e9XHHFd7zuVMCg5N6tW/MdTBpqBp4PyXtkzlrGSaqLmXMde8C6BeelqVT+NTg3IoHMNg57aw/sWcisjOwaA35p+8dku1DDEJcXVtTsa+lSZnTUZiOlfva6XDH9sbOuwtI5JtueCZM2nDBXo1e+svKfC2TFbA2/tr37IoFLS/edffvEMl37INpw23shDNeM0D1A/jF0F5JV722GA2/KGMGvrK9MGOxmL/rxc2LgNpJAT+SfJ3/Vk0+Wwsqjn852+fT11+Beq4KT98RPZnxWmHFqkMY5M5MMMlABb5tHELEIyorB9MVh+wigUDZOcbiYJApnWJEbSeFMYGGxq5sikW8j6PNQit8G3krA1gZDhTDudFs08p8hbifZ/iNHamr6Z7Zt2yj0NuovKRlqhBcwmIBGkeLauJjai0MYVlOyfVfd/YpqAoFdt+7g7+L77i4OCFhFtu8mMBK5tPr8bMJlNrYxmb/l0o8+0mnReGWTPAO6eBNQ4nDJiUBTXt8IfiCVdhUOFS7KyuI0Pt/l+7pBZndNWcBpeoi47zVDScou+VDSPhzx+yMwMjFNhWfi1u8o1Dk5qcGKlmgxYcT3pVWmo1Y7tj9TsIfjksjs2iROjX8CPs4J/9GHPYzuX/tARstVv+/Uy7Le2dUlSTavjyv5RPswO7hvkhpHgAzEG0WbjiISJdLZvNblA/EY2qYNQWSnLAFl8SCFNinObKjJsmctHb93R6nZoEQ0TkjXNVHm8KDpwaN+/wJB3kDbl73ed/cJHqInti40oGLsFWDjZyZfU6Pck3kWIzwr3hFZ5d+Edsm8ehGJRLKREOHKhnMjTxGKNbMh+cR9L6QKuea3eDxbUdPu3U2KdNsocX15FHjs6gPVm3wilEhAmIyifhOawyG1TTn2fhdFdI0DDH6+xubH7dVKFxPWHXLQWFrT32fVVJHu//4GLxJUHzrUhvr2NkUXm0JfRaHYcTZGji+6HKt7/h1bYswv45JyMutQ1WUQDQx3T/au/92nyGD0WVomJTPdsDxDK1VQJGOK5UkXYuXpXBXs6+lTMeqBdhVT9c+Xuk2Jcz2x9F/ep//YnWOg3UsX3A7ZbBq+ULUtO11U8FRyKIRHxQTHcnGze+zCutx6r09LtH5ZdsavaKjzHnjz+KO9Nl/TyqabpmkEGUzQZOYk1Ps2wW4zP9korTZEFAxQbj0Ek5lTsLQXFyTVc2pejvsT3ejNXhwD+f5Al9JsfUaz1px5OIpBgw5+HUUjoqAP0bdpMT98AgtbeTxa8AdivIGMH5ZZ0iyqX7dUFPz5L1srgEdHHI4dWqI9mDKTEiVWbqx5XL7UcqTJ8Y76KIS/19MK6FzFpK3r71XNTTAjjHudygOXjcEbL/HyCgKgN3v5hSH0Ym1thNdsJL1AwWkv71eC7QdsJi3PlYLk8eRBh4MTuZkbDDhKN7OdIJiP7J38p7RJkTd3cjJnPlPxQEIQf31F7sLFeU7rB61aD3dQfxogfnp+ZpyZK51jKHVQZX6+pTulu5s2rfuMx4Jjli0szOKj2ArceblWJ9YUSSzm2bySMUBUxtw3npUWCdG53ypDk/0LRj6oxbYQHS9el9Dz7r7CGZUUz0lURUXvSRJ5VPEFAz8sAe+itr/uFaP2SzeWOcn86tO/7n2PmCj32NADiz7nSndfHAMIimA/dVUHOcLVS0KotcEVCFEBBGwKcaOcgC78bbGWbnRM6novTkxc9JMa31inkMnWfn+RnHKMjc3uaGuPzsNkTPAC5M1Ivv168mDPtP+9k0M3b55M7cL3B+XW0RrbP8fHr141pzomSiri6eroND5g+O7hZHWtPVIxsZFUJmzUKYoO1ftPTdBxxym5mxZ8UolS2jc7oS72jY6m/7n1TVRU/8C9BZ20//vCw6VOxxMHi8Y3kP2LcpqTTxXBcy8ee6RdI8ts58gjzCu8qBxZVwKLnG63c5FPgQiW+AB6hzZHr93/qnKDzlMfyT5vgDxEun5o+df26L4+V0vLqysuO9+PbQS/MCVcFKLXSW7YvEpmO1cNZWXuK9+XmQWhiKt3LMrDLY+Tbp5IkjIxwZPK2nIbaXgpXGft6Levq6yB3EXLKh6dDL95jSeAVku0OYzHMBUOT+VOfTQ3GzxMznYit3Y4hhf2kSpkcYNXp/+3aDCFqUin07LU4rReggYhrmvpUhdX1NMOQDEXFebQDWHJ3mTT8foLqauhMQZPDtvQlYbGVuck7Ymo0OZ2NZZWapU4SHbkq3J2hOEEru3NW6E5xdmFWbBdVDUu12VGWP/GTUD+GK6IHNdwMvnaPzspB22OtraiaA9I34XYfzE527eM3FacQ5prU+42B0eyMbQuZJRn2ZEyMGcgJE4d8NN3/kfvTY4qjyq7b5Wycy5PEPz5+PDq4avX2yjNZ6nbmHRxBJqbPA9DVOT34gGLjabgpvfCLdaFzhWe90xNlX2h02gh+7YCsaCivP5p5I+UHzOj2V9YdrOEsG6CWOKWZ4nL+sD8wHQALihWD4RMEVNseNGa6GZm27jE4OstdVoNQAYty8jzihU/JH4Z5DqkrD/mz+nfOq2Ny83I03aeTdDq/7H1U844OerCXQW68lC5LpbHS+9ngC/Cjr3FBVjABR+1Kw2hWQkN5jPVR9Wyzi/ElSWqI+dk5rScwGnn6n/POcaUlC+0Ef3isIVhi9d+VjBWcNK8ZMhe1aVh0RcdXVGkAMQwIO8k2lUbrteYy8nXsQL7GBw7xUZYUOBns49vEEzuFdvXV6Oq0p2IFz8v+bE3sD36SJt3PRkFb/PkgMe0pela2wqbNi54oFKfjsK7pOt9Qvr97Zvd2LTlvtb0ONmzrTr4F2CKTf/v3zUJ48mZ+6qPfePw8hTyF5wdtvUxmt/m6B8zqPdYQMo15X5Qe1/OM3ySnBeFbXR4Cx5yaZmxGNoMcLMih7tkVgZhTXm+4XIuP0MCHlRMtoQ/ai1g4lslXdgBmUM/17x/qv5Uanvsk3hri1UPvZf2BjvDvqaa8RwfmdpZsEi8dR8zwqTGDT9zG8VOsafZM2w4czXO36wOq/9K7PCzawMFAjfl1ULAONM8tlgcWQZ023GpJWdqC+XXVRzR3CD6bH64RNu/oekoL+MxAgEUUJUD8lpTrKQmd8mKEB05k/UW3Ojz0Hcl8ECBcpWSGv2Z792l9/C+kAbUajGt+G5f+3darGSrWH8IgWKqkmNsCCvSQurifXHlFxWcgmXZ92XSz8PCuQs8RYpaiAiVCXJZmALy/8sgfTdMJuKIzrcgsmOIMqSoxJWXP5kU/argenzpqaDU8n2cTrjgeT+LobBOOIL6Hv+Aw2MbjzZA0yglRTObuIh2QDLQEoZct7x77uU/ezcR0DZd4cdpNscSkzLlEtOxRZnP9iV/lt0fKwzLIfvq8vrcRu+o4/hO23qvSlEO1Ekb5al0Tn6m9GfQ2sGE0B10n7d6/Gb2neLfd/3+9+lmJk239LvNTmdaqo1GBurUqXpZGQ35sPCnB2d+WbRD9IOtGcNJR7ClQdOSpG7F9wNAgPNfbHf1S1JNDUk88WHDth0+QpUlDasR8BV5orK2Ctp/3zU19N9+5QWdNqwsDm/jTmoNCf2CHG1OYj9fUL0K85eDcE6yxTvfyDYUsZqjA2iCYHcykgP0dirAkYm8xCG3iANWOyqOq5AlsMENQyiEfGRX3oPEblmk+FhmOHovQnZbKr+UPZqyA1vIN0izkhhn7O5oD3SbYd3M7zwh/l6eGJGLCRxQFGxAQpvR7JmNdTsKRGn4sUf7w57/+TcXvL6CK4E5OHLMffVn39ldE43V344sHrBXmhEgmwfThqIu4rUSJl+vGZANsWKxmLykvBEsYMIjAQUnUVFWDCxuyRmtLMKVi0/mvri4Er9row0xry5U+e/dhvCdL7K/uBM2yH+CP0HPfZ1QU3P5sqU5Oaw0bTVv6lQ6O9e3JgSozZv/BigczxNeFHOvE5FzGWrdD+kd/c8gCM8S3nXh8S+Tq+5hlbP89DCw02zgOlKsIEeq2Vuj+tEToNjUkmDtvQe2btkqfhce5RobthJ2l7z7WVmQ9UxygvZ+2Q/nTgRlOddTSoD089Z38CJ/1QpKafQyfs6I9Va7dBxvs0g83FkrA2stOpKsfWoK9yW2AE4OcjEvd5Kt/XOCsLYN/OHPv5AdBD+C+p9TsWi4PeuOIkP77rS1HXv32PEwD9gvWu+GzuTg5kDIqiHWvbjlY/TxNgD4SLitsvncuWbJWMKndOAqJ7Vk+psWZDTyyPQIQc301i9DpcI4oRQtm15Mi6MRB8rFYdZbHc3l3cpFWu3hMU1JfWhJsZbBy605Vexy5BESMPI6waQSIPffL/kvPduhjM/KTkhfvjw9IVUfH5VYcd2yBNSK+vvrZUUIOozKRjYaNo7ISIMULfv6b3Rd0SZ2peNPE/xX8uueZcn1xIqorVMWD8q+EpFEvVNYVhauhk9Frcdc+vqK2tOCq4Y8190Kk99xtvhbnNviaLIvuQQzJcskUpT3ywex7fGX836/FQ9uaFi1rAkseXVcqxhBJVv6s55zBzMzdkwQLszbhNB3sjQLPLlK5WF8VTYBWUBTuxREeVbx4MoFz6ExaJjfBcOBbJOgmMlhqfrHSgKPpk332pyW+GnTAPZurlXAMTMBFbRATtPETAC5PmHFDDncU9fRVruwo8z4+9rHKQri9B0O0481ZatnT+3edZoLN+Ws0/ffnFpjaRUOtUIsFeUIUbW0cM0QnOjnZgNUnvOLsgCS4HkndU4GeH7in5WgZGSVP28HMMxK/RxPpjUDLwsorkZEX+EC8Rp+9MpURnLb6Dgukjvmvyd95K7U6kFkLoRCHM9LxKWARWedBSzIJlkAXalMxpnb24m51Ok8+/+Zx3t66rLsmbasZoaHYcmajcZ7WTN/NJHzGnDkFGH386HFdxZXMDbUd2Z31ueZCk8c3xiyPpu2fhHzelHd8iNvX2u5tip4Mfn4jg/oBzuOlzzbZGzh8loJfXv5NQ7h0MbjyRfPBpaO8z4fbrxxI8yuRpdxSffhbzCyorb8GvzeVjfloVcHL233Dl0IqkRWWa9sbTVuYGvfBxNz5I8g3l3fn665byp7jSY1olz7J1UzecI7Os7G61Y5VxjRd5+5MnBpJSyjovD0DbiIWU36U0eMFVZU/qsMWsGas7HFFp1iGA8sYf3GMyNcEOpNhtS33jpz806brFgfjmzaCoq6Izd06e5u74ldP9H6gf0u0yOApNRrMI+JJPQj/WQR5McORL+7JDcWD9Bmx2MX77vRA0mCLVCMW0BswW6B3XwmFomeE5SCsZzkga+luaPhIDq8kkPcRBUESgiFUInqL9aU6NDAQLsHkUAkMA9ujEWsOTRglbHOqCz5BSX2B0J7jD5AzJq0VrhokbIddjsfhRtnvEo5pWB764PDQUC8Lpejq4nlW2JFyhRPdFA8qaWHUdG9HWIQP+2TFWoONqlAdBUtN3vqbFKrPUMdymqlfLCdQE7gZSoDcZdhiX3KlVtfSyDTzrBia83qtuYeDfTMW0LeCm/V1WTds1nLc3RLfWMQBQ3qBhjMY2ABKcf+m5VffV5Jum/bu3UggA2+voqDvPNaoVU4cMAqFF7bKRMXEtAen0HynsUTFclSDavmIQgRv1R4pc6pOHfOrSQ+skcv6WnCoNUVA9RzG2iKyM8EnZ3grZUul8KzZUhzaXlz097m5r1NzeVs6XUC5zOWqeEX/LnYK031qKHsIdu6fwylxThipENLFlseKkMN9b1XFmUuWnPkMPdXNSqIw8n8mtey+EWvHYxUQSGvHWSamWVXwUDSHiJ2rqpGwsHDnmS1/+Bb5GU4b+VWg3LHRI8YYlm0EQvKUTLnmBIJQcQ2WfxU22wKlcU4CxKLOFWnGienhARNhgVxK6mTVfEubkBtjoEVcAdFBBplepX24jwg1rBy3AGvWVHM4y3e4lLQDMvTe+7GuI27pIGjbhNI4I3+kvSjC3DcKg8cjNa7puIAIF552l5fH1YkHGT7f7zDkgffvjCLRS8BdrsqJxV04I5TRCBYlmVMPFERumlqQIZpdyw1NohFp0RrgUTVsTm0Ws1bCPr6czSzp1hmDiENGsdz51nZKnGUs16Z5WArvfCI56jYKoNdZLz8Rw827ZvLr4yM/JGfOR2rG/2DVpVIJIqebLu2SaXqmXJe/corvCQ4SpHDIV14RcAvR8l2oThn6ol8wOWM7bHPFZS0CTK75qP1fw+/X68NtHG29ZSpJYiCwSyxVnqqbeE+TUwc4x07NBWeuZx3eab8tPkxFikhCiiZgk5Apsyx3sPkwvXepctQPstceM/XpEiTM9OBxwlxgleLWMDjMlu5NLEy7jyCvvi9/F6rGxNM3fMEGkI+vOhuDdFqlW4TryFNt6GmDFWtfkq2bhrY1B87xX426qnqJ/Qa/RPm96MWxs/t/RsfbVvMz9dsVznsx9RqDaLV7ZdfOD9OHii34lP1wx9cde8Ir103+nYbHuRvPTksFe1QF3IxyMfU/ibb9hhDV2H39ugCql3aza3ZKCx1HVvsPBcJfm/ONzZIUQiBj5r3cfEynzm1pyppAHY06bTL5pdpk7tqfDJYTh1A8oK3wYmloPRs5/n9Au+cC4YwnhCKvZlgYnY4Jq5OhpkaqHchA8snyJ8R3xGK9x+yqnmem0bTHHgI+kmwdfasYC3i/u5yQoPN0PcZwHWfwaCb7WOStVodK6YzffAxZw8/RLKy+3J6sqKI/kEliOZl6Mn1t8TsP0BQ6pYRiPgHBT2tq8D0RPTzzHXsMXZ4cFhc225JiX0ydO8XM+S8CSfnvWS45SJcZNw44gBvdKUA2yMkfoMpRH7G0fsGmRlpN2rEdcDOnVR11eOqKvi1FnwC0eczVKzgKs0BSgdQiHWOtprBU1+5uUpFrgWMohzt8qq6APY0e/C6QKObaza7WqnVrq0deN5bn9Y+kJjuQ8T7KHt8zxMnAA7h3BnWPuoLt5C1t94KqhpxFgOHBZcqHLE1hwRdu7VDg8DNsojfsoTex6kXouevCDm/RfbNRMgX5gRGMzNJwoaJlzeAKAvJvTiKOwZLucnBeM4A4fqtXAQ0PxXyCJ5zFFzYKOeSEku92BmCJxDVpkBk4sCBFyfS/AVb4txhWSUoxWRKwmKM/SsXNGTIIgxx/s7QM5tSBQvW5JC4gIXuTuBlCxbmdYNgdz/5f7aBguVEu/CZhLdSTRFT6kHooUmZRWGjo3T/fmqrCZ9Z0bRZiclI85T/92XqJeGB4qYjb8EDsVS7+v7PDH5I2FA3qJqPImrVkOr2o0vkjYTFLbjb7+iDBM7B1sr92DvRimUsogNjrrrnZCC3A8SrTrbOJjQec8EAweW6K4rJ5D81bOEX9+TF1Jiuo5Vfz5tXr1+/uryZNDTcCgs9PpvpCApnXTo+RunYuL2pLdImVtoTghKw+d74xGODH9DO5Gb8/zAsddkRcyJ00nCSQbmJf/Ic8B9r4DBIS4qKvkkozXlrbIcYIvNndGd5LPY5N7W5yTeROFHvJQyZZ/zpQCQSjfSy5dHKSMgr90WZdkOPOqsBYufpwJVNGI2TjKOyqE650LwycZCvLBluqK+svS0ZEN55R2kiXDk9J6Ky7G0/rXzhfPBazeHq9A1OSzhcecUdZ327IiD82tE7OdkRyuks/ErPXZOaUI+5ayaBf7HLFq6hDbyHg/3XELlbptE13kGgXo8zOiWwg02rXnMmax+UEXf5r30mxxNPUG1tPdTs0/gcLrI3VB3ZpdnZK/88/Bp2ZeW2SnIbuUulO5O8T4379V+HT+SGdGa6ITSOHykrN6sMz2JMY8qWSI3WoogMiSiABsEjJvhr0K0dES63pzTJoe7Ip6DFNSQRY4uJfFNnmDEmG/7EoxYKHclJBc6GHHljSoUcOhrZA6V2jQ15w8MWPx3RbAz6hL2LLj/xusBwWJvO5XJST9K1vv/8ZGJzs5tys2M5CCdqoHwgKk5z7X+dXdr9NC4nSPzfH7JNspAfxUEhD1O+6Jtzg68/Pa/D19HBcw+bV2T1M0Oyns0zB47WJ4OR93RtGgtMRj9PWl09Fh091iMDSaUqL99YhHdrw05EK+Id8av+JMRHUvxPy84MVjrMB2p+CEJ6qeJZ/t+ac5ak5C7JMZdM2EVdIjfm9oIskrNtBMPxfs5Kp1LRhGfA7VlbmES0KJo92HrSIKGHtnFVvEP8ntZWMD1BQ2n5gu8VWt28UPD6tviRJJhfT/JQaWC2eQLN0dTwid5EmfTKSFNkGywn5XBI8sfSp5fTaA3kWykJWKq0AJpzg42Yyw0NQl/qVzlsbN2+Hev3kMS/dQG5+9h9IyAaxpAKanatWEgfVtK1AHTdQhjQRb/n668jQkpaVpUwPXfX5ef9bjYPaWkJKbm7I6yIXF1Ehpk1oECsBOgPT390NKRwlbuYGXV34vzRYuYCtvu4G8U8ZDjEPBqHLmF4hsDkvKDJmAYve8ZM4+6SmBt7iLkEemZjuiMX4X7Ei3hQZBsYT6YHIuD4nfRJdMloFOKv2xHh92Oe6k4dxAj6oHSN5l55i+HlwSK8liRpAAO4L1W9ono5+WceOpf9llxFOo8zlKdU5Fj6V8X8D6HpxOv6S4wnIwndcEt9OVtBV5Sz61uGdWk0cihkCI6IDy7l8ojg+Aj4QFhQqenBCcg7OgTT8jPqibwjeXEEcNFBuEjCBhiBm8zc2zek79Z36TfpwYmwhBihNG/sntD/UnVZ8mn0p+eHdVCc5EEnugTvXLhLTsrdGpPfQxgY92ltKwnHkzfihzS7caNtIKAfGKjnx/RuEn0cSKGJpyRb5Yk2W3zc9N69aKmLhchVxyBxa0EA4jStdtFC0EsJZlTuCQzYWcYpq69fozvfUYiFvhcHsaD9wMUGkagQtVmXH0eQsKkpMN2tSXHNmA6NjG0BbzU/lnAs8cuEu5BvCV7S2fVcV+fxLmcxmsWn5Xwa5B/m1qWtQ71ZpoGRMZ2i0+iefhQ67RumNXNCypclPrKvLjQATwkgBSSYgs/NKueQzqhCYItbmpItpNlh2Vq30omr7lfdb8bOld+3YEu2M3MD2VKSW4fvbcUjWYnKEXzwXh2GilwUO82+HN6sy8jI2JJp/Hxlbe2Kqiq2yncidub1v0alfv67Tx4sHimO0vfmW1VKVua2zKxtmRnw1s9G0822sKCYd3qnm/wv7b4uWItUU8dnRwMBHXUV+gDtoCv6sO1lOnPZ+LJFk/npBKX1uVe8ddMmCoKmSNsdU/mXI4Qw0rYU3UXLlG5JV/6laqc6ztIdiZJLgciFvbZJ7DcePlwYICT2nrL3/gsX6P790zwvUshlh8LPJ18KzxCU43wU/uijlgvKP7kZsrNdRtJp1tpFxhQgP21Kulb9cd1wCmX3Uz7qEsNO5/7HG5GCNDg7u1/f4cr29kv3r3/drvf31YWvvmpv+3RoKCm0JS8jIJyeUtfdtuv1x1zXHY0/sllCmvmSr05MhjWYeIB8dcU2N7c79aS3QFh649HgZNautGe9uWtTHbIwAWs2ydYfTCsJMJC+k0guwKYopMEIh8C4GXmQ7P4ehFzo91LjvOayKqMRTAjgvZoIdP7SvIzaqkw9eSDOLFQu/WNpFpembm1e0po7eDQpo0b1WfDZTrUKhdGnaAZtXqAd+i0PnvKMzbc/Vwh4SMFxWBwuPt8sLpmYl6HJdMt1yxRB65yC3JVNpVGuv5p+mJa6lprgKMHttoYaH18YG6e0F7tiWg7V/uiPsdpuPfhxBXjt/p8UFXFB19USK91rHtyy2ZYEViwcqP8POD+D5x1znfOz9R54muHD5eNc98vqlBvqrtblKis3Mvcz+cwtTPmInHlgnnAzExR3qiwSDgqXuKACy3u+lZNyjtBgPO1zu08/p9HwZuUQjZDStY4h6sYk0dRqUoyfFqJo0VCykDykMgnJw+qVdGodHvtsSxz0ASNpG62geWFeQkzJZt7m+JV1qqKnJBcQqQ82iuSNwTRdcIi0woUGUfTCBBLg1ntAk2chaLHACbFPolJP+f6q60L/JL29NKI23o8L7YRXF3/y+99NvdrZ2ZiWy+SmvTc0u72tbeGyFnxEEMSISLOjtsR82A/hbVDyuCqdh8Tkw8tSkQNjbC4dFV3Ohk3HGvO4eJvLNQpOBCy4g2vV+gIc4lzh9tFLIhQ8IUSzp9kI/vsdB56nCTkcOstdJ0FbOfGZZ15h8CASwNA44emQtjc3Q+coD4llkds8JLuO9nvyWA/cvCY6KEOaE7xUMHfbC6QzeHfvSjnUd0sUcDHdZ/UcCo4ejfRq0cJHKLP4MZSRE1GnXN6PDvbriUSIFIcXe0Vc98K61bVCOJSDu0cd6C56k5diRW3J5fn1mOxCwtTnHm0BKrod60Q5BHeI26Fy6zus7bJ00owrhsUshzq/X05guHHw/wbnsXaiiyz2wqXDxi0SY/V4cuG5Q71ZZSYpSBBCemAfC2XSoF4iof7DVBxV9WC/iHeiqzK7cgJpIpqw9d/i5S14FozWH2Gxvl72OyI1iNWgVWTHfuVoJpsbpvS7xSPfhxHv1avaJqmpTYt+xxkfTPym5WH1+idXR1LB8KXuyELZar+FtfOmwQP30dNjModsqw+/IMYwp0yiu89F4xkWxD5UQEcX7OlppZOV6Ll/4qqExk/g+TUU+6hrdy/u/AnktlE9fw2x6P/JhMC3jdZBVKOtd/mEGq3//xApt7f0WEqvf3Q7OXhH+5RzE3hOBYYcdGbni1jyTxUfBIp9/KKjQOFDcdwI6WPrEuGOa+xj1lGdedNuFOO1o0tTRe1FGNFdWB4fKyvl7ROQUPI/6aR9GHbzOHejk9UXoJ+r6ALF5NhwS4csvXjQOJePQipqsaEgxD3cZeQhn8UYCw0WorRaWa9a/qiEs/oRvwsdCGb52VafeYQyHRbvOWQruiBGnJGvH99eerN7jJdZB7oqq+tBT/fY3gpaaOgYCq7uydPMXVtT6JRtplPIN8/q1W+jsjmw/m5f3KBjGuZzJKv8TY04MOgI7QexO8xChPSl/Q2rHx6FRZqe2YvVjtj5cnFHCNrHYYo5nx9WpfNJkJXduIAgYjEg5LiQVCal2Bj5g1Yc1GbeW4KoF/tw134Gbh3fQc6KrDYA7RfLkgu4IHksoYCcsfEFk2WM+WgCd8Q8p5ruxJ8jiJD+qVAS5RNQ1AKirYs1Ka62OybRJ3NBeeGpuOgzzWswJNWhv4e/PDn24f8TpS4mb9K+86n3PJ4/Cltm7lFJbrPAIaJh4TEa2vARPcWQM6e7xEBAAUuGiKwvilaBFKOa1Z0yGz15wBol4hPnxhrew8w/0g2hdY25gdTFYvZ8cPZ2f02QaibBaGVjqBAupioa40lxEhOoT0qjdxuAWX5V7oIfOMYUdy827ofg3FU8u9GcqUogEhY1WgFadZ8sh0T7cCl74YVJv2ab9PR1UlOq4zQcONdbujK68vXN5TmmOyadbkZnOMkRimwbfm54oUkPQf9ugjteMwYjl98wC/yDpTuK7hss/+GTT/57ntLaaf57lueGlP9W1/T2TJloHMNSDnKOfxQRa+L/ArnDtOG2qPdOtBV7BNHxRBYq0Ntvj731tjZrwbR25usdofVuxDArwFdY2BdImGlH7cznzu31wMs/4QF5FEtzxs1vjB3SgU7+wMENnQeldggS9xsKyTgwx0Bl2wWhv55muAmcYM8n8/aNNnQt2N+STQWjPaMxx1sH0X6CHm/AJV9nkMA7p/1b2+yfj1jDgidnbZhNscrk/7fFedMFj2iUxfqfJflIEiTjlmDh7UGCgcmFz7zRwDABJ3jUS++klU+RxL4XXhg3KggjeC+KsvgAaZfbd1CRdGzlXaTdjdSa0dWJdSuNzIpjzx1bgZiViXWrgIAQglLdKSkvW+An5wuDY07mrGeysc1tEM/N6d6ukj+ieCw+84P3Korej1sahz3M8/FudhBPJSjaIfvcoDjIGGMSciO/7Mdc0E8QBLH83BzVXF5RJbrouIZq5gzTbcwzeJOeeCy8Y+dUeB5MuCs4Qn7sR1ygENHY8nrUzf4/oz9vCwiwGmHe6FO2gYb6oEgTmpztSkEEcN28E3ZCj6gzbtQ0pwE3HRL+A6fut56o/6jf32ts9POlp5v/Df7l7t5onI0lEotZsfV8XRGzGHJFr9creoKUL0PNGRMSWjZBXvUT/KArMpxQbCUegh9K1isFgwaxZ1fW31fYxYf55i8UmZnAwvEXqR52itvOO9W3qLRk6TIhgRAsPZL2Am8f+ULake5VFi8f5+4jUzVkYlZ31P6o5KzyFbqSyGUHovZFJWUpdtS/X/tubT0tnlYUubGwRAkWb1/W4XMfV9Ky4o/ysab9rw/QiLXt7Zalxfh6L7Xbn564NGa3z+Ayh9ol8WxPqIvWBl6Hplr3no2e3dFJNDf2OWaMDvpvxPz5F9XdTSWOLBje8/csPmNYs8sOsKDtrKW+sWzVsjwWGHXSfbVRzihttBZeQLQBn0jc777vkgzDhBtzT0ZawPBSa+vSXnovq+7CI2rrlSUdWuXy2Cf/Y2xDcl/inssTk+GWcC+av/HM0niCicJxZFEEPv+a4hmwo9b7uVsXiaLKRKjvS7BureXf9PatT5+K5YTv8sHJVkfuIvUYlCxIX9E3Eys1FXTlc9CXsiVVVQBvErHH2Q3cPAabXFjZuo+/WtQj6hK1mVaJP5+rvoOroaiI4tnyXvIf2E+9m061tlKrWno6O6mqKt+PSwCvDg48e+DNN+vqOhInSO8S+Wlffn5qVmhNq/H5EjdufPyxrtZ+mYR5ClBiZj1TjGW2dO/4jgRo74VfQFByIxa7CStcgDAc8Q/Mlodhj9m56SjLD6O5GwjTrusROOEFJUUjI6bbmen9NRZGsZ4GuKZisKhVKQXWjmlmM3o0q5MH5m0BD/2B6oGoo4Db+1DjWOd73FqW9Z/pc8FiTjhD0fRo16bRseeOz4qz5RlvXZUapFffyvDQMiN5lnjF5nhDblNjXozT4IwxikGU0yfAxADR2k/gk8tBzBwosn2OAGG35LPsecYCZM7qolo2I1CWuWvhb3D9+hUrFly+9Sqq2e6gHLSKZVUIziPw9tv6Tf+ci6WKgxwnT3a5XGOMMuUqXpEx5nJ1bV2uaSsUqqOHrgsP5R3iDeo7BRj5od+ro5DcNld9rAEwo4pKXaleqUB10UeYWeKhnZgA70aRPHbXz7MXsLcTvjJ2P+C1NU6PdEL+BLIxtdLxUkjIyynbwzrFr2QDZ3f4s7Kj5OX+dCV4TzcU+LknJ/jtot+eKa+73mKT516qGgb7VlNr9h5IX0lUWI+Eq0fUvM7LS56PQ0XFU3nh5mcxZEnv59HRo8Qubx1ENs82MvfkPFSFVQnPFd53u/sdPo/siwcvl9jaUhr6y1mjlbOeF5txRfB9CxnXwEGLPc4ebyR434zOg/S/RN2ivzq0/xozP45gg3CDOJgadpzVLCyemeeB7+NMtgrUAfzpNdaGQF3VYd9yn8UyHnjZ5XBM3ncffHexImMdAgEq0BbpP4ftlZvtlfHZM+EZCF4jy0RxPpslZ1UZ7E3X093/cPuJ3/0Z9LE9fpt3fMd0n8l12dLaeqCtbU3Jusrr41W+AAogX+nVWuWnnwhEq2G9zuTDecyKtnp5Gp9YBBOM7KwkTuBiXOKaJBP3qlnTuNE2bN263d4HxkZ3ArkoBLJALjo5FwDOuI1RJjuI+BGmuRfuwQ5yEM5BU7nTc/tmgSJ5IxNGVyvigmjZm9wcQmTI12UHlZuZ6Dfr9d71BKARtqRnwoxKONaEwvn+BE6QMzKMrfhgI8C+69gbqTCcekPycSRh4nP8AHAvQyVOVIRXJIarEsVKhqQw+kArH07lObH8Bu63XN5P3CaMW4fXv4n7E4cfpODWVYCSRk72PIe3+UD0/vYCkhc7sz6yoB1eEb1eYBCsXOIaENKC7Pyvjum4AyfFjEgUTRESV7kYMVJEgpo6OyNZv87AiBzsI4U+t976Jzqs5/Zaz3vGKmtA7sxzr35b3rQvZ7yFBjMlR0WKwcv61wdNenzwDRF6wpy1OB+i5tqAYbudgJftgcl0oPi0fBRN0i5O0pdW9qZM7XVF4tKtT/08STQbTb4u9Q1H6tdXG4nlLpOZATwusmXhfsbf8h2JaxMYy7hckstdxkhYmwhufv4/1di0MPSCgiYkgYqC8Y6kNEqzDr3S0e65J8uWRja2v7Z8+TUtoozyvXnJwBNvgE9ytfJdodoe7Ud3OR2lqWLerq8P9uhopTQl3AlLJU/eKrQRl29ezgnlNQsEzbxQzvL9GN7YIAmryInJqZCKwKhRtXVUhT1AMk8cvpBRnICbKNMieXN0w3BEACbQncH0xOZHJLd0bXAznaFt6erq1OZGzVNax+mP8QdMAaczoF8CJ9eDV7oDKBMgoq/qSYyoR24B+MnbtuuxB1XVp05RnPPFbx0ENoIRDtfESPICAOM+qTXQ+ZKDwjBswu72ut0gK8vlHvGu9InG1a0X80TjVLshz9PJ7FGyKuEj4YrXFkEoWCRv7QrIj+Aj7nFmYCI07K7rhrD+Gobtr8YyQLm9kd79SP53r8WKA5f+zu9VhPxHPH6ouhaWV4ah5dZ48Ii+lJ7Fp/OfuTp3VX1qdpjpMMCovkOw8mcCgnIMiTau1myoyrCsY++VpiwHPoc7spqu7O1YZkByHNbNECQomx9otQ+aU5EA4kBII+yAMbsHwZI0hYIwfy2Oh/ZDzNGEUaY/rvHir28LKrYS5vP/B+9F08T/C/XOmwm2N7Qt5rGDnfqs6bgWa+dXZVkJtpuO8zW/TJDGn0M6Ytrn5Y+Yg2NmYIv66FhiZGnaRaqmesF6hRSR4xDPjkpumnnBpCj3Fj4bxv6M4BiM4U+vFq47lS5DAgFZCRT7w2gMGnJy6V/o2+q/i4Af3t6ODo8NLox1dVFdXSt/OHkytKqlpSr0wbH991VMHyUxzj7zmOOzWbrumRdNX3NxJXdEAdblOpdua4ZpEmx7nkHXX5RZpKMRNHZUmtdsjHSM58etleyi6e35uYHYcTaBOe5LNQXSGn4jyPtV4HFUDgxYQ4wQ32aKxtkZzCChPU44D6FCexBzK/2GCMBO7FkWMUfATmvA2WZMW9M6m73afEPijFfUlDrxs2bMkR+cR19XNZ0vSBS8KMp5vDM+D+QfJojgVm2hx1OoXRW0/uFM+EFa+WBgdBenpaCeT2QPNdgemWqxTCsAJVuezQwKppV8qVrOe0xBFiZTEQXZtPLBtTVzD3pS9yzhtT5LX5bQgoPkUiK4GNrXOvvYe/Z0Faayp7/32Gzrvv3xeK3wC3kmdCBMiaxuzbzsUNL3DgfnOjsyqevzPUG9Qdyuw2CGyNYzkAcmPyIaLWkCZ9u8taaoIMS9ShWZ48yRmZVrTARmK4mj/tdg+e2t1TsLn+r+bW0hyGX8+iIGi3aBsb6hWwHS65xM/di0HRKFIrrprwYgOy87m2eHKvj2X8HhbQU2bqe/h1CEB0u59Z9F/O10qF6oqXa+Wr6UyZUGyxVEjx80bf+TTgAJxOonXE+l7J0VtvlyvlCgxXtvWzLXWn5PWn0pmLvyYA4J28kPlcZPdimln4BrncAtyaVf+0XTXnztS7E11VRR4UBDYVg4hP6rpzePpsm0rdhxWXZ1VRkcooVgkAaMPA62QEbCtCBOJMwCY4gb1N7DeIUlrGxRY1rapiVM+2rl/WmtLVaL23R1A+Z7/KBkNJDxeWNiivFpaD4ucffOmr1dO1YufYA5teKFXQeLBb7yChYo+uGlnOIMMaKLmil9IQAbVJEySwD32r3difmmUGd9RfG6YsEyKS2zqTuVUglMyNQi0x2T9lAkxOYyuQiJy5K7P2B0Kp/NhkyNdLX+scXRs2NdiBDy537LHt5aU7PM3hvVmzYd1VZXtq874G8AwohCQLf/jFlSgS/LZqT+zPr6EFOUSSI20SF+TEgIOCJHTiQehoDzzSNzySkzKWpl2r31zLnocVa0haYu4Lrpb+LvL6Nw113pVmveUE3TbScn88eTN+4OYuWS/8VXUqt8z+4+Wf8VOy1vEsbgyZm+lkdfGTge96SawWChSzveTtkbZYUl9je2mnTLcXwXEReEiboWFZmClzJDZHoq3efzgWAcNbNngvaX7TnvdUPXsRemEgAN4SbGiNhSuRVfIl8KGFG4SS8zbi0Rk348Id59HUTfXVYe2rHou+kViYu0nC/jw5c+xV8UZqAxghxdW8mgH5LBOHUXuAIjPJz/bVBNnK3m32+xyv33nD3nS5IP/9GQbc7nsxL28Fk6u3d9bH40ZkgoyXxj0ScEoSCMxOqGP+D3RYAbq0FOcOlgx/djbuWX8JcX7gpWarOanc4wEXA+TFu3bLklukFinEiH3zHY/MApKn9zj/ORwzeDDLnuuP7R9XtALuD6QRFgJCaj5vAXL37x2aKKVc762Uv87hzHPoc7IdsOjhRuxLoPRwRG3v1+7T93Zx8U2dUdaIcad5RzZaPba99vXtyc7P7XrP+9iaiiq7+s0EXfPhxfZPjoTf/3d/9Z+w5qMiOyppWHD23ofkqd90u4anjpsErGUOc2jW3oQLsQEbn+8JmzH188m3B26Ke+M4crxz8yfLT+oTJ7NFQ4qsx+CPJ9Yehh9iVWLusSe7uc3xVpchyWizpkvRz5X3tE8pO4I3JGkRXCW1Zgq5LnS/NzBIrVq7+YXJxW616PHwKMJx2kL6DruJdwjrfsPnc0PnaCp4Ut/jLlK7ixb+Pau9G8/UKGmn9/CyfHRnyI/7f8gmBS7pPXBLXa1sMcDsLhoHNoZOce2knFodYisxkgMGJAnhehaT4ICTlCSDYn+1TZQQW5hJYUBLJ3oMHnXttCu84KJ387yh/vPaB8JnGiBq78LIzAGj3NyPtTtnAWnhUe+El4IKg+SLTq+t+cwaGrCgqhtWQeGIJfuJ3zOozDr+IIbm8VEeuRInaJb8gB1gc2O8T8ZCZVZWZy2BpkDqn6UUtDvkE03jmvxk9J0/x4EG5LQuXwyhUXc2eD2bjPD5C66MBHeZSvoRNwYT9WOJlztw57lByww6N4Jmc0x84+nLIIWRRzDj2k0Wgauz/UzbjnQ3Sd0X1o/ntyp/a+fmfi96kLCMTxkl/2d4yDxv3WtRVIYJiG84q0d8W/uzwdzXuxJi115+8WR77jKG3jilb2/hQpOGjNYefbfCkAiVw/1Qsn7Dqy8y++v2znsRQg2tPHhwAIL40SnnhbJCeV8chM3wwIPqDUgixVpB4cXLsvwhexL5ZMJ0ZajfbFUlhe7IbdmEvNq8SjNitBzhon0gI5oaAwJKiw0NGZgCJhqIjUdHE5XZCz/aBT6pxyjq2JHne63c1dXQ/TjTumu5CunUSrcWICrB+tDyiv4GJUfmPdvYM3cKrwY0td/P+b/s9PJjrtoukNBF5uFOtXJf0u/h8H4yFkngCwGiVRe6adFn7WjbklE0LB64bXBcIiD9md7YNt/aDE7iqiBisC9LqJvbP9rnsE5uqfXSZrdhHFBNgadybJwm41LrbU/Km5uPFWmEy/c82s5VvL7uzdYID6oP9l0KI5YBL1QL7MfuMkNpTKhDh+7uKixonMiFadskeJHDt6/vzRY4jyqFJrmHDcc4D7N76Zln7+Q2/TzhWWmNi8S8ERekHZhXDpxemdEniX8B+iRV5P5yzT879G3r3owl3oxFl3Ns6WvJdf11VfFo8NI3SQjnTbrMvTCIyAegAx5sDqOVyYy0GeyltpPfPxkg+8U/G/DDkwjEwumwZMwoxWW4fNHjJPSPmSfJSQXoQKJoJA0Fi1xTLf0IjjjQ0LBVe/Ni40NixqaJxPfU1PYLWbJOGoG4xA18xOB+ko2i9zI+pOX61tRo/HlXLi/MYngk+CtkaMXVCflV3L+eJo4lsLp/9JJxcPinUsuUs0o2DpPyC5RZ3mdszvwgHQLvXMw0gJsGwZuGNBXZF6FzTtP+On0XJyVoaUMrqOnvf37F8ABjAHRrByBJCTKOf98yiaTkhiPtKHeSYccD8poGwn+8FIm21k6JPJRUVFSRdnl0RrY00WJscTiAS00Fmc8SEtjtZsQs9+uE36WMxlTQ7Lqa1dmpbXdu/bnKh3QV5YclQO4926w3U/3nxUpcuRAPLAiDWhPRdgXjDOJa38P9HkKIWWfRq1T63oS49O36NQX1Sbmk0rYnFr+iJpYb9EQphrBLz24fz0PLUwvSCLbbZz58Am6ZsBtQ6W63ce8+VPzgshq9TFPSDZPxG4d2JXElQM7l8TWssy4lYLtIJlVFh1DtBsnNQQnkUh5A0KmRVjFWv+tmqX73avxP2EUDKFIXlLOxr5qwpgceeYzORgMxI3KJL5y+ADkTyOmoROMDiBcaaYTa+d927CqMWSEzAnGxO6erorUJTIJpgzKKwLW/OigP/iGmmUjr/qOxjq4AI2ztj5grilMHzASX086JX/I1kfTHgZaM+Pi9gtGL0C2YFpivkAnPBnJtcoh9IHlShkF0KtQo3qnEKLhkv2QRllVIHehJr0QXpU6IRQVeRllEBLUNX+mSGXy9fXP0v0g1RP9SmlDlVUb6I5hH150j8fRBeHxulpYHIJUeUF+C18B2FIFQPqOq85kjDw8/ZAJF47lpUldVrWmYOCJIfFXrvXJmfsycrzoBw7MInR0bOwizt0lsh0IRgOf/TRxZ79dfdx/DfSZgSEHiqILiJ2kZNwguIdhRhTsKsCOPgQDRGaMWSYdW+xMGEWoliIDlPay+QRjKBHIBgys7g1Q7SxKCwcxuKDOElQDAjomcSy1x+m+wk/uN4T3XiH4a4qjLYbC0dM73FP4GkpJkGiwTpCRPJaDO4YeAj6SSWCaU53dmlFIvEQk6eiTeqW1gtLEd68cwI6dRIpQkbEzuIfFTaehjpTCTaXfNoycTCrGAYs8w6GfnDHElOD3Et3rPr4RObV223s493mFP3u9f/vcA+BcctpPdKMsCZHhaBDHH/EsQA1vXf28qS7e/lS/J5pQ3InjoWJJ/OY/MddlWhqm8kBaVvoDWYMeJPrpYdgQmWkNyAGSRGGh/V5bIVampxPxoPAHlmp0VKhSwfZysuY/VIDYyryeXsflld2SJHJ6WRifOAYw4kOIT8lpjhsP5szz+ZQ7PWhj20NkdtZIU2ckK3bQLmEvvRis6gH6nZQfps1ECbxck68m3IZg0PPjurftwemEzBM0OGoQ+Lia/l/XJUT7kEs0oYA6gvaHmfaom817Ud2RUlYQQ0NRzaoRFFphnYJC42MXDqBrYZJf35dPZH+e1QQVDZf8C1pGiqa0TTDe7AcFwiBOLCvvflg/rf1VWdAzJsmqaPfbpYABSAaF1Cg2RN0cbgl4W06wcwlgRLp/gOGu3G7CyM47oTs5zS9csCDp0fc2vAWgROyyDaJiDcpEk3yRJK2SBmBE29tuFV0AjhLqCN6shCNJgvpiVATEyEIWJYxssdZeYANeC6uG6hKGPegbu5xqF93f8aj5E0qRa8dW76d97k3BoGyXET0KKyMhEMLraI4BJiWYZrJaXuDDtvLy6dzJpfkfGqSy/+3eCKATupolkqbHdJov4V2xI/wz+blLeNbhjDeSGKdA1VZGFk+mDsk78fcltCCYTR2za5IghOfdCatRxSi1dpFGtbMociIx5+w6E44HA5QeY1P51ekqCRMmnARCnrWZelZTD0tKIoX0hg6dbKdx+gZk9ViNujwERYmM0MiQpgRNKCSh4CbkBJVSkVpaObZksZ6REXhOVClSucUo+kn7IF9AT7ODq1N/R5ui4jFYiPaYIh3WSS6zPv1KvDsK/KSgXDuV/6XdbqX/V/pXuKNpkLUhxaaTML6YAjTTIukLrME2TqCP/4huX7yWtRBNIpHf/IVCg0LHSxfTkg1zIA8yG33iROJDS8YK06KGFGCYGak6l7oWMhwLKzH3Zp7CBLRdKf1lVvSl+bWbKXBfn2P1JYOEpTW0sg+Md6qG6cesFQ5AAQhxKfJfj8pT0vy24AfTOjVy2IUCvGQqYI4GJz0T5KfGXNMKA02OGvdtU6E1U47F5K8DKjUCd7CyI81qSt7NqrVG3scqoCSN6FSvsZVqv6ZVKo++pduAnUX4qzPQHlZ0cxMEeSkM5PzwQj17gwn5PzjDyuAQUQzDe6gEokH6wayfkmMK4pmY1fMHCmeTqR1yYVt9kucYECzx12HDvmYHDy4AAJkevYtClBsdd1vrfMcSKM304OEtOptUvXCStvKBTVKXYpHBwrOoLBFIjr9zBf4F8+cFoWnuYXBdCcdGIcRR8MrrpKzmoYyVVhlZH5/xY+e9hPsAUZVZ/E1ghzrF2i226k4guFGXwQXNUEqDAfsgKDAIYJOw09HE5gDI6JPF2Lt+CyGk4DNZ7BnIwpCY04U4l40ul3uvlYXxuKgSCnR3axe4/lxsjEUgzHeH9VnQok5GIaDzRLhv9WHru9AJXLxJ/kaQcncCzUwAaj75pMS9KKmKDqfzsKQI/fE/lTMv8gsLwupBE57vVkS4/BTh9drNGLvQzb2XVhQxOeLBPmVC0IQGs7EtAsq8ArlHqAA1bFXYl5Y2uyc80CK4sW1Ajtu92werGrtC188lJBydZ/3Y/xblWqCqxxGpHMIffP0ou2pQEWhJxUikWLyE8mAg3ZAMvA0dtYUmz3FYt8HAAFUdPyQAyNyJtrwVoQU7z0G0RnBUzka5Ws8JcZVIfMIb3f35ZTGHY0pac/lNW5vXCQhBRr+ldkBCFJYLTMxNX1+/wtLi3fHUnLJUusgGhDeHGTQr4WaM7Qu1Uey5rM2ZMy3KWOW+uYbIKEa+HxYrKISWbr8vOSnHghLX4AoyMqA/Psb8/O1rGohotfhpCgHu8hvqNz5lVA36l73ZKdy1DiGYtiB9A0HozhAjZGY57G/jU+rJiv/sf3yQccflZNVxX7aAq33bUWLEyoOITESac0EfDM9mwlLvnniGwk49PvQ0PLyl/98pZ+ixvXjNdXjuj1uqqaaAt57u+6CvW0pMicTGM8kiNsQg6n+nVTi5fwwSdyQo0xSWgx4vM5OZNr1L4RhBQarAbNG9XdkUuLGTJCtMz0OjLJunMW8rqcLVCk1s+J8j0Qy+EZi0gNLR29/GI7sgwLWGDuynXtj0CXO5CTnUpCd7akjlLxLi9BBtGhR0WBRn5l24DQ8koBkBEY+2gHvgHLyH64ZTC7BsiZC4DwVMKEJk5skAqtki/pEl3kQCK+1teXmjIzk5Cb7mmEBANa63Bw/2MrBxU+3FpSft5eDoFy6U6bPYmRNs4C00HtZneuKwWgiqrv7i2OQgIsTdN+Y4Pi5GnBwdBGSLsfzGXm3pMTnAj3fvu7xXI/zw+J4CYdI6Qn09NA5EnE8zMtoIf3U9bGQkDE/wB9zfqvNv2TBTx4/Pv3L9hkgQM56fXggwCZ1mTWOzI74uuCAxLWm5s8B4diIRPgKMnbUM9Xj2IhjBMMnfJgXA/kNoJISqLJqTD/Wg7jKyqbm0tLm5p1/sCGXHJXyr6ys7AIKaBnV4/d8tOL8s+KLmEWrvk5RovOvecDnC52A2Uk5e5DgZRzn2niqpPR1qLSEuiLdfQ+EZJglsI1qCay92uJyOUFLeArkqX2dlgxk9U+gey1b6Zlkb0stMlD/ayIlScF0Hmr29uS20l2cnmMv30R7qZQn4t3T8+nVOdUUv2bWaEru0Z4FNLQK0nPf3ZpRUvZple4gmIjcWH4D4icjVNo7iuQLIlF01mbOf0c4llVE+ucIAFtdQ6OvkweB5JFeXENxk3FzMxDczfHdw8vhSNGRdGv1jrt69wXfvdLTS0pcz8oyE31xdf2zJtUU5LvVgv6qpYOsuQEu9wG3/0bE1hl2ZbbCL3Ifcbl+7rDHc0M0/4zwcywF1o1uzT+Tu7upri7asrNPyMCouqwmmvOoE2zZrQvfKf6b1g0mtaZqqqcpq22Ea+hrinQgDJvFAOOIj5gwXzA7qyrrDRAO0kG0toIRuyB9QbhBuhwSJoNCFXHHEkpL2pzHWj0jIyvii58oB3vjFTshxWVoX8RW7oPTVbbCp4bBR9xTyNgD3TWOwb1n4P/MfecQgRd2gOlPOpulz+AkPtBvdGF99oH7UI+IEPVAf6Mo+qR8YPJ1PLBErVxZjVXPJam+PoCMD/uw7bgD95BWwMZR3OObjsp7iiUAdjBHbUCQ/AKyFqhE12irEyzCF6ntLR1S3I1HRri2d/nqXu8nppsq1QRPJT97Lb/moZ3rafgDblCmEsF/NKhgl42qv83+/c31jZDxpdQdci2wWjXmcngyceiA7SHtH+497j9pAcbu0wNmWJqYaealiSbxNSEI9dqwuW4Mpoq6rnkupLAClqwCBiIMQJ9b5djodJM0oT+NQ4mLSmd8d9ew8njMDAtLbMK8iEWj2KiZ1tBoFzIc+4djT4K4vwl8M33S0xW9H6ujwg7oLWz4gYV/aPh1SzS81amzuxtKS9eoUwkhVokInsCFOMwRN5XQHXpcqPQf4TEWqxw3ecmvLVuTGvVJdg8OH82dMpR8/Z1EHZ3VGPPshnnEGr7Bdr5BUnEyH2JnWBjjmOk8jHDMCtAkBNc2dj8XpvIuYDyMnlUvY9llatZxUlZH2gooi8qndmewnwbT8ZU1Z9KfuxNUQzjCljEdT3qlM12DZuIWjWZSSsB75oNwzwEGC5g50BP+IJzaAocQ8NM9cGebxPbsBh0EZx8Q5okKRCLoe6H/X5TwFQ9+dwPBeGW72Pi4Pczwg1zDfDfpMvvQE5BzPoVov9hHQwWD6AecbaMZmuGwqqDPLSAI3rgRVp2dxZpKCB4DUXGehWbfus+VMBa1SSOkaAXpH3ZlVu9wOofwmTBEoJiewbCMBKb1m+2yQyjU48uUj2rsUacUhThRyIrnh6y1q664X3BfSY1OGZ6I1om83Gh58YN0gHgWtZDjk2dzbXmBhi+AMrOWsNl5psLd1TiXsKrGi/a7qeTlsb8/RboQG18LDsUvquVxHHhFOqJisUIf5zQa7dl/Sa+QxgTWx/VThl0XL/6QekGKEY0rfXr32v4Ve1Ider2xMSUFqwF7B34nQEy56MIN85TP6Run5rOzKeB4xyx6mSW5xpucfKKoThAkqCtCWOWwr+4GX3NJlMjR3YGh05ccyLD3o9gND51d800S7gGkhcMxLakh4AVjThmndFzhQFGIgKqgWWHrTr4YF3vq46c2FaPi4ejHcPT7MuQNfspTHKxRCEUTQEHp9R/JnqdDiSX9nGRQ+yX2j0sO3VRsYeyYGghCGnKoUhxyh4Kzck0CUE/26fiko3Dktc6NKg2rj3yiil80yPyGxTy4XLY5a5NlcNf0GZvgcGAnjup4ogPrBNrQ131/gm5+8JtvWs8xuYxNQEueKs9NJuhaCA0XNw6Xvsk6NanZCsxCk+OZxtP/lYqDFZFP5ZnyUVFgA4QnhCOYAImPc5TAKGgdM0YzkTAj5fw1+vUsbBMyRwtIkEfx6PjIv0meD1/asuVOmYIFDOKC+ABYqJP9zB8czuLqv6JenvFOb+mxRdFkQXN4EoJ78a3jZnN1xGvXPoUuXj+mAwr+bSyfJseskeUb6IzgxvfsCW+D0yva2mASbmsjReR0s6jhNer6dJtn2mqllvhtNv8SyjFdVakKjFkJVWUlFB3HDpFQUfSaNUBC7iGjXmc8rNMdNur0xg2ROoRpiMuCKqqAI6gfyxYYexhz7x7eQzSfl/1qRwKjGOuC0zPT8R4iOHIXUEwcxTJM751mXFBHYAQoeTv8mBR1dDvV2CoaUHe/lDdwryTB6XMffriwRl5gjNfbA+ExZY4BTR95klmaSSBM5NEXqd3d1HTh8lCcyaE/9tiXT3d20c9WcPiiCL3nEv9eU3OsBHqfRqNd9FN5OF7MLOaYV/vfDInHXydq9PLQKJbUtebwtpYwGgRJsJimEmVY0DZ3MgDqFW3PRU7KuQj32j0QTM7hmY6fWHoyjaol9CSOYekLfR6DXcFw7/1MgGeVT6loJnNzw6TfxAjjCEIggZqzqZGwnpi45kiJ6RGVCNo0nd+L2fpw76Ko3aynVCqPh+8D/SZb/Fq8fbYX1/ote26/P/Pbt54bVqyTP7o0x3bGEo0sWhCOKjZH7ZnkMrfbRzMsn96kWd5xt8Qn/BsW26hF+fh3WEdNDVVcrAQCk4mGjOQxF5wy8Z4JMXEtCOykXVzVcp2S9l23GYJRaRMP/iE8gGFg89nkETL7bOODhTagZNX2+HaCunSp0EYDqNoOpLZH5a92zVqAYTtLCeJHfNDc8L9np7Oj5qJORK9d6foam8OAcPIHw23DH+w/skP4krCsbWZRlfGJ7T9h67vNKPuibGyK8oOvbhkdBZWVQH6Etvv6MjBsXkFd3ZOBrcHZ2W+OAHgXSvSk22wnT5L4JkIYSmzC6+vPbJKEFnyh5u6MDWie15wxYU+GzfpGl0QI9RySdDRFuunom0qnYR8gX02yzMGBEff6fjIlio2xoyKdPa/HMY6seWxhvlDnmV/IfiFkPzOkJ4R8zP34zzu0cDrgiIL8mB+i7KRv4j4xTBOdIYy4D352oEaNCo8bwL9buYZdtiSX1WX1FCXsKAQPlFpul8HYBShYGFG9NHqzUk5PC6KDsd3NdCWDIbgUd+LiobGuB70Sp3m0aOCuLpde+kNQcBB7w4ZOEe3Xk6mMU0lpKjVba2g5E/u3xbsY+sq+L3yMFkTzvpy835Uh3qQoT8zJidu/X0ACa5zJe+CEuCwfo2XFZb9XkKBF81TBBBKgc15Ps1px64c7tjtbX1weUTvEAvWLayOWv7j1duGdH24pRL9+1UfIA7Ef+vMKeACyKz/jFsa40WdJ3XH/lzrN3sZm0SbRpKgbJFiGLshlAwPS17m6r/zH7OvdoZL78Lnc2LN64yGd/pBMr5MdlujDRhCBanG+6kG1usi+EXyk9oVzL4HGacpe3mN84glj/leyx0zDXY3RmYH5zmajvqmuXriXqm7uqVSL/ph7sjQwlO+BvKAOkg4CTIp64H79X9A5DI7NriJuey3uGC2CJhVA4Fzp3SmRqU5Z/XK4T9XzirZWhdFm/ag1INjJDeh9xjDDDI+KJH5u2JazS8QWcdprSWnzwRHQahwFtZlTi0+BvWXxAUKPbXmwPzurIURyLDqSkIas7J6bW46FziGaug6aZE/9Z6OydTQKMDp6Dkd/uOkVBpgLksUwWrW1+AHBRw91d1MlpTJ4BhbcdpJt2UJdycZQNoS5XYnY2NphywqPf/idpdeHDOKU5lVW/i0WTfLAx1DXtZeXWgHe3p6VAmABFxFz4GC9NCwahme8khkYS2KWVAC2dKRyTor4hqYBBvOCiHIcXoPGxuzGYFsJVB/cmNVk4IsOk5TofQZjoMkIdSdzV11InqCdmajrMDQHqgoxFQf6ll5LaPAd7bEU7TI6N8o7VZVkzmeuFeZ+952wawtrrkudImWFhVcxcOv3n0Zk3w7Rym2L3uP7vd+86mAw7z3zUnFZBFrxN/9hkSFrl+J8pj/HIZCq+pZgOBwJVz+rRYM1n9u4SwCBuDrhgpd1aBPi6DQibaaCctm9IlQcv6nZAI9vhMKZDQnxGozv4M2nFjQCje7KKEe18J/qIx7G+7P6VCjL4oA87OQ+DMU8vnD1LSr/Sb1Jb/3Kv/vrzH12kgAKCgcqqXtOlP7JfOqWOjyztgIFHA5L3etMWHCQHEjMtAkljnsOAWYHRGBEGhNoCDPfRgA1XZewcXZHK3RZAa1ZCvEuQ6T5ZzkQnLdpCZtMWN9jl3PQ9w6jjp5m9CgqQZFkkwU25CgtCovBoMix5CgiDOMrcwwcOa3vv+s1AXin/+bNI92yxVqMMEZ7pbfrORNBHy2j3ngUnChsEiYSfn7tAU4dqum9oh3Eahez/W9QMvJfX0bhX/YKt68eGbn2ubBC2cPDj4N0B1nJs0WnvPCTwvvswKqDtuyGh4k6JC8LIAEWn5xju1fiitLHR1R7fzCV7w4jWeys28HU7EnAF/3r27O/T4F7iY02Lw6A2yDb1YE7BtI1vVaJJ3JnC7SD20j6M1dvCLbEGqymPASmg8fCIeUUsPsxCSkqStXl7C5QGDHdV/7jOt1x/1c6zFizuxs4FZv9xL90Ijd3YtWp7m7K7W6JVA1kZAyoIlvcbiBWvl4Vj9w0N49IZS/M5ua4M4wqZYh4hFDP/C6XOnWf6kCOxCL9SL3VZnOze4VJgSJLwztCeA8FmxMSbwY9SCxR2DPMpfrYMPsJj3l3tDbcHAHexuJiWx1/FjQvFcmGXklfqY0QF/cVJysspLq7PdmvvPwKWOEt+O4jra1PVt98FGtLB8ki18evvEol7t7tisnOygZ9qn7bm29rS0oRJAregw7EU+LzCzabD1M/x0rEf2iFu9jNWVkECSCsVGHiDm2/8+jRiEuxyyRs0GZucMAuEvx1GMrKEnS4lRHnYxzx5xHeLjp1itq0KSTuU/TBkAwjgutqgQsjAv77a5FqX4z66vx8WS9zEp9EiC4L+HFwrsWiHpm9D4/x2TP6sd0tMBtcHpVf8AtQcbla8NWrMZ5ykqvkTuSA2yu95gbh9qEzUcdXBqoOMcthUYZcEriTqfqIpwx9CiCK+mZ69MSpM0VPiFuslW7XSwcecHk0PhfjSjS/Xnr+9GlqeDg1y6EeYT/Rc+Z7gTgIQW1GN9XcvPQXSwnZUAkm5tc0Dt1brgjePBrJGmdzmbDvQQ3TaKBbnU5mVmN8Vkye2Hm+iyC2WZgG3ezNE4pZppHu2VHtBmD5ak5P/09kT4nNAvCvPrKmZX7+yM22N8o1FYlv3fxeiimeWrrtPFSvZ1Pnzse8RcV0dVJ+aTWkgdsiTR1rlslVfM8J+dm5PFNDSObUJ4y4D5cM+1x2kJuQR23KU1AVTz6CodhEnwktmnZ2h2dFRIir2zldOffjLzbT8tJGvVQecCY1q9XNSc6Adn6nbZC+VYDXwvqW2dmc3AgZapvIGAcu+uQMkDL8NscsftdDc+a1kyCtGYwqyAnJQX31ReKjZS4B+rD4rrGnNJaxu3hfMTPGWEZB1Xg1RJH2cyXuGTE7w2djCcuvJAxQShJjazVhWT4J+JyDNTcboPimWq0muAN1SWcjwLGHBVCDvVhbK9pOcJBqkFMEhE1lIee15VAWAnGVa89XQ5vmWgGFkRSwjujEZJuIFC6SYA/W/Nzqxt33wVojVn08qKBvHswqvgEkX+bAbyLU9BVGAOm1YtYcACT7349Uysl/ZErua0rVBI9xjLLAGV2KIgstIeiIeOJ2aU43ETjhk2tYXV6wWdRzCKuyPdpJWXULy54+wFeSZn8QEX6Em765BkHXvmna8hy8ZsVLCPJS0XbYlakJ1M8BMk7iq7K4fIPtAeMMb4K/4F58YmAh+Qd0rgbTw2J9BJevEs7+l34QwqeSp+mOtyvOhG0fHcZz7GmmPEJRswjwCIH3uFmBrbOYco+TdCZdPpNAWWQ3OxstVMKM/K3H+OMmyzpMYY4RwWvQaBp4n7q1OO/rVP3RfrohOt+Qh3D2rf9XIrw46J/+vyR8bPlWmezsTGXyIbghbAyVhrIsVpTfrIPSSTqDpNNg1FzgbsmWremgqSZ5qkuhJUcLysLEVltiUt1MlW0EeeocZRYPZ5JASf9tS6letNImUpjvGysuAQp+iXFnOpmEe3U4lguPwFz1havAFAmbI/7BF/69y/EhtDDQvzBf3ToP1Z3qKpjcuLHjbEc+pAkRfcBb6Hf7ym07V68+fFiGd1xdF9vyNrSDvTunx/XjU9R1q226zZPw6lF5j2U6e798/5TH78/OHpQP9oT3JB3/vu4p/dS4bvqK2xgUEgCzCwGXjNbhULR9Dp/L9DgAYzgfTRX3j9WU/x6/yFrwoo+NIYkGx8UMOpkmOugDM7CmL7DSV//CZdg364dDND5kx4Ap9qjWc6jzlBHk0aOOCGUyOHYlIxQH2NVU6GFwlCQefqrWiwE9lAfx+H84/qTXqUre167cm1wTggqANDDR31QWmxetgH4LQfuCGEFKKIgvisu3t0cG07XBwZHtTfmoiC/SKIPoQUHBQUqNmCdCq5obIoKDtfTgiIbm/DgRT6yJDgJxZH1d7wlNtaOrkbMfnJiS6i89+s2uM678RQwVWOMPUOey333y5maplmOKysuOlXQK1ubD9duZkLGLyDDP7DqQxOJQWygBnemyusK6KDL2k/rSEgxv6bAuNrqz4pPN/vcq0NBVUcx60XhZVy6/+++iO+9sDOVoIPTjpFMy7tlzxUf/nM7DMRCYPq9mVhUbhr13sl4xhwRmNFMkZkFR/52A6zocPJ7pf/GoE8BXeZnX46S5087m8yZV0ulxO6fJC13QVl+1BKmRH5wYg0CIWBwaNESzlyBvcC3KlfEYGlH1Qw6mV5Ta0lcb4Yuo7cuzHnD0OWOKPBtPOU6dzOJysz44HRtT5OwD2QgPJ0oRexOYn5MK3PCZCaJvH92CBDBN2wgS87rgSRLHr13+ShoZux/H8L/yoi13n3pnHbbunafuWjoUytenuPado/csG0O4JbG6no1gohZyVEctaCfxyZkVlLOT6uyiulqoluOSTb/y1wNLZsYoymqbbzBAFPRnALVgJteusDveSzzc+Fvtl0iksPV0aWjSmLiFq4MTcmTtP6TszELo4PDiLS9Un8lZFrIjZFnOmerNpA7VGBtjj6nAqT3OKCfFOwbLsehDJA6SjM06Zml3duoFuzuF0PAT2tlfYHkOFqu+FYu/jRGLY/4vlnAs2VlAATgCRP4skCnNZIQi4nK1GA97ca9MfmEoXP70BXkwEYwzmLKbahJqbQ2gly1JjyzagVLLg2wLCEitz8+9tzH9JfflDyWI5MPXt17SYyabbjKuDH3+ClfoEMZyET9CMNAMZgi+Re5QwsW98nzPHjc5ogAMiYkgw7bpyf0NE9g7ZAfIEyOX4saJ7rXOeecCAkJ457wEeL9sh1jtERd4Ua/E3r/aFN3UgXC3LqdC9J8qssIQBNQCgfJI1b/i8hydOxwg4pqTQ+DNi2PcfmOQxyKYZR3idHrmEF+X/n/AidPsfPN0QSiOi+/0mzs1dZhGA8HKbzQIjngdXi+eSc7xFn32h/bIqPaGqMjClOvT09cpyRrVPbchGNVZlE+4n026kXR61PlGXrwyl1lsI17wIcnuu81oyxxkhhxl8lfXrJOMSf4om0MZtQFh0J/SMwmksSJLJkPSv+7Bac2MYCN2DCSV8nq65I+S/SMWYNavqSJ5OMsMOCc/4IlVoRe6uQrV4vNv3sexS4Vg1Z+SIv7Ddxieta9DfIOFB7IaZ3RBy3ZikPWTM6L45wMNSfLGKhTpSspbZORaPFoFwoPtBFv6ILCFelUfBYLgbpM4TL4Tu1ckeLYRdok/sWsFg+EXzXo816Ocaw6bc5Fu3I09u3Ej4F8jtnuMRL3AOGUsesycFZoUEk8k3Ygl1KR67GuHcIRzIitcpClnsXlJ+n2Zetf6lhYQEIMJxNHZhxaEgAndhODKtPwNQbxiWuPQ8ifTzK6gWaYtexIwy4Z963DLqlUFHNCi7BTtaKSBZP6Fp57qnAqQpnHK5vB3QIDD2B34A7MPzBO09rZT9fABDa1U6wCQ2IHanzq9ETy+XKE99AyFYIryFc8fqBR2vnRZm/lhuW5GOvxh5pZKMDcr4P8tosqzW8IjI7PDG1X50X3P80zZ+F1cNlpQLj3l65djT/me13nx3NeVHJwRFb9MD+vVUdgTiuKWodJfKrTUbYvMW77+6jTIDOnNy2vp++XCHNi8PZD7+htXAB9xzxGV4gUErVCbB53k+Cxu9zTXzH//wxT0ZJ/4CIZhEiO8aUkYh2dnYRDMpG9Stfj8UXVQOH70/GLjG4SDKBhFAgg2iU/iJJKMwxP6sPD/+aJVHNxdPzDvdN8UhCFmQdqDdCyZwzWaPD4OiAyyXk7nhZUx+QfQlYZ9L6tN8NPnq8rvgLiu+HhzPEHEfbl8WTGDwQlmBtMlQd3x1bx35OjhHenZl1+o/xV2YxZjDC8P7++fUr1bdGDASHdZCtLhaFCosEue/QBClykSvgIHW5PbNCXWe628zXXENDmRz4dJc3FxMxnSJhUvusBqi51mF6WTvkft9rcJr/1cnom1UNUhT9cXh56QkI3C3+mOok4gu+hPA0dPQsXDeMgCMuTmGP600rlzkHNM5jlE5WxK5OmNOw4SQq79YELAdZ19eObsCDZirE2i/N9L/zZoiIw5FqqmvWEoLXtE27Y9ABa9btwtA+QAjtckPhmQPHafLlEWslIrJsWEr2n3YjrDRKcvNm/QXowXO8SaBna7LkG3NM7XsaHwlxn0wvjx48SkLqGZzv4qwDlXEQ9JOn5zGFUF0g55gPB/KtoF8M24/3wkYJfUfhgLOfTaEFDjLx4K4WtL7AZcVkWuqIwQM4jp7rCneFeAerfRFBvqAR7Qd+YEZq1Ix67SSeuOHBDvtwYlkirMkD2yRg8xWqT4POavF/VCNWBPzqSybqUX921MKo4EYQdN4X9aJnvar6B19Futhox39vuv5eevho+rY43nZ02zFutXm2tqzKv1i1efARt7CkzZBPgEuNgzF4cHvJWmkjgDmnMzYSi8uao7QO9FR3/drPSoegMqv/u1F/ViLh/hAy3bSoAxT5Kw9r3/Jgy2O08ZwmW+lEnoBT/8nKKu07Nlmpr+hvqG+onq65rD50gs+R4B5XYjWLTX0+ntHJzZOLtRLPgJ1JnPnxm9OicUzl0dneHzfD77ilyZ/TiGBwLYCEyIdMHJ9GYGIcvTcTpJv0sjdwPlE66RBxyGgzmE5VqTeH1k9RqSwjJxQAd34S1uj6UtJg4OFb01sgKba5RbLGQfZuxrsmS/tsmNKlBI30xfp5+a0+vpMZjorv99joit1ChEwHSJOXvqILklWiCvWbNQ6Ljn6PcMTDQWLeYucEHzukOp2GS/cTgTNC8LhXpE7Kl/p4C60miKLeoBMeAGZU62RWnA1JU9zX0oruR9pMJFvMkv+o2P7notE0uJlhICET/FG/+e9/l7zd7h0QlpTDIW630vzpvMF4GPOzOPhmgyXnfSkvgWiyKk5blzdtd/66xQIBPm0RG44Spr+9f+1uyNkrpu/E6vCTk6MBy9Msz8qOsgD0Fz/ttmqaljHg0OMkHXftbeIg3qJEGSM1uQ3fvA9PeZCuZhFeSZLyZpwWUqWoUWmdGtov9NFK/SP9o8PWuZzLTfo9mxoHM6/6091n8TuYkTfwfCcOjGZW8XLg+lM+lPH8TdZLA1k5SlFLSLKsw/Fwo3txOAWvWfWgZufnJAxteAinRaZy7J7w5eRP4lHab617ZVYVxW+6jYxMn+UhzFS/vtnkgbapv0wH+sRGJJQ6sD5/IS0poWHSyJ6a1y6nyR3d1NFRbSgmhKLua0rd4zeQ1y+px/rywKbI6wB0ojBAugHOGvJUn/54eF8f+fJP4GRvwIN+7JgZ/Dj5dhJcv+atseeDKOi/hdmVwO6ZTwaO8f66LWyCgR9cejUZhY9DnB/VjdyHoDaT+XtSeMxwvrKD/XjrzBatpwlsU6qxF2l5vTr84J4eSEcJ6Lx5/JjSxiXl8yXLqe0sULz6za4kqeNT5e8VspOYjW0ArDyKLvXpitvzabYd+QpmiAdqqfvTb72Re+4+vPYCgWFwhAbnHIzsmngXr0/UMhqPwjaT+N+BHBT0U7AL4e8V+A+Dsk3R//jGbaZ8G5LqPBM9E45hVx3p/voLOx6JlfewGQA9SabmgWjPyFHrvdR6aPAN52/SLWNBdNuxpOszb7X45xL+04nyOLMhWhQ4TYyqEisuw7jw3a3OllwMHmbU5ns3N6N+K8Pu1s7n/2ZKVUWnlS36299efRuapl7r1nO3awbPhWRcTwJAhbftmpcVgYm5k5Vy112xsZtdh/6DMt/ncNCtPqwA+FnS73yWT8tkzuSxfOxOnz8fizo1dnhcLZq6OzfGA9/Z6dR/U3L7kisHyU1HJ7NuUQRmDJsDkYTib0WhHE3Wewb3eOLlWRD+Sa9quwsEyRDnRrmRkW9lUvHd++y93EayHCq7Ojs3xNvVZujbmqbmcBP3emrgpDXiOuybX1AYV0HQMASwSiApIXA2Ze/VoAnUQtE1YVIJKJpKTpZ1SeyaiPAj6JnMmmvrRELhRxDrcMFWEvvghqAZujZ111ZdgCmqqX7edkILyDSCZuPdhzUDu4krbUKYVg8AetrRRrpjdtAkuzBwYyGlg+K4zyCBWxT+P1+n/Ul8ZgivzUHN3uMuJvlj++XdI/pudskvQuG1jh0lBY+DQWTKpLVC5JktnOk4UN7zg+yaRoq9JAm3PCUTlnnlLeDaf2TEvCWe3PPisoLL7+Ac8diAGJfs4vuDm3WKDjhIiAI4X1JRfhiESCXBA4fK9RaoJoaKSKZOR8s6s5CHq7pgE0sC8CYROna3LIHJCT0f6mlQtxnfxXXEgEgVcIRvwwG7TnV+f1+vCEjkOjrktu6Hq5cOKWG/FcEwThvSaYDiKLJLkuBDGxNekRfyZapHRHBEreWONfkakw2fTHKa9Xm3pJJ061oZhsqJcVyNEaEpNaDIpfZwPh0S/Nukm8ePHwFoZ+A3d6dMfiiu9eVH24ENWoxpyG+sv5X3zwq9gMximVN0gKfpfqQm1tqYcbnNXAa5DgwnVgZysPWzYTGGAswtHkuNygjkZlnzRB4NfSRW2VPFi69phyAvtxoBC3NwBADKgxoB0AxvLMEuXGLRgFBv6ZWTi8C7E4xELhlPOvNF9uurlxwqgFk1P6c+PEIhdCLo0yvLj5Nr/824BFHsE2M1LPwIdMDcUCxqHetyNwHDJzJwaCJLkxcpNHyYaf0flP3oiFE3oWIngeAEQaBFsyfuHcJwGp2Ro0YHG+5m0spzBDkRvRpUvPzlky/rHHpU9uZZSUDnfXNWCakmII0OUaxZbmtGSJQVZc+gHicx8bvTpxfCPbn3qETxyR4iLTG0RE7HC/TDYs3I8NAU5O72jlY87JYpTUyzJfEvR6DgCw0hiCPWXJPpf5vUUsGZHuympgnDS0M6DBRF4QDIvcrWVm2GTRqbG5CzlTwDGwktGiKBvxr79+Hbsal+AALecnX52DyralECXN0+0lhczOZfECBKZPCj5UavhrTHPs8wDtll/7aiA5eUbjOgLtORaIKRIHwj3UeyM4KOALhdnL7LPcH57ULbeVo0IWVx4aWzbiMyop+QAbN7H5FqxBFtdVcotvE0GSU8e+g/mTIdOT3wE4HIO9xCOILjA5aLTG8w5hD/0TexIZQ5bAiDi3LkEPQCwjCdmEHBS0Lep5pcJ8GLdZLOpHoki54I8Y17gEvygR52nEzv5Dg9jWZAfr96PDO2U9DcNesBlXGQe0D3i9zYq/06/TqSKU67wyWFCsCHMHgqMkSx0wclCQZwLxKZs49hv54ooq4cSBwOovzZaQK8eOSF4B+hjvsRGaX33qF6zsBmBhMMouPjrHQNXrSg2dvE2guPClE/b/xT3YLaSrqpE0oceiEjUGgjNHEV7ZFZ4yRi204exBP/Bk+z9iT/lF+aD8ct4kiAJZ+RleNjONx7Du/qUV6esl9omiYYCxF5H1eas1fhVOVrCv5rdn60YgT+zjroggkZvvLn2okHh189xrUHRiJbFjwCEkkVWn+3LMRkUN/AxW/sSsBBcVLvQ4xyhYlyf1W3RM+SpLGqNKYvQ2wUeCsZtHZNe/7VPYPgt7i8r9yTbZKs0Y9hMS7LLjjcG6h7lyxIWV04KNDfVdPx3qax4AY1gjGcMZpHTAVHp8mAb9ZCi9KnJPKUUblqMrDGs9IMmacJCVYsDFO86kDjN7H5coaHzjKGDR7uZwv6vgo35cwimeLpqjBWAVCwC6wXk/GFbd94NQu/lgcFZOSEeU74fE7NO3FRQh35vsstt+D3LZZru99FZYZrlV9Orssss2O/Qx0WswoEcxvSo77KDXUsPvuXB9FurzoH3K9Yba1tpib+Zx2YJWN+ixy4Ci1b3N4ITbknh74vce3IOV72PBFedFeuWpNjEVg2ZFSmDi7llNQHJ7MkJw+pEvBodc2ab3OlQRI2mBn3+fstYK" \ No newline at end of file diff --git a/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs b/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs index d45cc02f64..d4aa1b7db8 100644 --- a/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs +++ b/test/HealthChecks.CassandraDb.Tests/DependencyInjection/CassandraHealthCheckBuilderExtensionsTests.cs @@ -15,7 +15,7 @@ public void AddHealthCheckWhenProperlyConfigured() Keyspace = "myKeyspace", Query = "SELECT now() FROM system.local;", ConfigureClusterBuilder = builder => builder.WithPort(9042) - }, name: "cassandra") + }, name: "cassandradb") .Services; var serviceProvider = services.BuildServiceProvider(); @@ -23,7 +23,7 @@ public void AddHealthCheckWhenProperlyConfigured() var healthCheckRegistration = options?.Value.Registrations.First(); var registration = healthCheckRegistration; - registration?.Name.ShouldBe("cassandra"); + registration?.Name.ShouldBe("cassandradb"); } [Fact] @@ -37,14 +37,14 @@ public void AddNamedHealthCheckWhenProperlyConfigured() Keyspace = "testKeyspace", Query = "SELECT now() FROM system.local;", ConfigureClusterBuilder = builder => builder.WithPort(9042) - }, name: "cassandra") + }, name: "cassandradb") .Services; var serviceProvider = services.BuildServiceProvider(); var options = serviceProvider.GetService>(); - var registration = options?.Value.Registrations.First(r => r.Name == "my-cassandra-1"); + var registration = options?.Value.Registrations.First(r => r.Name == "cassandradb"); - registration?.Name.ShouldBe("cassandra"); + registration?.Name.ShouldBe("cassandradb"); } [Fact] From 2365d8a24b0b434f78bcac42cefd85aedd13b5ee Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 08:29:23 -0300 Subject: [PATCH 32/36] Insert txt --- .../HealthChecks.CassandraDb.approved.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.approved.txt diff --git a/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.approved.txt b/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.approved.txt new file mode 100644 index 0000000000..e69de29bb2 From b7cdd1d593b129103f81e2ca7b28d83e1ae3aaf2 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 08:33:58 -0300 Subject: [PATCH 33/36] Insert txt --- .../HealthChecks.CassandraDb.approved.txt | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.approved.txt b/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.approved.txt index e69de29bb2..523b678e3d 100644 --- a/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.approved.txt +++ b/test/HealthChecks.CassandraDb.Tests/HealthChecks.CassandraDb.approved.txt @@ -0,0 +1,24 @@ +namespace HealthChecks.CassandraDb +{ + public class CassandraDbHealthCheck : Microsoft.Extensions.Diagnostics.HealthChecks.IHealthCheck + { + public CassandraDbHealthCheck(HealthChecks.CassandraDb.CassandraDbOptions options) { } + public System.Threading.Tasks.Task CheckHealthAsync(Microsoft.Extensions.Diagnostics.HealthChecks.HealthCheckContext context, System.Threading.CancellationToken cancellationToken = default) { } + } + public class CassandraDbOptions + { + public CassandraDbOptions() { } + public System.Action ConfigureClusterBuilder { get; set; } + public string ContactPoint { get; set; } + public string Keyspace { get; set; } + public string Query { get; set; } + } +} +namespace HealthChecks.CassandraDb.DependencyInjection +{ + public static class CassandraDbHealthCheckBuilderExtensions + { + public static Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder AddCassandra(this Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder builder, HealthChecks.CassandraDb.CassandraDbOptions options, string? name = null, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus = default, System.Collections.Generic.IEnumerable? tags = null, System.TimeSpan? timeout = default) { } + public static Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder AddCassandra(this Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder builder, string contactPoint, string keyspace, string query = "SELECT now() FROM system.local;", System.Action? configureClusterBuilder = null, string? name = null, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus = default, System.Collections.Generic.IEnumerable? tags = null, System.TimeSpan? timeout = default) { } + } +} \ No newline at end of file From 57a8bec1f33a9b69edf52474e5e7ee5a2a2ab081 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 10:08:21 -0300 Subject: [PATCH 34/36] update HealthChecks SQL Server DB CI --- .github/workflows/healthchecks_sqlserver_ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/healthchecks_sqlserver_ci.yml b/.github/workflows/healthchecks_sqlserver_ci.yml index 9dca9bfaf6..32622f313d 100644 --- a/.github/workflows/healthchecks_sqlserver_ci.yml +++ b/.github/workflows/healthchecks_sqlserver_ci.yml @@ -71,4 +71,4 @@ jobs: uses: codecov/codecov-action@v3 with: flags: SqlServer - directory: .coverage + directory: .coverage \ No newline at end of file From cd8d8b21db415655e140e88beb1ab6f3218ee0f7 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Sat, 9 Mar 2024 10:15:52 -0300 Subject: [PATCH 35/36] Update and rollback --- .github/workflows/healthchecks_cassandradb_ci.yml | 2 +- .github/workflows/healthchecks_sqlserver_ci.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/healthchecks_cassandradb_ci.yml b/.github/workflows/healthchecks_cassandradb_ci.yml index ba3895920d..b8c3e9e134 100644 --- a/.github/workflows/healthchecks_cassandradb_ci.yml +++ b/.github/workflows/healthchecks_cassandradb_ci.yml @@ -90,4 +90,4 @@ jobs: uses: codecov/codecov-action@v3 with: flags: CassandraDb - directory: .coverage + directory: .coverage \ No newline at end of file diff --git a/.github/workflows/healthchecks_sqlserver_ci.yml b/.github/workflows/healthchecks_sqlserver_ci.yml index 32622f313d..9dca9bfaf6 100644 --- a/.github/workflows/healthchecks_sqlserver_ci.yml +++ b/.github/workflows/healthchecks_sqlserver_ci.yml @@ -71,4 +71,4 @@ jobs: uses: codecov/codecov-action@v3 with: flags: SqlServer - directory: .coverage \ No newline at end of file + directory: .coverage From e7bff2066328804cba6635d5b62b897520714436 Mon Sep 17 00:00:00 2001 From: djesusnet Date: Tue, 12 Mar 2024 12:30:01 -0300 Subject: [PATCH 36/36] Update Readme.md --- README.md | 2 ++ build/versions.props | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 7fda5974f6..bed48b3570 100644 --- a/README.md +++ b/README.md @@ -87,6 +87,7 @@ HealthChecks packages include health checks for: | Azure Service Bus | [![Nuget](https://img.shields.io/nuget/dt/AspNetCore.HealthChecks.AzureServiceBus)](https://www.nuget.org/packages/AspNetCore.HealthChecks.AzureServiceBus) | [![Nuget](https://img.shields.io/nuget/v/AspNetCore.HealthChecks.AzureServiceBus)](https://www.nuget.org/packages/AspNetCore.HealthChecks.AzureServiceBus) | [![view](https://img.shields.io/github/issues/Xabaril/AspNetCore.Diagnostics.HealthChecks/azure)](https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks/labels/azure) | Queue and Topics | | Consul | [![Nuget](https://img.shields.io/nuget/dt/AspNetCore.HealthChecks.Consul)](https://www.nuget.org/packages/AspNetCore.HealthChecks.Consul) | [![Nuget](https://img.shields.io/nuget/v/AspNetCore.HealthChecks.Consul)](https://www.nuget.org/packages/AspNetCore.HealthChecks.Consul) | [![view](https://img.shields.io/github/issues/Xabaril/AspNetCore.Diagnostics.HealthChecks/consul)](https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks/labels/consul) | CosmosDb | [![Nuget](https://img.shields.io/nuget/dt/AspNetCore.HealthChecks.CosmosDb)](https://www.nuget.org/packages/AspNetCore.HealthChecks.CosmosDb) | [![Nuget](https://img.shields.io/nuget/v/AspNetCore.HealthChecks.CosmosDb)](https://www.nuget.org/packages/AspNetCore.HealthChecks.CosmosDb) | [![view](https://img.shields.io/github/issues/Xabaril/AspNetCore.Diagnostics.HealthChecks/cosmosdb)](https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks/labels/cosmosdb) | CosmosDb and Azure Table +| CassandraDb | [![Nuget](https://img.shields.io/nuget/dt/AspNetCore.HealthChecks.CassandraDb)](https://www.nuget.org/packages/AspNetCore.HealthChecks.CassandraDb) | [![Nuget](https://img.shields.io/nuget/v/AspNetCore.HealthChecks.CassandraDb)](https://www.nuget.org/packages/AspNetCore.HealthChecks.CassandraDb) | [![view](https://img.shields.io/github/issues/Xabaril/AspNetCore.Diagnostics.HealthChecks/cassandradb)](https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks/labels/cassandradb) | Dapr | [![Nuget](https://img.shields.io/nuget/dt/AspNetCore.HealthChecks.Dapr)](https://www.nuget.org/packages/AspNetCore.HealthChecks.Dapr) | [![Nuget](https://img.shields.io/nuget/v/AspNetCore.HealthChecks.Dapr)](https://www.nuget.org/packages/AspNetCore.HealthChecks.Dapr) | [![view](https://img.shields.io/github/issues/Xabaril/AspNetCore.Diagnostics.HealthChecks/dapr)](https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks/labels/dapr) | Azure DocumentDb | [![Nuget](https://img.shields.io/nuget/dt/AspNetCore.HealthChecks.DocumentDb)](https://www.nuget.org/packages/AspNetCore.HealthChecks.DocumentDb) | [![Nuget](https://img.shields.io/nuget/v/AspNetCore.HealthChecks.DocumentDb)](https://www.nuget.org/packages/AspNetCore.HealthChecks.DocumentDb) | [![view](https://img.shields.io/github/issues/Xabaril/AspNetCore.Diagnostics.HealthChecks/documentdb)](https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks/labels/documentdb) | Amazon DynamoDb | [![Nuget](https://img.shields.io/nuget/dt/AspNetCore.HealthChecks.DynamoDb)](https://www.nuget.org/packages/AspNetCore.HealthChecks.DynamoDb) | [![Nuget](https://img.shields.io/nuget/v/AspNetCore.HealthChecks.DynamoDb)](https://www.nuget.org/packages/AspNetCore.HealthChecks.DynamoDb) | [![view](https://img.shields.io/github/issues/Xabaril/AspNetCore.Diagnostics.HealthChecks/dynamodb)](https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks/labels/dynamodb) @@ -143,6 +144,7 @@ Install-Package AspNetCore.HealthChecks.AzureServiceBus Install-Package AspNetCore.HealthChecks.AzureStorage Install-Package AspNetCore.HealthChecks.Consul Install-Package AspNetCore.HealthChecks.CosmosDb +Install-Package AspNetCore.HealthChecks.CassandraDb Install-Package AspNetCore.HealthChecks.Dapr Install-Package AspNetCore.HealthChecks.DocumentDb Install-Package AspNetCore.HealthChecks.DynamoDB diff --git a/build/versions.props b/build/versions.props index a4ae3385b5..d9a98da3ca 100644 --- a/build/versions.props +++ b/build/versions.props @@ -21,7 +21,7 @@ 8.0.0 8.0.0 8.0.0 - 8.0.0 + 8.0.0 8.0.0 8.0.0 8.0.0