From 689276ea7dbe405be04ad5ef6004ab8d7aa31ab1 Mon Sep 17 00:00:00 2001 From: Fox Date: Tue, 23 Jun 2026 17:47:07 +0100 Subject: [PATCH] initial commit --- .gitignore | 482 ++ README.md | 2 + backend/Dockerfile | 16 + backend/SolicitorsApi.slnx | 13 + backend/SolicitorsApi/Program.cs | 176 + .../Properties/launchSettings.json | 23 + backend/SolicitorsApi/SolicitorsApi.csproj | 24 + backend/SolicitorsApi/SolicitorsApi.http | 6 + .../appsettings.Development.json | 8 + backend/SolicitorsApi/appsettings.json | 9 + backend/Tester/Program.cs | 10 + backend/Tester/Tester.csproj | 24 + .../Solicitors.CacheBuild/DIExtensions.cs | 15 + .../ISolicitorImporter.cs | 6 + .../Solicitors.CacheBuild/ISolicitorParser.cs | 9 + .../SolicitorImporter.cs | 29 + .../Solicitors.CacheBuild.csproj | 18 + .../SolicitorsDotCom/Consts.cs | 14 + .../SolicitorsDotCom/SolicitorBuilder.cs | 31 + .../SolicitorsDotCom/SolicitorParser.cs | 316 ++ backend/libs/Solicitors.Core/DIExtensions.cs | 17 + .../Data/IRatingsProviderRepository.cs | 6 + .../Data/IReadOnlySolicitorRepository.cs | 14 + .../Data/ISolicitorRepository.cs | 8 + .../IRatingsProviderService.cs | 6 + .../Solicitors.Core/IReadOnlyCitiesService.cs | 6 + .../IReadOnlySolicitorService.cs | 16 + .../libs/Solicitors.Core/ISolicitorService.cs | 6 + .../Misc/DefaultSolicitorDataOrdering.cs | 23 + .../Misc/EnumerableExtensions.cs | 21 + backend/libs/Solicitors.Core/Misc/IFilter.cs | 29 + .../libs/Solicitors.Core/Misc/Pagination.cs | 7 + backend/libs/Solicitors.Core/Models/City.cs | 9 + .../Models/Imports/Location.cs | 8 + .../Solicitors.Core/Models/Imports/Rating.cs | 9 + .../Models/Imports/SolicitorData.cs | 16 + .../Solicitors.Core/Models/LocationInfo.cs | 18 + .../libs/Solicitors.Core/Models/RatingInfo.cs | 15 + .../libs/Solicitors.Core/Models/Solicitor.cs | 18 + .../Solicitors.Core/Models/SolicitorInfo.cs | 38 + .../Models/SolicitorLocation.cs | 21 + .../Models/SolicitorLocationRating.cs | 13 + .../Solicitors.Core/Models/SolicitorRating.cs | 13 + .../Models/SolicitorSummary.cs | 19 + .../Solicitors.Core/PaginationResponse.cs | 7 + .../Solicitors.Core/RatingsProviderService.cs | 18 + .../Solicitors.Core/ReadOnlyCitiesService.cs | 19 + .../libs/Solicitors.Core/SolicitorService.cs | 50 + .../Solicitors.Core/Solicitors.Core.csproj | 13 + backend/libs/Solicitors.Data/DIExtensions.cs | 36 + .../20260622195820_InitialCreate.Designer.cs | 222 + .../20260622195820_InitialCreate.cs | 172 + .../SolicitorsRepositoryModelSnapshot.cs | 219 + .../RepositorySetup/IRepoSetupOptions.cs | 6 + .../RepositorySetup/IRepoSetupService.cs | 8 + .../InMemory/InMemoryDbSetupOptions.cs | 6 + .../InMemory/InMemorySetupService.cs | 11 + .../Sqlite/SqliteDbSetupOptions.cs | 6 + .../Sqlite/SqliteSetupService.cs | 16 + .../Solicitors.Data/Solicitors.Data.csproj | 20 + .../Solicitors.Data/SolicitorsRepository.cs | 157 + .../Solicitors.HtmlParsing/DIExtensions.cs | 11 + .../libs/Solicitors.HtmlParsing/HtmlParser.cs | 130 + .../Solicitors.HtmlParsing/IHtmlParser.cs | 8 + .../Models/HtmlAttribute.cs | 6 + .../Solicitors.HtmlParsing/Models/HtmlNode.cs | 95 + .../Models/HtmlValueAttribute.cs | 6 + .../Models/IHtmlAttribute.cs | 6 + .../Models/IHtmlNode.cs | 64 + .../Models/ParentHtmlNode.cs | 94 + .../Models/StringNode.cs | 59 + .../Solicitors.HtmlParsing.csproj | 13 + .../Solicitors.HtmlParsing.Tests.csproj | 25 + frontend/.gitignore | 24 + frontend/.yarn/install-state.gz | Bin 0 -> 408488 bytes frontend/.yarnrc.yml | 8 + frontend/Dockerfile | 15 + frontend/README.md | 15 + frontend/index.html | 17 + frontend/package.json | 31 + frontend/public/vite.svg | 15 + frontend/src/assets/preact.svg | 6 + frontend/src/components/detail.tsx | 137 + frontend/src/components/header.tsx | 42 + frontend/src/components/numberField.tsx | 114 + frontend/src/components/result.tsx | 42 + frontend/src/components/results.tsx | 38 + frontend/src/components/resultsList.tsx | 42 + frontend/src/components/sidebar.tsx | 140 + frontend/src/functions/axios.ts | 7 + frontend/src/functions/getCities.ts | 6 + frontend/src/functions/getRatingsProviders.ts | 6 + frontend/src/functions/getSolicitor.ts | 7 + frontend/src/functions/getSolicitors.ts | 22 + frontend/src/index.tsx | 129 + frontend/src/models/filterState.ts | 8 + frontend/src/models/paginationResponse.ts | 4 + frontend/src/models/results.ts | 25 + frontend/src/models/solicitorSummary.ts | 30 + frontend/tsconfig.json | 20 + frontend/vite.config.ts | 7 + frontend/yarn.lock | 4693 +++++++++++++++++ 102 files changed, 8740 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 backend/Dockerfile create mode 100644 backend/SolicitorsApi.slnx create mode 100644 backend/SolicitorsApi/Program.cs create mode 100644 backend/SolicitorsApi/Properties/launchSettings.json create mode 100644 backend/SolicitorsApi/SolicitorsApi.csproj create mode 100644 backend/SolicitorsApi/SolicitorsApi.http create mode 100644 backend/SolicitorsApi/appsettings.Development.json create mode 100644 backend/SolicitorsApi/appsettings.json create mode 100644 backend/Tester/Program.cs create mode 100644 backend/Tester/Tester.csproj create mode 100644 backend/libs/Solicitors.CacheBuild/DIExtensions.cs create mode 100644 backend/libs/Solicitors.CacheBuild/ISolicitorImporter.cs create mode 100644 backend/libs/Solicitors.CacheBuild/ISolicitorParser.cs create mode 100644 backend/libs/Solicitors.CacheBuild/SolicitorImporter.cs create mode 100644 backend/libs/Solicitors.CacheBuild/Solicitors.CacheBuild.csproj create mode 100644 backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/Consts.cs create mode 100644 backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorBuilder.cs create mode 100644 backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorParser.cs create mode 100644 backend/libs/Solicitors.Core/DIExtensions.cs create mode 100644 backend/libs/Solicitors.Core/Data/IRatingsProviderRepository.cs create mode 100644 backend/libs/Solicitors.Core/Data/IReadOnlySolicitorRepository.cs create mode 100644 backend/libs/Solicitors.Core/Data/ISolicitorRepository.cs create mode 100644 backend/libs/Solicitors.Core/IRatingsProviderService.cs create mode 100644 backend/libs/Solicitors.Core/IReadOnlyCitiesService.cs create mode 100644 backend/libs/Solicitors.Core/IReadOnlySolicitorService.cs create mode 100644 backend/libs/Solicitors.Core/ISolicitorService.cs create mode 100644 backend/libs/Solicitors.Core/Misc/DefaultSolicitorDataOrdering.cs create mode 100644 backend/libs/Solicitors.Core/Misc/EnumerableExtensions.cs create mode 100644 backend/libs/Solicitors.Core/Misc/IFilter.cs create mode 100644 backend/libs/Solicitors.Core/Misc/Pagination.cs create mode 100644 backend/libs/Solicitors.Core/Models/City.cs create mode 100644 backend/libs/Solicitors.Core/Models/Imports/Location.cs create mode 100644 backend/libs/Solicitors.Core/Models/Imports/Rating.cs create mode 100644 backend/libs/Solicitors.Core/Models/Imports/SolicitorData.cs create mode 100644 backend/libs/Solicitors.Core/Models/LocationInfo.cs create mode 100644 backend/libs/Solicitors.Core/Models/RatingInfo.cs create mode 100644 backend/libs/Solicitors.Core/Models/Solicitor.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorInfo.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorLocation.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorLocationRating.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorRating.cs create mode 100644 backend/libs/Solicitors.Core/Models/SolicitorSummary.cs create mode 100644 backend/libs/Solicitors.Core/PaginationResponse.cs create mode 100644 backend/libs/Solicitors.Core/RatingsProviderService.cs create mode 100644 backend/libs/Solicitors.Core/ReadOnlyCitiesService.cs create mode 100644 backend/libs/Solicitors.Core/SolicitorService.cs create mode 100644 backend/libs/Solicitors.Core/Solicitors.Core.csproj create mode 100644 backend/libs/Solicitors.Data/DIExtensions.cs create mode 100644 backend/libs/Solicitors.Data/Migrations/20260622195820_InitialCreate.Designer.cs create mode 100644 backend/libs/Solicitors.Data/Migrations/20260622195820_InitialCreate.cs create mode 100644 backend/libs/Solicitors.Data/Migrations/SolicitorsRepositoryModelSnapshot.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupOptions.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupService.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemoryDbSetupOptions.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemorySetupService.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteDbSetupOptions.cs create mode 100644 backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteSetupService.cs create mode 100644 backend/libs/Solicitors.Data/Solicitors.Data.csproj create mode 100644 backend/libs/Solicitors.Data/SolicitorsRepository.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/DIExtensions.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/HtmlParser.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/IHtmlParser.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/HtmlAttribute.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/HtmlNode.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/HtmlValueAttribute.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/IHtmlAttribute.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/IHtmlNode.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/ParentHtmlNode.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Models/StringNode.cs create mode 100644 backend/libs/Solicitors.HtmlParsing/Solicitors.HtmlParsing.csproj create mode 100644 backend/tests/Solicitors.HtmlParsing.Tests/Solicitors.HtmlParsing.Tests.csproj create mode 100644 frontend/.gitignore create mode 100644 frontend/.yarn/install-state.gz create mode 100644 frontend/.yarnrc.yml create mode 100644 frontend/Dockerfile create mode 100644 frontend/README.md create mode 100644 frontend/index.html create mode 100644 frontend/package.json create mode 100644 frontend/public/vite.svg create mode 100644 frontend/src/assets/preact.svg create mode 100644 frontend/src/components/detail.tsx create mode 100644 frontend/src/components/header.tsx create mode 100644 frontend/src/components/numberField.tsx create mode 100644 frontend/src/components/result.tsx create mode 100644 frontend/src/components/results.tsx create mode 100644 frontend/src/components/resultsList.tsx create mode 100644 frontend/src/components/sidebar.tsx create mode 100644 frontend/src/functions/axios.ts create mode 100644 frontend/src/functions/getCities.ts create mode 100644 frontend/src/functions/getRatingsProviders.ts create mode 100644 frontend/src/functions/getSolicitor.ts create mode 100644 frontend/src/functions/getSolicitors.ts create mode 100644 frontend/src/index.tsx create mode 100644 frontend/src/models/filterState.ts create mode 100644 frontend/src/models/paginationResponse.ts create mode 100644 frontend/src/models/results.ts create mode 100644 frontend/src/models/solicitorSummary.ts create mode 100644 frontend/tsconfig.json create mode 100644 frontend/vite.config.ts create mode 100644 frontend/yarn.lock diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0808c4a --- /dev/null +++ b/.gitignore @@ -0,0 +1,482 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from `dotnet new gitignore` + +# dotenv files +.env + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET +project.lock.json +project.fragment.lock.json +artifacts/ + +# Tye +.tye/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +# but not Directory.Build.rsp, as it configures directory-level build defaults +!Directory.Build.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio 6 auto-generated project file (contains which files were open etc.) +*.vbp + +# Visual Studio 6 workspace and project file (working project files containing files to include in project) +*.dsw +*.dsp + +# Visual Studio 6 technical files +*.ncb +*.aps + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# Visual Studio History (VSHistory) files +.vshistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +*.sln.iml +.idea/ + +## +## Visual studio for Mac +## + + +# globs +Makefile.in +*.userprefs +*.usertasks +config.make +config.status +aclocal.m4 +install-sh +autom4te.cache/ +*.tar.gz +tarballs/ +test-results/ + +# content below from: https://github.com/github/gitignore/blob/main/Global/macOS.gitignore +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +# content below from: https://github.com/github/gitignore/blob/main/Global/Windows.gitignore +# Windows thumbnail cache files +Thumbs.db +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# Vim temporary swap files +*.swp diff --git a/README.md b/README.md new file mode 100644 index 0000000..22517a5 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# README + diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000..f0dfe09 --- /dev/null +++ b/backend/Dockerfile @@ -0,0 +1,16 @@ +FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build +WORKDIR /App + +# Copy everything +COPY . ./ +# Restore as distinct layers +RUN dotnet restore +# Build and publish a release +RUN dotnet publish -o out + +# Build runtime image +FROM mcr.microsoft.com/dotnet/aspnet:10.0 +VOLUME /data +WORKDIR /App +COPY --from=build /App/out . +ENTRYPOINT ["dotnet", "SolicitorsApi.dll"] \ No newline at end of file diff --git a/backend/SolicitorsApi.slnx b/backend/SolicitorsApi.slnx new file mode 100644 index 0000000..f7accb8 --- /dev/null +++ b/backend/SolicitorsApi.slnx @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/backend/SolicitorsApi/Program.cs b/backend/SolicitorsApi/Program.cs new file mode 100644 index 0000000..c03d35d --- /dev/null +++ b/backend/SolicitorsApi/Program.cs @@ -0,0 +1,176 @@ +using System.ComponentModel; +using Microsoft.AspNetCore.Mvc; +using Solicitors.CacheBuild; +using Solicitors.Core; +using Solicitors.Core.Misc; +using Solicitors.Core.Models; +using Solicitors.Data; +using Solicitors.Data.RepositorySetup.Sqlite; +using Solicitors.HtmlParsing; + + +var builder = WebApplication.CreateBuilder(args); + +builder.Services.AddOpenApi(); +builder.Services.AddCore(); +builder.Services.AddData(new SqliteDbSetupOptions("demo")); +builder.Services.AddCacheBuild(); +builder.Services.AddHtmlParsing(); +builder.Services.AddHttpClient(); +builder.Services.AddCors(options => +{ + options.AddDefaultPolicy(policy => policy.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin()); +}); + +var app = builder.Build(); + +// Configure the HTTP request pipeline. +if (app.Environment.IsDevelopment()) +{ + app.MapOpenApi(); +} + +app.UseHttpsRedirection(); +app.UseCors(); + +app.MapGet( + "/conveyancors", + ( + [FromServices] IReadOnlySolicitorService solicitorService, + CancellationToken cancellationToken, + [FromQuery] uint pageNumber = 1, + [FromQuery] uint pageSize = 20, + [FromQuery] string? nameFilter = null, + [FromQuery] decimal minRating = 0, + [FromQuery] string[]? cities = null, + [FromQuery] string ratingsProvider = "Solicitors.com", + [FromQuery] string? orderingType = null) => + { + IFilter? filter = null; + + if (!string.IsNullOrEmpty(nameFilter)) + filter = new WrapperFilter(filter, solicitor => solicitor.Name.Contains(nameFilter)); + + if (cities is not null && cities.Length > 0) + filter = new WrapperFilter(filter, solicitor => cities.Any(city => solicitor.Cities.Any(solCity => solCity.Name == city))); + + if (minRating > 0) + filter = new WrapperFilter( + filter, + solicitor => solicitor.Ratings.Any(rating => (rating.Provider == ratingsProvider) && (rating.Value / rating.Maximum >= minRating / 5.0m))); + + IComparer? ordering = orderingType switch + { + "rating-asc" => new RatingComparer(ratingsProvider, true), + "rating-desc" => new RatingComparer(ratingsProvider, false), + "alphabet-asc" => new NameComparer(true), + "alphabet-desc" => new NameComparer(false), + _ => null + }; + + return solicitorService.GetSolicitorSummariesAsync( + new Pagination(pageNumber, pageSize), + ratingsProvider, + filter, + ordering, + cancellationToken: cancellationToken); + } +); + +app.MapGet( + "/cities", + ( + [FromServices] IReadOnlyCitiesService citiesService, + CancellationToken cancellationToken) => + { + return citiesService.GetAllCitiesAsync(cancellationToken); + } +); + +app.MapGet( + "/conveyancors/{id}", + ( + [FromServices] IReadOnlySolicitorService solicitorService, + [FromRoute] Guid id, + CancellationToken cancellationToken + ) => solicitorService.GetSolicitorInfoByIdAsync(id, cancellationToken) +); + +app.MapGet( + "/ratingsProviders", + ( + [FromServices] IRatingsProviderService service, + CancellationToken cancellationToken + ) => + { + return service.GetRatingsProvidersAsync(cancellationToken); + } +); + +using (var scope = app.Services.CreateScope()) +{ + var solicitors = scope.ServiceProvider.GetRequiredService(); + var first = await solicitors + .GetSolicitorSummariesAsync( + new Pagination(1, 1), + "Solicitors.com", + cancellationToken: CancellationToken.None); + if (first.Data.Length == 0) + await scope.ServiceProvider + .GetRequiredService() + .RunFullImport(CancellationToken.None); +} + +app.Run(); + +public class RatingComparer(string ratingsProvider, bool ascending) : IComparer +{ + public int Compare(Solicitor? x, Solicitor? y) + { + var xRating = x?.Ratings?.FirstOrDefault(r => r.Provider == ratingsProvider); + var yRating = y?.Ratings?.FirstOrDefault(r => r.Provider == ratingsProvider); + + decimal compare; + + if (xRating is null) + compare = yRating is null ? 0 : 1; + else if (yRating is null) + compare = -1; + else + { + compare = (xRating.Value / xRating.Maximum) - (yRating.Value / yRating.Maximum); + + if (!ascending) + compare *= -1; + } + + if (compare >= 0) + return (int)Math.Ceiling(compare); + else + return (int)Math.Floor(compare); + + } +} + +public class NameComparer(bool ascending) : IComparer +{ + public int Compare(Solicitor? x, Solicitor? y) + { + int compare; + if (ReferenceEquals(x, y)) + compare = 0; + else if (y is null) + compare = 1; + else if (x is null) + compare = -1; + else + { + compare = string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase); + + if (!ascending) + compare *= -1; + } + + return compare; + } +} \ No newline at end of file diff --git a/backend/SolicitorsApi/Properties/launchSettings.json b/backend/SolicitorsApi/Properties/launchSettings.json new file mode 100644 index 0000000..3abbdbf --- /dev/null +++ b/backend/SolicitorsApi/Properties/launchSettings.json @@ -0,0 +1,23 @@ +{ + "$schema": "https://json.schemastore.org/launchsettings.json", + "profiles": { + "http": { + "commandName": "Project", + "dotnetRunMessages": true, + "launchBrowser": false, + "applicationUrl": "http://localhost:5084", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + }, + "https": { + "commandName": "Project", + "dotnetRunMessages": true, + "launchBrowser": false, + "applicationUrl": "https://localhost:7128;http://localhost:5084", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + } + } +} diff --git a/backend/SolicitorsApi/SolicitorsApi.csproj b/backend/SolicitorsApi/SolicitorsApi.csproj new file mode 100644 index 0000000..28d473a --- /dev/null +++ b/backend/SolicitorsApi/SolicitorsApi.csproj @@ -0,0 +1,24 @@ + + + + net10.0 + enable + enable + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + diff --git a/backend/SolicitorsApi/SolicitorsApi.http b/backend/SolicitorsApi/SolicitorsApi.http new file mode 100644 index 0000000..a6c02e2 --- /dev/null +++ b/backend/SolicitorsApi/SolicitorsApi.http @@ -0,0 +1,6 @@ +@SolicitorsApi_HostAddress = http://localhost:5084 + +GET {{SolicitorsApi_HostAddress}}/weatherforecast/ +Accept: application/json + +### diff --git a/backend/SolicitorsApi/appsettings.Development.json b/backend/SolicitorsApi/appsettings.Development.json new file mode 100644 index 0000000..ff66ba6 --- /dev/null +++ b/backend/SolicitorsApi/appsettings.Development.json @@ -0,0 +1,8 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + } +} diff --git a/backend/SolicitorsApi/appsettings.json b/backend/SolicitorsApi/appsettings.json new file mode 100644 index 0000000..4d56694 --- /dev/null +++ b/backend/SolicitorsApi/appsettings.json @@ -0,0 +1,9 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "AllowedHosts": "*" +} diff --git a/backend/Tester/Program.cs b/backend/Tester/Program.cs new file mode 100644 index 0000000..1d6f986 --- /dev/null +++ b/backend/Tester/Program.cs @@ -0,0 +1,10 @@ +using Microsoft.Extensions.DependencyInjection; +using Solicitors.HtmlParsing; + +var _html = File.ReadAllText("/var/home/fox/main.html"); +var services = new ServiceCollection(); +services.AddHtmlParsing(); +var parser = services.BuildServiceProvider().GetRequiredService(); + +var htmlNodes = parser.ParseHtml(_html).ToArray(); +Console.ReadKey(); \ No newline at end of file diff --git a/backend/Tester/Tester.csproj b/backend/Tester/Tester.csproj new file mode 100644 index 0000000..dd248af --- /dev/null +++ b/backend/Tester/Tester.csproj @@ -0,0 +1,24 @@ + + + + Exe + net10.0 + enable + enable + + + + + ..\..\..\..\..\..\..\..\var\home\fox\.dotnet\shared\Microsoft.AspNetCore.App\10.0.7\Microsoft.Extensions.DependencyInjection.Abstractions.dll + + + + + + + + + + + + diff --git a/backend/libs/Solicitors.CacheBuild/DIExtensions.cs b/backend/libs/Solicitors.CacheBuild/DIExtensions.cs new file mode 100644 index 0000000..4b8ab16 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/DIExtensions.cs @@ -0,0 +1,15 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.Extensions.DependencyInjection; + +namespace Solicitors.CacheBuild; + +[SuppressMessage("ReSharper", "InconsistentNaming")] +public static class DIExtensions +{ + public static IServiceCollection AddCacheBuild(this IServiceCollection services) + { + return services + .AddScoped() + .AddScoped(); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/ISolicitorImporter.cs b/backend/libs/Solicitors.CacheBuild/ISolicitorImporter.cs new file mode 100644 index 0000000..791c72c --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/ISolicitorImporter.cs @@ -0,0 +1,6 @@ +namespace Solicitors.CacheBuild; + +public interface ISolicitorImporter +{ + Task RunFullImport(CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/ISolicitorParser.cs b/backend/libs/Solicitors.CacheBuild/ISolicitorParser.cs new file mode 100644 index 0000000..0119a8c --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/ISolicitorParser.cs @@ -0,0 +1,9 @@ +using Solicitors.Core.Models.Imports; + +namespace Solicitors.CacheBuild; + +internal interface ISolicitorParser +{ + Task GetSolicitorsAsync( + CancellationToken cancellationToken = default); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/SolicitorImporter.cs b/backend/libs/Solicitors.CacheBuild/SolicitorImporter.cs new file mode 100644 index 0000000..348be45 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/SolicitorImporter.cs @@ -0,0 +1,29 @@ +using Solicitors.Core.Data; +using Solicitors.Core.Models.Imports; + +namespace Solicitors.CacheBuild; + +internal class SolicitorImporter : ISolicitorImporter +{ + private readonly ISolicitorParser _parser; + private readonly ISolicitorRepository _repository; + + public SolicitorImporter( + ISolicitorParser parser, + ISolicitorRepository repository) + { + _parser = parser; + _repository = repository; + } + + public async Task RunFullImport(CancellationToken cancellationToken) + { + foreach (var solicitor in await _parser.GetSolicitorsAsync(cancellationToken)) + { + await RunImport(solicitor, cancellationToken); + } + } + + private Task RunImport(SolicitorData solicitor, CancellationToken cancellationToken) + => _repository.AddOrUpdateSolicitorAsync(solicitor, cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/Solicitors.CacheBuild.csproj b/backend/libs/Solicitors.CacheBuild/Solicitors.CacheBuild.csproj new file mode 100644 index 0000000..66de5d2 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/Solicitors.CacheBuild.csproj @@ -0,0 +1,18 @@ + + + + net10.0 + enable + enable + + + + + + + + + + + + diff --git a/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/Consts.cs b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/Consts.cs new file mode 100644 index 0000000..b6c3840 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/Consts.cs @@ -0,0 +1,14 @@ +namespace Solicitors.CacheBuild.SolicitorsDotCom; + +internal static class Consts +{ + public const string BaseUrl = "https://www.solicitors.com"; + public static readonly string[] Locations = + [ + "london", "birmingham", "leeds", "manchester", "sheffield", "bradford", "liverpool", "bristol" + ]; + + public const decimal MaxRating = 5.0m; + public const string Name = "Solicitors.com"; + public const string IconPath = "/images/logo.svg"; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorBuilder.cs b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorBuilder.cs new file mode 100644 index 0000000..d7c290c --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorBuilder.cs @@ -0,0 +1,31 @@ +namespace Solicitors.CacheBuild.SolicitorsDotCom; + +internal class SolicitorBuilder +{ + private readonly HashSet _baseLocations = []; + + public SolicitorBuilder( + string name, + string path, + string? shortDesc, + string baseLocation) + { + Name = name; + ShortDescription = shortDesc; + _baseLocations.Add(baseLocation); + + Path = path; + } + + public void AddBaseLocation(string baseLocation) + { + _baseLocations.Add(baseLocation); + } + + public string Path { get; } + public string Name { get; } + + public string? ShortDescription { get; } + + public string[] BaseLocations => _baseLocations.ToArray(); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorParser.cs b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorParser.cs new file mode 100644 index 0000000..76b56b1 --- /dev/null +++ b/backend/libs/Solicitors.CacheBuild/SolicitorsDotCom/SolicitorParser.cs @@ -0,0 +1,316 @@ +using System.Diagnostics.CodeAnalysis; +using System.Net.Http.Headers; +using Solicitors.Core.Misc; +using Solicitors.Core.Models.Imports; +using Solicitors.HtmlParsing; +using Solicitors.HtmlParsing.Models; + +namespace Solicitors.CacheBuild.SolicitorsDotCom; + +internal class SolicitorParser : ISolicitorParser +{ + private readonly HttpClient _client; + private readonly IHtmlParser _htmlParser; + + public SolicitorParser( + HttpClient client, + IHtmlParser htmlParser) + { + _client = client; + _client.BaseAddress = new Uri(Consts.BaseUrl); + + _htmlParser = htmlParser; + } + + public async Task GetSolicitorsAsync( + CancellationToken cancellationToken = default) + { + var builders = new Dictionary(); + + foreach (var location in Consts.Locations) + { + var httpRequest = new HttpRequestMessage(HttpMethod.Get, $"/conveyancing+{location}.html"); + httpRequest.Headers.Add("User-Agent", "Solicitors API Cache"); + var httpResponse = await _client.SendAsync(httpRequest, cancellationToken); + var html = await httpResponse.Content.ReadAsStringAsync(cancellationToken); + var nodes = _htmlParser.ParseHtml(html); + IHtmlNode? mainNode = null; + foreach (var node in nodes) + if (node.TryGetByTagName("main", out mainNode)) + break; + + if (TryGetResultSection(mainNode, out var results)) + ParseResultsSection(results, location, builders); + } + + var batches = builders.Values + .Select(builder => GetFullSolicitorDataAsync(builder, cancellationToken)) + .Batch(5); + + var solicitors = new List(); + foreach (var batch in batches) + solicitors.AddRange(await Task.WhenAll(batch)); + + return solicitors + .Where(x => x is not null) + .Cast() + .ToArray(); + } + + private bool TryGetResultSection( + IHtmlNode? mainNode, + [NotNullWhen(true)] out IEnumerable? results) + { + results = null; + + // going one level at a time helps a little with performance here, at the cost of messier code + return mainNode is not null + && mainNode.TryGetByTagNameAndClass("div", "content-holder", out var contentHolderNode) + && contentHolderNode.TryGetByTagNameAndClass("div", "container", out var containerNode) + && containerNode.TryGetByTagNameAndClass("div", "content", out var contentNode) + && contentNode.TryGetByTagNameAndClass("div", "result-section", out var resultSectionNode) + && resultSectionNode.TryGetChildren(out results); + } + + private void ParseResultsSection( + IEnumerable results, + string location, + Dictionary builders) + { + foreach (var result in results) + { + if (result.TryGetByClass("result-item", out var resultItem, true) + && TryParseToNewBuilder(resultItem, location, out var builder)) + { + if (!builders.TryAdd(builder.Path, builder)) + builders[builder.Path].AddBaseLocation(location); + } + } + } + + private bool TryParseToNewBuilder( + IHtmlNode resultItemNode, + string baseLocation, + [NotNullWhen(true)] out SolicitorBuilder? builder) + { + builder = null; + if (!resultItemNode.TryGetByTagNameAndClass("a", "link-map", out var linkMapNode) + || !linkMapNode.TryGetAttributeValue("href", out var uniqueUrl) + || !resultItemNode.TryGetByTagNameAndClass("span", "h2", out var titleNode) + || !titleNode.TryGetChildren(out var titleChildren)) + return false; + + string? name = null; + foreach (var child in titleChildren) + if (child.TryGetText(out name)) + break; + + if (name is null) + return false; + + string? shortDesc = null; + if (resultItemNode.TryGetByTagName("p", out var pNode) + && pNode.TryGetChildren(out var pChildren)) + foreach (var child in pChildren) + if (child.TryGetText(out shortDesc)) + break; + + builder = new SolicitorBuilder(name, uniqueUrl, shortDesc, baseLocation); + return true; + } + + private async Task GetFullSolicitorDataAsync( + SolicitorBuilder builder, + CancellationToken cancellationToken) + { + + var httpRequest = new HttpRequestMessage(HttpMethod.Get, builder.Path); + httpRequest.Headers.Add("User-Agent", "Solicitors API Cache"); + var httpResponse = await _client.SendAsync(httpRequest, cancellationToken); + var html = await httpResponse.Content.ReadAsStringAsync(cancellationToken); + var nodes = _htmlParser.ParseHtml(html); + IHtmlNode? mainNode = null; + foreach (var node in nodes) + if (node.TryGetByTagName("main", out mainNode)) + break; + + if (mainNode is null || !mainNode.TryGetByTagNameAndClass("div", "content-block", out var contentBlockNode)) + return null; + + Location[] offices = []; + if (contentBlockNode.TryGetByTagNameAndClass("div", "office-item", out var officeItemNode) + && officeItemNode.TryGetChildren(out var officeItems)) + { + offices = ParseOffices(officeItems); + } + + Rating[] ratings = []; + string? phone = null; + string? email = null; + string? website = null; + if (mainNode.TryGetByTagNameAndClass("div", "side-holder", out var sidebarNode) + && sidebarNode.TryGetChildren(out var sidebarChildren)) + { + ParseSidebar(sidebarChildren, out phone, out email, out website, out ratings); + } + + return new SolicitorData() + { + Name = builder.Name, + UrlPath = builder.Path, + ShortDescription = builder.ShortDescription, + Phone = phone, + Email = email, + Website = website, + Ratings = ratings, + Offices = offices, + Cities = builder.BaseLocations + }; + } + + Location[] ParseOffices(IEnumerable officeNodes) + => officeNodes + .Select(ParseOffice) + .Where(x => x is not null) + .Cast() + .ToArray(); + + Location? ParseOffice(IHtmlNode officeNode) + { + if (!officeNode.TryGetChildren(out var officeChildren) + || !officeNode.TryGetByTagName("address", out var addressNode) + || !addressNode.TryGetChildren(out var addressLines)) + return null; + + Location? location = null; + string? address = ""; + foreach (var line in addressLines) + { + if (line.TryGetText(out var lineText)) + address += lineText; + else if (line.TryGetByTagName("br", out _, true)) + address += "\n"; + } + + if (string.IsNullOrWhiteSpace(address)) + address = null; + + string? phone = null; + foreach (var child in officeChildren) + { + if (child.TryGetByTagName("a", out var anchor) + && anchor.TryGetAttributeValue("href", out var telString) + && telString.StartsWith("\"tel:") + && telString.Length > 5) + { + phone = telString.Substring(5, telString.Length - 6); + break; + } + } + + if (address is not null && phone is not null) + location = new Location(address, phone, []); + + return location; + } + + void ParseSidebar( + IEnumerable sidebarChildren, + out string? phone, + out string? email, + out string? website, + out Rating[] ratings) + { + List ratingsList = []; + phone = null; + website = null; + email = null; + + foreach (var node in sidebarChildren) + { + var isRevCount = node.TryGetByTagNameAndClass("div", "rev-count", out _, true); + var isLinksHolder = node.TryGetByTagNameAndClass("div", "links-holder", out _, true); + if ((!isRevCount && !isLinksHolder) + || !node.TryGetChildren(out var children)) + continue; + + if (isLinksHolder) + { + if (node.TryGetByTagNameAndClass("a", "website", out var websiteNode) + && websiteNode.TryGetAttributeValue("href", out website)) + website = website.Trim('"'); + + if (node.TryGetByTagNameAndClass("a", "phone", out var phoneNode) + && phoneNode.TryGetAttributeValue("href", out var phoneStr) + && phoneStr.StartsWith("\"tel:") + && phoneStr.Length > 5) + { + phone = phoneStr.Substring(5, phoneStr.Length - 6); + } + } + + var childrenArray = children as IHtmlNode[] ?? children.ToArray(); + foreach (var child in childrenArray.Where(x => x.TryGetByClass("rev-box", out _, true))) + { + if (child.TryGetAttributeValue("title", out var ratingString) + && TryParseRatingString(ratingString, out decimal rating, out decimal maxRating) + && child.TryGetByTagNameAndClass("img", "rev-logo", out var imgNode) + && imgNode.TryGetAttributeValue("src", out var imgSrc) + && TryParseRatingSrc(imgSrc, out var ratingProvider)) + { + ratingsList.Add(new Rating(rating, maxRating, ratingProvider, imgSrc)); + } + } + + if (ratingsList.Count == 0) + { + foreach (var child in childrenArray.Where(x => !x.HasAttribute("class"))) + { + if (child.TryGetChildren(out var grandChildren)) + foreach (var grandChild in grandChildren) + if (grandChild.TryGetText(out var textContent) + && TryParseOwnRatingString(textContent, out var rating)) + ratingsList.Add(new Rating(rating, Consts.MaxRating, Consts.Name, Consts.IconPath)); + } + } + } + + ratings = ratingsList.ToArray(); + } + + + bool TryParseRatingString(string ratingString, out decimal rating, out decimal maxRating) + { + rating = 0; + maxRating = 0; + var parts = ratingString.Trim('"').Split(" / "); + if (parts.Length != 2) + return false; + + return decimal.TryParse(parts[0], out rating) && decimal.TryParse(parts[1], out maxRating); + } + + bool TryParseRatingSrc(string imgSrc, out string provider) + { + provider = ""; + imgSrc = imgSrc.Trim('"'); + var prefix = "/images/logo-"; + if (!imgSrc.StartsWith(prefix)) + return false; + + var providerAndExtension = imgSrc.Substring(prefix.Length); + provider = providerAndExtension.Split('.').First(); + return true; + } + + bool TryParseOwnRatingString(string ratingString, out decimal rating) + { + rating = 0; + var prefix = "Average review score : "; + if (!ratingString.StartsWith(prefix)) + return false; + + var ratingPart = ratingString.Substring(prefix.Length); + return decimal.TryParse(ratingPart, out rating); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/DIExtensions.cs b/backend/libs/Solicitors.Core/DIExtensions.cs new file mode 100644 index 0000000..b7feb4f --- /dev/null +++ b/backend/libs/Solicitors.Core/DIExtensions.cs @@ -0,0 +1,17 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.Extensions.DependencyInjection; + +namespace Solicitors.Core; + +[SuppressMessage("ReSharper", "InconsistentNaming")] +public static class DIExtensions +{ + public static IServiceCollection AddCore(this IServiceCollection services) + { + return services + .AddScoped() + .AddScoped(sp => sp.GetRequiredService()) + .AddScoped() + .AddScoped(); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Data/IRatingsProviderRepository.cs b/backend/libs/Solicitors.Core/Data/IRatingsProviderRepository.cs new file mode 100644 index 0000000..1ce39af --- /dev/null +++ b/backend/libs/Solicitors.Core/Data/IRatingsProviderRepository.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Core.Data; + +public interface IRatingsProviderRepository +{ + IAsyncEnumerable GetAllRatingsProvidersAsync(); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Data/IReadOnlySolicitorRepository.cs b/backend/libs/Solicitors.Core/Data/IReadOnlySolicitorRepository.cs new file mode 100644 index 0000000..7314b88 --- /dev/null +++ b/backend/libs/Solicitors.Core/Data/IReadOnlySolicitorRepository.cs @@ -0,0 +1,14 @@ +using Solicitors.Core.Models; + +namespace Solicitors.Core.Data; + +public interface IReadOnlySolicitorRepository +{ + IAsyncEnumerable GetAllSolicitorsAsync(); + Task GetSolicitorByIdAsync(Guid id, CancellationToken cancellationToken = default); +} + +public interface IReadOnlyCitiesRepository +{ + IAsyncEnumerable GetCitiesAsync(CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Data/ISolicitorRepository.cs b/backend/libs/Solicitors.Core/Data/ISolicitorRepository.cs new file mode 100644 index 0000000..72dd972 --- /dev/null +++ b/backend/libs/Solicitors.Core/Data/ISolicitorRepository.cs @@ -0,0 +1,8 @@ +using Solicitors.Core.Models.Imports; + +namespace Solicitors.Core.Data; + +public interface ISolicitorRepository : IReadOnlySolicitorRepository +{ + Task AddOrUpdateSolicitorAsync(SolicitorData solicitor, CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/IRatingsProviderService.cs b/backend/libs/Solicitors.Core/IRatingsProviderService.cs new file mode 100644 index 0000000..f8fb306 --- /dev/null +++ b/backend/libs/Solicitors.Core/IRatingsProviderService.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Core; + +public interface IRatingsProviderService +{ + Task GetRatingsProvidersAsync(CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/IReadOnlyCitiesService.cs b/backend/libs/Solicitors.Core/IReadOnlyCitiesService.cs new file mode 100644 index 0000000..0322247 --- /dev/null +++ b/backend/libs/Solicitors.Core/IReadOnlyCitiesService.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Core; + +public interface IReadOnlyCitiesService +{ + Task GetAllCitiesAsync(CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/IReadOnlySolicitorService.cs b/backend/libs/Solicitors.Core/IReadOnlySolicitorService.cs new file mode 100644 index 0000000..030270a --- /dev/null +++ b/backend/libs/Solicitors.Core/IReadOnlySolicitorService.cs @@ -0,0 +1,16 @@ +using Solicitors.Core.Misc; +using Solicitors.Core.Models; + +namespace Solicitors.Core; + +public interface IReadOnlySolicitorService +{ + Task> GetSolicitorSummariesAsync( + Pagination pagination, + string ratingsProvider, + IFilter? filter = null, + IComparer? ordering = null, + CancellationToken cancellationToken = default); + + Task GetSolicitorInfoByIdAsync(Guid id, CancellationToken cancellationToken = default); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/ISolicitorService.cs b/backend/libs/Solicitors.Core/ISolicitorService.cs new file mode 100644 index 0000000..1bc9d56 --- /dev/null +++ b/backend/libs/Solicitors.Core/ISolicitorService.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Core; + +public interface ISolicitorService : IReadOnlySolicitorService +{ + +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Misc/DefaultSolicitorDataOrdering.cs b/backend/libs/Solicitors.Core/Misc/DefaultSolicitorDataOrdering.cs new file mode 100644 index 0000000..7621939 --- /dev/null +++ b/backend/libs/Solicitors.Core/Misc/DefaultSolicitorDataOrdering.cs @@ -0,0 +1,23 @@ +using Solicitors.Core.Models; + +namespace Solicitors.Core.Misc; + +internal class DefaultSolicitorDataOrdering : IComparer +{ + public static IComparer Instance { get; } = new DefaultSolicitorDataOrdering(); + + private DefaultSolicitorDataOrdering() + { + } + + public int Compare(Solicitor? x, Solicitor? y) + { + if (x is null) + return y is null ? 0 : int.MaxValue; + + else if (y is null) + return int.MinValue; + + return Comparer.Default.Compare(x.SolicitorId, y.SolicitorId); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Misc/EnumerableExtensions.cs b/backend/libs/Solicitors.Core/Misc/EnumerableExtensions.cs new file mode 100644 index 0000000..90be174 --- /dev/null +++ b/backend/libs/Solicitors.Core/Misc/EnumerableExtensions.cs @@ -0,0 +1,21 @@ +namespace Solicitors.Core.Misc; + +public static class EnumerableExtensions +{ + public static IEnumerable Batch(this IEnumerable source, int batchSize) + { + var batch = new List(batchSize); + foreach (var item in source) + { + batch.Add(item); + if (batch.Count == batch.Capacity) + { + yield return batch.ToArray(); + batch.Clear(); + } + } + + if (batch.Count > 0) + yield return batch.ToArray(); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Misc/IFilter.cs b/backend/libs/Solicitors.Core/Misc/IFilter.cs new file mode 100644 index 0000000..8e82d43 --- /dev/null +++ b/backend/libs/Solicitors.Core/Misc/IFilter.cs @@ -0,0 +1,29 @@ +namespace Solicitors.Core.Misc; + +public interface IFilter +{ + bool Filter(T item); +} + +public class WrapperFilter : IFilter +{ + private readonly Func _filter; + private readonly IFilter? _inner; + + public WrapperFilter( + IFilter? inner, + Func filter) + { + _inner = inner; + _filter = filter; + } + + + public bool Filter(T item) + { + if (_inner is not null) + return _inner.Filter(item) && _filter(item); + + return _filter(item); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Misc/Pagination.cs b/backend/libs/Solicitors.Core/Misc/Pagination.cs new file mode 100644 index 0000000..ed4168c --- /dev/null +++ b/backend/libs/Solicitors.Core/Misc/Pagination.cs @@ -0,0 +1,7 @@ +namespace Solicitors.Core.Misc; + +public readonly struct Pagination(uint currentPage, uint pageSize) +{ + public uint CurrentPage { get; } = currentPage; + public uint PageSize { get; } = pageSize; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/City.cs b/backend/libs/Solicitors.Core/Models/City.cs new file mode 100644 index 0000000..f183649 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/City.cs @@ -0,0 +1,9 @@ +namespace Solicitors.Core.Models; + +public record City +{ + public Guid CityId { get; set; } + public required string Name { get; set; } + + public List Solicitors { get; } = new(); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/Imports/Location.cs b/backend/libs/Solicitors.Core/Models/Imports/Location.cs new file mode 100644 index 0000000..14c6fb6 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/Imports/Location.cs @@ -0,0 +1,8 @@ +namespace Solicitors.Core.Models.Imports; + +public record Location(string address, string phone, Rating[] locationRatings) +{ + public string Address { get; } = address; + public string Phone { get; } = phone; + public Rating[] LocationRatings { get; } = locationRatings; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/Imports/Rating.cs b/backend/libs/Solicitors.Core/Models/Imports/Rating.cs new file mode 100644 index 0000000..7893907 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/Imports/Rating.cs @@ -0,0 +1,9 @@ +namespace Solicitors.Core.Models.Imports; + +public record Rating(decimal value, decimal maxValue, string provider, string imgSrc) +{ + public decimal Value { get; } = value; + public decimal MaxValue { get; } = maxValue; + public string RatingProvider { get; } = provider; + public string RatingProviderImgSrc { get; } = imgSrc; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/Imports/SolicitorData.cs b/backend/libs/Solicitors.Core/Models/Imports/SolicitorData.cs new file mode 100644 index 0000000..e3489e7 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/Imports/SolicitorData.cs @@ -0,0 +1,16 @@ +namespace Solicitors.Core.Models.Imports; + +public class SolicitorData +{ + public required string Name { get; init; } + public required string UrlPath { get; init; } + + public string? ShortDescription { get; init; } + public string? Phone { get; init; } + public string? Email { get; init; } + public string? Website { get; init; } + + public string[] Cities { get; init; } = []; + public Rating[] Ratings { get; init; } = []; + public Location[] Offices { get; init; } = []; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/LocationInfo.cs b/backend/libs/Solicitors.Core/Models/LocationInfo.cs new file mode 100644 index 0000000..63ef4d6 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/LocationInfo.cs @@ -0,0 +1,18 @@ +namespace Solicitors.Core.Models; + +public record LocationInfo +{ + public LocationInfo(SolicitorLocation location) + { + Address = location.Address; + Phone = location.Phone; + Ratings = location.LocationRatings + .Select(rating => new RatingInfo(rating)) + .ToArray(); + } + + public string Address { get; } + public string Phone { get; } + + public RatingInfo[] Ratings { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/RatingInfo.cs b/backend/libs/Solicitors.Core/Models/RatingInfo.cs new file mode 100644 index 0000000..9564194 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/RatingInfo.cs @@ -0,0 +1,15 @@ +namespace Solicitors.Core.Models; + +public record RatingInfo +{ + public RatingInfo(IRating rating) + { + Value = rating.Value; + Maximum = rating.Maximum; + Provider = rating.Provider; + } + + public decimal Value { get; } + public decimal Maximum { get; } + public string Provider { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/Solicitor.cs b/backend/libs/Solicitors.Core/Models/Solicitor.cs new file mode 100644 index 0000000..0172467 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/Solicitor.cs @@ -0,0 +1,18 @@ +namespace Solicitors.Core.Models; + +public record Solicitor +{ + public Guid SolicitorId { get; set; } + + public required string Name { get; set; } + public required string RelativeUrl { get; set; } + + public string? Phone { get; set; } + public string? Email { get; set; } + public string? Website { get; set; } + public string? ShortDescription { get; set; } + + public List Cities { get; } = new(); + public List Ratings { get; } = new(); + public List Locations { get; } = new(); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorInfo.cs b/backend/libs/Solicitors.Core/Models/SolicitorInfo.cs new file mode 100644 index 0000000..ac7c5a2 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorInfo.cs @@ -0,0 +1,38 @@ +namespace Solicitors.Core.Models; + +public record SolicitorInfo +{ + internal SolicitorInfo(Solicitor solicitor) + { + Id = solicitor.SolicitorId; + Name = solicitor.Name; + ShortDescription = solicitor.ShortDescription; + Phone = solicitor.Phone; + Email = solicitor.Email; + Website = solicitor.Website; + + Cities = solicitor.Cities + .Select(city => city.Name) + .ToArray(); + + Ratings = solicitor.Ratings + .Select(rating => new RatingInfo(rating)) + .ToArray(); + + Locations = solicitor.Locations + .Select(location => new LocationInfo(location)) + .ToArray(); + } + + public string Name { get; set; } + public string ShortDescription { get; set; } + public Guid Id { get; set; } + + public string? Phone { get; set; } + public string? Email { get; set; } + public string? Website { get; set; } + + public string[] Cities { get; set; } + public RatingInfo[] Ratings { get; set; } + public LocationInfo[] Locations { get; set; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorLocation.cs b/backend/libs/Solicitors.Core/Models/SolicitorLocation.cs new file mode 100644 index 0000000..84111b3 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorLocation.cs @@ -0,0 +1,21 @@ +namespace Solicitors.Core.Models; + +public record SolicitorLocation +{ + public Guid SolicitorLocationId { get; set; } + + public required string Address { get; set; } + public required string Phone { get; set; } + + public List LocationRatings { get; } = new(); + + public Guid SolicitorId { get; set; } + public required Solicitor Solicitor { get; set; } +} + +public interface IRating +{ + decimal Value { get; } + decimal Maximum { get; } + string Provider { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorLocationRating.cs b/backend/libs/Solicitors.Core/Models/SolicitorLocationRating.cs new file mode 100644 index 0000000..f578ac8 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorLocationRating.cs @@ -0,0 +1,13 @@ +namespace Solicitors.Core.Models; + +public record SolicitorLocationRating : IRating +{ + public Guid SolicitorLocationRatingId { get; set; } + + public required decimal Value { get; set; } + public required decimal Maximum { get; set; } + public required string Provider { get; set; } + + public Guid SolicitorLocationId { get; set; } + public required SolicitorLocation SolicitorLocation { get; set; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorRating.cs b/backend/libs/Solicitors.Core/Models/SolicitorRating.cs new file mode 100644 index 0000000..e8edae2 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorRating.cs @@ -0,0 +1,13 @@ +namespace Solicitors.Core.Models; + +public record SolicitorRating : IRating +{ + public Guid SolicitorRatingId { get; set; } + + public required decimal Value { get; set; } + public required decimal Maximum { get; set; } + public required string Provider { get; set; } + + public Guid SolicitorId { get; set; } + public required Solicitor Solicitor { get; set; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Models/SolicitorSummary.cs b/backend/libs/Solicitors.Core/Models/SolicitorSummary.cs new file mode 100644 index 0000000..da5f195 --- /dev/null +++ b/backend/libs/Solicitors.Core/Models/SolicitorSummary.cs @@ -0,0 +1,19 @@ +namespace Solicitors.Core.Models; + +public record SolicitorSummary +{ + internal SolicitorSummary(Solicitor solicitor, string ratingsProvider) + { + Id = solicitor.SolicitorId; + Name = solicitor.Name; + ShortDescription = solicitor.ShortDescription; + var rating = solicitor.Ratings.FirstOrDefault(x => x.Provider == ratingsProvider); + if (rating is not null) + Rating = new RatingInfo(rating); + } + + public Guid Id { get; } + public string Name { get; } + public string? ShortDescription { get; } + public RatingInfo? Rating { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/PaginationResponse.cs b/backend/libs/Solicitors.Core/PaginationResponse.cs new file mode 100644 index 0000000..bd0694f --- /dev/null +++ b/backend/libs/Solicitors.Core/PaginationResponse.cs @@ -0,0 +1,7 @@ +namespace Solicitors.Core; + +public record PaginationResponse(int Total, T[] Data) +{ + public T[] Data { get; set; } = Data; + public int Total { get; set; } = Total; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/RatingsProviderService.cs b/backend/libs/Solicitors.Core/RatingsProviderService.cs new file mode 100644 index 0000000..e4f2ed8 --- /dev/null +++ b/backend/libs/Solicitors.Core/RatingsProviderService.cs @@ -0,0 +1,18 @@ +using Solicitors.Core.Data; + +namespace Solicitors.Core; + +internal class RatingsProviderService : IRatingsProviderService +{ + private readonly IRatingsProviderRepository _repo; + + public RatingsProviderService(IRatingsProviderRepository repo) + { + _repo = repo; + } + + public async Task GetRatingsProvidersAsync(CancellationToken cancellationToken) + { + return await _repo.GetAllRatingsProvidersAsync().ToArrayAsync(cancellationToken); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/ReadOnlyCitiesService.cs b/backend/libs/Solicitors.Core/ReadOnlyCitiesService.cs new file mode 100644 index 0000000..28b8371 --- /dev/null +++ b/backend/libs/Solicitors.Core/ReadOnlyCitiesService.cs @@ -0,0 +1,19 @@ +using Solicitors.Core.Data; + +namespace Solicitors.Core; + +internal class ReadOnlyCitiesService : IReadOnlyCitiesService +{ + private readonly IReadOnlyCitiesRepository _repo; + + public ReadOnlyCitiesService(IReadOnlyCitiesRepository repo) + { + _repo = repo; + } + + public async Task GetAllCitiesAsync(CancellationToken cancellationToken) + { + var cities = _repo.GetCitiesAsync(cancellationToken); + return await cities.ToArrayAsync(cancellationToken); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/SolicitorService.cs b/backend/libs/Solicitors.Core/SolicitorService.cs new file mode 100644 index 0000000..ad329a0 --- /dev/null +++ b/backend/libs/Solicitors.Core/SolicitorService.cs @@ -0,0 +1,50 @@ +using Solicitors.Core.Data; +using Solicitors.Core.Misc; +using Solicitors.Core.Models; + +namespace Solicitors.Core; + +internal class SolicitorService : ISolicitorService +{ + private readonly IReadOnlySolicitorRepository _repo; + + public SolicitorService(IReadOnlySolicitorRepository repo) + { + _repo = repo; + } + + public async Task> GetSolicitorSummariesAsync( + Pagination pagination, + string ratingsProvider, + IFilter? filter = null, + IComparer? ordering = null, + CancellationToken cancellationToken = default) + { + var allSolicitors = _repo.GetAllSolicitorsAsync(); + if (filter is not null) + allSolicitors = allSolicitors.Where(filter.Filter); + + var matchingSolicitors = await allSolicitors.ToArrayAsync(cancellationToken); + + if (ordering is null) + ordering = DefaultSolicitorDataOrdering.Instance; + + var results = matchingSolicitors + .OrderBy(x => x, ordering) + .Skip((int)((pagination.CurrentPage - 1) * pagination.PageSize)) + .Take((int)pagination.PageSize) + .Select(x => new SolicitorSummary(x, ratingsProvider)) + .ToArray(); + + return new PaginationResponse(matchingSolicitors.Length, results); + } + + public async Task GetSolicitorInfoByIdAsync(Guid id, CancellationToken cancellationToken = default) + { + var data = await _repo.GetSolicitorByIdAsync(id, cancellationToken); + if (data is null) + return null; + + return new SolicitorInfo(data); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Core/Solicitors.Core.csproj b/backend/libs/Solicitors.Core/Solicitors.Core.csproj new file mode 100644 index 0000000..faad367 --- /dev/null +++ b/backend/libs/Solicitors.Core/Solicitors.Core.csproj @@ -0,0 +1,13 @@ + + + + net10.0 + enable + enable + + + + + + + diff --git a/backend/libs/Solicitors.Data/DIExtensions.cs b/backend/libs/Solicitors.Data/DIExtensions.cs new file mode 100644 index 0000000..a8cda75 --- /dev/null +++ b/backend/libs/Solicitors.Data/DIExtensions.cs @@ -0,0 +1,36 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +using Solicitors.Core; +using Solicitors.Core.Data; +using Solicitors.Data.RepositorySetup; +using Solicitors.Data.RepositorySetup.InMemory; +using Solicitors.Data.RepositorySetup.Sqlite; + +namespace Solicitors.Data; + +[SuppressMessage("ReSharper", "InconsistentNaming")] +public static class DIExtensions +{ + public static IServiceCollection AddData(this IServiceCollection services, IRepoSetupOptions options) + { + return services + .AddScoped() + .AddScoped(sp => sp.GetRequiredService()) + .AddScoped(sp => sp.GetRequiredService()) + .AddScoped(sp => sp.GetRequiredService()) + .AddScoped(sp => sp.GetRequiredService()) + .AddSingleton(GetSetupService(options)); + } + + private static IRepoSetupService GetSetupService(IRepoSetupOptions options) + { + if (options is InMemoryDbSetupOptions inMemOptions) + return new InMemorySetupService(inMemOptions); + + if (options is SqliteDbSetupOptions sqliteOptions) + return new SqliteSetupService(sqliteOptions); + + throw new ArgumentException("Options type not supported", nameof(options)); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/Migrations/20260622195820_InitialCreate.Designer.cs b/backend/libs/Solicitors.Data/Migrations/20260622195820_InitialCreate.Designer.cs new file mode 100644 index 0000000..0b8622e --- /dev/null +++ b/backend/libs/Solicitors.Data/Migrations/20260622195820_InitialCreate.Designer.cs @@ -0,0 +1,222 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Solicitors.Data; + +#nullable disable + +namespace Solicitors.Data.Migrations +{ + [DbContext(typeof(SolicitorsRepository))] + [Migration("20260622195820_InitialCreate")] + partial class InitialCreate + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder.HasAnnotation("ProductVersion", "10.0.9"); + + modelBuilder.Entity("CitySolicitor", b => + { + b.Property("CitiesCityId") + .HasColumnType("TEXT"); + + b.Property("SolicitorsSolicitorId") + .HasColumnType("TEXT"); + + b.HasKey("CitiesCityId", "SolicitorsSolicitorId"); + + b.HasIndex("SolicitorsSolicitorId"); + + b.ToTable("CitySolicitor"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.City", b => + { + b.Property("CityId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Name") + .IsRequired() + .HasColumnType("TEXT"); + + b.HasKey("CityId"); + + b.ToTable("Cities"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.Solicitor", b => + { + b.Property("SolicitorId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Email") + .HasColumnType("TEXT"); + + b.Property("Name") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Phone") + .HasColumnType("TEXT"); + + b.Property("RelativeUrl") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("ShortDescription") + .HasColumnType("TEXT"); + + b.Property("Website") + .HasColumnType("TEXT"); + + b.HasKey("SolicitorId"); + + b.ToTable("Solicitors"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocation", b => + { + b.Property("SolicitorLocationId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Address") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Phone") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("SolicitorId") + .HasColumnType("TEXT"); + + b.HasKey("SolicitorLocationId"); + + b.HasIndex("SolicitorId"); + + b.ToTable("SolicitorLocations"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocationRating", b => + { + b.Property("SolicitorLocationRatingId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Maximum") + .HasColumnType("TEXT"); + + b.Property("Provider") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("SolicitorLocationId") + .HasColumnType("TEXT"); + + b.Property("Value") + .HasColumnType("TEXT"); + + b.HasKey("SolicitorLocationRatingId"); + + b.HasIndex("SolicitorLocationId"); + + b.ToTable("SolicitorLocationRatings"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorRating", b => + { + b.Property("SolicitorRatingId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Maximum") + .HasColumnType("TEXT"); + + b.Property("Provider") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("SolicitorId") + .HasColumnType("TEXT"); + + b.Property("Value") + .HasColumnType("TEXT"); + + b.HasKey("SolicitorRatingId"); + + b.HasIndex("SolicitorId"); + + b.ToTable("SolicitorRatings"); + }); + + modelBuilder.Entity("CitySolicitor", b => + { + b.HasOne("Solicitors.Core.Models.City", null) + .WithMany() + .HasForeignKey("CitiesCityId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Solicitors.Core.Models.Solicitor", null) + .WithMany() + .HasForeignKey("SolicitorsSolicitorId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocation", b => + { + b.HasOne("Solicitors.Core.Models.Solicitor", "Solicitor") + .WithMany("Locations") + .HasForeignKey("SolicitorId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Solicitor"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocationRating", b => + { + b.HasOne("Solicitors.Core.Models.SolicitorLocation", "SolicitorLocation") + .WithMany("LocationRatings") + .HasForeignKey("SolicitorLocationId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("SolicitorLocation"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorRating", b => + { + b.HasOne("Solicitors.Core.Models.Solicitor", "Solicitor") + .WithMany("Ratings") + .HasForeignKey("SolicitorId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Solicitor"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.Solicitor", b => + { + b.Navigation("Locations"); + + b.Navigation("Ratings"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocation", b => + { + b.Navigation("LocationRatings"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/backend/libs/Solicitors.Data/Migrations/20260622195820_InitialCreate.cs b/backend/libs/Solicitors.Data/Migrations/20260622195820_InitialCreate.cs new file mode 100644 index 0000000..708be18 --- /dev/null +++ b/backend/libs/Solicitors.Data/Migrations/20260622195820_InitialCreate.cs @@ -0,0 +1,172 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace Solicitors.Data.Migrations +{ + /// + public partial class InitialCreate : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.CreateTable( + name: "Cities", + columns: table => new + { + CityId = table.Column(type: "TEXT", nullable: false), + Name = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_Cities", x => x.CityId); + }); + + migrationBuilder.CreateTable( + name: "Solicitors", + columns: table => new + { + SolicitorId = table.Column(type: "TEXT", nullable: false), + Name = table.Column(type: "TEXT", nullable: false), + RelativeUrl = table.Column(type: "TEXT", nullable: false), + Phone = table.Column(type: "TEXT", nullable: true), + Email = table.Column(type: "TEXT", nullable: true), + Website = table.Column(type: "TEXT", nullable: true), + ShortDescription = table.Column(type: "TEXT", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_Solicitors", x => x.SolicitorId); + }); + + migrationBuilder.CreateTable( + name: "CitySolicitor", + columns: table => new + { + CitiesCityId = table.Column(type: "TEXT", nullable: false), + SolicitorsSolicitorId = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_CitySolicitor", x => new { x.CitiesCityId, x.SolicitorsSolicitorId }); + table.ForeignKey( + name: "FK_CitySolicitor_Cities_CitiesCityId", + column: x => x.CitiesCityId, + principalTable: "Cities", + principalColumn: "CityId", + onDelete: ReferentialAction.Cascade); + table.ForeignKey( + name: "FK_CitySolicitor_Solicitors_SolicitorsSolicitorId", + column: x => x.SolicitorsSolicitorId, + principalTable: "Solicitors", + principalColumn: "SolicitorId", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "SolicitorLocations", + columns: table => new + { + SolicitorLocationId = table.Column(type: "TEXT", nullable: false), + Address = table.Column(type: "TEXT", nullable: false), + Phone = table.Column(type: "TEXT", nullable: false), + SolicitorId = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_SolicitorLocations", x => x.SolicitorLocationId); + table.ForeignKey( + name: "FK_SolicitorLocations_Solicitors_SolicitorId", + column: x => x.SolicitorId, + principalTable: "Solicitors", + principalColumn: "SolicitorId", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "SolicitorRatings", + columns: table => new + { + SolicitorRatingId = table.Column(type: "TEXT", nullable: false), + Value = table.Column(type: "TEXT", nullable: false), + Maximum = table.Column(type: "TEXT", nullable: false), + Provider = table.Column(type: "TEXT", nullable: false), + SolicitorId = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_SolicitorRatings", x => x.SolicitorRatingId); + table.ForeignKey( + name: "FK_SolicitorRatings_Solicitors_SolicitorId", + column: x => x.SolicitorId, + principalTable: "Solicitors", + principalColumn: "SolicitorId", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "SolicitorLocationRatings", + columns: table => new + { + SolicitorLocationRatingId = table.Column(type: "TEXT", nullable: false), + Value = table.Column(type: "TEXT", nullable: false), + Maximum = table.Column(type: "TEXT", nullable: false), + Provider = table.Column(type: "TEXT", nullable: false), + SolicitorLocationId = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_SolicitorLocationRatings", x => x.SolicitorLocationRatingId); + table.ForeignKey( + name: "FK_SolicitorLocationRatings_SolicitorLocations_SolicitorLocationId", + column: x => x.SolicitorLocationId, + principalTable: "SolicitorLocations", + principalColumn: "SolicitorLocationId", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateIndex( + name: "IX_CitySolicitor_SolicitorsSolicitorId", + table: "CitySolicitor", + column: "SolicitorsSolicitorId"); + + migrationBuilder.CreateIndex( + name: "IX_SolicitorLocationRatings_SolicitorLocationId", + table: "SolicitorLocationRatings", + column: "SolicitorLocationId"); + + migrationBuilder.CreateIndex( + name: "IX_SolicitorLocations_SolicitorId", + table: "SolicitorLocations", + column: "SolicitorId"); + + migrationBuilder.CreateIndex( + name: "IX_SolicitorRatings_SolicitorId", + table: "SolicitorRatings", + column: "SolicitorId"); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "CitySolicitor"); + + migrationBuilder.DropTable( + name: "SolicitorLocationRatings"); + + migrationBuilder.DropTable( + name: "SolicitorRatings"); + + migrationBuilder.DropTable( + name: "Cities"); + + migrationBuilder.DropTable( + name: "SolicitorLocations"); + + migrationBuilder.DropTable( + name: "Solicitors"); + } + } +} diff --git a/backend/libs/Solicitors.Data/Migrations/SolicitorsRepositoryModelSnapshot.cs b/backend/libs/Solicitors.Data/Migrations/SolicitorsRepositoryModelSnapshot.cs new file mode 100644 index 0000000..3552058 --- /dev/null +++ b/backend/libs/Solicitors.Data/Migrations/SolicitorsRepositoryModelSnapshot.cs @@ -0,0 +1,219 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Solicitors.Data; + +#nullable disable + +namespace Solicitors.Data.Migrations +{ + [DbContext(typeof(SolicitorsRepository))] + partial class SolicitorsRepositoryModelSnapshot : ModelSnapshot + { + protected override void BuildModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder.HasAnnotation("ProductVersion", "10.0.9"); + + modelBuilder.Entity("CitySolicitor", b => + { + b.Property("CitiesCityId") + .HasColumnType("TEXT"); + + b.Property("SolicitorsSolicitorId") + .HasColumnType("TEXT"); + + b.HasKey("CitiesCityId", "SolicitorsSolicitorId"); + + b.HasIndex("SolicitorsSolicitorId"); + + b.ToTable("CitySolicitor"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.City", b => + { + b.Property("CityId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Name") + .IsRequired() + .HasColumnType("TEXT"); + + b.HasKey("CityId"); + + b.ToTable("Cities"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.Solicitor", b => + { + b.Property("SolicitorId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Email") + .HasColumnType("TEXT"); + + b.Property("Name") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Phone") + .HasColumnType("TEXT"); + + b.Property("RelativeUrl") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("ShortDescription") + .HasColumnType("TEXT"); + + b.Property("Website") + .HasColumnType("TEXT"); + + b.HasKey("SolicitorId"); + + b.ToTable("Solicitors"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocation", b => + { + b.Property("SolicitorLocationId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Address") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Phone") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("SolicitorId") + .HasColumnType("TEXT"); + + b.HasKey("SolicitorLocationId"); + + b.HasIndex("SolicitorId"); + + b.ToTable("SolicitorLocations"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocationRating", b => + { + b.Property("SolicitorLocationRatingId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Maximum") + .HasColumnType("TEXT"); + + b.Property("Provider") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("SolicitorLocationId") + .HasColumnType("TEXT"); + + b.Property("Value") + .HasColumnType("TEXT"); + + b.HasKey("SolicitorLocationRatingId"); + + b.HasIndex("SolicitorLocationId"); + + b.ToTable("SolicitorLocationRatings"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorRating", b => + { + b.Property("SolicitorRatingId") + .ValueGeneratedOnAdd() + .HasColumnType("TEXT"); + + b.Property("Maximum") + .HasColumnType("TEXT"); + + b.Property("Provider") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("SolicitorId") + .HasColumnType("TEXT"); + + b.Property("Value") + .HasColumnType("TEXT"); + + b.HasKey("SolicitorRatingId"); + + b.HasIndex("SolicitorId"); + + b.ToTable("SolicitorRatings"); + }); + + modelBuilder.Entity("CitySolicitor", b => + { + b.HasOne("Solicitors.Core.Models.City", null) + .WithMany() + .HasForeignKey("CitiesCityId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Solicitors.Core.Models.Solicitor", null) + .WithMany() + .HasForeignKey("SolicitorsSolicitorId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocation", b => + { + b.HasOne("Solicitors.Core.Models.Solicitor", "Solicitor") + .WithMany("Locations") + .HasForeignKey("SolicitorId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Solicitor"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocationRating", b => + { + b.HasOne("Solicitors.Core.Models.SolicitorLocation", "SolicitorLocation") + .WithMany("LocationRatings") + .HasForeignKey("SolicitorLocationId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("SolicitorLocation"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorRating", b => + { + b.HasOne("Solicitors.Core.Models.Solicitor", "Solicitor") + .WithMany("Ratings") + .HasForeignKey("SolicitorId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Solicitor"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.Solicitor", b => + { + b.Navigation("Locations"); + + b.Navigation("Ratings"); + }); + + modelBuilder.Entity("Solicitors.Core.Models.SolicitorLocation", b => + { + b.Navigation("LocationRatings"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupOptions.cs b/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupOptions.cs new file mode 100644 index 0000000..6a0c460 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupOptions.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Data.RepositorySetup; + +public interface IRepoSetupOptions +{ + +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupService.cs b/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupService.cs new file mode 100644 index 0000000..7e13c54 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/IRepoSetupService.cs @@ -0,0 +1,8 @@ +using Microsoft.EntityFrameworkCore; + +namespace Solicitors.Data.RepositorySetup; + +internal interface IRepoSetupService +{ + void OnConfiguring(DbContextOptionsBuilder optionsBuilder); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemoryDbSetupOptions.cs b/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemoryDbSetupOptions.cs new file mode 100644 index 0000000..3387933 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemoryDbSetupOptions.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Data.RepositorySetup.InMemory; + +public class InMemoryDbSetupOptions(string dbName) : IRepoSetupOptions +{ + public string DbName { get; } = dbName; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemorySetupService.cs b/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemorySetupService.cs new file mode 100644 index 0000000..3295f2b --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/InMemory/InMemorySetupService.cs @@ -0,0 +1,11 @@ +using Microsoft.EntityFrameworkCore; + +namespace Solicitors.Data.RepositorySetup.InMemory; + +internal class InMemorySetupService(InMemoryDbSetupOptions config) : IRepoSetupService +{ + public void OnConfiguring(DbContextOptionsBuilder options) + { + options.UseInMemoryDatabase(config.DbName); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteDbSetupOptions.cs b/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteDbSetupOptions.cs new file mode 100644 index 0000000..7bc1f54 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteDbSetupOptions.cs @@ -0,0 +1,6 @@ +namespace Solicitors.Data.RepositorySetup.Sqlite; + +public class SqliteDbSetupOptions(string dbName) : IRepoSetupOptions +{ + public string DbName { get; } = dbName; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteSetupService.cs b/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteSetupService.cs new file mode 100644 index 0000000..2568541 --- /dev/null +++ b/backend/libs/Solicitors.Data/RepositorySetup/Sqlite/SqliteSetupService.cs @@ -0,0 +1,16 @@ +using Microsoft.EntityFrameworkCore; + +namespace Solicitors.Data.RepositorySetup.Sqlite; + +internal class SqliteSetupService(SqliteDbSetupOptions config) : IRepoSetupService +{ + public void OnConfiguring(DbContextOptionsBuilder options) + { + var folder = Environment.SpecialFolder.MyDocuments; + var path = Environment.GetFolderPath(folder); + path = Path.Combine(path, "/data"); + var dbPath = System.IO.Path.Join(path, $"{config.DbName}.db"); + var dbString = $"Data Source={dbPath}"; + options.UseSqlite(dbString); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.Data/Solicitors.Data.csproj b/backend/libs/Solicitors.Data/Solicitors.Data.csproj new file mode 100644 index 0000000..5685344 --- /dev/null +++ b/backend/libs/Solicitors.Data/Solicitors.Data.csproj @@ -0,0 +1,20 @@ + + + + net10.0 + enable + enable + + + + + + + + + + + + + + diff --git a/backend/libs/Solicitors.Data/SolicitorsRepository.cs b/backend/libs/Solicitors.Data/SolicitorsRepository.cs new file mode 100644 index 0000000..de69605 --- /dev/null +++ b/backend/libs/Solicitors.Data/SolicitorsRepository.cs @@ -0,0 +1,157 @@ +using Microsoft.EntityFrameworkCore; +using Solicitors.Core; +using Solicitors.Core.Data; +using Solicitors.Core.Models; +using Solicitors.Core.Models.Imports; +using Solicitors.Data.RepositorySetup; + +namespace Solicitors.Data; + +internal class SolicitorsRepository : DbContext, ISolicitorRepository, IReadOnlyCitiesRepository, IRatingsProviderRepository +{ + private readonly IRepoSetupService _setup; + + public SolicitorsRepository(IRepoSetupService setup) + { + _setup = setup; + } + + public DbSet Solicitors { get; set; } + public DbSet SolicitorRatings { get; set; } + public DbSet SolicitorLocations { get; set; } + public DbSet SolicitorLocationRatings { get; set; } + public DbSet Cities { get; set; } + + protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) + => _setup.OnConfiguring(optionsBuilder); + + public IAsyncEnumerable GetAllSolicitorsAsync() + => Solicitors + .Include(solicitor => solicitor.Cities) + .Include(solicitor => solicitor.Locations) + .ThenInclude(location => location.LocationRatings) + .Include(solicitor => solicitor.Ratings) + .AsAsyncEnumerable(); + + public Task GetSolicitorByIdAsync(Guid id, CancellationToken cancellationToken = default) + => Solicitors + .Include(solicitor => solicitor.Cities) + .Include(solicitor => solicitor.Locations) + .ThenInclude(location => location.LocationRatings) + .Include(solicitor => solicitor.Ratings) + .FirstOrDefaultAsync(x => x.SolicitorId == id, cancellationToken); + + public async Task AddOrUpdateSolicitorAsync(SolicitorData solicitor, CancellationToken cancellationToken) + { + var matchingSolicitor = await Solicitors + .FirstOrDefaultAsync( + item => item.Name == solicitor.Name, + cancellationToken: cancellationToken); + + if (matchingSolicitor is null) + await AddNewSolicitor(solicitor, cancellationToken); + else + await UpdateExistingSolicitor(solicitor, matchingSolicitor, cancellationToken); + } + + private async Task AddNewSolicitor( + SolicitorData solicitor, + CancellationToken cancellationToken) + { + var newSol = new Solicitor() + { + Name = solicitor.Name, + RelativeUrl = solicitor.UrlPath, + Phone = solicitor.Phone, + Email = solicitor.Email, + Website = solicitor.Website, + ShortDescription = solicitor.ShortDescription + }; + Solicitors.Add(newSol); + + var cityTasks = solicitor.Cities + .Distinct() + .Select(async (city) => + { + var matchingCity = await Cities.FirstOrDefaultAsync( + item => item.Name == city, + cancellationToken: cancellationToken); + + if (matchingCity is null) + { + matchingCity = new City() { Name = city }; + Cities.Add(matchingCity); + newSol.Cities.Add(matchingCity); + } + + matchingCity.Solicitors.Add(newSol); + }); + await Task.WhenAll(cityTasks); + + foreach (var rating in solicitor.Ratings) + { + var newRating = new SolicitorRating() + { + Value = rating.Value, + Maximum = rating.MaxValue, + Provider = rating.RatingProvider, + Solicitor = newSol + }; + SolicitorRatings.Add(newRating); + newSol.Ratings.Add(newRating); + } + + foreach (var location in solicitor.Offices) + { + var newLocation = new SolicitorLocation() + { + Address = location.Address, + Phone = location.Phone, + Solicitor = newSol + }; + SolicitorLocations.Add(newLocation); + newSol.Locations.Add(newLocation); + + foreach (var rating in location.LocationRatings) + { + var newLocRating = new SolicitorLocationRating() + { + Value = rating.value, + Maximum = rating.MaxValue, + Provider = rating.RatingProvider, + SolicitorLocation = newLocation + }; + SolicitorLocationRatings.Add(newLocRating); + newLocation.LocationRatings.Add(newLocRating); + } + } + + await SaveChangesAsync(cancellationToken); + } + + private Task UpdateExistingSolicitor( + SolicitorData solicitor, + Solicitor matchingSolicitor, + CancellationToken cancellationToken) + { + // TODO + return Task.CompletedTask; + } + + public IAsyncEnumerable GetCitiesAsync(CancellationToken cancellationToken) + { + return Cities + .Select(city => city.Name) + .AsAsyncEnumerable(); + } + + public IAsyncEnumerable GetAllRatingsProvidersAsync() + { + return SolicitorRatings + .Select(rating => rating.Provider) + .Distinct() + .OrderBy(x => x == "Solicitors.com" ? 0 : 1) + .ThenBy(x => x) + .AsAsyncEnumerable(); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/DIExtensions.cs b/backend/libs/Solicitors.HtmlParsing/DIExtensions.cs new file mode 100644 index 0000000..286b841 --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/DIExtensions.cs @@ -0,0 +1,11 @@ +using Microsoft.Extensions.DependencyInjection; + +namespace Solicitors.HtmlParsing; + +public static class DIExtensions +{ + public static IServiceCollection AddHtmlParsing(this IServiceCollection services) + { + return services.AddSingleton(); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/HtmlParser.cs b/backend/libs/Solicitors.HtmlParsing/HtmlParser.cs new file mode 100644 index 0000000..2cbd4cf --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/HtmlParser.cs @@ -0,0 +1,130 @@ +namespace Solicitors.HtmlParsing; + +using Models; + +internal class HtmlParser : IHtmlParser +{ + private readonly string[] _voidElements = + [ + "area", + "base", + "br", + "col", + "embed", + "hr", + "img", + "input", + "link", + "meta", + "source", + "track", + "wbr" + ]; + + public IEnumerable ParseHtml(string html) + { + // wanted to do this in one pass but was quite time-consuming + // so taking a little lesson from compiler development + // and lex the text into tokens before parsing :) + // deferred execution might help it still be "one pass"? + var stringEnumerator = html.GetEnumerator(); + var tokens = LexHtml(stringEnumerator); + var tokenEnumerator = tokens.GetEnumerator(); + return ParseHtml(tokenEnumerator); + } + + private IEnumerable LexHtml(IEnumerator content) + { + var work = ""; + while (content.MoveNext()) + { + if (content.Current == '<' && !string.IsNullOrWhiteSpace(work)) + { + yield return work.Trim(); + work = ""; + } + + work += content.Current; + + if (content.Current == '>' && !string.IsNullOrWhiteSpace(work)) + { + yield return work.Trim(); + work = ""; + } + } + } + + private IEnumerable ParseHtml(IEnumerator tokens) + { + while (tokens.MoveNext()) + { + var token = tokens.Current; + if (!token.StartsWith('<')) + { + yield return new StringNode(token); + continue; + } + + var noBraces = token.Substring(1, token.Length - 2); + var split = noBraces.Split(' '); + IHtmlAttribute[] attributes = []; + if (split.Length > 1) + { + attributes = ParseAttributes(noBraces).ToArray(); + } + + if (IsVoidOrSelfClosingElement(token)) + yield return new HtmlNode(split.First(), attributes); + else if (token.StartsWith("")) + return true; + + var tagName = token.Split(' ').First().Substring(1); + if (tagName.EndsWith('>')) + tagName = tagName.Substring(0, tagName.Length - 1); + return _voidElements.Contains(tagName); + } + + private IEnumerable ParseAttributes(string tokenNoBraces) + { + var attributesString = string.Join(' ', tokenNoBraces.Split(' ').Skip(1)); + var attString = ""; + bool inQuote = false; + foreach (char c in attributesString) + { + if (!inQuote && c == ' ') + { + yield return ParseAttribute(attString); + attString = ""; + } + else + { + attString += c; + if (c == '\"') + inQuote = !inQuote; + } + } + + yield return ParseAttribute(attString); + } + + private IHtmlAttribute ParseAttribute(string attString) + { + var split = attString.Split('='); + if (split.Length > 1) + return new HtmlValueAttribute(split[0], string.Join('=', split.Skip(1))); + else + return new HtmlAttribute(attString); + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/IHtmlParser.cs b/backend/libs/Solicitors.HtmlParsing/IHtmlParser.cs new file mode 100644 index 0000000..199a93c --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/IHtmlParser.cs @@ -0,0 +1,8 @@ +namespace Solicitors.HtmlParsing; + +using Models; + +public interface IHtmlParser +{ + IEnumerable ParseHtml(string html); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/HtmlAttribute.cs b/backend/libs/Solicitors.HtmlParsing/Models/HtmlAttribute.cs new file mode 100644 index 0000000..70a8fea --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/HtmlAttribute.cs @@ -0,0 +1,6 @@ +namespace Solicitors.HtmlParsing.Models; + +internal class HtmlAttribute(string name) : IHtmlAttribute +{ + public string Name { get; } = name; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/HtmlNode.cs b/backend/libs/Solicitors.HtmlParsing/Models/HtmlNode.cs new file mode 100644 index 0000000..050e011 --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/HtmlNode.cs @@ -0,0 +1,95 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Solicitors.HtmlParsing.Models; + +internal class HtmlNode(string tagName, IHtmlAttribute[] attributes) + : IHtmlNode +{ + private readonly IHtmlAttribute[] _attributes = attributes; + private readonly string _tagName = tagName; + + public virtual bool TryGetByTagName( + string tagName, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (tagName == _tagName) + node = this; + + return node is not null; + } + + private string[] Classes + { + get + { + var classAttribute = _attributes + .Where(a => a is HtmlValueAttribute) + .Select(a => (a as HtmlValueAttribute)!) + .FirstOrDefault(a => a.Name.Equals("class", StringComparison.CurrentCultureIgnoreCase)); + + return classAttribute is not null + ? classAttribute.Value.Substring(1, classAttribute.Value.Length - 2).Split(' ') + : []; + } + } + + public virtual bool TryGetByClass( + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + + if (Classes.Contains(className, StringComparer.InvariantCultureIgnoreCase)) + node = this; + + return node is not null; + } + + public virtual bool TryGetByTagNameAndClass( + string tagName, + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (tagName == _tagName && Classes.Contains(className, StringComparer.InvariantCultureIgnoreCase)) + node = this; + + return node is not null; + } + + public virtual bool TryGetText([NotNullWhen(true)] out string? text) + { + text = null; + return false; + } + + public virtual bool TryGetChildren([NotNullWhen(true)] out IEnumerable? children) + { + children = null; + return false; + } + + public bool HasAttribute(string attributeName) + { + return _attributes + .Any(a => a.Name.Equals(attributeName, StringComparison.InvariantCultureIgnoreCase)); + } + + public bool TryGetAttributeValue(string attributeName, [NotNullWhen(true)] out string? attributeValue) + { + attributeValue = null; + + var matchingAttribute = _attributes.FirstOrDefault( + a => a.Name.Equals(attributeName, StringComparison.InvariantCultureIgnoreCase) + ); + + if (matchingAttribute is HtmlValueAttribute valueAttribute) + attributeValue = valueAttribute.Value; + + return attributeValue is not null; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/HtmlValueAttribute.cs b/backend/libs/Solicitors.HtmlParsing/Models/HtmlValueAttribute.cs new file mode 100644 index 0000000..c8ea5e4 --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/HtmlValueAttribute.cs @@ -0,0 +1,6 @@ +namespace Solicitors.HtmlParsing.Models; + +internal class HtmlValueAttribute(string name, string value) : HtmlAttribute(name) +{ + public string Value { get; } = value; +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/IHtmlAttribute.cs b/backend/libs/Solicitors.HtmlParsing/Models/IHtmlAttribute.cs new file mode 100644 index 0000000..4240a2e --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/IHtmlAttribute.cs @@ -0,0 +1,6 @@ +namespace Solicitors.HtmlParsing.Models; + +internal interface IHtmlAttribute +{ + string Name { get; } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/IHtmlNode.cs b/backend/libs/Solicitors.HtmlParsing/Models/IHtmlNode.cs new file mode 100644 index 0000000..e473d8f --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/IHtmlNode.cs @@ -0,0 +1,64 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Solicitors.HtmlParsing.Models; + +public interface IHtmlNode +{ + /// + /// Searches this node and its direct children for a matching tag name. + /// + /// The tag name to match. + /// If found, the node that matches the tag name. + /// If true, only check this node, not its children. + /// True if this node, or any of its direct children, have a matching tag name; false otherwise. + bool TryGetByTagName( + string tagName, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false); + + /// + /// Searches this node and its direct children for a matching class. + /// + /// The class name to match. + /// If found, the node that matches the class name. + /// If true, only check this node, not its children. + /// True if this node, or any of its direct children, have a matching class name; false otherwise. + bool TryGetByClass( + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false); + + /// + /// Searches this node and its direct children for a matching tag name and matching class on the same node. + /// + /// The tag name to match. + /// The class name to match. + /// If found, the node that matches the tag name and class name. + /// If true, only check this node, not its children. + /// True if this node, or any of its direct children, have a matching tag name and class name; false otherwise. + bool TryGetByTagNameAndClass( + string tagName, + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false); + + /// + /// Checks this node (and *not* its children) to see if it is text content. + /// + /// If found, the text content. + /// True if the node is a text node, false otherwise. + bool TryGetText([NotNullWhen(true)] out string? text); + + /// + /// Checks this node to see if it has child elements. + /// + /// If found, the child elements. + /// True if the node has child elements, false otherwise. + bool TryGetChildren([NotNullWhen(true)] out IEnumerable? children); + + bool HasAttribute(string attributeName); + + bool TryGetAttributeValue( + string attributeName, + [NotNullWhen(true)] out string? attributeValue); +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/ParentHtmlNode.cs b/backend/libs/Solicitors.HtmlParsing/Models/ParentHtmlNode.cs new file mode 100644 index 0000000..61a0eb7 --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/ParentHtmlNode.cs @@ -0,0 +1,94 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Solicitors.HtmlParsing.Models; + +internal class ParentHtmlNode(string tagName, IHtmlAttribute[] attributes, IHtmlNode[] children) + : HtmlNode(tagName, attributes) +{ + private readonly IHtmlNode[] _children = children; + + public override bool TryGetByTagName( + string tagName, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (!base.TryGetByTagName(tagName, out node, noChildren) && !noChildren) + { + var nodesToCheck = new Queue(_children); + while (nodesToCheck.TryDequeue(out var child)) + { + if (child.TryGetByTagName(tagName, out var childNode, true)) + { + node = childNode; + break; + } + + if (child.TryGetChildren(out var grandChildren)) + foreach (var grandChild in grandChildren) + nodesToCheck.Enqueue(grandChild); + } + } + + return node is not null; + } + + public override bool TryGetByClass( + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (!base.TryGetByClass(className, out node, noChildren) && !noChildren) + { + var nodesToCheck = new Queue(_children); + while (nodesToCheck.TryDequeue(out var child)) + { + if (child.TryGetByClass(className, out var childNode, true)) + { + node = childNode; + break; + } + + if (child.TryGetChildren(out var grandChildren)) + foreach (var grandChild in grandChildren) + nodesToCheck.Enqueue(grandChild); + } + } + + return node is not null; + } + + public override bool TryGetByTagNameAndClass( + string tagName, + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + if (!base.TryGetByTagNameAndClass(tagName, className, out node, noChildren) && !noChildren) + { + var nodesToCheck = new Queue(_children); + while (nodesToCheck.TryDequeue(out var child)) + { + if (child.TryGetByTagNameAndClass(tagName, className, out var childNode, true)) + { + node = childNode; + break; + } + + if (child.TryGetChildren(out var grandChildren)) + foreach (var grandChild in grandChildren) + nodesToCheck.Enqueue(grandChild); + } + } + + return node is not null; + } + + public override bool TryGetChildren([NotNullWhen(true)] out IEnumerable? children) + { + children = _children; + return _children.Length != 0; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Models/StringNode.cs b/backend/libs/Solicitors.HtmlParsing/Models/StringNode.cs new file mode 100644 index 0000000..4669fb7 --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Models/StringNode.cs @@ -0,0 +1,59 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Solicitors.HtmlParsing.Models; + +internal class StringNode(string content) + : IHtmlNode +{ + private readonly string _content = content; + + public bool TryGetByTagName( + string tagName, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + return false; + } + + public bool TryGetByClass( + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + return false; + } + + public bool TryGetByTagNameAndClass( + string tagName, + string className, + [NotNullWhen(true)] out IHtmlNode? node, + bool noChildren = false) + { + node = null; + return false; + } + + public bool TryGetText([NotNullWhen(true)] out string? text) + { + text = _content; + return !string.IsNullOrEmpty(text); + } + + public bool TryGetChildren([NotNullWhen(true)] out IEnumerable? children) + { + children = null; + return false; + } + + public bool HasAttribute(string attributeName) => false; + + public bool TryGetAttributeValue( + string attributeName, + [NotNullWhen(true)] out string? attributeValue) + { + attributeValue = null; + return false; + } +} \ No newline at end of file diff --git a/backend/libs/Solicitors.HtmlParsing/Solicitors.HtmlParsing.csproj b/backend/libs/Solicitors.HtmlParsing/Solicitors.HtmlParsing.csproj new file mode 100644 index 0000000..90bc4ed --- /dev/null +++ b/backend/libs/Solicitors.HtmlParsing/Solicitors.HtmlParsing.csproj @@ -0,0 +1,13 @@ + + + + net10.0 + enable + enable + + + + + + + diff --git a/backend/tests/Solicitors.HtmlParsing.Tests/Solicitors.HtmlParsing.Tests.csproj b/backend/tests/Solicitors.HtmlParsing.Tests/Solicitors.HtmlParsing.Tests.csproj new file mode 100644 index 0000000..df7c6e2 --- /dev/null +++ b/backend/tests/Solicitors.HtmlParsing.Tests/Solicitors.HtmlParsing.Tests.csproj @@ -0,0 +1,25 @@ + + + + net10.0 + enable + enable + false + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/frontend/.gitignore b/frontend/.gitignore new file mode 100644 index 0000000..a547bf3 --- /dev/null +++ b/frontend/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/frontend/.yarn/install-state.gz b/frontend/.yarn/install-state.gz new file mode 100644 index 0000000000000000000000000000000000000000..1a7cf7b0e68ab584992466b45551c42bf785a885 GIT binary patch literal 408488 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 Qv2yk(|HAd@&wYw$jd33;!1rbIy0C#z&{> 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

#q;t)K6Z-*XFe$dAK~KnpZQQBY?sX$7e+0-iINg zh1S^PR6AM|I3jE70;pdpajW$5@A_T?rAF@u$o?#_&~YwiBStc%z<@q+SL`xNb=+Cm zJ?l91*el1{39gZ8Ays=ETh$n&>=DrqRUebc`bjC{GVq~!B#vbXZP}$7GsQQn zt{-sE;R1NjSo^Hd(N^n0V2rP7H7*k$GECRQi}Y`CoqF>cbmG}7cpEwUt>&G>VeWTZ zgY9&f6d-M;n!wVaAKKw)nYasd+tHC`U?p8?wm1SaQJ2t@iO$;cgp_*9k=g-5iZelc zr!d7`aq83^8vcFkoZCAUH3hkz1m*qKi3UAV(~-xe8!6q#06fFh3~Jyh_<0IXk=kkJ;m-c%yLw+AbuoKZb&^;SWR=(WeOS?5uu3?}dqF9(P4j)rjz|_I@ISbOn0HC?!ZrVj! z;iJYpi>bvNBYnfa$ZJm66|;f`;c9-YdCLJR6i{r8kVNZV(w)HBVu)Moaqasu)kD6= z+jnuv$Un!&@9JTC>9be#)t#O}B& z+W_GkNMgUDw0kpvuvpkN(lstTvW`rUeU8I0xY}~-U zV_dVLS9_eN_UkV@{cu~KynL^1Ym6AsaDv_m>H!VWJpsEz9lgyJ0gTS(4zeL^;G_%* zV2@RYI`}rWS5(zD6XB!g&w>g*noEYU?@C0&rfx zKtPr3dnrJ%6N-A*wsVh}Ztc{<2vE|HYZ9rT#%`oV9^7DPgQ>{~BZS1rOU35lt{Z|4 zsWHJq8=METQDF$2AMWZuf36>X1a0S$jONMf_u9UW=u05Z%0&FaSS{)>+M5VSSTsQL zgc(LYt8bzO+gj_%o@Wa5s@AT)IO$ehj4=|y%~BQ`x-Bw@%73mL@H!X(5C zQ7pV~m8v^kEqASCSZpwvZo3~r0wlb}BipJ2*szVO{$ufIAnAL%8uYL{k+&g8pNhU3 zw2{bLKUcp_5POuf!HHKu1}z2=i11vHe`{0xd|zK>#yorRUj4KpO?|_XDF#5z0i~?h zUecEvI2pc#<^by0ah#9FBk_$=-`op^q|PHmv!9OCF=r zfqOv?_P%b11qIN})DE{!b&^XWe*jgHy*Gmf-d*ErLczWWE z3B)ddgVff-musQlH?JI+3BY$r584}+j0Ka0f1Ba{3`Ftk@9I6=JrBDS&t1NI2Z+A# zMYt*%BG*l@+8$9lwHa#d0;G8jb9^l9;9+hDS9)lUw5#o%Uex6r@^fV}qd~VX3(e64 zB61(b$U;jJac6@;j~F3qFr-blU5YjEH32N%HmZMhY!n2Fn2hjF1hMXudni_ImDQ$g z&<^gFI<>52_trb2(~<8O7=>+Q!lSn|!=bN%C@uEr9ha*#v~Iy0xt-tsZ|lSRKh?+2 zZ~mr@dPo&{?i$`Z241|C9^-N)RFZ6?iE^)wd-Mf5557;TTh7=ZI`$%jpftm$p&*Mm z?VN`38bGU{U$G_(o;o4**X_B`;~cPS2bB@a#X;jePWtURj5wqsyo(^{ep z3?0pu865{}fP6Wlfd({!Bp@?Eo6auFED8%QAWu`#b~FRT-OLj;2J*C#2-6%l*m<_J z%qbGL0>*zX1XOy>3UddXj^N?Xty~%EhE# z<8t|r3AVE!Sb(Dsp9`6%eJs#4Mgfxqe&`H9i##!*h`C@TmDbb_e4%?!?hyN~tpR(S z`YmIR+pMgqHKJ>a>RG(f8RT9+>p<)k-Mg&By=oUMAiI!|p`ejqV6(R9MB%uvT9gRk z@CF4&PCpIF?taOPguJ9p(7!#FoxSRIu=DnZA3uEj{N{)H9B)3>rw{M`^yoVL>_xma zgz&dAr$K3{h>XyNhaD48nnqCIn;iVlXEr}td+)x5AfKi;2A*JqAR-LsmVjB8NQ0~5n za@Te{yM_V<#fcvg(S?(6Z&U_qN8$Lt0>4rEL-E>sn0R03PM`WufB5v_ zy*{jNp1W+fXYf}RP$Rwyd4$Es@zo3{fHh#ZheaELXRe+?# z@;^=__#P$K^ppYdz1Cd2F#+kS~O{9rm zc>uQw9sl{mQ0NA*}{U=$e6kI(%g~SOmph@aj|hZ-5D0}+MWhIBkjq< zV~g1iLT4dndA1`k@z_D&5|tOC9tbnAk&7Xn^3Z5*D>23y2(|$zqOU#1D^lZs`t*I( zBLc;Nbst2G&Xl`qyOvhtxE1=yjO}fy3Xt&5;vHam!25 z5M#*nbd9YM>Yb=lUm6MQHKc$X0XENUtVeoBO>!5Dw2K>O*qW!nw(OzQ5QR-=Ii7d| z#~HnPT7j@t#&f-<`-RJbgSk(>%omJzkVt{^9h!nx?b&Bu5^lI=bZb9l7Z0M_h%xS8 z)6ai>_Ye~E>~;IPpTD^xM!#K&7+>$%x}WQh9mEY3HQ4y(#&obFx8_V_QKQFY63(#U z$Kvk3P*3@G7bN~HPCX6wKJG_jVWb#LxA1V9aaT{n> zw>_opeJTJZw39j58qv_(i|)UC+0QqBj(3lt{?A^%`=-N7B%N)U?8_YDo&@(EcVrVj z0pQ=o-ROR_17?gzC)p4n&JNnQL)5&E??Oi>cL& zsZm6ETfh9G7zIyWx_d^!mo2rK%8d|Cw2pJ&X;b> z0Q?cIz!@9*TdXfe|L9=uby%gLlkNvUaX$!?Qj7)>NixB<@w@zW9ir|woZt>UZK;Gv z1!7Fru>fcTuy8v4OueS8+EE5V{6MCd)vyEK?H#_;izRvvGw!`Z)B>dgYaNNvzCgCf znhZw1h2GXM|GMj4{PiF4oSwaYKik*;_iraK+NXsuMfj&R2lFP6SOf5U@RyZ&NzNk+ z`i+ttUCx%_bo7!8K_RyUm_e$B1X>!}DL3Lg@#xLzy2rLe;>7XRdh;Ax4SkVY{e$S7 z5ToR>umSu{pItZThJzE;LGh0hEg{&5naPQJhfMXvK<5)O6 z7X|Q4?J>*{Z)V(DFcdG9dTvkP^V9ov36}Eh`$x|8XD{D<%GH>5dbDg zh9?LyKu^lkr19~X9aD#)XAanC@K2e90E*>)V0i(?F7_(kLfyJ|sLIN=UhC>c@U1lE z1Eu92+@M&$lePFMs5_9a;lNtWm~OiemC1)f8!hnstCq)#N{mOfglKnyixHHo<*f%8 zmNVuuo;^c{vXP8ECfoswl=cCzt=fc*5j1!dHMb}5uP^k^&PQntPhPm6Z7BU-zutcx zkL;RhS~1RCX-j-V{}Fzj zs=->0mh3{Z92#R9jEB;XA=>Gd<-|znyX0jyq#wDs0#huJ%$)cNB8hiY%fXF-xxZW- zC)=j&ls$xT1Pf5W;HzZh?ye9}D1@AVjZCQHPXHs?AZ^5%21G==rC$D*cOO1{syFri zPjAm(A7WviyLzt`sfh5Fh(VJ{SJc29wiS6|+DvoTK<-Y4Y$j>LHzG^cSplclLM|!s z!5n)`g?PEkZcYcV1Sl6~@sO5mA`Vc>Duk=eb8_X{a(hwgSr}_4tPBWgQ}8o7Pd+@6 z7YC*!lm#cfmcf7C1U!)fHw6*frwz2^)_^0cS}Q)tMMB#2K+a7(O zIj8OR^!<>3sP*|xeERhEyNAJ%PhP&;%hJ~t;XuN}sF>Ot3OzpKaKGp>xcDDF%~1Ot z9|NR$4>TM}VZ9#;FYhap<^rjv=FC#K=X}?@V z?Xy?z=lmubzo)O}jDxTlS}BXHWyHee1kK1<5(0=+%#Bg*7&{ki;RD_Doo63RJA4+) zHB-dg3oMq75NRRwP()JqMl3jpDSkK@A%I|*Ak8UFZev^k z%*DO6x;_w~SrgDK){zOHz8eH$YdF$iXoZ^xZ-8CU8v^O`Iv}%Kj?C%@F-NtNNOIh@ zBqnoLA7)Bs_c{GvJ8esbt2h;%ZEjbC@6!@8K^0+Y7Vc(_i0zj=#KuDtPun zzP`hb|Eo*y1h+du-iD}l)P+cMF?2OM`ZIzr3JoL*V#f!*}G0fLB zo2>)vXzHp3v9D0U3|2_rZrUJ&w!3_!Uznuy$&2^ut_tAteS>jz&RET6HZVPTY=IK0 zWYS6S?X2YxP*$L<%P;RhLH`H2jYPHbIDL9U%=;L9A(u5ej{?R0!apw{?YU65(ew@G z?CphF*Ffsbs6vDZ0gitr^&W>C@S#Ag2e5|&-ZgP!1|-0hXU7+=<9! zoVnx}>y;ruV?dc{!fOu90I6S5Y)lCO$4HzY9bPeMO#ou`Hr;8g1tH12JSlFTdv+l} zdUEvTqId4dmQyqPDbNJHuaUSJjdds{JdP<~63kh%a^PV{>a9isu-zKc+1D(Xe{<>C zfo3egO7PJl3p=^3Hc+HAUXe^veIg?AjLnnt+pGG|KYpz9u|9qOwaC3T`2~*oXn&u) zjJGT={n|Qi%{y43JI7GN{CAiX(joA`g(jl$x(#+B5Uo3G3Yy+eM(u+P)lm$I!ll!U z&Bb%Kg-EBqC8AgKJS~BjR*&dw5G+Rm^7gG%t?i0)6tv&1TIol!49D-b1@UOv<}ukE z{Ds_guIWxgYnHlV401##q>3E_ge$ZigqE(!G#mh|p&^_Z=qNXIg!(y+Ht)Ujwe5ZF zwSD&T-E(4ICbAt6K&ab2q^*TWFpIIu88rm#-g|B*8dsbIyX20!0t4`kwjbJL42y0j z?`ws?WR365wjEnfqa)yABtYJxMn^7e);@#|`0Yj6&*)QlQroLB!}tx^)|pB>hL70r z{nj+Z^{Os}eW3%n2Q1*_0nVVvs-`0^;A_WKHIS6MHp5>raY5Ma+aT>zRLEpZ1ZyVXe-)){cY< zRkz7wcN$#^30TK+kR1XbBwAS(m@C^mT*PD9!rFm9KfptB*oLEzR%i{(ovbi|crBIb zyXLpk_*Wl4ynFZ4k1xCWyDz8kYkT|bHM|#=e)-bs87@96W69P4J}2BPk$u<3RXcid zlCdXHJP6p*LoH*p34wZN+KLiOsnyar=ln?zW^N6Q>jE$sq>-E2`0i zL!EJ^^>KO7$r?cgJY)8~Ownng-rQugVhIGkSuVo_WJ7E*@Lu9Q4};tdLsL_TUZzA+ zqE*rN8e`CyJ+0Z1;$?Muaw zF@0pSwS+M4hn+K-2OPA+O~Ob#VlF<&YR%jU&Q=$QHaolq7Dzp{1s+6I4CXRu;+NS$ zCf%uSaHigVVTD6o59yIzK4*d2JPp5#Y83!mPSA%GSc*urn0<%N=#1U=>Rl81HQo>& z%|Q*U{S8*Jx7=HG+NvI7i?0DYBPI(=fJU6RL%iSZ4?nzl-I@OE#ksllq#-h@T?@ zaYl0;Pc-@^n^3mCAZ@v`&;6njM4!EOcL}27%>X}6cA zkpSJS&dArE4VS{xKm%ZStSEtsHq?h_4-Q@xDg~lW*dW<3bhLg(mZA-fdf!1-*-W)? zUvkVxA!~pT8Q2_%6c}e+P`7z!u=?YNcOO2!{q!*D?8z&4dtI`x0t%S%o7o(ovua~; zBBci3r4WzJyyo%Effz?7Vnl(kcB>OeFV(&~=pA64z{D$rRJH)B=Aav90Go7=Zu7Vt z%(VqwqEdlL{Ps0PwDwp4S;au!>O83dZlF&SgwbVhOlB-Q8vZ*4jIP$;(_5Uvlop>g zc>D#Jd?}Dcm*z;r99{x#AIy^Al?4V`YI?V9IM{Covp>XlZ`YeIX;_c+6Hi{fpSi5s z@Bi{2|M&m(AMN)%zHY7-oR$YhX9zERwk0Q%&*)=aARR}>tOMVUIVo~UC-S!RtTl{) zHZdai%Ti55fXyzjRi=|S6V5ZvX&ayn#xL6phCTo>hTR7fG7CaI`)MpoDLriJSz5L> zkQ-t)PoI$o37tGtVp=KGV4EPPzvAf~D)DanQUTT;QgsFnuQa>>VT~PTM$?SN>TxAv zbi3Ky|MfjsT;G5G;oX~82_es3!JnVR10&imC$W~4?8Pu;LLyylHMazTL-0K5`l7rh zLvM>ZB+urfK|eOH<+cR?BPl5%oLW&l@6?8LuCq{HA~H^{HKICt3<2wM>80Am)Qb<|%?|;z(Fx#a ze096GwlcBRqcAG)TnkJVrCS5tzkPc9!;kOk%|E2AJ$ngnk7RjyYY}W?2T;1hQwfnU z3AGqt(9;EhFk|B#kJp$Ry5P%hZn#@^o6B5-+DCyTzjGh}<=3vRv=`oScZC;odjz)tcKL ziP`j;OQ%gC1wTUp9$q_;;w^w54%Re933$q^Gok|9LC#iRz)DkJl6CP3Lahx}W0~CW zE`3Aj{ih%HSMSw-%a0%a{ON_D7oXqk_#6+1?ay7vTde6W!$hbt z66cFW+{QT6r3J=RJDD6rS14`u+|AifX`?fgsPCF%fDBKp8#8Dsc+Lb_J4lZ*+7pD! zZr-v*=PGY=hOs1!JlMJLq0tD9VuLknv}%`4^^EC){NCkr(O??2X5Q65FR$*WcaN*u zXRqGRugCrO{B>w|T5o5l`vCfj)uDk5#2k{PkT3u`J%{-@q*;b1Novy}gb^sOCh*CR zM7Z%mSj#)2@ZE+c-)Olpna404KO`P?w6ICF_%4ba`8PIJ zQ+9k`w9gI#&jNk!m|~KSL=xHp32$$d$VeUu(~Gb#4+dLJ!fa;t;Vq>PS_PCy_|*dd zFB}?kfekglbs|M@S=(pcTC(1K*zxK6-~UiQe0cl+JT%2VdHwFy<1g+>?}TdL&?4%M zRw{`cAeq7Ewl*59F^y%Ho&ts)Kb4JU)exY)X|cJEGMOD1sRmRD9}M|1-LPf7Ff;?P z!`oT4c_u&%JuPmhIlmad#Ix7!b~^X9=f5wER5a#uY-k`)+>;@w$wBObhiI{-Qxzbg z_zW3kCZNn^fs~uZoz0g3uP~6Nmn>aCgyjo_Y#FH9GP9jT=g;uV!+?ByLyGM(iEB$Z zI^q$KNu%367ZNA;Tw^y&*-4i^oDpYHV^0Ag*jB~Gip;AzD3trL=5Bizrj`vpjHTe{ z*n;~4ew{9<;uAvk+x`4aeR@+LKYn;Pn|t=sz1Cq;7;j~7n^P9LFUSveN2);7F39k; z*A&2UPyz!J#}!hGn$zpYr<_q72W2UhKhV*unJ0tbi}@{0bnFD&4D$9TXZ3V$F4ZJK4p%SS(L-@ ze(Vxc;P7#X&hz~DPh|O zNOD{m!niah!ou;n80`!@2N*YmTvzM1NXJ0WnGxf4poANz=?Ex8^;kcO$#kGCBE12F z0~uuxir9VNBrTE-0PwBJZWALXN}zthdXrZil~5lDH3u+G1s+lE%9{}Oh3unV-6+TE z6mY%mekNpnomR6pRn|FTI-Ge-8em;|I88e-P7cL9Ww_t$$j`-O?6fxe>IgUi7d?zw8Zpo53tGsOa$8Hg z3!HHqN_RgXRJG;;=bOyYAr07sUXJx8O) zA(&s5n}f`<*oc(bT_HaL_YYwxniH{6P}@7~+-J~+T%D2QbsG=6aG7zusp)Z6Txq@V zV8EJw2AaYE4$EmU-sL=50sP8lo<|4_EPRXLmF%fG6#~ZT2@p4x=xY0P-!@r?Q{sHA zlpcM_U%*^lrPgQBz_iP6m>EuZp@XZL)ajxeYfeHUpIj^3* zn73ko8ZQox3D`)n3W{D_vN6uYa3Zp#9}>t{%cKN;e`rf49oUqj7J#vrV!mfI1+`@% zlu4!zbZx13O5<%1!h*XrNBZ2tw00Yz=mOpCvXe_E0sx(IuGRJ^#qFmfLrxPoZF6KA zkZ2$P6#Rk3n8N#%!L!j(!{{UMMzqZ!&bp`Js?tZ7eFm2o90c4pd&7M#LfGvVAN}9{ zUgQ7fhgcs!Jlfr7FXC+!@Yh5-Z8I6cg^aO~Pq0`Ne1_4kq$Y;eW+dotW6}~<0j+r> zg{Ml>xn%;lp zT4$+)TGx9PBC{0vxvYB}B&)$aWK)`(Ir3&H(6_!mYX%3p(P@lt*ij)QLvTVR2I|zY zwmc@Vp+$~N>pc}`WDtn;=lVReB9g94R7D~e#!z&vuyls#xQk;^>U6vK_x1?ncW zb+QBZ(y|>zL!2TYy`DYihGJVMlHrEWF^J4pkJuCPY#0_vn(lRHYXA58wBpBlQ98Z( zSl`uO9_{Y4SMi?j^ksLqSsSY-aUWyh&esQerxPxJDWI%#EjOB<+aCgyoG491dRf?&ITVI zq`16vqCNYbd!7X^z-8p7O*|X%?R=tT!9l61m7LX` zy~fUYOJe)Y)$jlK;lraD&a;>9o&of-rLoqASUMY6b$zfvcmi@6W=`H#hI%pU0?QYF z4DmBp@a(7)>s$d%s}beV!%e#%ZiTUC+imbxqX3?sA_rzwrhBQj)r;g_;q*(A!908I z?!9y`uI7M->a5idB-O&^dvp(rhC$Ny)9pk@q`@V;?t!1bz_B*0Dq2FY=HmAtn}Ff1 z9?1SfL|B!s$QH?$5Vkr^?jaiI3ic_xEqu5V!6{&xm0+TEa>WV6%wV@1_m2WSEkRLf z$Uy}nshw?#-UOH`TgK>;(2*skW9)9N1OA%_egFgPp}~ulN#=v}2CUbg2yA!F9Z7o6A@Y1;AX}6%AT8(xpVTO9U)pJ>{-BkDC zLd`%rk9pFX233pn@Q%6>>WFIaUO!AQ9Vnj8ZOFTp&T z3OT_`p!wvZ0TIIKum$T;g9H*BNP#gb3zDslAPFnSC4$9q5nbA6@?r+)am(qb&eqPCx{-UI&H%O*NRtfnIFLM_4TM7$WoUFR$;*P3l!;@w3J{b>P;0B2M9Knbo9&0sl9vl#5(8}uc(V@snq|`1+O_E6++Oh`9 zIdmXH@HaZW)b&;~UJWKeF*qR^p0mY0(9J*@v>0;!Ivyb#T0dVoFKn5DG>xQO>L8FJ z=dLHg5@16c#sJ`yM{9_s!wmiyQA%Iu`UbAuC*n!l-_Rm|Pb&V$?wx0^;0*){6Le7DBFg3 zj13<84LR%{oYSqK=NM~;HaA>(4j>vXm{ow6-k@5*6dXt%UZlA0pi8z8z$u8)p3z(1 z1N=usn-KV~)*Bf41cS29+v(3>V`C7?81BzKnjUaq8&YO?QN}#l&H~g_Cz4Z;Xly-^ zxH@1!b@2_bcNPuaCqYHCoRr+O4n#H>=|*t?3qWG?V(}aSw|M?di2BppuM?mjKfe7F zxL%*XuOA*8dY-+AKR=cITXQ)Y(r8M~05q&)0Mkk$&>fkxF4{h>@w;<#^tfVCQnbh= z1K~v7))jKpiglH=On(h+kz4U}-Y0hQQS&L;|4Sq5r$xk;rMJOlSe0r zxM>(_5UjK&hVl!X0Ys94gT9-OJABM9 zE)@3J>-Q?`X^z%snU;tO$*4@wc*CNig~2cXC8~UkIiklJFilOHHu_A6vxG2@9ztu% z(p}znp0;A4OM8Z8&}_D+d zFW*LdAs62Tu>Vic(RlWfzPi`_5}(tiJ|dA>QH%_GV0t%%A~aEr>paYgRAQvskLA#k z5Te$QpVOoB23ctxgrx)XG6`oF$^z)xLe=nXO*9S9lUdtFg zD5L;0_wB@_1w#oi7@4})uHi_VSq-ECQ^#RJ8tnVA91Gx|5CpdIR292KAydF_mPD!_K!m3<({3?yG~ReuqMMcbl^2X zYy#ObBPM8AU@ciDn0F6Um}%w0l@6Yt4KJdVb0HL3+0eiCgqC+jQ|AsRYHV7DoSE75c*`pz zy!Gr!vXHdb+w6;1iR)1{U?PxXyFt<5OBmvDj_|T%yLAiva&4B+UdW$+U4fP%|FXj) z8>FFq(Mh2_r<8d+o1vfF)6Su4Yv7Erv3y>Q@8L>NYV)K{Y(jYwnaK*Y{%j6O{PZKDDzCNb3Bec2;|=pZeYZ&)zte!iqVz>KanaLK9Y1g1J&#` z`T|g!PZJ6!AoK;-M}q|x5rcf&cdX^S8|^*z*g%D-8Uf_Xt9R$6{hIQUW0(6GZE}s!)l?6W z=te3{PFbk~96|MtkaN&@n{N-G&$cB73Z^TYx+Otz4$g?CtOiacWJ4wJQ!H^? zv}nVg=sD4R?{iKq2BgmeucjcuOtsn6=mdKPlt&15xB&hx5x1r6?_d@A^w%Hq!$V8$ zvls8)Ch{c;Iy_2f!dvdfF%S=D9rU5b(P*y1+*8o>B1rWxgyCh8J#drRE9dUh0r);s z77}!Po^#?TzHS=(gr81O8#czl0ydklojL2l4eA$$M}7A4-5N0MrR~&!;lQ_Q;+e`W zBXkx%;pQisXyc}-bh=Xhex$#*b89SuQ!wfVg z5Jv*7_pwc;0?u<_7HZU1VGx+aUWqmlGl?&muxv~{x9{q2*QZZ!KGnNgk3Oo;Ub|bI z!B=sk3kWu0QvQBr-^u{{w{eOwZt)?LJ3co9pewZ6%Y z!zi_KcfKsJE3K_@z*{*8(w)&qM~LpB+etibM~9PJ8(X`r@<2;9qFJ3?h93(T{g_*( zV7ihzx6;gN3;wvmdm1aw==-EM^|ob#@`grnO&$Zm?HYP9oKRYT{M~}uxyvK{Umku; zpS@;3^Zon{IG(GT>xAe&m4`wi8oEIU)8a8@M~4!dH%_cXa_8VR42FkMGKX%_!k3%L z&fY!?Kw1PfQaVgdwr3zGcIpr$an6owtXt~JyTqkHUcE~Yd>r_c^3dx)^%i9l*+K}O z)TY6a6Fw1U^p4R`MDj!1qDw(51{s%;P`d;zy{!w_hdc<9oe}|3SZ&X;Hm>YaFTW*I z{O;X{g^~M@@%d2$@!5-a3w`=}KXO4U1MFV-Jts%DDGI>ks$qRz(Q!p|z+dTEcOjDIqAT*c1CKfFwt*OqGv(NbEz@Cs z=xyOV5(6*Rd$&mBZ`u;=>3A{W&O-kMJvbf^O0+Xc?CX!CA6s}hE%ZSG^B<3crJf2A2m~)Du6hwAi^|RWo1%x}u zR(%2BU)5ERn7u3-XRa$DM{!+^h+JFuh5>e7i2?AfIkFZQ^AkOXW#`7zjULtLcqxFV zJlMo-zE*&ai?A%PG=Vytx$Z~?@BehYrjNGt*-Lld=zoF8tgT>#9hAroqrx_F`-NqJ zncfY95m+AwKn~2U>w)Ns_o;T`>Pv$$V7$&iOKf3%%=n5aGQ=t#upkWSzA|cvNvUrH zqwI65R&1iQV(G|0dif;G$H8D5cu#d3U4c;;j9*^=b!futhEWxi6fn7*wR8d}DvI2y zPKPjy8z>;OUja+pfsTeobW@k%h~ZlJC*9id>MuWjc#lzQynBn=j z*{JWerAKJEvODvkd3+(|PiZvaMYrU=#1S=t!7Fhe!{(tzF|;{#=vo#bw^A2{3xp=j zb_ylpIp{KuX-IQ*E~Js_njlmhBzm?Q5I(MU05=9Z4S&dMj@DZfs~so_^hMUbWXP0hnxF$}Z|>v^WWo7se!T-qK;HlMQ_xSWWxZS`2>Y zZULD}A_pE>eBe(No#1^!HHJ>$#&l1B@f-AAjf{YowT_FrXlpQc?K<^(z?qE{_*37_2%7&M^e*guiS0B;ah9aW$e=cXPMCD|5i4J65046e_`iuE5Yb9Rx^kDtqH6wN36AwpiQ_ zYko2Ou4k{??S9Hjx{j@$VC-ADB3bpKA1nZDbf28O+ByoT*3#J|IWxifO9aXTth2{V z%2uos+*y1(4R&$a$7^EKbRlr);NQfOjk!iLCb)8_vGN z?3cyhdJy5XhRIhQ4BeQCP!U_!=n#^K0E#%NgLm1KDbUjTD8Jpz)n=}8DrFw60#292 z9Q#xTBIYI(gYzJPaW6nLW3i=6{DFdt7Nr<1Xk36v$gFQ=oFldxWjDYHbIyv z%-ICt+X^w*?Q#3t&u`!V6)4R7>w`Ug_S*gY8`_X+_CicdYjfE29%OyNVa#DFNIHM>sQ4n5u)va})SIIl2A z9XphH#nEv|zFN#NwCOZzhwSi5I?HbdY`^;H{eHXNKJw%|dEIWqIruAU;ur$cd}uG^ zA}(p(FqM$b05htpz}uAvW1ee_>=3yn(~?<+Y!L_F0_2)ry-CW6)#DnEnZQ8jw&h3W&)1SY8`&do*?M)n+q>u4}g`RttH$E0vL| zvT@Ks<e=gfdjQMV0~kr+$a@xmcx@y#M@C{FsyobkoEqz@1TeU_1e^nN z1ap&KJ>|4Qh72T9phN)80~q&D0mvJc6a6FL>AbAsAD4k zcZA#A7DdXq~ZeulvS_l9DLb|uZ7}!>tzb=xYHe*hJI`pl2@OIcgnQ znBpr;1UppEUWC8e37|ZQ5;?tdkv#jAO;ON3wJQ z9Q$~s0nCjM?pm$2C}6xQ1dau*QC;Qw=Mpet@)q+@TopM0-ip5@ou}nU%#`pP8MyM$b37ch}f%> zbFytD{WJ??)dOPgfnW<5ZmRG1~hJl>52 z8BM6x%9?jszp0vnYcT4vf_yudPwV1jQ?nPTS0cdzL-Y)f4(Jgh)z>$w3P}Vu2SI&_ zV2=oeBF{_qX?gW>5NEL)mkPYKh2OwWI?F9b@zw2o_Ojjfd%t2a399F|g=^CqixDsn zp}2?wn9AI6^9M$V39-q87)7L9nEidmFgE07E@~?g(8M{A0*^Cifvg2%1>j=Ar_7#vKa}lT)|_!A=O<09pF4m8&5!;mJhYHquVv5VPV&f zzlNp1QJcN#zPLM=auj?ZJpbtOOt%HJ@rE%k?~EAr>0_;*9-APay>z$T-mj!-QT&F4 zG9q}cj0W<8(Luwx9~gn=BC~jCmTggq@q8@>yYz)l_p^kt^fW9M3bRh9_p4@?8hjSZK_gh$|UNyEpd+qK4 z|1Y4^Xa>Q%V!FHhZ0HUF+(3X&Gdf5dw%Iy@M+c7v3}M?%s#^n|1A@)&LIM95pB!Cb zFlj0>Nh91_+k0Hzyy-|U9&{CKeva|&%ngdlagNiZfLeJj<`&TVIFjY3FpOkNLeJQf zmKHMvUf$BV%YpZ#RiH>j6~E5miNF&v>PR$9K?^8qC2*+?Vm@^9YQPAo#t&s?|N5fl zem$4t*{k@Ph`Z;6`FGAk8wQA}x_a^+Bc`9dvhf7VZf`_XL$kJ@py(F;+xbNVvl3)TR?;@(ZOx$iNK>~V{c_@#*mpS^r{;9C9~vR(}$FQ{S% zkFbBJ5nF&kwiO1uZ!z>ddKoE`zhwVE70ix@Z@^3P;T588!yyIP8 zW?8-W&bH5Xl+W~2QI$#VwH67ycphabIk{112ysI3JUEwJ|2pU&qGZ~yo(>-*$|`?jI~`6DK4|JSd7(Et7Y z$9Ml}{2zc|+7Io2ejNbvxBt`r>E-R0m-qkqb^7an`T9@)Z?Es`>B)UJoWOU1tRI+* z&(k#(F#gL+a=Pj@0dT#it*&jsv04rsvHUp{2VOnnOw z#3Dxd&N`em{op%+cA=YrnFLDQ9ESU7&ICyfx#t#%oS^qh(mY|f$-E^eZl00T@ekzT zoLbN&jO>#Tfp8cR)G%iV?XK@}f&w5y)L2nf&jkZ?L`Uig(ZbOkRY$|ydCkaz7pq0P zl9?=V+Ckf_tV5ml@C*Fgzi4)T_6mNNAhCt!u7OFqnow%WVfAnThjWtem z=tyoGvvc{CL?oE|Y5@F+*4;Ga0ymMM!iBzmq%d-!>kL#CPk-&pZOf989r`gIh>`Sh ziqmQ}!=M(7g`Cj~q)EnI+DP^|o$c^>xU>Jm*GmyTV=r$VAGbGO{L>%K!xZteSMUvsAh4;prQ2%`*146#5K=YNbq{@ ziLaRh85b;zlZLxDGY#lg2$1{Rs$=e5c}{l3gC>yEW;qN*3foQHJX*AGY zpFRv&j)hSi^aU*jF-H1xEt;(|ED|WY)sZ-_q}8V2jprw%L#yJ-{&1`R;m<`MUq1Q! z&-LNcyGI-S?DhOU@5j$R7cQqQD_WcqJ+EPq2Bg@+CkuwQsy6UHqEQpGnM_ul9t-3h zKwM`S9jfUW%g}wrwNFuZsVL~Cu0NEtlMUHf=1J9V2d^9n&feTXl~kRJJJbglaiT44 zl?fqT-_|i*SK)E*rJUmI9ZxA5hHGccaV}}JOhH8u6C)Qq%LU_!ILojo%yY-N^O(DI z`(q-(uU|L%afRc#%lG|v^)agzc(EOQ*{8 z+9RRGl1*T2)au+YV}|hlG(}mS`~eFR4f*SW=&?}(Pu6izX`I8Z=1=u&&||`GsqHM9 zeHZ7(%dYx*xUIkWa^8J>>t7z7nxDOX-`&{4IJ7g7llp;+*EKGWNgtScFDM{nRmUUn|KCJ1=LRy#kC=*0k0ZE5yJ%SMlshdhwlo`3%A4? zh00#(E~b9rTz02^@NPnTGmttE$|%6PQzyo6JQkGnkU)==?Fe<}76aI?tL18V%r9W+LJq-F>7xulb6u{PsULQW89Z=9tVx7exGFjfFW z1vs~v%n5T~-&xX9HMy^qbE0|bx1+FsooD~_Xgi<1Z1>%v*XqUM?VxjPRS3W-Il$YE zwpIEX8xsZLekHbgovwb6{>@Saky8OCL2eLpr>rA}aZ5B)wF`c5O&PUJY6(+FJ zi94o)XWaG=Hl9!%J;Wz`SSSVrY;PEys}qrB7_~wZtY+lmOSd~K{j{kmNIuHZRa-IT z>L}^b=};`=Ki9AE5mawSUygn^N4_RY6)^dm?fi%BpU>Nu_vg(wTG#g<*k`ZgpL68< z57fTprOsRj^9b_s03nO!#ChIEX65yk}xJImg|TH( ziqIUI+h@y-e=aAMZmQv&XawyUs>LdpDpb<71Kv-XwsAk2^Gs;YBk@Ytsd==3R@6O( zDgwZ^Lz$w>@Q#o%aWY}MWhegoi!|{Gm5UE=;>S-P-o5jd?=@sOR4omg(Th`FqJwn5;_OLofM3d}5X#JD{r*VqvQ-;z~eZBvUBSuMKu zIYcQY{*YkG0a@5$&+2UOf8Z+7D0Q_%+rT@eY$zI=TTi$>Ch4?u&f?UwF!7G&K9158 z>OkFm8#@2*e)^c;Q2c8M+nd~v=D41`j`w!=SGtqIXbP2x80O=f>`ETnwPCI;5;*p3 z+4(p{_c1Zq+K&%k*K|ueG$w5{TqF?q#jS26;)rALp+@1D+NO!A4VTgIAuSi4r&r#| zTY4J<({y_$igPv3b_30IbarbbjsaEC?u#7gO99n^n9qp8wKWG?L(oAII%+(7n8FCy zAe+vmU{qIkTpSsf#T6B6k09ea3HWb5zIi2$JZc9$dF5^)K;OFeEqLWs_3Rj{#-JKO zmw8UK1+n}xGtduoGXVTeFeAveozL0u^SO$o^sRF(H(rGC8ho}YP^9n3@?pABhXIAx zurG6-MHq^>twUJ{`Cd*t1e*o0A&6u*7tA^#y9$}q2CLy38E6|5lTZ|aMcFw)(wR*X z-gJV*vVp6giV0OhiANyzT(LH%@i;XI4Be@4L$=$=ykGg=pUxj2y@H>-Zr|Nc3P2kJ zgTRbPPI;QOX#aTiwT%GeaVC)1HVIw7m_EDtuO!v_3B?v^Sbk zMlv?z>{lfyLqsc(!tGA4#9A~)_OTWciL2wGn;;1@zM-I=ZoB@((nlgqOh*FJWXO|( z&C~Z3(KGgRUYoCZiz}zjOqfyy5;aRu{aNEmv!PdXWgX5f|MIV2KA(Si^msmd*}jL1 z0b9j+_8v+Ti4M(SY)o{OuFw)~d->KjruXB3#_h4!hV-bAewTqEI^a3rgPm(2q!ev3 z`1{Z=^u7x&_xsGCz=XN`PQQ6gJuifn<`i&Q(lgx8;-(p9F+#2k>tx@-A z{WLNK^8}onO}V+@POuB!rj8;UbFUa2U?z7W-L^4QmO!Y8QbQk3!y&3C&aws--B^yl zRE*mial>?IZ|GIi0T&&OciD#c;+~M%NXYChuEBkb%Ff()Iit*^x~=hAaRiJzPi%Df z3=Dw@oRMXH02#m=g$p1qP>b|Lq{i3OpVN*1=6rtp^8O1tv+sU-|MKNe->$M>|L;G2 zd3hLOefDzRKDz7MHWL9lR~xwIGbPdVAJqa*`GKpLF#LesR3_Lgk=xI_u8b88<53fF zm$PG5UPWpeC1jB0?A3?i(;!x(n1CUb)H6}nUF9LSIg2?(Vjlr#BZZ)0#872uOCanP zMxHnWdIXGpL9RQ>yrF!EY8CL&<76tR7O1-;9EEJdavXRWf8E|UL(go1N1z&S5`{wD zwEo|=`PZ+$??)!#XRqWfm6(23Jgk_bZG3D`{wQ2!H5N2kp$<};0XuH%5Lcsdn&HLCzWBK9B@r~my5{sg z8ejonv?RLt^XHV*uU@zK=Tg*_Xno_KKKY}O_-8NT-AMe;O#$uOkHe!FVwHM%JzD{f{?PV58v^B!un9*WcC`fUe(@9ROo*ftaV(3&bE69i;G!B%&-(v_P;ZX=eC=v!p={z3q?%#dg-S4;HpS_H?9`K)S9?Q_;r8CB| znBIe%@Yb#CbYy*iPjJ$1yQ0royR!@}TNCZytW!cHCY|uM7Pl)u93A0tbg=)FkHS5W^M7ghVx*xjqJoA zg9mNkFG1i&(ZB>FS*bvhwV*AN7Mks7KyFh8rlwgt#ou{&|0+IwdRRYx^5WeWDClc} zVzdAVVo0~`9@Sl=g<^1~tvXEZ8Cw|D_)Q%_hSm34pegY*xabuM#)0WMppG_9MjS}e zujLA&8Sorc+E5+e=k!=SvL^9eBTpc}F4QKrV+c)QZG+I&ZwgIVpElMalkqedI|#(v|$)=osO;^f~2ze@uvRv7m^)j0%^6Y@6(mH4BhLRE32Uu-0VWos%tUh z+6B%4E&w*ci^P2~r5)K7i5^ETTsr0kKSVFZU-W3Q@5tggdEnf6T!Rn~>AedVheFCK z6Wq))u8dr`Q;;X(ZSCpximA;6@r4@ z0sOB#JMNDl_*^l%iRd6OD1ER&_PT=czW~;KT`@M}jF>%^EzARqjuBzZ(<#Yui#w?j ztwUz;@Zp(-a&Rg#jI=hmG5Exy$$8cknHa`R1Tc_iJ7}JxBQR<^XhLL-&aiA%yJ1cU z!sxP^GGjzXCs+=`Q!TXvv9}qJCwz`3?_kcSrIfagM&Xt{RaR+@u&j{nv+gr(&)Eyvth?u&91SgvDJ(S#iOkVFcw4~NG2l~x@qFzw zEG~!6#`Qm_CFaACsX7*^7AlYUZ!6W~-Xu;?L-q>Gu%3}f7xLLF0&ixYgnpLr-%@f1hZMzmZrmUR+v(cF7$PcHDK}>F{ zn6#Pry2UQBthFj#0&oy8UM5EQfOAL1M^%}HMXjOY0p(8Llf;qIM)}WD8>&XJg8H_E z$L1l};#aR~%10mEC$HZ9Bm4Sh76Nw1`soWYdxw6gLozSGL&q36h})q$GKc`!YGd;0 zz3?%^uyDutv*TRTC3JyxNV{URgi#gRBMfp>j|KZ+AAFW#-4y_f+l0kBe%())*MS09 zK-g(I!MQsdqsY>|&2d3BhvCbNp|>t+jIZ2me89Vny#~fDEE*CkueV@`1i{rD)v3_0 z2i{u&pt4EKfJog!`}`jt^#z{2Xtz8t`esnVqH%5sz0`@VhYF>Jb>P1bQ5z523dxo!D1k6E3HxET#U1v2k^30=r5f!`mB~2enh9+^td(r3crdV=67&07+;y#Rx zT+2!B9?@S)Zt>a6c26pK{f@57#?(jc*rLNW48q4Qfbi~^GCG>At-WTqu18Bm^2GG*Zu2aTrlzp}9&fnWOVCjt2)DK3EAdSpcXg}U=X8=%Z$u_omg%4cP zJE|}vs%AJSve)={z+I05tse*^fy6?RhB3@Es_IfussvzJwwY4s42hP7gQj+wMu;My z!pqLtcqHAjguXQbUO%o69?~bT-k_ zYb+7K*FK@tYiDslH{p#O0Tl&huch)h?9*DquxL9t(qxf_3}kMNDI%uym<5>V9sCvm zyxlQ#6AdzpIW`&10{|2*dWo~VLfc4Vz}o`h$%L7le3Sr9jab5f`8uaIgu|%OzEU+1 zfnV4AhHKN#0hm+z?BOsUwp*C-zx%qYe|-7;0^{UAoj*OQB0hT&@B8hq_Zr14)5w*F z3O0HLron4sHlcwkY(m%A!r?GN@(9ReRB9TxRIv>s_3(Xq<10moDThPJFfUjfzL>$F z;3Lg3RN8?S6aJ^k3e&T%o`1sKK>~*`d5`OE> zP8g`1976_kK~3D_Kue+f;$uKql#9>0+}OO)EoNL1@wLWz-8uShWGQn@p#8Him01%^ zkkOjLp;*!f(`dva`{~JOlLDl4+nuGsihyY4Rphg3j40v&@&h8tI%MqX3oTlqOI*L{ zfDYWij4%cSIZ<=M0F#V_>txNwGfg2ui@qgJ*2&`2fG@4=m3=o1-rTYb&gcK~(|LF~ zefGlLUSss@hDvLOvlIyB*&Cy4MOz137reJx>^33V!W+WY>;;wzl95fbV8g@|ROKF! zg@ij=zYQG{3=R^?(P$?sUWm4Otj;G!LWqf%=WQFu4@^+LF(KJ|`8Bf)KB(>xHjpP! zUjbo4duY`Yb1WMvE*QUtQDW!w~h6fV4sGg{|$i&=F*`S6r_Z} ztxz;7;rMKACCW))rV9RiI2hH%cVBIi;{Lf{ee=1qpX90RZCt5|GbABUK(}QTe(&(u zAI;lS((lWWDm~}poAY0O^0$w^rB7bKd)Lluy0qt2)FMunQqeQ}oJ_k`jfD0X$xIj| zNYM*Cggo5QUeJXz8!&)?-9W<@Xm??{aj+MDb);}NBFs_%{iislG_`02!?KX?}Z|ddkd2`->`Shpnx_+O%g5LwW(Sf7ZI|(WJS^}w? zI>PE`-qQwY>xk=yC9Dt8SZMN6fb_~-jPAdWY8cgoZeeMeqxtJyF#ERw9#ApbS{^m} z*bUY|UsQU#vxS=PxaM8gi9>sCp|hqAqzhZHi2^AL4-ICC0hApaC?;G!8XvPCTOxIo z9D`UbF(awKy-9%tk6FgU+zrDNa;|P4n8elQz6AvR4urlpAN|vL|EMAN?8UqH6MlUU zdzHmCO})Jk&;$tikW|501JnoRoF?h85EP%Mkc1+kspXGcXNXd#eJWhS#?lX$L#5fIwaCtkO}vp6pjVDoG2NNk+yStQu@`)AKpLioj-fs zzL!hHo63xPME4Ed8gg&=51z{tC%hL^GvF!Pv@n9RbEYoLoq*q(=L7`PGKtBCBSGZW zfMs#6q;bec-#d?=jY*+?Rj7C1`p|Ey4;ZDpN-0h<=_1G^%GTq^Ay#&1eghS7jFOTZ zu-rEVnpq=3+T$yb5Rl1270SkQaR~%z$SfY)fG+jw*K((4KMeqn1R(47yZXDAcRzi4 z_tU2z@uzzLnt1Z!-L_`vtE{C{%EWkeHtnJVPO(#ZQ08ihQde@79Nj`S&FHm+Po^|&SIZlSu{P+oj=yI%2)5hV zLuXhzoKfkEhQc+ztDIUh1oS$BFo~`?=41C&v#$yACZszDfAT2UyBk^wXZKdRGG*x zZ|}CMi48O#)f>P^WJIR`%V)iu6b8^0x*r`5;w#?&t`6Mdrb9I?&Cr4$qW=f8K zC|Y4mVWi_PIB)Z5vyZSrLu{AuWDN1@n0n>+iTi?e{o=$g!}Sw)MG*qrt}E~=;+XEn zC~7-xwZI>aj|xzRd2H38A_$TL(ZycJ9HZ_@(rKLAQ}N$jss1-F@8j)H`EXYK+3R;- zY+7II`~WL2DyGvLd{&IkRluU^da{tK-K<+7h;Fb>BY50ZhEVGbbK_A_xGlSAlH$z) zqDJp~5w>FU?wIK8Lk97cMG$tE*dDi4#5CRlWBHf{%fh175C=U2lUN|bkm1W})s|S} zMr{_foox*C@%ZGbwfoYwPV9+Hf-@mt3bBhKF-d~PGkGt zoYWDcLox{V+SNC6C(xt7bha=E!}Ex#5dte2U`>fzqOlLG3qdo~)kw?dxqWg^lcP-& zqc|8AWgXbAGa#WS42Y8SDWlJhIV(=gG7Ea)qH_{J^`R)h+i((a4I(3`B4@zxSkTrV zhy=MR5j@}JG3|i+U;Vc5|Mz!0{MNs`^GEYn&tAye4IbZU1Ykr$;01&?{D8!=<`5aA za4m!*;|3vb;xvyN^up?4R2+j}YwojwW3rliQx0yRJpc$87`kup5mL>Dn(6Ee)hmP> zpi%D~cLgZ4a=h=eIxzZhx6X4GW!6+GBe(=%?b%KC8i4O1z9~qHVQ3O_s^cJ?&7EAj z)^h8}cpCn^5Unlgi+aah2_l^GX<+;Vv$JjkYIl$Dmk*zj8qP-%#3!%h?GAsdUdVBD z!}`>E{hde;0}J8QH74E(2963NyZE9AD3IdV!qjJ*VFd<0ri~P*OuH@UR^38jhec* zSo0uW4O`JbRs{-=?ZMbgmt z1kM_>&AHmlv5nQ6NJDITt<){!0*465&Uo{BZjxhbpmV?&jgADLts*dA>2@E6dGqq+ zl|23zM(Uouh~JyO!VwNVGPEYcwH!0pX1gV=wA0a|h99)raYz5Y4z6NTgIl-jUJ>Ln zt#^bGhIBw32W+qc^=p9i5S^s7oJi(8wFLS)42tq?ZR!_AD|q(W-F5}O+0%BPUDiOZ z)z(0VUpyxU2W;8wb^tv~$i0wV?)_r2jvab{^2k0X4xZ5gBds%+ti1%+^xcYkcM=7n z1@bTf4Vv0g6w|EFuyJnhwAW#2E}LjfPM>{@q)LJFV@k{mI1HG)s5EZ}7r}lG?>=&c zh;K{*@3YBA(~(^_cH6X%QePRU+xI~J7^Vgrq;&RfJZZpTs| zsxlz-Ee60u3U8i{w)I4|I`>$O$JwaIbOQT*KDraq{RW+*{35_90v?1Y)Fxn_q+qRXz z-cA_*hi~116}CkvBPW*=<~+=~JYzUFouvR{@W*)%y4y`7WWLw742?QBr!LH}|&YOuyQwt>~Xm6@V!fdxBP zw`p2Sr36Phz|v#u&Iy+Zh&CPL<44FK0ewwoCPvDjoI1D704UgL4JbWD2h{c2XGbtG zpp3gdGA>tUn%ByugR&rcE#y0!!rS2{yrW0~fNGEx&Cy{HEd~*7$tfUsj>pD?{2E}S zl`S;(Z}#=ye%;sl^x@t2_x9Oqc%N!}tw+g_IWM-G0FXZmWX{D5rJHl|!gs&N0LO#o zPR!D`+OjYQWl=iuVL;V>7i$k+$egW3a5nk|F5h$`yFOyZ<~dcyN@LzcLbpNUoftkQ z&n|YQB4F#J-r{1YFyr(=5XP3y?nPHEs`{t})?Qv#qEmP(fQ1M86?yWWUdXl4?qHq* z;bL)_o7b#4d$~!Ub;j*g=WoC6?H~Q^PY<{C*~|C6BXQTIv3TkVU>u41p5^SdWM!WV zv!p#!_UY@`z$^)miI6}Byy;UggLrslD+>nd0%{q|mnUXt_CdfN0$&saC(ja_XjWkO z(Z_A5;+LaFd-lS8+tB~>p&bv;ZF}?n{L7ag`7afY2S)v#_&~ z3)naxwzF*JA$%>4OGlck(b{E%*-$(w<~9!^?b=F9SHvM0in1BT9t>I1s&!U(!t0Xl z7PNRUG~o~^%^gsAMnPR_z5Bwr)<)L_%`|5`1YpBzF(%86DIt2;j@U1}V|$&L?Ffy5 zFjK}5#I*+^%Xo(lfVgVLVdmW;QpT!;aoJ2V#?a@bl^l-B%kri9%J{NPtB#cg!Hro}LE!J=819pu8eCtgj0u3K_|# zQL3WD2ZmgRZ=5b2F;cyUY2rHB59)@5%r;^2qw!=52IBzXHc1$M5ex)s0;pf=#b}Z0 ziEVJzDR^!8ye~niuMv-5PB_vgI%fBp7;EnMw(%!;kAK>1S5 z)-=fl&i=vd6Ay*AYp!uN(hj!s3g;0}gHF@>1<@x02}5KACLiYM68%i?6y5OW02`KP zDQuKy0_)sCgSkb06>LVkZ=6~HoydkH{UQrq2-Z`f-h_u0>h0dMWBL?>6mixdo-0x6 z1IBvK4e55P2GE1x&N8&XT$&Rvw~o{XX3(Lq#<{G;&j5payUXuCfB5NB!0_@0#EN)S z$a?Zx-afnXt&kNRvXOqMjakFmU?i(m8!U{coD4%2n@%_JrDLP3vJ;O6pV9qX_m7cM zY)EJ#02I^~S7uIds1c-|N^#JRc8^priHlJ(zMItRn=z~^;;2Jxh{u*i?>$>98!eG% zA;GYS?PC}+DPZHLI#f77xewe)X**CQc}IX zzsG<3<&($x3sR70ujDODX#CJ$+eH`DF$nS>t}DHBssVc!0ert2*xd&;+iP5Z9XcfN zhE6VV8_}H6g(MA2v;$@>h&?UGUdAI^-={%pQi`pCcBQv*HPD;r?PE+D6UCs0`cz7& zM>%RmqYdMQ)0ecuHMyulsgOL}jrP*H1q8U3=IXKAz-@IPpPbOcj19?cX&arRgB@+5 zS%h>?HmQ@ybA5k{fA{rG{pP1nFOL%HPhQ9Sy4Kfx)$YiI)dR-3a+@7j4GUWtI|=4V~@+|mbUNq z_ZR(|e)d}4s;Bt}dVPp@vXNq%h|)}H5wKZ1=hZ$}_>^r>Hh^Ha#`G)q;M(n+ftgo0 z6J%WFd_#0;9oR@L+F5X#R1T{9YC&L)yLX9u7r3$ z=D9cYqJQBb{=<3ym)_D(UdP)&-8Zc25%e8FD;i_1uF_fs+N`8D+U^ayC>9qkVE(Z@ zggbfD3W035h7B8ffOVSE>?}VWVr@a&e5@mMRSwKCWbVi>UR{87oaoL!U2af#1kG-n z7PPONG;xrWrR^Myos5O{n&?Di|0+dd$i4z?L|M@501LC_91L=pnW zoejuFl1q;|dC=lJ$i;8=hYxQd=z7#{c=F19?^bl>WpT`?0qNH|ZS_3}pxweDAdYil za&VrtLD;&mNWk3805)9iREL&(Bi4(%&Dy3`9htw~oX*|p zd9~IICyaI`l!ez!b@8rgGuuvd6~IAmA;Dt19lD@kz8N!tbj3FYft=eAyEu8;%-OiH zCyI(|!*|T8FdWA)k^uJ<9PQEbHfZ&m`26|JKmYjfp8M>TyB+QO_MxSkv0}Q{%8bRk zqc5{Dluxw~7LkeDSUK2$ZK}bJ44~R{M)1wj@!MyVhaRQeI0?cuHM>zH0?Hs#qxOz+A7cK}3k~rtL!u1RQjI`<9<-Z# z5{<3uC>AUnoqP#5_u0UhKKQC3bqXI6`GlESdHT40Mt_?h-u>wB^X)?dcN$ zoZ{$~MRd-deVB9x+{f|4x_s9sIMqf8UWUZJPXcoUWqI;K6C6?ORRlG?UIM$mr9riM zjCEQs#Y8cki8u-E)nwWkppsAFTPdPrXKGzjH#!G2N3?Y|^aEN6WK6z}>K+(og**o^ zEpXiejtvy(l6iE7q-+SL3({z3QzW4GG@h=D)~W>npa9X?f`>E(J><5}`)Hh!+i|DFLwnaQ3Exj#iSZ~%()G2)`9o9O~*L{8Qum1>LKh<%C56fh`$JmyAyXW zID2*{fV|E%eZ!o~pgyd*qU{nD1~?2n^2LEA+nBDeT;#|4bjdmB8J8yhUIrf)Lcbi^ui7Y&Z4RW3`qT z?K^T^M?Ep?vnKk3kRV;AhsFKsA;fOvC)IRf0N9*`;(?Zo74BJ@il4%1x zbI@pYG{t!LB&HZy27!jhY$M|}<|4dvu60lp;I(m!q~#u~qHk8m%MOk3L4^D;n!jj~ z4!N-Ow;$R+oG)*#rrx6=+$S&H_nuWT_@Hppooh`@FmCRUt57r4;OB}ZtxcnjU@ohi z6CgV1KD$6K!1#LKiosW6|*Lf4wvrYNwOh6(jPbrYcrvStTiROa<~WNPCS+Ok)VMusH!1_^8+;?S%4 zn5)kk9dWJG1$bSp+h_H!{_x@BqdAdhuiAae=4%B41O+wxWM>YXG$%sssCi)0*jGb9 zp&$hXbHa^){{YDlV8qqNK2}|uE=Cv0)>*Nucl5oRCECmuO;txy5zhGBhqsi?= zHBjN&K?1{%KOIIaUrD@h1>Bc;LH3AdZCW2Z&v2VCPpzN;(At-61yY1nRnSLKHMg2N zdW;ROw~8|;RDr?m>FPYzMRJ1f;PGe+;Ko)ORVW>+qnsp7Kn579ZP(%ns=#& z4LJfB(+E{P^YtImh>(U*gfmK6?Sb zx3M}mA#<%lD1;7)A-$&W10UC@zS1l(q}^au*?A$A%RP3_lY1SOCX?}nSW;a(clJWu z6cw)QpnVn}bji=%^3n9_`uxRo`CoZAxWLBj;`CDO)QKJL={nYroFEX2={}bm(&SR z@bEJ*``^LzS|-4?B`9he8XWSID4M1S@_>G2K)ub=cXe?j|G}(g&op9`;J2$zcITf@ zzW?!8FQ47xn*ri?_4y5^2|oJghY8jvui^KAL$UBG=N;2qLaKo_=P57X6$D;6P@(~@ zw5`+wG&*#p&zyT-_Fo6<9V1r8aFg@yn4#SGK1docicsn7fD?2AR=O4!!iN(WyW3hY zZlGg9tG4h?%r`hSnZTFRthaKS5wHRwfXzTSV zLe~dXIVjXYQP81~PV}|7%e)%^`c?e+;h*0>sslfJ-R`S~ulw1}lslRUT#1i)+IC$X z9lVrtv^7CXaxg`2HUO5@X%oMaZC%>wv?Xn!6nBQZ<&31e8y(SnzzXT0NZO_^;9hxvort=zQY7P1eXPOR(5@u#%ry&D2XR~4FQh`dR z+-qu9n_a!P1$cDz%+>KHoS1jz2?G=B+OXu^*Ma}S6Z-6xyR|@k8}||5{Q$>0)^hg- z*VmKTu=v3`buAdZ%%ShV90xEv-h&ZD)iZ z7F^UC_vzyT58OGw&%9>zhPd?RD{KNh-R31vs5In4Xkp$BfJw|u=^n*Bw>xyQ1oV#9 z>41?Ykzqn>cS)3(8qbz%c|Uv8RLpD&`S!k*TCW-N_Mmj_=>PTh+Gpi5%V z$uSIJi-0@nfREb2aUzC**fQ|$OHQv>n?+AYMbfvat~h09K~OCC$AV|KE>M`nLi7F@ zG@_l5*cy`B55Vv0JH4Grx6JBEXQAc-F3W_%VH)Gp>4is0d~JLJ3qw79!p!MQW1~+U z2Z$$NAi4~KJ`Uv^n1eHc8l8Ju;wn^RiIJ_{x+$J+@Di5Dfwb;6XZk09`}XA_i{#l0 zci((_-B1jL*_MTW4@E67u=Fygk?pVwK^FlZ`5nG#`9c1%BM8|r;y4F))>@dtM!tmH zRnC=x3||=9VU9Mn4oE;P67I#YrnCqe*MaSI9}$~v{Vg-AtT9=N@xbwj}7$X%=EA3wkO z^5LJ(`$uoxXD{7%&qbIymCN%qbMAGSd z>+tZd$bwFz!L5Mc0mO{3KC;QqGfqaabXse}b%SZdyB@iZgP;9LOh4*ER0jrKQtcRV z^T5%SCLFrPmnh6r+lEXsO)bKqp^4bP8>b-!3) z(;J=2P0r|aB1HV{Gx{I@diy@#GG~AH+Ht#}ss6B<^z2pq^IW0+(Cr8PI_EBfc5HAE znr!jFT5`?+eWz&kA&#z|SA(~A!RB=xx~Wj|m_c)|Gzjf6DP}7JqFxl*{nYBn|KKE# z34Qm+jt_^;*C`Ifp_x5+_f#31?&S>@DH!oWV23J(L@+9Z zxq$^!^MpY~+L=ocn&0K#gr*;xb=eP&T47S~ZqACjYMj##tZ*3Y?lcCtK_G+5<_X?c zs97A_dksaYx4x-$)6L2 ze=ZdL-7D%iemw8|(bhhB32)!S?Fagr|1AO2kBl*986}tiTBti`hp3`h;;akkO@lhz zjSU%8*=u)u zz4>-uwGLQzDy%*ZNbbguc(h6~;4UB^hhC8rouvt)T$^naidZZ$@v=b}ZaZU4#88Jd zy2d(b6S<+k53p6$bv8uv66zGsD-?S>Ta^c)XwRjx(d5RQ6&0o@MwgSjHnz?&_bn-- zAPw8#2`yytiql~q9S3DzfDjn5Gz`mXgFvgFUJ=ESYBUfG2fR-lr7KY5@AedE#qT;> zp1pS8yWhwZ_R+BStCdv%@mVm5&!a|OgL+fpQPlbcW!i4%OpUV#h?d3>vmU~D_-4F{ z79F%{F`4CV_fkzI> zgf(%G+=yx3*C5W^{Sc((ZAaTc;KD|@hI(BE(TTe#s2;Fii;dZKQQ+AaLouc>sR^a5 z!wmyR6Vj}1;PmI-B^eA)8nv^kFs*egQ_L{0a!Vli?aSvk=U={jXHTEKcK0~NugN5M zn`oI|vv%&11EcZ69ds33>tr4-qO~Hk^>TobND2V(sdK`xz>4<=P6ZZ=*JOvn;2@IT z8uVpdbqVARUVBo8$ZEcZ-+fFyM#S;rjiK=|41`R9YZaFk^YDcXn)Z1H@RNz6PRNkT zka-0T9e1H(4ux4#kx8qDSTXwGfN4QiIp^Go?8Ho0!g&feNx3}*|9)SStmj`o`uoo> zA0C;VpS^(h1;f`3H#c3Lm%Du{KIj6EIw)&ec5Wk)lW&KaE2%Y9eihk^6u zWQk%p?vP&!OktcEDJ!)5a7L(v?%u*5k!tzqkB`64Uc37+;cIEB;1BM?!>X8ejD)pO zjoEDxRYMb)){c`dCvdHz&dX)>h_#}(wh_n_L9A*Z>`HjGh1=X?b?HcTb#t`7IyG<+ zD^D<7p{LzGtgVNibKpKm=d3eqi>hZ$B79nS4Jjcdim_2B;VMx zvhRYjw5!HLdGjwOJt~bQ&d^uZ_62TL`F;WCseuEqau*G zs5t8^}6HRb_cLbO=%I z3~h>W|J(;8DYxo2;2Z>thXdmfp26_NADc$(DJJ!2_Ci^?IeD?)!7{O)}*t_bjQ|4OFk}kL62#->Q zXj|4E+%>K+WGLAom%h|rpcGnl#BYaA#GYOGjSV37Y!o{YF1ArLjsj@BgQAL)xuXcM zbxb&6jssk{Pjkz5+@vqk+h^?Gy#E1P^Skq@9>yBJdi3rEhi|tico#aEBMXI5Wka&1 z7dz^+E(^hJkaivA$vGHN5`?a=ZUCo1Sie})(9xiN8XrVyA0I3OX{i^pq}31xlfk`s zMHwWt=xr<%W5y`U+jq}OW5ilAOHmc|BiW2t%8_+9(6%`cf<*W**33cjRTmaqf z#Ib6&;;JNVU?K)F6<SZpnpp~?UW_%*QbdM3`?fjlDEmG-7piUDp>5nllFI@*bCgiFq7K$OcP{DF zCvsZljn*5pFYbl1c&YYvS?T2#h`2E*pa!%&4Z6>2JhxFoxT26=>KdI8^?U&imkW8U ztsEN`(oKS{-SllK83lpSDV+e15xT5XX`rk)CXn7iC`uaIBh}8S+bR7w|6)Hp;#2APBEeb6tFFlyT1rySVDMn=!3O0Zuav7PE6Y zvX7dum7*j9lJWs`I0|3uf}#_D!t_KisI5CjF%*D!h$!{zWrH%Vb`;7Fn_EdvaG8AT z-qaHCoe2iftR`K$N=}(Ea@Z2@rVFsr;xWd+={Ax88<+#VpgMEU)inuR$wJ`T?R0)$ ze|WUtzIxPdK|JH@8M@=tMfS0Xh33b!)%WELYZJb#A)w6^PZ(yUN}I0}!1S#tix$M! z%uyYd-*k!`Z4cd*RftP)6vG^y?3@UFT?6C3vhbK2v5X~ke$DzP`&*n%?;6!oObA(Rtp3*U(!mC?TUSd#Mrz*m~GG*$m*rftC19X&gW#6;U zYo|m!$HCKVx#_`H>!L8&K*qlT;oe2%Um=5KWn2PTUz=Rpp&X@N4a!`+VkHE5t+o$? zHK2fKjf8Xi;oSbiS1r>Y?ECk5CGNa|oFCy!Up$;o=ec(%QkNe>njVBVN~9vS3aE)A z{SwkSa=K8MM9ScHKyb|=8xk~;kP&H;a~y#8v!ER+?mcU0t=<4cMgoOWyWSHW!uCAy z*4)nX7$Va*L_kQyP>?b*#C-+>dlpb}16);Hw1A8pSSj7-DMd!K96|tqA>s^AiearO zWZwa@JieH586DxC>w^%uA!Y!jaJSpn&2PT{^wZP6>#K+EzL);CEoWg3z$1VZkSUg> za;7`_o@fms-ICklP6Hi@&fO8@=nY>~9$JHo2C6p*ADSHoO}(jW~y1z2A#1Ne~-> zc`$PVv{F}&g1|Yxm)hZZcO8~%)_U{1`uxru@|Sod8-DfR z-Q9}iYpae)wwIJB>A_6l8)EptQaVJ|f3=>IdOS zLgN&*78Y~vp*+F>Z*IqX>^XfI23I<0!t=_V4EPaSUrflfU+&e}HsSay2vFpH6z^5x-{fkL$>?&pv%Gqrn^`;8LU~qN>o_fVpOk%01rlx&9)czj zpgkhG%eJ$xbq3DC=4@@AF|HubHfv1)R2pR1h_YG>`A%h&c$MB(n#_$-OH@w4Em&a! zgk3>)cl`9$_4FR)I7d%gyg&tRh^y&}td*Wz(z>=5tJ_Slv~ANI$8y17yjuqz5fhIp z#v*fc+K&1B*01}|fBoH0KiG%!tv38`(2ad4SbOd0-J+ste--=h1#+0gxDr+QBI2KD zAd;ge9o|vx+``)q?SB0Py-`qi1=LTf&RP4Srp(OW2rVWSBoEXfE7!1H*BoVAp)j|9`Z5ti$U z%RmgA@NV4MftG{N(;^CHRK&-1J2{%C!>ZHj$+Uj0|37&6ymhO zJT*Ew@kC0S3|@Q8J6U)l+bs00a8?I&n~F?s7Q=Vo{>x_z%jY(Jg_9vvm+pV4eBsM!$+Jff)3HxvD(y%pBp)Ud(G<~zxxOr^v|>VslI%A z1lW4@Al_FjzC{%pk}g0d-ZJ6U9?CY1xgSYm-sUqyj2aveMJ?nUmP>Bc=Q{9F?6wf{ z!gaEc1jxu8ABDt-ljUa@ln;JG2Bk$Y-%)d}J2v^`zD*MVJsZyyLLfqsq(5Nr+6GTdgYwz{wGP^L>X zMNXm?*vjDjA|2Alh&eWMU;A>#OaM5RKnijUF)16tMu@Dxd%pq)2j#Y9%T78v1>Z86>V(ZAbXZ?VLFyT*|NuR zAD4>NOp0S8n4*a^RNNQd*UGyNv?_9Zp`D3iqz{BMgA$umgwPmTvQNY2F|qg<&GPDZ zNjU~R3t-I$!b)Ig!3SQ{Wkqn#Odf@h@`Ls!!1p~HAJFYV@}xp2I-sWLV3`J?3Fnuz zJ`WZ8HFyFsLTe^$wZ5-X5Tyrf(zkA_KYsWAVWQ}(hwT}cv@MW#uTP9o9HA4Q)u#ee z1eJNFNgM73Fyee|AlHk7o0&z~K^KhtYagkJo7x&lLjVDSfD9$|y{$I+C; zYQ?&Pwxe4N&zN`Z%4?k_4fW$TvgV|@M-kG#F51F50J+Q=%4hg0?@a~*>jU;j-NLhu zoJ)E;S_+bpyuxEk1tw@a~^J|MSCc&TEJ6KG^x~1`Of} zRkp6>GOzSe8h9%nVG9(QVQ}Kn1=0@6!7!He(VMeYf=rQTkJLu1k+|13hjU>-a5Gk4 zfDlb6PxyckFk`{kn0egRyp@Bydz}Cri7)>cEGa6|Ar9w0PdV%93X37A42R*~P}RfT zw2BZgb;0v;0{oIhvqZX89$OL`X(%~`t)_jaWycj2c#iGHc`I7`Z>}kQg!g{&u>JDp zs}Pocz4;14(nNT)>PXG0%`>5g@2!DRvLWVZXfF3)aDPJa6K(4_)sS(&&z?vRy9(!# zvjz=_6%={A7cx|P;cFfTl%WX`CGZ(wnA~a8jJ4&6F(x9f5$sFUWekZ#x+@_ic^%vz z59o#)X4keEkY0k*6cr2F;NkZbO0)?S=_a+fZz6aL+nLk`5-R|C8qk#?VVTGJQ#oZ~*^XH}d{-59d_+zZ`=-&I{A^gQsZNKmGwaSlk8s>O3ua8I{jQk~GL?l(q1_B$7 zuTnHa8G5TV=fRf*!N%d0f`>AL3`SQKdjNdFOFD`Ge!BJ6nI~kBhY_HFutw&&iSDZW zs2drqRe1i1Q|;YiI1>bYq$?N)%t7V|D)}As8suHJ_uBF2N?mB zHaLf-Mo3a{$(kp9P)l?wo9vAo%VDU7at1t%cqX3gOQ2U_0!?c4)(>i+&OwRr9@eZ2 zhu=meQc2JUzby;X8fi92W^+fO1v#Nec4_5cKKKc3dYa@!I;eFB^=mBzXlV4c2Wa0D znG}iy8I)##&2L=0F~B|pF(tt4DO6=et$->7L@iI`lj;54pH1&0ZTO1^@!8~F%nUu; zSTsgQ6vbjgqInZOnrEPibfOuQ*eWeRDC4jUO6rUlxAE%cRP149AtoYoiR3|HJ6AtB&2G=qCV&G-1UDs~N!V9t8qb8j7SJl4R zioUAYSQ@VWymjNJv#C0w1JiihtJ`Z_sJc~v@CJO$g?f=9fsMx;4G()c#-PS-53yxp-oI<9j^2Mu;t7r@GVLR~zY;tCT2@x4)7PiFVG zUuXC6%6;`1K3%z+fkj0pk-C&P`|PX(Le_@3@uIPf6q(|ZW)MgoNKj5UJQYpwRKzT} zZwhBb&@_YaHx`t#6NTK}S{*z!(2zc@U(sEi>Q3+70 zUfBNTI3&Eu&z#_nLK23{iwd7`_s^6My!Iq<`k@OA<7-5*g2n_ zxqo{;Rr%-VSE^SJHEl0UE6% zbOy$g4qt9=gC~V44UW)738x8&g-FcaHs*Em6|ix8G^F|6+9xBSuQi^G_8Ni*a7mda z+=~0^JbEl@uC*HyaZ)Es3+Yn;DSRSu zh}%S@=(ESr@4ij%jxAP6zFqN#ie2N&rX$c1X6!I8$kFoq5WPb2sj+d_?q*oUl! zxRLiyp8+%FyJV6uLcVTb_<7w6lng#|86py&wfRP#r zvSv&k^Tcs*jCj#O63ITP6J1X4C~4CiTxyz9r=JGL*}0x*ICrpP;wx@>yD_^W`_CFg zY-<)IeG0k2My5)iN@~JTEXf5!7oMmB84}%QLr6_i)Z_%#;NDS^+yTYWSp^Ona_9gO zIyzz`mfGT7S2W#{nLmeG-IXzZp4>+WwigfKv#I5c3&7%|4TX3X53mS9m&7hJWFP9> z8;>8G5qB{}e71!aGP^I+GlpE(Qux@`#2La6HAIc&Ds2i)?qkzJJ`s{b;1Ro} zgrf+d`-r0nE(i{>JudLa@znybNZcxVPT4S(%F!$k&rlZbhQLhVD$wv!?t-AN1||fw za3%Xnz&&Ae07WbV4%$M3(rT(9Pw!K2Q~TbyKa$D3cnqJ-?d)-C!1dF)dT5tIX1R9= z@@1UuXdO=KF^9HxP|D=qJ0wH2w=%44b83nLW;C>f!OC`DOB|(xyc9`P4O!wk8j;6L zWdteSE!*X%2Ma1MEL{Q?=kmsmZtEqPUnr4p06cc@JWF7V$lXxHLjkJ8$}^h9Ry+F& zFX!EA!OnGne9AUQ#O2jun=KV3!voDq@YDO$+uVNt@#BYoe7GyWdKjNgFU154Vfi$4 z3nx^p6$h!~f_+Xat?f0b?HTG}#l2!Jx+nWl3`knBLlfxWpv~Ssggs2tlWc^iqa1(Ll!03Cn{a zD06dlN*#3OOrRIq(T=D;Z(}hPG<+%A|uGJcI zba2u&0zVImk!4FnxiPb?-tdlXv4P|X^>$#Jz%SEnE@M=oo2|3Q-g})v=rY)!%N4D19X)uQ@Ln`~lYmst~p< zfIv9jY&nK65|V=&SxABk!N6z1{9AJ!$I-`1CkKJ-c{{!0ykT7%2+FL<24i?18}d%9 zjW+s$kN+?dn-OT7peP9|B4(_w2~1l@7#+|hkjZgGG(=Iwgg*U>mffmtNov*D>2YTnNX(BNF^YcBnkU(` z9FhbsEDh&j2jKC8xHHGS2zH4>Ir|Df6V~VjaYbYDe&!&M@(w`k5G&>C=tK;iW{{)X zh~&9;05>#${WCwM{Zi4 zK<5hN?}3!VAjXMs5ZX05c8}tLXs8l_BC|Er2ql--m@$@hjB^ir8%r1RHR3D_#G9Q=w6n+*&0_D z(aT4+WrZN{E6b~}j;7&?IR}%(N-HEy*TDNx z5ER}}N!x6&9&gzC@y)f}u7Ds&sAms1SHn_3ih*5OL7S27|_v@QNEcZZ&##Bf+Q6C6#cxZGQ?qfa| z1bKrTL~~EXygL{>$VZLE>|UewaVl{y`8TWGGj6Lg3qs8lqAhXhvJ z#cdj#8WWl&#x^$^vU;23&)U_y3)Q#jeb)GU?I1qAE$;&_Ml^>em?3TfcZY_#1Lv9D z5l)UsObDS-3p`^&vZmmqbKelNRP3No1-GGazq6i%EU3nt6$MkVqpfTwf_W8Lp&e$Y z+e$`lI4#_5>x`I?f3DOXg-hf<*^$lMNTEv_Jg30N*OE|{pzBuS(Kh!E{=7`6A6*km zgVU$sN<(ds7*f_Ch9tK!$hL+{@v}0(!8;Z)<#=fG8Z4fWpiGa&OPd+O%R4# z+Y^#~a*%FEAuE6Znss7bXGhXD9d8IKZ*qj-5IJ$=D67QoyFDvq{O*tMKX8A#ZeKl! zPwQ0DTU|+ztufq-o0!!vBhorkft=k)UxmsP*zd$~7DdtdIPcN$&PJHUy4-c*Bs@nc z!pbubgCxw;`B10qt#2SEvNOE2CAW(7uD-7wXmC%4(l1-{OiwmsoX`^F)Eggw+QR@# zLjkH2ZpY25+0bj}#qDKbS6sc1!^oP`H8%A*gJNk@1uD@bW59uqe0O=aHUIW)a-Z~v zUOk3S8weMOlxf;5-_`ZVj#yyhSair*T1NsI+{hs6jB=pwDxLQBEwmX%{B~heB*nn^ zsamsksc4e{A=E;hWr(T-Qv7Vs*1^wQw>3ya5mh3?WPp@t<{ce(tY4SLk|^XJ@PuIX;VApsVtv;s(B|w|3ywWZ{Fti z@t*wZA$+Q}0X}P|vBJR;@Y!3tlHJmpssWmoI*+p% zWSNBRcIRF|iDHo;v>UL#w!qw)i09>I%M;N8ONO;eDXO4s5oy3cw zr?rLaNI+H%2Fz}Ypt{5tS1o1KxGdj2lLRL3uHja&vx^kmPz0rYpHQ!)qAPoRUL91Q zt?zz0UaJky1K7;Edk%Hf>!cA<&NRKR+B=U;7~Vh=nh?{NTrUWC2wct4)EP*_X@#T) zLt1xtL&JxUEL4R?PzQnRx||h^IF2CgX%}ZGnkLvW{SJ@&@Bb`g>)o&9GQD~fpCSG* z8cQcGcyO!MHXz;0d-;`sW73Wy18z+v4oPko*msQGf?8_>2q2_yX42{%nXX-1Iqp2# z2R6kk50{q`io<8}m2QLGspoAG5_~N-Kn-(68@QqLUURf4!7UWmAXwmg0!3R_ls6YL z&-+AqwpE{AXd{6pusEA#&fXj^P*AN=)o-?QgVTz5XrS_#6o8Yiw=Ai@`svgAcmMP- zbN0pKcFR-kUpSO5;OEP00kocT_d>h~JD~2!H>Jant{O7d*FtrH!1O}>ep=vW z{c~mN7nt(j)aOqXKRsTkuO7f>X_meLIYAz^v%_3Cz-(ejqDcu^WKyu2qV&lK4DG7( zs1}Tr$|w#Lsr5a5K~*@K(#APoh8HCew5}j|8#kV38{1-rlS2UFxwXp=>z2p!BnSr! zW+ygsVGiJhxYrYz4vjb^@OGRXiIi~EUF$<8l?u(}Nu4+tU zr!;d$G68kpiB9mtiTx`?W{7YL{=+a#nw z2e2;Kw8h7Po~dAbV}V=Nft0^W14N0a!U1U%&%4L%>Dv}WfaK0o0|{0!1}YB0oNJYqG;lK^ zEA)|XSjbEGXF&(FprQ zj|P=UZnl8T5IW%_h(D%|q-;l#X3N@V>_AdYst>>O`n3Z>+G-caeYWE=XaPVu7>nV| zT}*FcxqZBMq`UB$I*bhOd>gRE`Q;4jn*#)yJVG0u(zMZE@gP z+YtyA3nb-2z1P6vI*fz`1X{Qcvg2sq^af+NBYA;`R`&xW%^k14CQKp4eo{MT6~Se+ zK{SaWvQT-0x15nhFwuJ-+V+--RN;Xz0S3(;g#_)bAg^1Cv+xpGterZNZ->w2o;u4_ z2$_npR{R_)eKW^@|I0akT&#NaNIsikZs52a{K*Ici?eK8>|x;x+cc>&FcWiZ)a-@M zF#?yhX>a#aS3z(a2 zfNcpr%7Y?iBGSw!uO~}v_ikpub8^>~v1`A_nJ0ovT zP~A)?L#{u1RCJkH<+{D=9znF(JjvQbe$(`Y-0nGOI)}wRh$YrQVZZmW zghsNNwznvrxfVifkLPlHEl20rkEi%QeVyW;&0_EV@xxEJTYq;R6+K=&q|c^W)lNpZ zi1m)MM3Jfz(HltYh+*jmw3s149dj>}(UBkAz1l!mI=FS-w#tZ)kB&Bt#ay`90Jep` zoHhi!P6VVBlx^-(t!1p+o^Q+o|A#gYT`ImVE=?Ojf!5v$nY0jK*zqSWJ>E}8!Vfgz zy|x4bBA_{W+xlW|o^>;O8^0U%k@Lm=4+w0ivjllLorBo2 zEo1I(u(IobzZ)-&rT8ci0F7(-G4;I=xn)s%K%hqj4OBr)4Ir|@Eggn4{^x|5o4NiU zZs&RpEbNCF2d^E@XVXlbqsv2 zIU1RA>`WD09o89z7AbHcaKN2|B%p=WiX=%CZF8LfXZh~IY)DISgD@!t1DOFPk>bF@@4e_c7^=)cE19!`iC4y26E2$3!|Q+1Zda zd9j@*yZ1jlm}V^MN3G!(kLR;_b|gy~Y?1}|8>DQ#t%gYURbWHy)j_<|RO&~}D|kqs z)q(&Vw&pezk_b}#i@8u@T4&jn4ueqU(#;eB$SIAKE->j3;8aa+yG!#@4hE9k%Cfqw z1xGz8Zev>6>clzIB}m7@dSsoeAZ>?_H#d~VaDpR^5&a8lIGN$^MGtAr;HJgoX z9D|*(#E;-_d@|4f@fY*_)f@U`LBD!HpH1|_cXZ~V%|6EIj9%9cp99GOZQzoKg74^8 zU=_5-xKh%t1E|(?@S$Pt!35wb4{`|n6s3L^_%nIra>xbZD(1img{P04)A!wVY*^7e zC+iZ^RN=fbGD06bN37Q8&|m?o1X|Mo&MG>EBC>sli=%4}x#22MuS;wprDhMK?9w+f zELCkHj@5*k9`}xzwr1x%c{u-%4=4J`l797wKAUM&U!{P6qez?xN}{t@2JeZKG+p@U z_HqT&(5TsznAkX?%_V)SrJ+VVkwm-wibIlII)Fu}V}f>=)dX8C#ylSIXW~xXqus&k zux%q13P|-q$p1wavMtCQ=JEuEd4XpK%UPSs9oP*3V$ZgvTL=Pkw`8k{hxHZv?e4(M zGoY}r&`SXmXto+p{KiNL)GmK=0{_|xefdS7Ea+Dc=hJDXl(gaZ z55jhVu~}S5fr(aVQ+dPsYLM1zaP47FruiQpO!JfF{Oa+1HqW>r%%kXtNKBY^kff#S zuyxAOr?+VeT$7ARRbl|zb_oPEL?TnE$7DNe8Gz!N0Nu}y{^$jiSTSZmZH~K+AT#Y8 zgt4!L74Y_i#`S7$lBQ~zmFh=9eiP=^Qb53kw?TbenhNcf24III?TO?x5H5_1E?UDZ zG;ol#XcKV-(+v4rP|o6U25qyCd6))wIgS0vnhQdVDrj8`S zOOPt5fJpFw-L=_hfNn_^5f3ET4&)Lqe(KnmZoA;r9%D{!lku@|Q-p4i3eXlk!6s)-*^!`MPWUlH=Pkn3>;663(@>MklXbrm0o z9T)!7Ch{Q=hkOXVmOIPv43>#BFv=vzqoH+CAWOV+Zfv!%7Z`G)6Wk6g)P-CMv7Oz) zF=PdI%ACfYLp9DNHeVh~XP0SPZS9qE5PRdC&TsekXQi=Up3s*o{K99YLyN%3 z)*w&5I7NJtV4Cp_;(S9+^`0@}*g_K4G!OT_88=G-Nn>6qX=n*{d|rwO={!UU&U&3m zv7=L8XtKw$S;g#qN|!-*E|-P|1CnZ}j!jXh+iIc31Fb3U*UjSyk_-mGJk?SEL{`~^ z|6z4PU&@-{_NkRn^?4rvJ9KTaSwVcC3kKg>8>|GRvyn0#Z4$rU$@tkH{$!G0J(y1) z(1+@Z>Zr+UjGd&A@B$)Uq|sKZI-P*;Y`n*ER%hO4f>+ZKd4WH@H)WY7O)?`#OgI85 z6)9Vy)oAI_VI15=##y*f;lXFO3X;g-11S@Qp9Ox*A;73WAxEHIII&9WQ5ZA=+neOR%ohuVl8R_{->rx7^K-QK>DLe{ttJP{A9;| z^=LkANQBd7Z(l^*rE2c3_XgGS^a@ElkXBXL+hO*pOr{T{2Z#o3l-7g_i|cIwvEhU7Btw5n~$&39~FOPLo<5k09|y?k$|5;szG)w#h)7Li5= zD)=!P0lX=w@*t0hm>G$Q<}?L({TvHEvvzwZEA0Md`eqOI(+vKvA?dSA=`ckm*J_|t zu>hD6Z0d=OCvGhe;k?i(7)Q|SIEW!B^1g%M;U+4CBBZp9h`QduK1_55dal7w7V>}m zvnl@9%%`s&&}S1p&n(AF3|STGsnt*%yetX6@xkCOTC4)`u-B-Ft98gDcKKdA*U%$; zd>8f`#3CTbr|+d_9U2zSh=Am66Pfm;2EsmyKSj4x4?*Oj7Mued?U4i=Dvvj$eZ88f&;m4If20#2cbbraZ`yLvdESmh+WGTMF-sf;68^Y z?yook$~Y#k<*UN#W5l9 z-%Up!YXP(l6hmL@tckk)Lg#dL$T?)JGa#*Fz!A85LEH-aHVj-%%5Ga2!kyb%8|3;{ zY^`g+Zeo) z{XYhV7U|ssRV9yq<(B;?%i^;<^~?Y`ZUJY3M_ zfuclO%w~k!%y)yi-hHY z3z2?!=j@V+)wkS{0}EVS2kWc{Jd8j`RL%ip=_u5m`aa>tQ`GTuusd2s6qE?60v&Ph zWJDy?8IXuVdr-j(^4-uUd-i|0o8%`;`PHNOv`2+#j5Bdm893`F4LC-}1>!8hM-?tQ zS8hD`$#Bo3XlI&0zm}4q9@`=%TeQbKU1*zE?V9)0 z%wzHD(fc;5zrn1+VzJ+zPC%P_Dj+Gv)iy#~h*CssYRC*e*E(A1Dw4(F`%Pdo3Wndt zh;{64slrlz)>?IGg+quIp9We=b6C=FJSIxa$F8U#(L0CRP!p(W5O~m1kv9kROXeKq z-irZPXcJ)Hy=AvDnsK%3J78QC1h?8`udMEiW%AHm*1eRdr3Li%5X_Y>P85NMARBrc zf~IaGVbACKLw)%2$m90vk^45G|L2ePCBFOLzx|~D_lF;U_+R<|`F}ft3jddnKYn@t z@q>N;Kf@*e<^6~MBR>A{qkZ|`zWv+(*H>T@q4cm5zR4X()I;{+C74>X8N4omU|Lji zBz0GvHKR|Y)<ZkEAWdO*K_bO20@~yj*z_0l z5xjcjez8}-&H2|b!-nj{i4R7Xc7&85-f24;w^9}(XM>8JSH|UdpIVEC?}=~}9a3=B zuhUVhpx9{<={^zU8FLIYh7k@V2OiH%SwKx%ljjL~=KntIE zh0iNcN>3NYvkIWl1ML){TA3CKxgC1ZQx#qJrl=6}-izC!0FKZF;O4d&LJiOgQYP>@ zHE(A0@ABgh^?m(NAHHDoewbwV+VQ)!oAb9=;DZAL=R-3IwB*(zM!mEHrq99Qc$LZK zIdeij?in@)*n@r@4+Pqz^u4VQ6b=DOLc0&G)G+jcm^Yd#0&v5UW+b+^Mz1@Ah0Jvj z=1k^hkVxzmZD#}dadl+h0V070ut1RK%FbgL^%>IlU?gY(z_|Z{@lZp^E zw5y%ErS{+_IDPMQ(2CAp$)kHJIMWa}nqklyG8#r;ei#wmea#NOjZ3S9abc<+4cL3( zf*PkIJa!p|vhDIHIk;vah#Bc07e}C1Kerz9zt1}FKh(P)KYjeMK7Dy#k9Of#58>_9 z_OGtw!A?{|l?R+0XYJieR6?o~!T1~zW0LB@ONHXdXa$dUhk^EhM~F{Tun{761X&eV zfqa;d&7%x^CZZVg$eKbvkd+LG=b^a0T*(2Lra`U*W@Q3?fK$mpSzyAu)u@8XI-gp# zHheP5f%(%Wj^c)=Ze9rM?qg*l!N^;-j__wB-Q=dkTcd-;_4%Fo z=P#cuzC41LzIgC{85B&v@BI7uChfV*l?#6`f|<6W>l&zq$CL@=RiB2)8=}%2CpQ!1BC}^-;87|B!XJT z&IyqC@>HoZyF-5byZZd@^LOumc=yu>{BwX^9xd5d590l9{C05~S4MF!2S<-8-Lo_KCQbF8thK>H;Xf?j@CLVj>KtX*TEI-qL;5#C!DT%)FK@i~a9 zRnry<1V;%7y>W#;6dejiE(9pS2epRE%a2A}w=kx^vrnJwU*5g{5a0il59jsO<9E+u zT5pTiu7^H?PjV0FOy}r=Dn4-sNGJeGQ4>JgCQ?sL!CxMobGjLlrE;tyRk#$E>h62B8QYy#lFvX$%f1r6 z#j?R4P$)}H+XFznBRytc1$HTt#kj$ijhQ8p7S`7gEUmFs9j+5YY^i&@UA5ovAJl*VYKcJB>xcYNdf^9I6R@SlYZG2B-pG(cayN#0u^?HXs zz0H*fEC<-*Ht@{Tcp6#uiPIIy8XVL?z*;8<7|Vh4avs$B51oP|zw^;|p^Vnk4%m3)K!=|LPj3`=S-Q~r1wyc|Q+IWVZ`1k*`~Ihgd-1D>?{>9*+l$AZ zmP=L;{4WL#+D63KBov?tADkyTGMSD5s*zCqT>6MT4Ss#ZN|bHzud73Ka8< zJ$Co^rnjX^<188-5l!ftUg%Fny%LeLlCU@9t-XfN!tqAljW(sBHHmAV^2Uuu7QQQ2 z!oy8Kz{YJ3X31p?mjVFw$eue0+CwDF2KL~to%uh&-(-h$>D-R{w2%e)o2)zOyeMe|U7NzIp)fmuvf4Y%1dDZ08^wO;z!z>)Q$r zr}PbF(b0A`4XlY38G7Zx9c%?)qi(f!YEc}Nt!d;X4Z9?y9ogAnZ}zjv3Yk@Sy`y|! zhdbY;!~SKRsxKb9`#I&Wxc=2Ut#fayCV()V#%TjNrl+_cvSy=aQ!6SPjo@c*Oxcw=0y3X9vm~fYP=)c5+4HHPGPN;nZ7sVvn`Y z!mjTK(e~Rd_`m(({fGBI+UG~B^wlHx%NdoQ?@8cIq45JPC64z4KN7rEJZ$yRIxZtI zbVE&#Fy+1mxV3OzDJt38cnz33CZNXA1gf+;9kQ)JM%#e-c3OC9bHc43!D^U=GuG{l z3Y?8IC)Gv(H`FVe50o(-4qzIb)B|xbtLDCpCf&|}+DU=zIOI6ph7xY1$xI6ctJ8*Q zuC?K~az`(2!a7zQ19bK77YOC(iW zV6VYjJV)YR8$O(4-vuv#(F)B+Y*YmcB=Z)Yvg0@mB!Ofx6lLb|y}QLgcJ5TufFZII z0^3S5rkE)A+^ISzeqz=chx>+(j$;T~ni)2wLTk1I&5Yel>fhu~AF@8ZyQ)hMT?MZl zz5C7gt*A6vBBL5&|%!g)>5UyCLC;W%MFAUH+o)zpoy=2lwB%Bh}q&?%hYD7-%nSq{U$E zZx6Ki8yheIlF^W=3%?;xWD#G0W<|*H&;rjtGY~WZRm&|wLsAd}qXhj3nBLYCSecDb>n%cq5hpg!0uUX6*Q+DZ zGjxTPgZ9@Jc*!tj@ZKkZ18%ZxFNhFKtc7i(>Dys%UVRXq0niyI_ghr^clPGH)#RvxQO?#wH8ZupMHdo5aowi;T^Skk=VU$jIQIwm1)k{Tf`1}UnV&OVsdMAOG3Zg=0m zz5-F+Kh`C_cHr(WN&Hp1L5t|1v$O-j50&-8671$^s zL(f>a5yVEl4IHpS4|+9_r$zz_2F*u5XpvdJhwOs_QHDcZPAUT?SQVX@=@rygT@obQEzp zS5iY)tKO;A9<0YH*Pa5SI+zX$K{UKaWrljtIr}07`4|C>QOo6^i&&(h=}o(#QMhh< z=A-cEjiz9q!imRcj0F$ZN(e1?nbUIcOKNCL^urGyTvghIFhR#|uQu9t8!-_~gp4HAF^ z5gM})%MlmqlGZoWP%eB{uEt{l9gGYmHEHg|>79|5JezHpL>;;IEN9yp_SUN)?Cg_q3}PaXN)dwb7Y_6c=sAU2vTc20kYN=C?Y7Q=YhCD zlnT*vGb#saFwSdC;BsfqhB(P&7vQZH!#m}jZI9b)(r?iue;40X{Fg`1)EAH4eVWbJ zXR0@5lJ1F?Jl7b?NGaF~7lb>XWOhqfcRnA7OU@c|Zb>10VruyD3t^ z%{uw%9pBuPs`Rh5sxMd25p`1%MQ-N&XUY0kZXVTZo@dH{z&c)u8!tKirh z1|rTLcV?p>P5Szt{+qx5>F4|9?|=3`zI*EZ+@*W_ntsos-6?xTJtwxAgM}wB0;2(- zU(@0BLHr!b_#0#{cg>)%q7l~t3pi_n5VIXF0@U5-({b9Rj9((yUtB}j&t6)LVD@Z- z%+c5DBgMG8?3{!~akuC?rE^uxV>X=-e=L&Du}Kdxyf%yJLYmv~fip13zw^ z6}YI6Me29bF4|`X1ncW0<*Y6{(m>a~pZyCpR)l;f>i6+r*-QXe{#IYDl!Nj%KOt_)N8{=Ns=2o6vxy$n= z=*B^C+Pc=Ht3x?YL*o!VK zFOJAdko#qxVCFh55p%3`SQnr3$G|jQo^#kxnF@BuDIUAreDg`YKmFnN{^R}O-DmpQ zYxkGWbpQEAGg=TJS?8I`D(7Ruu@Ys>yVh_Nb|e4F^m+BYXBHtQe7) ztT_~SKWYI?0B(atclWFvu+w^#ogLoSpf-H%yk!E3>;#!|8KaDfak}UTp`nTfM(()X zhO7J}#I@jwXG}xj7K@&`(+Xu^NUT8KfFe3m28xwX zyLSrQ$L>9HutF}=lR^KP%?a0tCLr{%x}Sn_CMdS;@cjmpkE#8$+3d1I6!%?*ZTn=> zs>q${AgaO%2ie~WKX{`jP9Yd`|1L8=eNvD)DrG2a2r$Lo7Z3f4Ul_&#oidSidkkpx z3JCU>2l}u6XZ_>fy;m9h*DZ7N^9X0_+rw^yY=yB{!tj0cM z%LAV2qKhLN6S8eF`?sl@jqDpG`C#UKA$K& z(b(*WDBFO9R(H4rX=g);5uoGYA8YfN5pN6P3g*xbu^o)Cu}YQ92pbm;`dgZJ-)nUU zMzo0tQA4P@*FE%R77hoVjyP^$vblKdi_+c4ov6+xzJlL6N3I9}H2}@MYZ0Vj za@`>N1A`ckTOAJVW1Dz}$_PvdD&7uM(>pLg>iCwvMt}e2$DeL}sekz6Pe1?i?aS96 z`@I&;XD{LF@mGF5CfTGT__=Q??RDX(J*&3!7SA!)_m2|F9E8gKN>KK0Z>ej>b3hYfI{qM={?eMhgzRg7OFV(Cj2eOGnMayrj1xQyBN;KSI&v^ zrkna}lI4HaKfXJH@yUz#HXizG-;Ll;Kq`bb%L*iVvV)!S5b7FRg5=DDYD*V>W5*zj zT!Iz|MpgDR209NeWcx8Aor3(R7KlfW*oEbe8;Hw;J-9fXI{?jieP4y~LtKV83q|GB8W)_*tss2%`$?ue#u#=6m%%b+n^nDv-aJ-@DKfCcoijZaV==yrhrb zG{%$>mxb{2-)pTf)vXuy4xE%WR56JrWc6}xn-MhjXlUQ=!6$a3Ttgs~t@dGe=fG6> z;nAaf0?V?IulFVSdZqaffApX0$6r1^1Aq4Nee|Z@z#hHBaFQ%&wRQDfjG~RVV$4kX zj(fABecp)+#Ta-~<{b;xv8N~G0>oQ~*2(RCmff+>joxDojD^jM*KMr@xea?NW|ZbD zjsBnp@3St_TpJVQz97TN9UK@uw8oe!y5a2$1e6k)=fK3{8yIK7dFWK27kS$B0tk(P zLQ6L5GF(IkPEA`ytMG$(1T<-suSej2|8sr&>4(3oFa7gRe|T^I{p8hq8+rKtRH1a- z?RMwsG0_;j@HavU#@BWfMj{vfAQm#wst=@|_aN(ra^;!qW!;Vfdpk;Bi?~;N2~;)4$=00&14!i^6C`*r@fQ54N-|bt zzaFypsR^Bz1}vpkR7tcJ&m+@8sqPK`Eb0_=d}ShSjgW^q8W9h7BtaahCI&JK8OTyuq;aL}N4M9syeTLz#h z7lYd+Wvlx7Ai;NLZ34h24lYM(IxigC#idlH|enCPkiZW5Ps zjyDaOSc~bP#i&RqnckEXI^cT9%>xB_Bk8@6j!fC{U^7bVibiNkoU3`Qc%2D7GM<=d zC$1G!cbqvlNLO9Y+4NLnrW_VrHGeHU{Dvf-1)eR%CD9m zUk9jd8nF1RA(H1}S{EBM6XUbz?yIAlfeRe4F5s`9aA8fq;GB*(v4^kUzI?+&{oQ*? z+fQD)k4l8x)XW&qW#2m}o03rvb#hQ{ZD7oAqk5&5SI=0^OQDWANKM@hlGlB%4$px; z*vwXV%oCeA=UpvQG?35Qw}}+=z`zf6`s=_&4qmP^(9VL=6Ctxv@Hy|^hv&I-lysU5 zc;mTHA9@he{pb!+D}st8+z~z0BwHZ0fF9q^f7_mSZ@6*>E|cJL9~dN0&OxtuyTAJ5 z-~RZI`O|&xi~89s_xeTs^9T)(vEA`c!-*m^x~_JuJ~wf1gRJD9hRHop{5S<93NjiR zGtW>(UwX}3G|p&Un2ko;(DI4_*F40-A3*1p&N&6{x=uL3@=Y&wnc)I=PQ`)FBG+_b znTw=a%>>@@(Hk)(c&gz*yfSjjxDQVF?86W1e&r0o$(Ar*qZdKKi9ehVv(=qs1)gwC zYfLkY8U5NE|Ifct(60aDe?p=C<9jisPhQ23Mrp=Ll$`;a2ToBySp!gSE`SSW7IHRY zsNhTn-=g|CXCSIzyM!<&sh7pyw3%i@Idu2l?>L?9t%72%s}C-NO#btx`|=5V?PALR!K@d#}NDNH~k*3P05XKM_^#-D9U|66#}5C2pVz9=$%kEXrZnLl|2 z-%hOlI#+)6&fWkTGlb-PpB`b6WwcG0?Ygf*re*oaAowh8SJ2kv6-=xhZSU*LGZnmMpN4RX0l8`{V&8fsuvX&ourVAocsk zY{IyJv#J)1%vDJiP(<1S=nrj`c^e}$Fnj>RBeYSOB2bVfd{uTIerMYqh=9I+YwPEq zfBN~$yTyplUb&BGSyxu~qulL*=^Zk{zcv29+;tgJ!L6uUf*X{kA*G?yrWzxT>*5!} znngWgmW;Y=^W^0$-sPd-(<=l6XP?{W0$J^{ArGWCQmlQREEJa)fjXRco*TmhXVrE<+^g|TK7fdw2 z?#BQ3|MTsqAHV$3fBsfqFplvh>X%>Y=P%ELes4?u?B)E372JU4UAlBISAgsK?a6)9 zAPB*h;dphVhi$a^4KXhKa8P_*IKMd;V?H=D0b!2K6O#o2P6t3b(>7Y5hbwv{rhl|= zm=0E>*B5t zMc0T=t)__txLYp6WX8HM42qf`aOQ&P@GCv*Z+`gtBkB}C-Y@yn4}bfIAK!blpS^@1 z5wt*CxDc1mqr`rF;VU0|8gK-lC{i)uBq+D$b>$)RvY3p=TysQ9amUBNK?H5dJec|y z@Pn+HMk-FP7gW`Q@D7sB=4nCtrlX#qJvyP=26NFwdGIKpENGYDCWHzMp>|Zb(K4@| zYZrehc>Gzo)}Iahg39|L0&sjstC|L%E%<8Qm) z%?E$>;{8SIb^iH`OhDR$G=hq9ihyX6=#+sVe_9CU7C=r`gS93zrk?<41UYJ0=C8!% zwVku~(nZf*6#b3ZJ?Ob~E5!SoJK)YN^? zq26}f#-RY7z0X6-aH#v{(dO_DP)IGl7i=XxlIHHrvl+L2P(L_885AcQ6Vb9d3Gr~g zmMOq*`S$gf_xaDCymTK`{dFW-z?17y_1a;$r!m`paD7~{?}Y}S%n>VpI*M1l7`%J5 z^bdv!5&>6$V+yLNXHfC**d}zVAvq4v7IWLfJt)I_XbnNlYos*P;DN&LljsWI8Nl-3 zeFf}X1!Th*8z&4{>;?dTW0$3XWPVnkcm}lxpTd~2U0yRARbobqzLqu7LN#t&V3d); zttT&N_F7Q^85PXkM-^+_OloA!+Y&eP3Gni1JjqQoF6NvJ0T7h zR=(hCnzz>(BOx|+95YW}n#YT_VS;Fw7WRGVqUaJ?g4(GMpA@MO%HkF8a&oNr*Lz*{wjw;dBFdG=z8C}R``ZJ!+n7efqgjD;Bv zNd1;$EXzR2A}($$D|!ofe;Dbfg}&_M?Q^VE8yH!~9$sVfROF26?c4iT_2VyJKj86y z_R75mCdRM(@ustZq^M_fK@U1m`)T#UfJK11A*z77HjW}!5upb8h}TUV>_{EHLz@bE zHq^CnBiPDFMel`&RX~qPhT6+Gi{_?7(1OTYPS0Xi=3S%GQ z1vua$L=rb;CM}jQR4%6_k+m@HwrPH2IRO&5$C&&YZu$>jfBdC>{?UK<^6iJ8-hHm0 zynJu(IKTGTYdJ=cPN8t6fQQUoy~&Ux4|5F7V?uT=4}8{kFKYIAhh3v1Ou?+N$>2Atn{td2&xze?nK3V%DL5aQ}pWx_#$d%FAc_F1XK2gRhgLdYPkNp<4g- zNx=N^FOluPdzT0D$?N#~eD|LKFW!%6Cehx#*>jq-$Lc-%tQZG;6+(i9Z0y@(^8h#= zBZgc<*P!Exb3)F#xdRr!0T*%7In0E?Ho&L&aeo~j74bN1Nh<3#lj!i;`oQQ0VD=V% zcpqDLVRRK&RvX^!gb8iE+lSt#-4(Tiyn-+_iAokn)DpUPN3~Ct(8?ff}WT29QbG*qH6+y$kPw-tWEXK!xsrH#fe&o7PWOb?rKH3|?T<0sy^{ zP)4VAC|aXyXj04r%nM=i<27#j?dwG_(SQ80et55J{K>2L(S|H6a&4ef=r<|Z@xf24 z{roigXzm2&zxDssE`aVWV&YX>+@TPIiXdMp_dyGBj^H|4F zaBvJ3KMC5W6-ttcmEZbAI~g`YHx)%&Ke2=*hZF0PHD4^#h!ilj%z}NLC!7&LR{>&5Em~5E~!FnBjS7R*x z6y}0bdG44!wk!Bb*42aN47HRbUilh)nvHO7_mdjI#b#NeXo?S&F*%Mz`#_3oQK;^m zU^d`lWgP6Ma$D0cj-ZfOW3dx{oT(C+ft@W&Fx)Xk5waK>j)3}wxAI<1Gkb4s6B$pPM;$+9AflUmGjLt=eJ~7`0S;7`$)e7B=lGokQiRi-S^Ii zHnR?^$DV^yAO~{22I>)kAr3iZ1FbAe@7|JSdbgDWGdOO~yCkDg6+`mqZb0#iF@Za7 z#F>GrQS_1Z+x7!~_Ts%0BObq!D^p720YrSG z?pXuLt)@|`K)F2=f_gwmav6lHIn8`p9fCiZB`r{m%aJkk;COB1V6@v}Jd?*;>|8m_ z5XIvv3$++9N7rfG$uwd@5k$DdAjX6r0AuRPo7UJMYz3I?kn_%(C1gu(%am7_XU(p7oy1cLqrm+Tu}o|>WS$g zH0*EqnjqtDXI zt;VEgfuho^5l2|YMiPNeR5Y-yn52xbOi$l{{3FIXq!=+NI}Kn*6T!!Z|HUL+99}=K zzdqr20q&o@bZ;9te+vHNuX1>@;LXHuPAE#@Ni3i!XDw(Y>pO^5rQUMrugW_RNjYI=j(RKeICorB3=FEt*cl*D&PSf}UN6Ka!rt zs?tEXPOCxNEDW-DcC6VxxGQSyaa=B6k&vfQn0J|A5UbaWVNHzUA(<58$|NvL>e*7S z-MRnt^_TkDfBEU>f2twAI|1;yYxuSp@hkYS5PkxyZJ@{|aGT}`ogT6T&0Sl-S+Ea* zl44-0uOC9@p+Fid3gtQss>RxSlsos$oT6Q~E2cj(|vnM)CCUUxSp57rT)1P+}rNJAH0mqT;bik?@Gi5!Un zoEZ=Y6PO=B>liHBJ=(*3Ck}s`d|swL^#7A7fX`mVx9{xtLlgvA>~=&TgRw%mvlx}i zm1VN;-I^Bhu#V*!U>G_Ju3zZ89=zRiadzDsVh~EAfr;&ikjGvKyDY$BhZ@A~1P1-N zcW>v{r|W4>7q98odkj2J{K?>}ZNx8Etc+UK3z}6#OmI^OFTs)WI0xVHq`+|uwE?rt zMsLp$l)pP3o(~4u19{Mb+>2u537PHrdV~GXf2#I>`|^ALyLxK=@0yK1c@^J&ZRf8n zF8A9R!j9=-AgN@a$J=}`5!R%Qb{QsAtk1m-!doP3n;%A!9#S9Q3?Z6#uUj?=RQ+6& zXx%x}8F?k1w{@9_`O4w=7q!=!*x%grrR+sFFr&8PAAr`kwVZJaq!uXe-&jW-J@ zb~rrZ@HP$k$2^F?7Ov+@=7r069K{C9!H<@Q zns~CBQZ%PRIk)EOzIE}@TY3*;cnW`IC3GDZ(d~?WGKX1}~`2e`~*-Q9QsrUfd z>asT`Jg@f2+)u%E*vd-|Eyw_{d~j_90TEgjabH+H>wc;?b9$e|>gPN%w3eHKb-Vz% zHie-^dx_;pSK%T^FWc5@bYkr&p#*)IW~G39NcJEjwz&ITh8mtP#jOET|C~oyYY0+_ zF@2ex21^edECroo_E@1v_|?Lh744hbqWg$1WChV!*t047wYB~q|KicUkLUXA75wPQ zI-NnLW0n_#QE@kDCVTcEjBCQs&D@ZDySeeXWf%{nmKF|$%)AFCHE>QI zk9-E*GJwF(g^so1RL@1Ai3cuH1_vyBmmTUREJw2K=Tp~xkfG;>tz$Ow#VuVofg z`_jG}S*%UKj|PaaJ}@B21Sl`OTRXU5Reb|=azD0M4-E1&Ix!rq0)XeLq!#Bqh?!ho znEP%Mz*bUd-n7YiYOlDc8Zw}z8ZaBPx~F!ISjYR6-o7;%a-;~=b2io7*JQtrwf`F& zp+36Ne)iIRbfX=x6VrwZVHkW%cTf{gH8e_g!8^Ml=DsLqHtIgJ_#or~*QQY6N7VSW z7U+_>*OKWNRkdD1Vm{#?nlqUdvQw?Cq>7(l`D+jMH)ZAh?6v#oHQhLL3T;%?j~sXo zZlZoebVAbaSzXG<<^#aK1CeEc@vxKDmc!$QJw7}@iVhS56Q4uiWpl9!G=}(g4aDz3 zD}{Y3_g)IJ$8Y?m^V!SykxK>DjRksLtj-Wx0=X+&h zm!qaRG4dhJDQG-{vpA@h-dJ-UC}s>SA~A=eIJQS19G6UjvpJ)fJ~5_` zv)>t~B^VjeJiOR%(*~C}y*RHN!5{jNdm}FRMwf$(zSbEMimL%A15SD{g@l;qJHm73@b?G&&jRD$e)yX2LTo>IF+b|Tch*Mae4IXP2NAH9umxC~TgT(o!hQZs2RfaE z#;i)mc;J$=+fzgeAB>&*T%k0>F~ALdJ}Jcl&wdK^Ku_ zJ~d?yPurz)c>~Nk*8;}gW)=xf4bl*%L3rVT*~d(bB;V0cL0%w=79stPlE5P3#(M{d zJ3~8BJ$O66Zqr8CroCxmZygd%!?sL?*Q6U66(mOH!8G_HOiU7E?$TR46Xjc#<-?W$ z&C{xIKCJGY$Q%)%UWMyy(1_}R^b9>D`JCsi@%2AGU7x@ET7UoXWcz2Y;D^}?BymbH zMACR!48lJ&o*H2!mvQ%ec){j55i;=|5a=yrH_##8V^4wHI3Lm5a-3h|iM6C31Nw!V z5z88~xNs62O;a#*zWudoaT^)k8^|s;W}MH|Tf<@Lt;_*JopF~SL#l!L=~|6uDy|5s z;uCQ~x^su_VH4BaZSnLd_Z@G>Juv3&%CuBr*B*d{Uk1afs>ng*iwV%m(|Pq=QQ`?7 z1_*ruz0%l(I^(^DVVLVv!Uzj(Yqb$_e(&d;B{ zj33n;X?5HqGz~LAy;rKZH=x1z7}aV%HRM1;PX= z1)M4c0y)v@?isRF{hri430kA2XCz`4(EWnhZl}(?+#9q~1eSm=J%V}5m&g0p_3g_q zKYjV*&tL!W^_Q=I_uhf(vls9qFe<+HJtnLmz2_#GG6Tm+oCtt;aF8#oAVWa!U&mq` zIP>vh&$HLSTq;otD@-YjYHm{>Cy$Ne9ljM9jD$-uR!9f&MFAgK%-0Vt4$X$CJCyO! z`9L}W#y=LQBg$N#e<^9OTypS_T80~h-J;;V#%+nA%Gl6ZGP0<Ph_x*)X;;d=!r-mp89&%`|F@FkB!5S*XE^YsD$R}`wg{o^0vryu^DS^fIcd*b!aUdN9n@~S%n zQ#2KO-mFXGp6oN+@10KNh)4TF6trnn215)I9!qYSjXAVu5)akWVhh7Ao?}3`i|iRQ zP5gNe#$otuUj{fl?K@__`S7albu6Q)}*lGjE6hGYM-4Djt}p z)+Psdw&?__%=hx)ojr7{x)WYN#A(Ff#L$T`%%8o0 zZ^1#|OOf4Mvsgopk>6G7nOxL1vzf$W2oMbxuV`UAcSxR9ozkT`hN%`G;)aS0=hs_|H#*A**g_Z_sNHf#10bjhF1Isf+2N(o?aR%UgEuF<|54b59iYI2Wu?AR26eG5C77ox~fPS(S-q zhNWp6wjq*n3RGC8k%c*N+w&ZfX1EO}$deOT+dJeyrQ2xspjIF~HX1Q~Wp=rsa=AFv zC`Kb9d0kjxsCq3u{>QK1zWi9fbDWI7{J-_{d#&5gUct8%gFgit$G{{x9aOBD;avsz z26gL!f@|s?n20vdH$U*FL~hMj7BcE?KDs+I(bmIymNwi8>nm@g#X05V=o zo2HDd%HYTAlwo^sZ_B=z$f*YP!a;{QuQC+-Qq)$!g&;ErHuFEu;?AAsl)@_Il~WnI3& z*Ojb(;-9z(#IK6tpCHL|~|96-m-mOf0_PTxahC0sM zlDp3d(gZ3r78z^c7waxC6Xo#L`xcL>#EbDOVW-=4;M2@=7zxUYC@o3CJZ|o5uHe4W zeZkPi&3%)inYBug)+&C(8CkZ;YtFG^x%1hLt}|PCrNKo5&#EepsteK1l&f=6^0-;x zvEXbB8X?{mic1K`88uQVX*MoU*TAuapj=^OXbQr5K9`uizM=mW&-3^G^PhSFA0LB1 zdmTUO_$d1|Y1Trzhvr?Fus$6~9if{YvaCyVl{wl!fUcsnyjeyVhfThTw(ak(Ym|lui z45&O6YpSW=HPjyv3@di5T#zeZLsTGwa-8QrZ<}@1-h=%facLs~2YP6ZmYQI%B4Y^V z=4&eI>$fMo_;dBUF^kV#yN{ea#)Smnm>4BfR&}{hCIAq6Pbf36zOZ-(gUG#??{Q3P z-twXFpO-&uK=l~RcbggQC%?YO8DKEQQ>>gGI{QN9ZPRjxW@S2x0)7!JDj zB;t_srzx<2zusB@!}s{i|L||$zW(mL8q;Sl-zzhdf4#LL#9?R>VZQS~EbUjX;f8-r zj1)aU-1i`>@LUBICamuhepUqI5i|q?upgjWp;|^Y)`UU`FBDEM-RM&xJg68N+*=bL zO0_rgZZArAJgm5lBP!vbA(XOr!y}8qV1?AtQyGBM&DfbG@2$cOk5zhG0t`PD6HkE; z?Er!w9r@M-1bX)|>ja}*L44SUe2v#V_^*EY`yapj&w97d{@E+{A+$KX5_A8T2j2ln zO08YxlQ?n^#8B)zlZ59wSL`HUH7Hi@X@wm80;w0)F@sX(fqL%77#!}^dP0XD9ACq1 zKZQI6JA|X?%^2Qq7OeQ$>-ZL|_-jtagIa_mbL_{%nFch9?Vh_P2+mK8gdq_}_Zy)= z{Bavyh$xB2qyjRTZkO^oP`qxI7IItZ&q%df4u7LY?ad?ga zqc?&nLl=&*r?0+=r~b`1@A~yX{N2$0UJ3D&m+-S8E9q$nQw$Rz!{DcQNc`K6tEJ; zJWTcG!egT@+NHUmA0IWq{N&4M1Z<2I-xbI9>YJ+-(3qz!p9Sp#`zXG{783*k52XCz zdutEAQ#RO7Aplw6OhPwjVsl4OYOSNM5t+Y!9_=6h_S^5j1Lfb#wteyfel#W!y=}=9 zn~#%s;!iLt8Fe*HZka@#Wq>9J<`HDH>WPDf!fJa0u=qZ0Yk^ubFJYD}cVY5=maldm zZVxR_22b2BF-{kh5caJ`-6Qp<}bh0yQ6rYy?`IJ z=o)ZykfxBa!p>*U9eE=WW)L~yq=7+CoHX_r50Ygd_7PAp??GW(Wy7<*$Z}7FyloR) z)P{jxG_jHK(JWh|fkY4BBFOFBH?E~vP&XhjG!EtiaM>AiuMMN0gSR~z))m6c+G@Lj zK261b07=y7ecTw?r+MSQJT_y3F*|Z^10-l|k47p6qcNTkc5#jYD%cyW%(s7Gr027j z?xS}VjEC3&QnfVB9S7Ga9L_>C?OcXu%>oo*`1p=N9H*H76_6O{Kq9mggEq^^HYjq~ zb_Dp*L^>4rIiAp|V6;Kz86x0H;Q0D_(ShB()#P#<6q^>I`3%DCViDU5(2fBktF0k} z7Wjs+x!74|k`D$Kj&rnX0H&D}gU0dE&avr=T9W$XhVx0b7Sy~fG^+qYkS z`s0`HY#E@7|3sO2Z!`Ynh5YE9<%?fY_6BXtQ0d_bI96^m&7PQ)K?5H-L8R=xa9}?z zGp~TQtT%lPjI6B5Mml#XZj?p~5H)2=+UhsK+uBtFdD2bD+^yi(uWV#nnV`*vY@ZdF zFi++nR1yZWoE-Zie_a^-(KYYZ!6H2F^exhnn6?eM$q8rLEVqGqab2JQpKXu9=^_^@ zcb;*Oi8%=Azm|#r%XeGwKRY1*^7Gd}yq8A(`-G-KIse zGzKG3kMz5u^4c^jiaP{n)y8aw+PYhC2P;JL4*D=cBQUv&(fhky4o2X1J(oU6pH>6t z;OMokexv0<5?sU;C%?K?aC>U5wK<`qe;gfJb8yC^^2n281Oi}D*w5>PF(Pd=HJ9Bx z>+X2qOBgk0gnC^hF_;lMFh9ST53Ee{@|(Qke}DJ+*1HpWpS_YFfi->Os6leinX@LY z1~#lF(ivx->wQbWyN|jDaxUkba!Y(bDG&K(QN*fo57)ee5R!~*djkRF!;6luM8YR~ zb&)Ez%8makeS=_>!b~%~qC;WJ?y`)bjKULQFAy)pVp>yVR-?577?0L-52O+d!i(=h z62ZoGe}>G#sRq}@NJ7_U)LkdCti}-N9X$s;z1QH=|M~6{{`QOi{4V6+lh^X?GyWcK zJG~2(!rr`5w~fiB7+cA5sXBZa5!WEX$zkm60*pO0o`5P3=;@Mj!*{!IDWJ7t;or3R zV&?o%PP|lJHB$Me<6LV+la|Tb&+wdE7yCMgmfjl-)E?InBq>;JkTTksK$9XQ1gz4r z;S*_dr?6>@3lluRJs;kqX{@S(*pg?D+kL6Q73##VqG=ECqg`{n9-05sKkE#9-1zzI zHGKPQzu$9f25+L{82N*F9_iLF#1{hayK&Aj1g@?qw*Q$096W+~6AcT%svZIEghup^ zyD<9LR<&g=o$Tb}qO+HHyzy)6on$7|B~x@_Zc<|e#XV4K9GZgSj69G% z$U7m#7_-}k0X+Ti6p4ClntGXVNI~_^KlBo?KlasD_AZM++6LW%_gPo*$eqm>lRCZH{&h?fEE#jHrPBjfOp$d#^eWy=j#ZA`5QRPK~c!9AS>(} zIqn6|9fIeD$&^9>K1}pNad*cal%cUXk$1RID=eC8zo}FqSSsaZpzU1e5pz|<1h;R} zxgefB1BjSebpd1)udJZ(Dj2D{e1I}X5n+?a26}W3TG$FiebZXK6}G)IDkTw+g9G$x zoBWHr^M^0*XRqN$gL(_us`J2lP$YG5u`iM;isCj(WN?Wbh)^JX^E*~HPKAm2P;e~~ zk9CzrF+`xPYBK7(pkYA1AqFNIo_O9GG^-Q;4Z2z2rM^MsG7+u`d#GFt!=!A0EZnX= z?3u(tci$V9j#aCpGHy*_%)yw-I!!eVvXwG?hnvsLM1WUWqP&&xD_DGW-?FYjAh5<= z`Wn0V>%aXme)@-haUkTg7x1HtFQo`rS+08?=#Hn1;V_s@sO@<@2LcSYp&*u7xi*H+ zYL*>IjG!QGx~3~xTLZd&&NJ;sKL9G?lISAlW&s$_zBJ+OOCUg7wd zUTEYx9QuxlI($*XKM*>Q>tk4E= zu>Ln7euu#$-zWzD=I?+1HGluVh+KU36223;`1MKzMkP#9CJ_FRBlq5{X92zu3+e?$ z>TV~F_1?z>JmO6@Q9l^j%L_xoaB^o4jC!ZXS%Qq;XcPwXoZVfzugi33FoH|<4t^~} zqChoP4&B!dJ|v#et*gdHf{&N2t2ici=!#wt1?N@ZAn+Yyu%OOi1p#4wAH-e=BdyCi zj$?>~^>zh;hj8I}ril(P7qo@1?fL)nk3W6;_Vs0W`a=ZgXRqZ)l}R%OPI(4hYdYiR zT7d}AIA(L7TWEVih%&$`<^xeFhaN@c$QU^ZthCn7UE;=DHq(h3B=a=ZU^5p zK>a_8Z)04MIhL$=tvdhfuirj;qMyBRZ^NtmSNY4ZM1K@?-g`yC%*TwXn!vz-+3eaU zal6+kaE>j4mrxHY#Eat$jxC$yrkpYM@|(z`1p}*p@viK<_9y_5Qm~@Q2$|No{2E^U zjg5nR_Ue6X1m7HU^W30ZJu)DEAoZQI8-Goo zgCU8*CwbFrx$!smU_X2P-g&U=PnNt~OV(<+mfL!<0>F5{-ofCxSZ0-X)uMiGcdU9R?HW9A{l7kZ;xj-^)p`&7i*#TPwGbmI# zGJz!x5LlNFeN(9b-r!gAoB#6DAKtaSfARvpz0LkQnYRmsR|Z!$&Ue_o!2-lKw7r3( zGTDt;xq}gMkpJf_y=a>3NpT0=#U6>EK_e7yZI2D2 z6l^(8w3?^|svMVjk$GX*2aqO%JnzmbT>?r8X#2oiKp=tQkH*}X?pfHTDmSeiM_|qC zx_m%HFrFBPBqZccBYhTkjX8ug*Xx7*cQE?I*WZ2p@t5}=>Sr(BN8^^$N8&fk^9pcV zE^}w@J0gup^dO2f;n>(2HbdGI8-OBwD>G2*8Ur22_4p4KXu|E|oXhay#+AS%BHO+^ z?k&tZj4*g#^VaLB2^t&izGE?)Zt${};Wl$2K}T!?e-;VNru#fhK(q3*v}f%@!a{Ah@v zR_$DsahTgRYE~fCImVdc9(=m>q%{=Wu@C0P2^*U7VD^Qut?2`}1a;8KoDBnrut+W3 zJY1J3<&;2`K@Kg0g$YRrIj^mGZdqU_W{B=J#+luSm@%9m?uE!1T&!2`uCV5L5C>e~ z8u-DS);)WVba<5;4bjoHHt2uJa(PT7lUk5qM;V!eL&9S?x-@T$h=2XhjEG-;_ijJn zvlsBA(!@ce)0RqLVljPPMq1${9Tn7Z+@SBHTgNLH?%SQfMekh+&gWqaF%go!P?KEN zoFz*p8fJ#pjNT?5&L%+$eE^vyrj(Q35DiG48OzwKf%+}{!Swnq<hc0NI))E$YpvR(VJm17YNmm_8|HselVmuI*jq^f{&t%7( z#wAM;0`pl7eWl>r$rBEzi;)|~pcZIR0{G^^K78N@uL<)sW{ee3aSYk03e71eP7g~t z5hn_m`qOXbL;k9N`uR(FzSpq(?3H^Jf&UqR+yQ7BTtRAO-T>;NeAg2;ZDWPR7~?Q& zImp9h#@FGj2OGZU!8dQvSg=XeCad0lFc}HYt{jW;7y;_FDDfM5 zqMyBTZ=dM*;^7Rmq#HrjgQP~Vi5!s(r|Re)&a4to2(@kZ+Iq#4jv}CTrZ8m2(p^ z6>~VCcxS7v%tnk#u{8I*d^QY_M-+_rwP5Wov(!cjger+01d1u}PJLS&YL92j*U*{Z3Lc&UD2{A_}Ul>+}(`n0P%}u-s*ycMF zRXCU%XKLcw(i5;A0z3W`cR8*qR~ITl@CbaS@vHE>-yxvyofq&mpzl-D7){#778%cl z`|bw)P1l83$blGj*BVoK`5v(^w~XLD8K-6(P;mr~ByV-7V%2;K( zDl%7m#lACh*SUp<#sM!>VA6AG91gp#)l{rw@w9o69@p@pW;lBG5^I5CyXLFta0H~c z9l%3paLHPx;3^?NOV_=|MH2>#!+MfIKMY4`0Q~9CkfVz+Znk6*=L-Vz41WhbSNxw zzc*X9_G^hu3gI_c-bft_XD@m3w0mAC=^eIJ=LNcEEn20Ai=5`U7jM>i5r*Z0Rx+|- zr#^XV1-hu62AMntPIX1judqL+n&~MUUCfu!i0D^*nhCtsuXyLB`&yms&OR8mcNEO! z0*O?K%7!RG9TgcW5I^b2;AAlF(nB0D5gEwmT*H+P62orD(vCG%X%ZeRym_MIu8J&3 z9S{jQ;dT$Wu3py3WXsvi=B(qlX4l^0a)vlmNk@Sl^(h8R>>VjbM(ykwg`6~AgC2(e z0pkLLJ|%P(C-U<$o-*|EoZ_(8&N7H*KDr>}qp0mIqd8F3Hg zhRJ&Ls3@2%7R1_cy2n7sf)`jYCn4)rDYTk9?nRiECnL|1MCchf={L{ZR z=y@|!`h6Ggm9thpmrdBr5d8tge{m)SN;2eKH7lWo2{=BsH!)PqrFMbeXI$CNP`oab z8yug4SBepqn|UQu=&FFceGGQlVQ>v{Fi(eapDw)u_Wj4Bof+XRX&lVy*)NR5b}AX!771B9x)G355Cb_L>4WgA;N16 zcBF8hIf)ef8lQM8gK${Q>p&wm;8~v!PwZ3g^3MHIs`#&d8@m7c;rm}c{P46K-|8g4 z^BR8b6-)3G2q}_LkBl8dH)o8BRJKDk;V<*^5NUM*a}NL{n7(()qtBJzPQD)VAPP0T zu@3$uF-jzqtR)z26E^G?+TIwLOZ2OZh~IAr$a^p3>o@Hu;W$u`@fgbiwy7v-%poQo z5@c0Pp1sb^BQpo7Q%S-;Mvf{zc1{>tkp>0=NROCy;OQQSN9rhk?xx+La)Pr~?54o0 z4rt^1a`KMI^UH@6rOoOQ_eOS&C07^1vXWtX1G)otrqO4Z+PNp7C&y5`AeBc`Hpfl@ z#->LhZ~3*}c?n-j$bTcz zaIM2|4}gloN~^7MN3FYkT+2mMnHHb9i3LvmeW8n8F%V{*d$Ay`lM@M#lW)?Hv)DKm1_d zfB4@Y6wSx_!-t=L`S>Ol?41|#YggNlZJS$kb%45L*=9Mxn4R#7Nj&MdfVSEuFd{JR z_oH{}p^l_;#_qfFCK53`QFr=2_b4M7O*(zUGr0)SMYACc&J`Qgfxi5JDZ}`HJDxz# zZUcj#r{(z3k({~j(G01NctHAQQ*elQxf7ObNTiqD^A(uqZmF^?~|2M zQ>q>Eqk{6a*SPX>Lh!FY{QTV?>W5E!q5s(P``*j=)d|pE>)=h1X>C)2Yxmy3e?JM4 z5Y=+Rf#e-gn?-PDHa<={Q-g{>(B6s}7ZEKd2p8U`{E59e5MW8PFwh zyezDKR~+Q`Uc0Ym5l8e@OiOeY-~q?M@Q}8^^w^zS=nSbl$!2*M_V%{D;9uE*Y?#fl z&$+y4ahIMAR^n71at&0zBj~5mom=}%NcG1Bf)6Z*e;^9g_g==YdZZI}alOJ2^f_XG z6T_1SnRsVl<|2zK0ARZF+H;d&U$&&qQ4HH_Pvr8NgF-&9DUvo2%boc&8hj#juXc>ZC&xfoyh4R?W$sl4nK2!O(P=|jKF$otfB8&8y!_Wb)3;GU z@4a?kdrs>*PBLUGZs;XzHS9s+apaMI>_tSN;}4nPC`-kMJ9c$KhZQ@|#{NU2u5UXf zTDA>){#c6}|Fdm@AU;>(j=}?RtP|0oFV9^!UHcR%;=+*h9?VcajNx0?X$TW`5(Ayo ze$K3`zB7C}Z?M|tY3;+?9`Mq^9N>&SHuU*@^e#9Wn)J((B(qQjfjBu57vjB#R|f<|fTRIuh?_TX z5kv#t;4VJQxSe@QTU&@_Sm%QC^TaG-87~`8k;%yLPN3>Cw*+F1I3MU@QiDCPMRm#u zpKy=PBO9ubvunGf+)Z`@i~6 zy1Bmh8h*9&bS1*TD_qFws;=sbWb0f<;NeEtAp0}woFazS`(<5Y*?1xtYx#^uBd{sL zIx-acj*+x0k)bdMN&}3^RGgPdY7I(+fTIK+0kG7Os)qv7PXWLi1tUt4 zX?oFCS`A=zxug8{`~!ipMUu-{jJaUo!9a6=lg&Eqrd#{@t0ri`+s-t0GmN)mCm^9 zpp{uspFDlOUAa?I#__92bX$#CIPZB%pxLjxT<1x^d_}1zaEQ}_G<~2(N1qg7gM%R> zLuUsjZ74|LTKTtM<`ciY9nLW%JdfT!LI+|TLB=ij-gAMuh6W%T;G3t`qGq5LTkQaq zIn)#m`E?vkrqGOaBOOV2sp%7L8{_>%uiYJ0&3%pL#0k1z`tH%hBK6Bh8Qmc}9RcUU z6`OT*B4a*nuUPg|dTzS2H&@*=_s|fY5XauNn^Ltw4w@T-I+(pB=)c|2XLKYm+xpzFZ}j0 z7bY^r!)N6=UI$SKyrW?XeCZ7Tz3i#?UbeUPRKkOgjLqsUwB> zAzZ-FlDfPnf@9qMEH3fI5?e34y|ImkGeU+R3#RVG*5-jMg}mjlU}HowcFu%#Oad_? z{qRPSyoqq}E=B%cLl3y-%X11TC0mV`Hfa6#;1Sim8fr`Bn#LQE7Po1r`qXvN+l?Nw zIV+;69V2AfVw*@LVmCzLzTQ(G}>0N_676n z8YQIJP*8_3oVmyEa0UAq(?jfDt-Ha&GFT$C4~+MyN~`EX;cQ11tGlw0RmB?d2}m#UGnnmK+%;tolnL^ zBoqre&y1X|CuqfnOjeF%^T9`WKPZ||*s&a9o!>UupZynZKi7A^e)xQVeXO^2Q}4Ze zud6LI%|iEa{MMK+j%R?1Et5qa>U-Wvj>{M&uH5U~Va{lJuX}-bR}l4hYlaYtsXB!G z*%81EuM@-0;93_1CGaQ-nCX_)z1HU)_IZP0egnYsxwFpdWZ9HP3-F$()?m(-g(x8E zHAi)g=3WVVJ0eva0>E`H+H`o$kA2vI(4(=q?69u&gp(kv4>@U&EI}YQuGD-fxMX;V zkZVbxE2Ho!5?HcE(U2_KBz1xy-JI214d=#JG+?GfPnk4Y1;JR5Z=-{}P>&j~xrXQ?l|5ACt79|6>O&asdd zY&aRw1mnBF^Rk2zPK7xc40DK4bPRthQ`Q`Z!Zc3a$g2R`?qhEXumh!_(>-wqNr5vGsUF0a(| z89P>mEZMn&>WSP{6(R&3FPe+DVlaEwJ>0|b2Ll<|?qa*>+ziljpdG=dk8q zSimi&$U}uFZr=1mWRRM0_4q8!{j)#)=~Majn^oeckA)P$zx?paTQZXOUc=Xy%5P(r zAq?&FHnUns|w{0eIk4^nh#_Z_MqC`Xo;{ln^}(^64Ir#0hcH%U^cG{+s&w z`wu_-f~?^F@Q3ey`daD#-mCbn9%p|uGeQIHjDeUxJ{Yb{R@x8pXj&_cXQ&Vd?yB>2 z74M1Si!h$UeoYgPsoTc!gS2SFD1*fU(O97RJ`pBLgZ9`++d@$3b!X(0z3h-F>lnv( z92jkEINRlU4;+_EB4AyVg0CK#m#W&0^9^$urBpOGLVPI`RCEZeboM<7p)u>igFA>S z4bU2?8A$!vLXx@=hWOH_`KO=u*<0$>cV4$|^$277bN$@57%foH5Fq+`=R{VsFJ7cm zW$dm?pQzu6xtWjxqOZp{UJ!4JvnNH+Eq38X9WH_B@?9|JNE@PKu2?FK`?M$umP#k?Ro2J_jg` zvk+~Xa{+}wJpEOQ72bGYVT`2-`@SXM4ixa==ZFYC3_IU4ib6!-OpG^>A1m;btm%6} zr|^vRo+H4Q9vW8zQS^Nh?TwWI+PdPB2kwGRm~*}uEME0nfBogd_iuId-+TE!Z?OOC z%LaQc7Vyi%=ckbJpE=;^fbU3Cq>>o}Q(L54A$qrgo^T;aITvU-N>Olr4+}HWdtK@h zw0T**+a6`&RMD5Pm^aLMfi=-l(?0b7VglT%||ep$Ahl%-}C1fuEe{%%y^mP`eZajnK<>s~3c! z*MYpea8}W30QPGdof#xB1xRf!o}NGwWI<0>4=NVun6dXfx^i3B$S15-dmhLL7D-$+ z6Ty!$)Nq-jfE`S>t5$yL=l|3G{zv=e!w-M>n?3eVp1SM1{PC@%;rCv~*9X}*vCmNC z{}z_I^qjfeKsyt-F&dsY7i&hf!sFOMMj@hu0}77zwQQj>I-^z@RDp&$KMShXebN1a z)lsJeW{1F3VzwGPWQZ$VmRb(J%XyXlByAG}cbBR$ck4cwlpz#%&$A4%h)-sjhKj_@ zaq#B@$jf=C5f#p`hNYi4Fy!T}Q3H;ub?7=Fl5r*cWWFe`*Iu_}#m(vV(!u+0e*L+= zdt`R?AAYHiKiK!*{rt<1AK$bkyz@eSt6S}FMo27?j&^e66xk904I~d1fhisavAq%R zZi@jJ8+p!CbRI_#07BD9IA9(*3zbc{=o(O`)pSHYIJl4M5w_!A>Z@vr7WZQ{`UkVs z-g_b6*lO?mK7YB@PCz#@&un+z7a%BLH&u|SwF^E}NIh?eUWfQ-CEudbQyaJay?7*) z>7C=wsf!4{(=xn zhFY#^B5VWbw+L_xdyCcNrl}LH=&MuU9iX{ImZ>DpQkQH5qpP!Dx|adaCO5xe)*;hY zC%kFxi0B)l{7J|2zs@gpSq&N&ar1MK0n!3?^A7JbNCpdhL zRQD4^XMbfz`EPNSefZ($`iMXLuDTHu^H(2!`HSz`zW?4W{{36Gg7;qBw=}O<*2{Np zTx+k*)4r+0dYfg^$UdIFk)4B(AtBILz*dZQ4>Ml9=|D=Yuvt1`3TqoufZBvWT?}iL zAj_sYXKk-(s^PTe`5Vpar*jQ|(-ufRw(m+p3=lO$yf%Ot>bs9vH(H&b>(%VbaLM~E zYr!sgI@Ha52_l<=wQ|FE~;doS+m?NLMo=j-M6(+g_VyaQ5iM2PFT zXgk-gohNplr;l8WxiKeRVXD|chlvVmUzhnP!xRYKfE@o-jOd(bs~)~(+oi7{cY`Jk zB&)XfnoMUQ)_NBRgivK&oD~b5Gq8@pSD!RDEKSC1Gd&I8$9^_?!YGP5DiGAE1(HYv z#YvBK-Cb=t^Dp)0RrHy)AS` z#Lb)Y%-Xr?mTZ`PGC-x*8W&G3Nz93$RHRZ#BP|L+7z~U8x^gb#Y?R$Er<(9`)|q<7 zIhfpBty5@r!kWF$evaXW{QU4uXsPhf!J4!Wws()kp@DROy$2YJ9qf}XPMlh4`>-fZ zW}c3!(l1O}M=St?dWEjfQOha^pA=df#U=_kWLX8I3bDXwL_Zy^)xCfgg324;}%T0N@Jfp-Gz|5?8T4WAJUMy2w0SpNec_LVS!IlUO*?C5}Dr zn&T{5;GIPvV2c2vOkJi?3ZavM?fX#GQd%rLy7SAbVxAx7Hr;?U@G zxDZ@90&)jXZ-)%GiR%<2S7bsBi2NF@$9Am`yeb@8hXsZzvVc~2@Bb#&)($^f~E?j^02N%ovlx4|)u|aLLpCgh0#K z_%Pv5JCLr(&O2@EnW`YlI3loL;g))Brv@|lL?AF`0G36qd*%SQf$>qoWsE}X%zJX~ z7V^W_K`wH{_1S=-D}0G3P^3rUvl+-)g_OoE%}ne(=;479Zgj=^Eb;$*Tzx@*qfh(G zNBiOD4^Lh8hmSx0`j*A~y;t+~So7Q1Z}ZRRpYx|zWiWDpFk6PQ9?0^wpH?Gi_l#&6 zu(1$LK{rII5mvB_di!NWE4oV#yp{&YCU8(7M~8YMxBkZ1b%hy`i%?l@lC#21oH|?L zOTPj|-&DDw7| zfL~iErgAq0ZI3}$3PXj3e}Psg`OC59fBIH??{)lEk2Y+zPkBNZ)R095E<%+HvJ+68 z4(mRcoT#5JUDRc?Ith}K$H;XT(?J5+;*FpGfq>_f0Q_no*9Rja-1ksk979yfSV#Sg zn^z!yq5FzzGY*cjgRAp86WyUkG5{F}d%fe5E{#QSJ{P34B_5Sh~^~VoCywz8G z??rs0ujbPeu)PTA+!C4e_kfkUL%PnBR#t__cZ1XtOZQ{y#G}2oa{HK1uNUmDfo@3m zmAJA@;OK+OSJs5cp)cz|qpv2rG4Y9brI_9Ol3L)hwPW551t-ETZ^8c)wGAIGtc5ms zA}cQZ$6)eXnuSUM=?yM^W zD*r`@b@I4&G|!P*l=4>X|Ia?@{=cgq{_x?4x26K`y@cQXCL`RrPgv|@q)6tngr;i| zqT9wWS+ySEpKl&;*(e$?d3V5Q*a^QX=pTl61ohfWp7C|DXd5fU`v5ApU06e05hg{1 zJN?}LQVjHax?sNd()|uL7eJv5+G~Zv5TO@EP7I)%MBT-=jSOU$U!*lqCrvtNh1z3! zM#v3RfxZyia7q+VXgV{`HAgnK7{I^o6MbxCsBFLo&u+di2kF133+8(--S1#?p-wZ5 z`a{)6O$`(~e3Z5Y&7c*u6SKh_2`SFHf;$pC=~B}z2*DiVA{A$jgS71u0z4)jyQ?(m z2^on5YLrg77%5MfSJ10agx}NVdgrBky}5MyssX|sVo(@ZML5JUMMC1|bG!ASiuT-^ z{WwFh09~4G+FXu=NZ7)(&Lj#&zCfAqY+WOeO}d%3OmbSBP$JaK)2r7>dN7gBow5%@`mVI*cOM71r= z*i3a2F~xAId4XnLD_@>mzo*yYdoSJV&Bf#BX1jRgAlas9zu~;+Qk*;>>nu;Cvrm?| z7V|l1&F=)9m4Q8oL+2t1GnZj%<#lVj}N5>f}1Gz<=*OZ7aEUGW}mqyV{=r_Y2hXJ+ftwF26j6?fKUX*0%` z-C%L_riK$_KxSXL^Ho-SHBeARf|0|yBMr3sTd|hq(2f{)0}NFt=elGe z%$X-r|T;<8K-UUd4PmEYKj!oL^U<{`~VkwxxdF--ra(@5WF!DXtQWxEnR7d=jO9EDbkA;LqdXR zCn#aY!S9QSi%bO?5nk%O#>@5?6j(AZ1a_1621aq7KBz9b7>p0~yz3^;YF>y#y-Q(0 za_CKCt~`x214K3A{R&$30lUd1ohIgdi!5^kfP^qpC47Dq8pm7T+;sob*EijFS$|pI z|M(M9{N8Gsz4Pk+4mMyPkg}|7o#DCh;)Ns>Ahx*{LLOw!b!-{c3WFGB%7#b|Iukl$ zG$UJ;S0Vz^`NGakc(p;jMaU4u@Ff1 z$dy3Ku>{PrU}fREur{^K0mm?b2A&m?7X&av9N_>rAhCLcE1v|NY8{1X0IBrJIT?YA z2m}7I0srw&AFDss&wugv_)p$@`M%X1HZTGB%^+YPbgxhZKQ6L$&F&06Ep#nL@709g zaBM~6kpp^x1Mtr9h5UI?2ONS2LFDi7fOE}KQwu-g$~6?}uB031(dD%fN-ug$UKvm_ zbz<&}?CfL4)udxLf>y=WF3?-EK}to=l_TKguB8_; zNo)qxCmvUJ`p_i@Yp=3z)|cd^Kl{^vs-bY7@-QMXnWfGz;XdePyPsL$)JEHP*(TMBM;(-N|%_e*#h39`q^GW!)aW7Ebm1 z(3bo%FB-XN%)J-G?^-64_I+hEKdAD_l0>}*5WGVt(LFv6Sx%&huZIAZI%0wvFp7|F zi;!GZWuZf79w8n!agFcMwS67!@DZ?gD?o3#1Qd#nungX=*X$+v{C|Ajr{BGLk^aSx zKmPmg@HgJtbnm^S-|D9OTe$su$k&1n7hXdL!0E0!3)zxB_OigVIyW!fQ`LPuvH?*_ zL(Z0LaFK4EcDj1Wa6e2m4+izFUS|$gGD2*a-D7L&;6B0-|GhlgelOzf_g=Pdbz@P<1p2|1? zx8OTi4x!$i_tw69!gzLO_65<<>|P`y7zpl;=B5%kx%OGf;^MllAA z!N>X`>*H_7+FR4icV5PCb)&&`{>fB#whZ(wH{vcTVnU`62f)W{t!dFgqrrmI!uJf` z$j${=6v%GS!y(8eJ3AT9$>Z6!qa%-OWOJf(ksA`wd1yL<@nl@I#)Dsx%od{5*XS!I zHstP$rU0`X(Chi!zB)PC6YR?CJ&gO(Ma}#)y@`c^S2SEs?~nzT#ek*fUf8GToF!Yz z#{dca>hn4JI)V<~oA=Lu`P*yr=fD2p7yA!i>2Yq=hODTR9CJw>mivO@b_3(Iv!PK5yce)U)C+0uz?{(Ts7}+5v)(HYl_IC+!Mi9O@!QES#@)q&J#v-#@x&uYDGnM7Jjr~MH}m09rwzX z6rL6B1R2SKYt8pW*FHQu5%!Dl&6d4^$bk8q{sA`F-g`w~Z#p#Z=xnr%d6(w6K4nw| zqSQ;o8#OW1dLYYQxGjL--o6j!O6dp_<&jl$LdZJ}nh`)E`8Y-x0}&J>aD?98#uKRr zb3t0~=J{&VE>qQe z5qQFlM1_$~I|fgi_@HSTY&R31ckmFnf!OP%Jv|df?J5{nJJ-6Q(2H62dYFvHL&mnX zk7j^@2cT;PNOPBCo>Kz`g3}jOnnYwC+z2}Zz|9eS##k(!d}t{}g5`?|_jcP~5_JCV zru*;yqQ3vBK7RMdAM@Am>u>hnTbF|OUe7lqkH=$BdhZhs|ARh_V}<{vHUo8|(qo4tvb5te;Ab)2E9soK7P3d^G zUohm<)BhHns$f>~C8B+FKLPb@2x08qwbN(ATfH#LwF!9*-V7qMAo*LWrL-rNA!Oij zUc0P$Ihxjve1r=^8#=O=TkiLAD|qi^dqd&)P3)}sCAV)GsNjgiLvS73t}T*_=RzT9 zEhXYMIK{g2m1+~~3iG?D2 z`R9JdX9m^sy%z){d7F_UNqe42i$Qh8@Os1bRl}&fksx!977B5x(tyetZf9I&;5|KO zGKBjqH;ks_cw`5)_B|tc<-wGBHe!V*X2h@9?0CDu38$!8BzYAgSJzW#UfU8b4+pRF zfys`T3=yHMR&Wj0g(-jAs6Z=z;(;3h`PMRxbA8Q%A=jVQ6&hV@jxB;g+jJibDtf_3(Et)ab?@moCHni zZ7ODD@KNfN>p}vcu5PJoh{Or8l4UfLfF$ot;+y4MAPMQ#-x@mUZ|=;;UOP~)B)Gt< z2h5GfBWfbCHS`Dqu54disPs`x5sN=b_oegz;Lu3j>L*))S)~)=>RPgKV@Ebet&=AO z*?xJg%6OiB8LNc>tX=!!a_2xtY}B>++%_?)wy+*_x}R1=byj(>En+-!7Kb` zzxKUX^)*%dTiJL#{+#8vc{^5N*0{47w^_q&7jhPlx@0Xxx$Z$+tJ*}CP|a(zY#_37 z17MGo1;j_*lNFB4IhkYlfWCAN+Gl2!&kk}zKfD7;!+wYEm%iZNZ@=Tc7xMS8*&vx? zUU5}q*aTJho;#70daQkFaSwRdd(uQ^XxUkua_5$~sC66j?dYYNk%{{_bAtqS=0Q+< zHX^A4m~g-~r6F^3qf!^5K7rS%kGN7oTddZk_C5SmidXFE?G zni$jhH2lao>8UKDVsPVbeheT&K=}9Gz1B(IL=$>uS)oq7uPs2sUS1CXsfZ@li9wX# z0*b#an8$-Sr=7DIG@B?kN=A6`K7_CkyghMNK=KM>2)t5vp6THTe_Hte454gD5Xrf8 z+yndV)B8k@WQ_e{pZ)i5?6YUU{w4?>^Jl5-b6pz75Lz@6nK z@^C+OAX=$73zxavhS9{_2l3NAs%#FOF+>ko{x<}hz%#80DJ6)4?5r@$nUegVXL7j5 z@3f2d-plp|aSt;lhN5&938T4t(1(zbQx(RFdmSdli+uQQYGi&cxGMIFdB&l$bUtBM zeaBi4AVgXZ@)fqKZQkeNGCkUQVI*bnK{^dQ`7gm}4QoXS*8+5aD}-wp($k&~reKcX z1Z1bfParqe59}68anV78dc)%|&sOFhr=%{Yc;_?4O38-D(jt(P35@eJ>5QUtHzOrH^T=Zvm9cxVRg_>2kcS;d0Lcv zZ)?(z?^9WbO4q$_fA**Y>*jWF>;>V9ae5L4r@1=Xax#%j(Y*{x!z;ag<7n*q6 zW?e3vrPp}*II-}CxEeW*fw6{f2zc+AVd9u;_)1?_DhuH(d3T<`QOa{*jC)8CR|W^R z804h+`P7onrP%D-n8e|poRB?VS@?FnJ)x91soobzUdY}DR8f(3c!K=YzNWHM1HjF{zmNh zFTNyD{PB;!{_x?Kzy58v{g=P}`PX!h@4cL_H{8AOOCjH`@z<6kaB+CUY8PWbQZ5f( zPw*vmhtdf>V;(w!eqh+30Vkf1WgL1LSlh9hr!ipf0zy_G(FH@~B{6*sbpD_d{Gt>( zpFwB!u*5(!l>=T|*HRgMoenyL?#uf48PKuL(7kE&K+l=+)0gCygTXGMlWNL_k;3~T z)5FkqHEl(f)g5^U^5d%Dyt#puye}IXzn9nKdoSC!yRkl>WIE=xJysbqllq3@tnhSC zOMxmXz#{?qsGv?}8>5fT$p*~`e$K}YF@%}9g22d;P{~R60^_wdd~%>;7D6F-4zwO5 zl%vlpQjm6Is@+E$X{;mSEK^AQ2^V+a-lYQ^nylhV_=8O8&2UJ%3(C)ij97)$5ILLy$@hR}$4Nz;yN zYM7FBrqk`u&5F-6rh&Lg#G8&Ihs3tra~!|Nz^#f8qTUytzj4qR96p@aopy^yE68f?kRG6$Ik93MnMPto7!zIyLfd&3*NZ~`^sO*%Hu zN4~jltV=xPxSBw?!+wv?6?UP8gRBzyp2?AWC=ycORR#%HJI{9o$lAHV+!5DCbB0Z>jARIo7>t5Nj}+DwGJNr~77TWL-NsmuIQ`adlb9vfAv&qB<%NT|4fr}W-HwXgpLwShyyfg-_qete$ zS6a3aMRNdloj1p{;G&EP+c?4ZeD4{R{zyaSy(}kf;N1>G4yG6caQ&FucjHZY>x?RIsJR+8;StFTp&AOctZlNFF?8z8s=-(j}l zkTDCnOw8rz5qT)D#D!D_15!{Z3ytkZIE=VVV*4tOE?nRIU%z;VT9eq!88alytODqB;<2$HC=GX+ESot0YEcaRG z^q!66G|;RzQalTP<*yf2L! zqt?yaDvy9&r)>hQn_HZbO?z`qgg%3XDmyu5_Zm5~R!B@)=P`gaqWuIxFCBBMIJMZzHQ;1G@*}^n(3PQf`t-OaB(u6(rY*Zpw?GWS`%y$CNhMOR% z@XYONa!mjO#M+@<-vI-G>qRE|L+E(smAShe0K`prcg6zTc>BPG z15Pq&TOgiNARgrmkmq%4o?(C=93gi=00($Ujsx1B&vp8-E7aV~vd)SLJ62-6cExUE z5y<5}y#$0NgG2$J_pvb(VS|{#MS!KuJohHr%g$!>lYzp#gb!kZ z0gPtST42@)cz8n&u4*HFpOQiVlaNR|IQrC+mlV@les00}3)L~6By!aQU6r`IJ@iFJ zEeHL>svKSTC(+|pZI_i})F*^2%pg410b>*>QTSLu>)){J*4!8JujacZydJg&b5gc7 zAwPDP@Ew2@$~o;ifQ%hvxWtqEtcBub~i+ct!>y|&&NcR?xSYj5yduA*Hd zYsfrD*%(!EovL&1Jn4_j8tQ|j(!F}?DMr?YH4M)arvtPgOyklK&V9C4_TWRJP%cnI z7gHFy+%tO7fFRP~a4g!@69EG2T8(3)HYK)Wz&f#tX5YlTwg|u!9yA|)An;qbRQn!% zmHqMg|B6LJ1 zk&CFEys>oTjNT%SX5^DFjV(~5htCRKE!Vbs%n4n;$My-8*hqBAwQRFH7z~sxn(cFs zbr(b5-wxZITt~&Nh$%+tq#Nq_qDXv*nC|5C0mHCtTKOd4ZS0zvM{JQ776+NMc&m>< zEmjxTK9oN9!~pqmUwBh->F9x`Di^y)`(o4e$X0Ry&u5t2(gVaY__1fLcASwh=6X&F z-p>Jz+v*xw$H&-%4&G_D%TTolZSZpn<6~n)2GI0**<>`5cE#^N;}+GjZFq3{%HYin z-*ol#dvDEN)Qo#Dry!K$iNPYO*7a0Pk?Iht*G(Jy$zwWvIWY1Cq44w$)Sr*M!r(QV zSUOI;!X2-its)c24PZtEf+`Vb-WLK=#;bIMthJFgV>vn<)O|_tHR5T8R>L(=`!0pU z%lSZJgH3x0@k507{rm(?b{p)_<1?U82J=VND!HSP%)qXE2dW=!e5eRtTBaH0?0Hd* zPQ-!LS~XO2I`)FAtnzDz7@F7{H4$-hDXLDQpHPeLof|W#oKH9sZ(c64a*viZF-F(n z0kCmfav*I-p@43Yqhh$w82Tp_7x(GOc$9bS+6VPQsip1N3#{qFD4ZhPmG4MhF0iJVNW)e_#$F!o22mLT^@U7Sj znh`-M)7bKv4jY0oEJ%AoOTeB5yxhTk%3GEwb2IKBb+gP4D?_TCyR3u*3&Ga zR6?wdR@`&yJoN&4VL5$KtbNJ~Jy`)7RA%+6zCME@!_$v)ILDQ!#+bt4esb3%<%Qaj z@>~*feS#R*xf4C?MV>Sbxw0mafehtq)EE>zTPEiKzUf(K0top_Q z0h*RpY#X$uUO_u9Sbc8VEyKA`Wktv-KVsInIYZvUmZI{s`}#qF`KEmh7XzFN-cBG= z`ln;qH{`;eL_uKzU+OkQ!!W~olwCx$a^n?FL>R@?R9i59?kfU;id)LTMtC;wOej5yNPqj zg(wA0wA>KoY7b3FkkI&>X44@^QF$h`f}cHFdSuirL>ar#$_vOG666(y!@k)G5TD_a zT_QUWWF=4nK=dng3D@iqfKMc4dF>6|2|_mHlEU6`M(jn6%(Q_ig7c@*imZ*JEo0zb zJ}y3smW%pz#*_)J@3Q3)p=Y~{1}>(0EF&cKHeb#BdrxXKoQUHbB@T?idU z^wHfUiE{&)s+jG-v5P<>bF`+w!IK15y-O9>l|k~HjyvW!J_o{#4{kn|y~kZ!LeMac zrGXL5Tn*}cIrz+Wd>LA!yR;paVYQ4MW**(R|Z+`R@){lB~{r}9JZIUFZu0*#4 z2uWx;0>u88Fm@t)4^#I3Ji9Z~os|^<`fxv9?^K+_>I-{Le*jA#5_ZL_BYx&f?$IDU zZ`s&Fv)Uhp8>~~vCCro?^XHNG-Y=i;G2j`=8;B38UTah!K?D?osWIT75T_+7!mf{; z_c;bU{u~AKI`25%aU@r0LOAuibUu%L^Q_Xp@evYB8nq&q$p>tmQkOc_9$UxKcJjty z`w17S-5d;yKT_0|nXm3R0rjbI9}Yz&xuzezxAxaD?^*IZ++RB%F_cQnPm^cN9i<(Y zpmExuqgtnZ*tuNpR;3$hP4rJMjX_cS_TwXgf;z~02_ ztwX+0rasTd!arZzcWtYEZd&U@-pg23E3FzKPsNU+*8s0?~ z_Sg0rMzmY)RxOa|(+tRx;T+$W$#0|9Ulj99HtaP19gP?1*K|qvk@c-aV(gnW?v5gx zLOSl@(+;lj(4k0oCY=nf2y|cOZNSKzR{7jwel5*P2B2W%PN6_cL-o7M3i4 zj?@eX_Z)5caZ@o{IOS4rat3)i(Y(Evpq`3hmwpj81yjD;f&+KM?u@dSvxFqeDX;Mn z$g{EN&=lVZ;-uS)F$Kfli*35vs}QbEbciwg8}hBzS8rO|atR0k6hC;&k5;=k*O=#1 ztBsB5BB5c69b>C=^Y~^*5c(ZW+^-=KcW^}W^)a=qBjXd!YV<{;f*$g0v>uGW zK5MtSm`RrC> zQFD$o24&H2XWfI$SnCXF*>-z4k6#mZP@a~jY(C5`pUmMk-PW`nunAR4f=wbn-QO6T zQ|b~=-D8JRlHRwtE?I{xtDNyMBYn?St8a1!W`EwV+}4IHvmDAkU5jlz^PGL>`M#FB zz3x~W3A(M;O(qn$rmtdVI!DvF;ex7r*VF!SftvO0*@5@n$#6UuN7>xn$SUZob=_b_ zcDGOetE;E?1BLGJ$Inx_ra&=?!|y?C%#Yu!V?=$M`!(6*ee1Eo1R7H*hrv3~&5KP= z-*Xblcj7KtBYL#xuB^6b}q=L($P@k4vsvWc&%I*u5r0j z8W9)Wh*!tdU#z(qgL$k@X4$i(xxbxXS{D$H{#2?_QFPDP@V1?vg6onY(%4KZBJ`@z95V%vG2qM%7_hGLfW})Dxs<(udg@e zkz7L?)6~2li+2yd=UbJoKJ&v`(a{dFju$GJJ5T64I$trFVAs-O@JAmHZ0Btv&vVrn zZ{6~2>NdG#wZ)#jKHsu<0Yf4uNM!E1lNhV3gZUN;RX)PlWlt|cCBkd&@?^W)l#vz0 z{O0_>dWx;eC6q&`2T&|yLD;Whj)hHAbBa;JjVOC*>1UzuvDSDs9%t=?sUMC!v9WIZ zX3*%>+nDn_&FKSdYfo`&fR&W)FWM|$d;75iNYW5_rcih7kXT`Qqk5o;titk2!Pa_G)Sh-RaSeT0f1(Y~f5 zURqOg*WffdOY1|mrRKO>AUZRwGYo>@@)m3=UP;TTK0Zs+X^c2lSy37JY9x@=qNIQg zU4bfOaR4JV@d0^#zh2cwtLm~!Fbtk?cJ22JNScg(9U*9Ge1!?I)zA;R&mpYb#5>hV z0KWpxz(;r%jyWZrPLwYzl`&TXH2)UE>}F>^bF%f$&AN)G^!4FnC21n^h@F0KF=ggL zwAp;;>9G9Ad3o7TpwL@q?pCEkGHR75VbSSt#nbt1>zTYhW({}3O*<|dKSF7}<-Wu)eDPz>>t5-6f zmyI4|)%o&ze|GL$DWs8rihv#zUw(y_JvYfx@O$edxz?*1x1=*QBI%>KJ))#+^tKT* zoDVBOQe(1@14l+H^FJ#Kzs`DXD+c#I(#xwYnS()$o-eyYPu)KETEQ!`#168jds7?X z6Gw71ICx=ph>0AY~F2!HlaE(|BqFZ``zJ#Du(+shmKH)V;p5l>am#nqT59*23F zt|j}|(eh0$+Ow-;aR4k747cBuTbdz5M(5~#ugt%y9MbVhr7l}kY@jj$&tCJ##pmWIn11AJF&;Wf_;ic zpu)$A+iQg0zPt`g@ZOpA`{zxIbL=}8WGC7kqGzI|=veEuLgY5=G;LYqJ=i(*Y(wTT zzb75$2?4;5GAw1Ejee*YmLdVsTjd@|2wLy#j)y%Knv*2=RlRC-y=Q&T!v2VKt=Sy% z9*?@d=v!t3I^{%?U{2u@tY#r1@qp_xJ$*=k@C?urJj~{-g|F{*<>nSa(~$M%@on4l zR=^OtGFI0$eydWqOiB|GMgYwIBUK1fXL>f@JZ41W*|4uMlyRo5PGC#O8F?q7neB5P zWDbUrc~3*?CbN&u^naa6P2ODl&3oy4ZPf-c)4zQL9P8O>_RrC%fs2K>9yZ<6n7<>H zZ-^S~v^b6)aXhW<6k+|Ic<9OLWBSm1OJ1AAh;U8$ zrd+f`iR_ZA3D_Q);jaYP&xfn2879}GT0=9mKqubXbESQ%DjLLlNw`5xG|h5WP0bgd z9oV5;9HUO&)4c5!k5cu!rZD=TU^;>SXdKj$nF99bOC`Z^l?SaA`IytnOPFkh&-t0& z?=x>UfZZ9nj4hHd^wWEh3yd7&Qfh1NQ7!4tKHINon0zzn{~I2~8=<7jOvgcBFG4;k z$9pja9$Q&2e|d6V3=HS=9L+;naJOILj4u_bMgliMw$kIPM!Wwd}j-!aWAzOB86Fr2B<6*iC# zNoUHx*dxfPJ>cf?p!&_tTnK?PzFiw8@>>{}*nmSpxl=9r$xE}en1MN3Qqt}h5GE#< z;iSc6n3cx)*pNhBK634A&W^@nu8eqzBk4oc4#e25X?<*)jArP~dUS+5-@+ILCMlO3 zzL)T5XNEy&iAYDs(Ok~($xfGT1HgGyG9SIbm=G^eK#GgYaNj2U3~vw?$Xh+&5TcV^ zHMSnTbg@g@>w>#OEN!)>AV}}eoI7%lp7Zp#(CFsMY=q=}eT08Lu{+)SnA^^{(e$?JEaxEC zcVZ2MM%%Nf;$lJo&?22kZ*IPUrYQE~F+F}PpJuD`69F|&PCXY**ECYf*4sg(k!^a) zZbF^zP4QQ^w(@Zwuu&>2pVVxUVoHaG?(+MrEG>)L&TH2nvl>lMw;Hp{m&A;iX5c-JOJeJY6 zKMs}K2+Gd4*4(l$Ud?#P=F|lF)>SdYUbExiKDuAwFRb2 zjRB@vZl8<*5hJPy${SZZm2ugDCQI%A%5LZ(cS=S#}u{m>`uUs-B3uFHnheU^Y>W^7~WqqE~rMug1Khv?6t%&vH~jNorC zR^r-`ENz{~n)|)pWnLe=Ktv}Sxb$3Jku!AkuZZunhRv-H)L<|dRBS?Pfs&|| z2mskSsa17?yT`FGy=bmK;=|b!b-5+g`E1dK0HBWL6N~y>4R~y_?m^_*rXM^U9i;%@ z!g#84aY0a~>0tpI{SIFNdR3tlQTsz{CO|Wa@l9`S&aLxX5AOP6L`gT94 zNXN!Jxi{8xKnV;3_G2rBqHWCGy-!B~;5XZ2UW9rz90fMne1THr+fA(pQVW&$FcntR zqqbbvdb=Uh?_JsUx636$ReU5WTLZ&Xr}BtqT;BRkV&HY#B}yms0*WQ zLl_6w`2?ZgeozgZa+0|i&(^Y%C7+1i&EBVp@9g>d;PoZr!KSFscxxhX%VaZ;a(7?W zj?vYV{!z)qdC+1*pK6)4b=i%MNziqhRerk=PU$0?1~{LEs59D?>u)$C=^dY4p7h4*hYlIr7n0YW|Qn768l-a2QGA=zt6n^X7V_244R9!tj#LUC=>Tk z!fL)>UF8U#w$7?YAmVqt+&Hasd>TiAapUVt8*&*84Ln2oo~uPL$7ojVP%{0i&g+F^(t^VEI>zj9v!0mvpV)e#HxKfr_Z2cx#U;VbE9w`5`u8h+Nf!>2{ zdfz#2ZzECYu13seyL%#CyubAr-|4Zau?LqLW3ewk-7o1+%;yY>R3pTpk9S68-Ohv> zfH#7EI}M$9pHy{(7b0ZuhlXZxNBO+bdNZ}tP@?i$K%vO5t;PCt^xAfIjmy?xNZs;w z=6BW>QJ#+9^vpfmdLUQW zHM}fb*2#R$_Og}Io&x0_n=cEc{`2}KT7cXkvm&Wz-B7*gx6YdOI&a-(Y2{$sF1nYt zX7xffI?#~=^kP^&7dtjD<&jzQA%LQG1b05Xkn+ae6m1vj5Z9ai(C7Fw#IM+ze=*OT5Vv{L{WR4ouljRaEL3 z`Mpe?&z-pV;0cpwvij*a8+?r#k>A+sgbm8Ga%SBC5+fz!;06fGdz8xV9#-CD<X6U#{hsyGl{5&)kJS1>seC)M}FbW*mBqv`l1@?2r~9zHAtl} zDyIKpvUCAjP$Uznd9zx)7`x|!zUEW6E z{gC=>DSZZR5GTqmOMk_RzAovswB#>FXQ#$q9{tFQM{qY~(n~V100vaRjAabUGq9Y- z@J>pKZl|Hq0*mkG@{_-e3I6YVA=ci19@VxAagleyzg8B4%EOx|V zm(bxO0-JX6fOB}w4QiQ&;9&p}dFL{T9zv!z4r7~QpwTkUzAXgBUi(r73^O!i=do?zwyAm*NzlYpEr(qymlZq_UhKtO#os-|4sIhe%U*X!**%{u1VO6(o5W`!_05w?1GcwMXMACe zoQ+Cf*7>t{M@?}m&0i&jIo?%9a`OW9Wy%VM1=i2$3NdF7l0w)(u{t7?t6kmt$y5j= z%APHFBYMXKX4C3wpG45();7Y7{I?z_@%pKfj5Bhaiw0nw*J>7h@^oD{0DbS67$~<& z;`^J39}XGxD>pOTWW^Vh&@6Iw`2H2~ISw%_Mh3Ydo1`_U#&1Mo9LHNCgo;ETWsfCM ze=MKQm(Mg<;I@NI7Typp%IQ%ZOn4h?!=-#;>1tS*SzmkxS=ByT z$Z4)$=H#SWryu`xAJuH=fbs5-2gW)&GkWeNqaYiut6}#m;up;R$S>GLtEa%9#P~86(Ly$nk%P8>ul6^^VBFqRYS#Fl+? zzr~+^P;$r|#+M*Vp<+pGep0NrMJc`q@qilu53K+$EEe9)__E<(&9o{hF&2$8{Har|J zW)BM?973w*4Kn-f9r|@wx6%Ati731X#J92L`sA*%u)5tl&;CgL{qwg9Av6r%P>u%7 zS+Ep$zaRd| zFoZL7HM7Z+&;DJAJND8d#~##+;~J-Y92Ne z)_UJ5`abuV4Xj;k4aDU1SC<=xDGqiLNpCyYf+$@t8i;lAqS*_*_vSWbYcjr=>qB9) z0yl7CMlEWNarcMqK8c4xY{FP83*HN5Wz>oCC2P0nNK z&R;)qzei(Cv0x(|X8aUPzU(zyRv;|lKKRlz5STHbB>GwVd?yEp$!qubEU>_snA{7{mp*IROD)(!x)T9LEbR;4Ilw01c`8)`{?Cz z>6P2pK%ytCMngYxE+vW@cf`dGVXo{ouH8Xs7;ad6JRc=irnR~H0rY&nF#wa*9%Fn1 z;L8B@L)3ndn>?H}HPKpqsL?0hdgGlXV8| zj3a-)Ivbkr7$fUP}VZ#g@bn#uRMi$&^2Ffmpkzi=Lmo zr++Syus)P?shT}?j9eMy`~_vw&SVvjTIcNO?V3iO_Dy5ne3%*^cB_Eew6f+{hGlB? zeivTRb|)4$0^IR6cY=hAl?osvp4qQ(n>EK-4@<-M&?9uB#e}qVcue0sNUCr|P&J@; zb#`~B)>%HjbZ=(wm;Y{#*9TBzRRv~1nrAu1B^11_^2h*0dDa0~% zZJW1?rJ%<3uVi7r-3|9dr_p<#(<8q`)Q^${B>|Y zn8`xI_8qdI(V>iVnQ~=*lmt}akwBy?=2^aYBf1}Wj9&QM-@R4^o#b*MY^`_v*{<;& z;Yi=`zfe4Hm@*ZgeCq-ZxWi4ZU@v>4-lGVAYrDCA8{EyxK!6al!@jXU$xnVpm3Nxn zP{^%&>p5Zy;s#VJ%aTDFVPny=@3$U|w`CUhp~r*El(Mkg8#3h4Ybu#d9mPyWF^o!o_jKM@Gdcyf| z-di2OVa)XTt<_duI^gaM1;)gjHL8tuw;;*v*l-Ia6{An;nU0~1l|P~HT~K~OpW0fn zD$cX1O^ojNGusD5=P~-|ZqA;(ahqIX;iKgp@yJZVeuUllpr3*L<$Bw&Z&S?#ml<1K z`iNM?=734WXxXRrFSfB$RU_N+D^aY=J%9!DeCWg0H+zj=aQGz`e0CGY!(5>wQKqlHQC>yQ!21%8M@%JK=B0@lZ{tE^m~qaaVTlz?Gamg< z4_jD4+l73Fu}8;Ko2L*6>KRXA`wc$FHvowQWP)}d%dFF(oqYto7~Ci$h_EO;NPUg zIIznX3(4XJ9qxV(s3|h#G6k_E?x2^@u?=Qny^UOW0oy!-?Kf5d@9J+F=#6!?Z`kSA z<&LpN!y-7oKvxR4<9#h%Iut_#%Lxl$>-Tf-Z*`VG5jGEgNAi5hU2Wq`{_Ne*wCq(A zj1?Q<{%~;;|0d|S2HMfx2-jJKsfU#rbf||~t^W*cvloabpsi$&jkurd~spmz^w zWc6{@y{)WYujLKM%yXRM=)zWbeOUOFRAwl{_-9YTS0s;u8-rgg^BSy*7|f7M`jHK3 zFcQfORx3ElKpTUg0s=W;E$e>EyOXm3^3NGvGI$a!{_p^?)w)C>&&R~g8twHYKa?fM zWtepC2u(leVUDYbVUy;i)btpz?&2hRPltH|BGO~fK*?JWS4-Bz{@ekXp=^W0ip6n1 zvT`G}KVnGFC?Gq6^ia32yLx+l;bxGt`FjVv{71Q^t3xI2?PJo)l(X*A^Zd~6&IfewzHOka&;!A6(LtFw8x%5uLGk6&@wFsg!uKYb zfpTFLA>@Uf&4S9OpVfEIG08^zgr|x$EzU^CT(vOMB`~xLvg_Ql6a`(`f%oO-eAbWec;ic0`8w7(-u62S z0hNxu)+b3B_UN7FJbpJ|MOkYxbajw4OO>O*4Mzy$d%>h5o( z{4C(P)W3XRL`V;;$_mEjU*&j;<(1ZYu$`6Q?asFFHNHf1Y0Ac?J~UI(-n4-|;55wW zSUW#)f(^~tL8W|-o_#ypGVvVR~q_zJ6)al1>LXRdpc#O z;0MY<80H%F`hNP}gV+>)5l2t#6Jx*|@evya24I~!`3~M-c@+pS-Z~2x=-=?l5H*JJ z6O#er;~TRbnkWd%jv(7V4w?`9Fes3ery@&xZNpMzw~4v3gi#C+y6I%bKDwfWQ9j4f zbw3%;+Au(p{hq;mZr{!tnpo@{O;1t~*e49z{cQD#QR}>~URZB*d&879tk}$&SJB~GgCV|W zd@PhsN1kBBbbbC;%z2xgCsGwgp7#w_X=ffrK@U{{NzS1H3w1k2<O*EqYN6(21iewZU0&{a$b8soW(8~!U zE*5+DD9$q!-Vkc<99R=h1q)@}x4m!i|4WlAaM_m;v6cG-_B-D=-w=d_bYtDk#(xZ1 zg^~xNah?&t7J!D}s;~BDo#)Pr??)BG&^n{njCTfJ9(>O7R1K;nWNz2^NJa0-A*hP! z?3X1>%y6h5MCFYe9>1rqDWAkhnN{m^6oX(5RE-Rm4$bAFHiJIXw4qz=w1yKQ@}7K! zOzdayzV?;gQak$yo9oDF29RzNjcazn;sHwTDk9|f?LsHS0N?O%Gu8(wOa{=6R>p9oAA$NPJkqzGt-A&VCE!;Cp*vOj`J@G26}z zA4z9-70-CwW;S^vgo%^Wn5Mkg!p;;2#=J$9RcMTqtC1p{uz}>{+VH>Cs@i1tt=k2R{^S z7n}DWS$#0Icit1uIF&cI=V$Njs;dnJo`#nM_f8F&6aLcuw6HBvZaLd)m!OA+Q%!sE<+&;k_QJ{;RA26Zv{eP^|4qt#zz?`F`&>q#;DMRvtha$TM`i_ zWB?8=m4e8-?svCZ+rIZdGOZlYP3!#;joWg0yC%w@hEQVdmbI~iHEEs!UEanrs&u${+> zx^JEi$hv@m)P*`%bEzk`mgrr{0@(3eN#_=Pwi^c(iDk270oYPJGR}Y{q~w7mSlz!lJ}$b-pq9`hk0|m|hlz7-Q(6=Q-z)`jWE< zBD{MKD8BcIR$q=x@8lFyAgw=yKNF};D)Ek_YuHW zj^29%&2pD>o8CPk{tlKCN8v=am9y>r#e8BrNKBY3hGKE^cGh5xn< z2NkDTzk9RICdJ9o`v~a&FG?M^`$UpANK&Vv{QAj^Gc{+_#i7`wr(m1*wS?b;_T4e| zt)I@k6PSZCI-Myimnj(;>nwgOev);H@~niOM%o4GmFIJt69r(q=0>fEQQA9MV!Ye) z(FEd$Z?)Ee5`)bDfVe$@5b-5q!cU;`1`BlS?Z@AL(7J3U!DY{Tf6w;wubYEv>M9!o zV*QPeKs31fUCit4(HgXZ$bTy+W0oFZ&f?3!v7!#XsJ^*EY6a>On|S^tpbPu{WC?W^ zS{C1+8?lI2D9AC~S9F7`Q(ZM^TU^#mb#2=Y4LM?!h76)lyU(h342bJkgyJ+<%r{=& zm09-A9?0fpG9;D_2V`yJSi{El2XX+W8DtpH-bl5lu_nV~(zbiD0e`TaTO%&Ig1RU0%N9 zT%r?1hJI}=K1t~hg{^*W%hz8m7|)|`thxJa&cGZ3u`3iu)!3Uy=c2db7jO{cOg3?M zYR!jYj;}E_nUiXb#;^m|DJhUXPSyG7B452=vx!E7Y)^8o zcPZSIoqQ*I`AJ9khGmB6*3aZs+7+w(%tI^(Wrs;N4%pD!z@&sY%8-g+PRwIA}YQy7MhuC4mLWa+$5!0h{r zg(akMEwpQHo997^1*7RE$oT82?;)@mn0QC*K^!aTWAFe;M5{0N2xHK}NepZg_4@Lk znzCZ-wlkjB$r4OL6`#!Y1Q{S*wt9PIF_<)F$s3SADIyP%0kb*WI^LGvw?9T^ z-vDo+?A;yHvlUolmW@{`sQTfN_D` zj06CGqsJz>0vX^%13dRdd>MMlPGA$pzX4in-1lw}5@+H$es&$t4gszD8q)_9kyQs- z;W$v&(EHrZtxF*Bl8uQNP;ECxy6%S+tSx1zsCkJ19;V}UKw@#GcPjynKJOMc{lM6O z9&60=d27cvRlfw!Jo=Fb7yo4Fw|osQb&D&y8s~n?HG{m3jgk@{NbA@%+1#JGQ5N2b z`HCkshVxNi1}d_nUM`Ie<8Asb-VOO)N=u_9#TI}btDETcscBSymy#Ys?^qF}1d`Iw z$yXmT^VI7T1?0MeA_FG&9mLQ#rP9HfGNe-jD}*0G&x0pf?m6e;hx@GFZxV8p;0-3g zzMbNt{64JZXC2;-VeCFzlBh}i8{AzsSP$gJ-TT;x>=U+DlO@#@xW-;!&`C7@7E4VB z(xX{S%Nf)6^Tig#R-644wtu}=`Q_I7U>uFY*t{=#1$%FUV+)H%=qYk0f}1uu2kicp z?JH>tT`qIah~fnzzJV7%YXn%Mih%@g%Ts9oUvuBhKP@T#%}*v=pQYeKNU(M~g-&Gz zOZocV&v@_VhM;B!f2sjwYci7|;2!h?m?s+x*(sXVc-AaQ-N{Kf4nMa~B{zhRkPs+& z=l7R%1YG!y&zQy-kOd$(jDA(l4F6)h=SRwLlyD8dTH4s=mtEfXMXvZ_XYDlWetYZt zx*6U-N>JoIY~2b@^QZb00Va(BTt3;%;j?e^Z+h!Y7_ob^0`7aY^xoIq9X1hDafT)U zfw23YRn8AI@>ewr8y0UPS=)ZZRlX$D+c5bU>fP^Kh}lrG(-q}945E(LdkQ~?G!}?D zKj{)vL&X9Axd0|Th4nAV2)8YtemrpkNbV!1{Ok=H)bCM<~bBp-2U=KEq)$Ke>>%^$~k~tp(f!p!C};&a#EseMs~b(9Oe; zQP8b9ougF@&~yB={ka3ab3yd$n~;ekVtiMSSKcEN%==RbbmoT31@p=<`i(w|Vr9%? zt35#&>7GcDU8f^mLXlaLaRK)0;?J7OKV58h2+%Aj|C;0|7o6Q%E};(P3Y{Z;Synw-jc9kKV`yb~9oa{8O~^Ka#q# zeqr?mkT&1B9j(b@tyOnGg($*Jk1g_}=6W3q*yC+EGhXz4`b7ESQ%Z%&LLD%= zw;%-42KDG%IAPs|V)WK{4ah}{M=cuXJD^AT+ay+?>$Qqc|NcZstqFp!U!8diJXmFw z2PBdSD6B{!l3+-@eP-=DE`hphqmMb`vc-m?jzY2h6q|5mHpocO)Ty!k!;KQML?p+j zdBpEfAV^-o?3^8NZT~pd0;((f+N*)?3MX6#@MU>?*urs{^o(4(FYw#pdk|DtMB#ze zF(kei`DA?=eqhKx58Xzxg3SPC5fJ9~7+^1z&k}ZEB>`D#M4DrV8{{GSfif}epoRl~ zqT>Yj9g@)4G&t!8U5GSt;t+XU^56C&<^~TFM*sJ{lw{TrMc%w4RmxK1debq^4%xLQ z#>s@jRN&v1A)B`gqg1Q0947c&3EtFxnbKC>9QQ5MtZWNlFg5R`HYH|H@~L$VJzv0& zWuyL39D&-{zoJP;Y>LhStPeH1#H1d zxW8j;14P`ENOxVU-=mGSLJravT7Lr#vIi+d0R&=PWO<~3>8EjPWcKA&$UFJsv}H)A z4LK8f9=1?@9q@kmCCKkNd)zc9u4aKo-b7kTdt-o-0zooqz1SxNbKbIuCH{hb0;_>A zhUgf!K0l>4kBxEvLYs=RCcbnlnO9EmCQjEjx&2@BiFj=G*&rGFIBe!71{fk^5a66l zH@$-_b(}y4Q*R+E)~ASW7DVNI9|91H`NxA6+qVYMRL-PZS&E!C2bQHo0KhJvw?^2_ z7xPm&Tdv&kaVGg#^K-y{DaV5RSm}CH1!_{OLc*kBK0efud>4fxsa81T`>}^@^ zJi-z>KLZn!)z23o_UW2l{~-xs>bZ|kvEE46VxR;}cNqMV4*GQ{fpdUAKLr%|Lo{{} zzL-wj77gmC5~Byx4Y4~-+O(J;1;=LIlNO0BgwUVQXKlc01_Hjw^GQ?J2`nj&FPS|z zaJNGB-Kp9c6zeFQ(b_J=W(b{7c+g&d8(D%G5OI8|I=zoWs1AfNQ{gWoYZNou{P1D6 zo4*d~BMG@bbNT9k5ZAiW*|U&~@*KBV0g)wcu*g^rlfQEhs z&qH+Tp+1NkA((E@*!mh$h4CR~nN6hMZu)S7e_qPL!)gSH4c;xj1rqh1E__I3-|D+HZiS~5E~%n>%*NF>a3p2kCoe>p=l0+aJOptOuAj9}w666n3OBb3U@M>QsZbL7-0G z#3~IQ3+LsvixuWIn#0*B4-gfs4>#&uL>0S<8~$AiVy+0$B3sf4iNn(N#c?xKXTe16 zd9uZdHF@jFhkPS*Q?R_ z4xo@DEHGuv;}5bsj)%0``0fJfHksDUVCFXtq^$xT@gjOVMftPyuH09N`TcDF{g4@F z-A5-d(wKxa9y%S!-Y(gX2pQ#$E(Gb+`vQoQ{rmwp(Z@r%Oj7Xp?zl!0P@V_3hNvKE zdmy?(NO%hSIibyG!>r_hZViI}twRX+JB>x^SdsK{Ljl&> zH*xy|{)pG1be=6Z*>~na#7$R#N?4G&CMrB^+PHM*Bs81f+9PjKVag2oW)$t#yEa+i zohcA&kI2RXjHDCh7!Ay3_%qJO_uWgrI1|bQeAJ}Lv8j0@Fs<`@K?359EP==GaxDZs z+L=~^mArt$*X^YRj*)#dh>p|7tn-ay4zNX3Fj$3)boiD2oSg9H2ou-080wZzrtq}X zb%qtCh)CN>$n&^lMVv8PtM4?x2-G8{tjRIF336YsssqbuKS?CWxMwxO(i=8|W5*yC zZ`&J*cYC9tw+fpTZpt~gFJY+y&|A@d0T6_2&-9TM@||qpC+OpR)dRNq1l;i0kFZQf zb>xE_NCpohhs*s#nu{#4w6hZJL~h-QXQ>pco4y$jK`Sj`mKzXugS#h&pAeV4+U)(VvdM_ zgM>qtV>LuSP%ja`quPb%I0B z8%EHmfw>^oZAM#do7}?)yuXcL4^1`Z;`uQ~TSY!XRRHink7do6a~RIg{k8{Fql=+H z@Hxh9{n+22V#|GJ^^%rfUchd`9%n1k^tXn7ez$H=paGg3HwFZKex`Kr9#jZ8H86vC zNo(YV-Dn=ruRvCQI2w;&ZQxTnw5DzIgy{Q4ULmT8PvmRHZ}pz&qg^pHdIe4}JJP4V zM~pWSK{jd=_@U*sMqQIhfSI)~Ja7-ID>23-?jAX&7AwFecdm9Bt=($_`16+^0a$Co zGrSD%7Bdv)6Bzz@2vRp*`Uxna6N+`o0-p zZZtAUL?d&;cM7)uF~4~Az99d$b~X_J7=v?=I6_iZlI1uK zvMXkBe)%|`J8*=6z&UyR6}YSZ*$q&2%pUU`=!^25F?SK#@yN;kF!b4Gz~X*_QV-oO z-4_+~f<`d&qC0^A@!lmO;zTaG`8{!F2875@I>jZ$o3b943XRoajh^&;-8WRD=qQbZ zvYbK&moWt-`);pZyI~?apE>L^GpYdT?sQoUFrN4N&~~r-Jhg}eYX0q5KamMK@4F@q z(2zS@$s)-hnVBIJj(g7fmn$=CDGI!<3k$`p{D@{e-+#aZf4wKMJCAeKGf#wye{1*+JoSxdkMM1MFBgrxSM&ILX?=~+-YFF+Edd)p& zlI5{J78lUh-PeFL1fAHnzRqZ;Icq5<<4Osj;KVea zjmFtV*413{rE8=5JnR?adPDcZQp?{X5b#6 z;MRy;q>G+LY6F$UXFLD=5&S%8p8DqlCug`^02BbH!MB7N$Qr@8UOz|cq)+JgkR}I$ z3KdWOVw8)8A|n4FhSeWIA?0WJd9iU3$p$ao=3(#o?X3R*f1$>5CKeE$Id~8MmlUT! zv<#~8j3J_}-90`ykYiwCGurW-^t0_bxzKNCpMkU>zJv|K5IPp) ztSK$N$B_ZhA=x3Ho%_i{&RDQ7YIsOt+6*iy5ugsB4!-`3i8bFSbkCn6F>CJ&#~zr{ zfl(b5@pO>%pat7yUjp(r@y0$;D1EF?P7(+}hEGD<;Cdq3fDq0;?2d8##T^Ov>?39= zB0BQl*_{0d+ViueZp0vh!3Q?wLzPMT7=vu0ui$e(%q6nGIIDF3kWqht?>MzkAUu>M z%)$t8BzSAmkTwq)uASKvk2&v-hK zi4DHfwpiLD2eY5p5G>Q3z;+q*BCsrio!MUUJu|4#+7~BEPWwU$`vd)r#ri_rnH_yA zA&oxyhy3#uukVx8%r7}nP@LYGO>iFgCJ<<^^SzX~P2?VwU?ez!DQ>a$jzs~VUur#| zlD?>iJ6}8`HRSH_({WW1ML@PMBu@rECr7Z@qYLUObslI$nY=;ai22fDKZd_H6gV4eK9yvy`Ibp)Qn) z*Xvb;xRZn`r@ekl8=n2|vR;Q2W=vtO9V6-H*=hpN5=DR#19=Y&{avJ*;+4^P05r*dr6462mImsDa5ApFg86ypcph%q6;{hnZz{tjT_uXa0 zM@a8fjDk2*02V0ChdEp0*V_JyHepKWU%*mQukRj>(uMX&-)sk(d{*f0c(U<@V$AC7 z?%(@z>AvX<;7@9VhdRvENc;XCN9ymj9twK4`n9fus?!NaOEOtZ3s(9FGUhzHG zaoV@@1C2X~%l+a~P1wm9gKfCh3n2@>KBsMBhO&|8+g?){Zoh)Nq8va(LP9^`~F4YmmSz9~z9v0hwr_(0G(>|W<{O4;7N6~i2< zZ9ABCn?1h|PS`?W{WY_^K9|%J(Z-Y}$4od>dq5{7_*OL^xpTvxjTnQtKnt`)U%Jk0 z&lDUC6{E)bNVIOJFVvXyp5)N1cq~du5WYtsK@nt`I!+V+07sxq-j|iO2XP?^QIH;v zq;(L|6k)5{5dZ{Rpq78e)@omrN*F$omC(;VVHrt~4*{Fd>9~KTnA^(i%JE3vw+bcz zlx%xl@tU+JiRR6lhNAxx&&2{Mq>nU-0 zeaZZ0YYDmo$0hVhk*SlPQ|pURX+dD``9_P$EttuvE?_-)y=Bi?wcfkVL>voOy#GQ(@Joz*#o zttQJBEXIJtNb*C=s%%sVk2|yPC*OQw5&QYH9t+AwoL3jP*fJ19ye{}9K$0h^_W zkDzp$kc#{p^u#0|)?YvHE&Cx)L*8+3W<<$aE9t!rvM{kT#p63z*7y}skC6`(YPE0;LZ+-(%c-xyBNq~K`ru#`g zvyDMgwSGa4u?GXgZGFTSFZ3UC=awYN4P(nK5dMkZ!xDS7IXFF1AtG2chiW;=*082o$zoTl?i|^odMl7hs5m_xa zmf%_ua$6y9F@&3*H8kD@AZ(82??CB20FMvi+HI$Us^N}RmYiE*1WrSmN_3?*2JS(~ za7={SHJUPBvmNK|dh#G!h8dlW)*@XbuXBw@xg?mO2Nas_rGwS)S&Oci=K<9Y5OS&s z5b9`TJQuYfdQGBS6_VO3RW4f}8W5$O37+w85dm4w2- z1e5LDylZD`Jm;DtI4*r?Cc(DblM%P`N zL=}zm{MnmM>;)bDA&Er;Wu`psA zt3#9o#1($%z7PodTE1SBu&&m7zuc-7^--C4XQS&{>kYJ?vJn>xFbeH`$_$u8oqij8 zDzTwWbvEr~2Nq#N+}D>E)2&7n)c|x|>9lMIDO!S2ne~Go0I2Ru3XGme7GC`wEczMH zLz88#O)bk%j=^2!YNhvHW!oGk7n);#3@sXRHMUPD{&@}4#U$O$5XIDxBI(RWJa;Fp-^w69 zVRA-zCvY{{mvu_6lT1(qW4ZD0ACOv1s}&H$;`S{7-!!^J-sKpe`pWelS)+XA-| z!&H+#wvt!kOBN8An1M9%%r@sLH8wxZrLZ6oQ&(@F&-Q~|-Z zf~BkajYAlRbza_fi1-bF`81Qc5HL-DY^-;=Kj5b^J?d(Zn0RejfeI`NL|vzvijT8+ zevqdi|9goH+x0aOrsSddaM_r3T7Ii=b+|@6^~t_Es!{M0N4c70krQ2F==&+uJNuc8 z-L_C9*=@kE=1k1Saj|s+)XuguPdFNvEwOT?JEgOopzB!Ouw`i!d#S>|;Ad+#X@dFX zg1t!;2W)Gqj}hMNA*qR?Q)(&0S$-XgKinW!D(OOAE{-QTi8Xd--v7|Plll##bw<0o ztDcWonRDWs}OagHK8|i8|Q}o7z>X=L4OgcG7Hoi9P=o47;ls{$5O|A z&|9zg4XXEAa~#N_oTzUWUS~(o=~g%gXn+>Hj?qbveAZ8joL%}<9HAtNeeSs!DxUT^ z34=b>rQdi#qS{Ih73ELpD>wM@y1xrQIZCkt}$`wv>M4cIBAEsYH73 z?;TN`n?kOve&(EoHBb^VeYRhIZ>+_-fCQGY^c+YnWNv2DX@KV#ae>yVK+Z1<-O?A7 z3>V$BDb06>>(^acP&j!}-7Lo+nEM1tP>SJ%br^U*De_#Xa9SVxz$~>4bRuM`l`AAA zpEA|SR<*mzs{6s9Du?D>SsUNFbb2f843??|n;EqOYlTLZKppDuDuYs1xQuc7(9y8A zikQav@O+F;}=3}5(1>h@@UF9wIswDcCC;i2ltd4YHC z(_lqq)H>hv)l0I$(mM#SwnIY&Jr!p_B$dQvct4(oMyO5rMKE_AFzHyBkT^nSl&l@S z$C1cG>WmT0u#LMG*~kPjjTX7`Vj)*dI)^tUlzhUpve;;`i=JRCTJggZJFc(#?x>cP zVa`6DfGx(*x5``4l++~J*$%e&7L_LkdIzN)ls~STP+4r$*-q?L5@-`gga_Khw&{$* zubcaW0F`N#5Cfp5I+~z*V{1@Y`oON_;DjFXh^)jaW&!zf99wI!yhKCbdpeH$C>Uug zW8DF44xVVm47J9~xG8*7dYOaXVLDCc=*Lxo2M#zK05R?)*d(-9Aa5EQ(Gpuro2tX% z7d1}d=ax<%Qv!`MPySxQS=Q=E3|tK?!;SIKwEflin9R<%7IcQYZU&QA73MSpPJlwvTdb7I_8noH6R!)X!2=enXJMs{VTyoa8T!~= zYmxdi+(N;LeU(mrt@20Sk-MceM!K~GBj@D8z;59c);Uzp3(vs~u zE9bt1E_G4ME>=?w&1#;m?NO`9qw(*m>vi34g0>uI`AR5RYxCHsL`w%}53n$txs!=% zafEzukk*XGEPD8y9Xs3tl3B{uFj7g8r$R;m7pFii>3|P?6Sqah-8n1R9lR7c(6!TT zEgP#Ia^;m8PtJtkLdc;%jSvN;qbC~8x!notMMEZW)!S&m0IY_wgQlcF(7oQ(h@TZ1 zw4Z6PzGxMzBEiPxL6453N*8JohuItc2>va%B13113^@*w=tIHqV7BJ19!RD8E-Q$B z5J%vYaF;1)^t!#MVePW-tP>j0;#HTw(V@G%$m!9nvmOkF?IIDa2&#&S-#cX^j3-vZ zM_dj-fVog1m{Rvr?$*i435@~KI5KgCl38O63-!2MvpxoI!uu$iEPY=&p)rAIN@;Ee zmtsXw=J$XvxhM=W08`;ASgn&T+}EZhqL$S`R5gJ8JPS017?)K-#q@hPtH-!Ry0wn& zab-i?2f!Nr-KQP`VtxZ^ff+R$E~GNw+7*H;|H1lpEJ0`zmaRoSaZjEG^@eMbq9il7`+ zHul?!i?sTY&Df(MxLze5Y^AhlA-XA+w=&zVJM~F*4bVn=o=AMmZ}PVMUcA{+?U@s( zJ3_$N)KmF3PR&=OYph~oC3T*Xcg}fzGfd~rD^onqyh?K~K?rSj6>`|gLocel+;cYD zgC8a-2bF`yIm!PH^8hz}AI&asIV0-00d5JMAT8g@F#SxsSF-HEH-&)Rd>5)gmelC% zNt0@dD+Cp3r-U^NinE0Xc0&H^#jLNouOmL>GdIydj80hU1-q54~BDo}E?HohR__%Jd&X^5QSVbAofGxsky34m4$r?7Vy?a*IAR9o{ zgaP@cG*dao_<}q$loygAItS2N&$D!nM@zAB@P3^19H`ZbT7_@k4o4!|WMNs)us#~| zbfAI=Me|7=CnZtssRf<*)~*W&T?J>&wvoD;Tu={p?0tW5XwFw96HO_o>tLS1{(YseKeAuo-*O@}0 z(E7I0Y)#c4$u9uGKzUiv$a&wT_bbe+=~)IlpFRji_XSx#C`Dkza%e3ulMyfusP34k zK>seS#Dlr%NSk;|z#u@AmA*+C5S-jD)=$-Vr=~F%g(`cPA3?rzsKt?!&*3NznxISM>Sh+%; zN_b>?5lpL)^6R?|H%zXnh9kvp&6Ffm7`34>Ll^GqXuXZ`hst@NEPk6k7kcR(} zSjx-eo5aZtU;6zaz#xyaA^Xf#%Px27M(n%hz2q@s@u)c0*QG$-*;sV305DhW&Y6Et z$NxVQUq*|klAHX(*#&zCg^4Bi2K1ncAmG}yHEtvK*tYc;+b4!|jG5jW_4YZ_OI}~( z8d`JopcuH{nfwN(vC^d+)qWvs#Jn?Kw95MB9Wjr95-k+-81L;;a`KQNpB%K?IjHgJ z0{qgAX0m!FQ&j7{W?P*_eNLF<+>nHPGjoFt5^y2A%5fUTkj4}TX-9b|xv5@(-|!p9 zShaV&r52PZyi)6|eY0AJR@qKoI};QL%pbzYhm$?2Gu=vA_=w$w#&O4aMq`6sThI)c zLfq;yIpxE%ctE`$_#?#5f~leKwtXTjtP{MBtY;llkGC;IU^noU7&N*V^U!5V;@Hb;_{=}8OFce`9;_gr>BFszp@oMNd#b~zjna_Dw{#TFpc1Id)VE4R`1QCzLE96ZBKf)KG)8qZOjU7e0U^Yh1oKS%C|!w@?xs!mOSq zUgi?n8}#61@!pjA;tMkyuIPeMY#GQ8+(@^QZ-?BV9VY|vr*5x?hj`(z2?r>cjD5!@ zdc_(Pp|_$PkzTOWc6h$fbD#9%ecn5a+PdX+Wm?2&Z%CQ#&dj06_AWnMMh)6d1pwSY z>7{nw{J9c1bO^+9fO&W|Uu%M?_?_M!+{5c+*ixy?0szO{k^#vX%|4p~efBG$SlUM|bAjc4nrjDC+c*0qb)k@Kv% za;E^B!|Hi*mbafh50HbQ1fdQLCw0GPTOG}6NRiX3p+Y-Vh4oAus)5L;HrAiJ;4&1- zWI(Q9B%d$-HQ3K{A>+y>ujQztY)@&f`~^5~qSGxeX2*VI(A|-SzU9XBY2T$4V@G9; zVjrI!y>(Btoaf?mH@d|D?KsiD|H6eRf&Z6bV~Z z>jy~pF8lVgbnZ?H08~Gb=YUv)7eCqelwBUEiQ`9im0k9+i1qzh2dW*6#Z+U7et>t+E^sFNcpvFMdOL>eK*eTXBJ{^ zi`vcdpkY?)sP#VZ9T%SOHgygcr&$L8YG&^hn3BzsY-)*ka?!1u^@K(Qx=X7_99lFb zqOc!HGSFvF8ysLrg00QCXkKTWe=2>VHTd|Gl8ejk;mw+!jcn1y)B}S9GnP{lYDVgC zO^yy5;XPaB;-?pF2SOot2NFD7GauMx%koiS!vo97$)&DEDcHZ`YywM$Hm>?SBqpsa zd-DZOX}+zLq}JVe__=W=Sk<>uAW{C8tA5nZY{b;zzVZJm_v6Ldop1)GIe~ZpGWg*) zYEtT@_Bki3F;OVBvMZzmXYu*CEJWLm5odsY0!o?seH*=VJZpY)Y+?=ZcBBDfgzK9v z)5f#qmVA2WS$22&8CZh2cO#_&_+@NJrhz&xquCd(0eg~JPOb8$l%SLWYWCZ%z$Q|$fo-O=uCy28}VGSc!Udnhx zg`yF4E;7jT}*=U+vE>2Ki@PLci;GV#Fu*}nVo2n0HWT{sR zBEVhbYh`RUKmpP{KqmJydviviF&1z8SvCR4ffM>&WpE|Dh}a;wY~saAp=&R&$JbB{ zIWP@pn;}ArauDAFK1&o4mh!t<ag6lEloix@3Y4^ox?s$Ee-qvP`-U~`5QWgAqX*^pV4KG<)j_hcJuK912 z`o4wtEpTKKW=8DO=#MOze)A}Ve10CCy%Hu)6C?+-PW}MTL)RYVbj=Aehek*5yG4Zp zKyznDsdzZ}3356ToFx%SzJ@W1@m1gmdZWXWl~+4MY*_2UiC6pWe%m&d z>PXPbQ=~b-VHW$R&=yMtU`QE+A60=NG$Xra+c}R{<1);?zD$DeWy0uxDGqo~+&niI z4xsj%)Czx+GuPYr7{H+z1p!3F`@Jc2oB#sxYARSuAL>{!jNJ{ z9}un}*?zd75f2Tc!=H+T44M;N7@O-Vv%AgW5CrLPp|Y+ZYytf4R(LX9!WD~ILKZ5Q zSuHEH!kwu#&Vip-h7I*j8Fy*tM2q~>TF^qA^*x&A(E?lbJUd)cxq!zx_+$cn;zWQ5 zZx!b&TQ<4Rz4dyWn>6}8`Pg%R_O&c{9YqdBFa}}&=#eQ1M394Vnw5N?+8Uu}kg4RB1vDpvyu(*7(??p)$Nk6_UuU zcT~^~3si_gtF(mtBc(rMYjhcLl^ybhE~7mgzshxq&N25cYv-0i7Fxa9`+B8OYT9IS zDxH94PBN?w1U)6d1>DP33~MjtGVwNNn?TGN==Sr{Bl${8(WT;%m5Y@V6z*smUh7`O z)*DBrBVG{JLd!rqy2f?JJs^xRr*%RGbB2%%nd=}a1C-LdxJwD1K~?%StY0*4hua%^ z=*QxijqLEe&f8-UAsV`W5$RXFSXLkbrapcU7r#>6rzm zICmH+r*trld-MB(-!BU)GdD&=^SEfv`%28)4^KR=DZ#*!2AS)#bmn<-qs5ZDBPi^< z@#${5FIC!Nr+VZ3oYoe&3+P@P+~khiNEX8bIZsaxb>faxcJIVh2a_}>3cFi3%)w|{ z*P0ttsZbhvrKJ=edvRzJ5y54h(rTB1p#LyCk5y-;oyZHvFKN97( z&0nb0KuDq7IR#5hOoAkrbj!L0xPx80ME%}*0sr&9atbkHYllI`TU{06p7sWur2;Ec z{zrg!dz6Kpb8;2rl}2iwD}4%dJrbFHrBZnvAon%%&tTRFYx zp!x-!hK!HRcE^r3p2(ww5u)WqKRLYjih{}E!*2rfgI+HjhgUwstPvLu|4Zx^G19rPb@IIfyZ0LMw ze~eX9Y@aH!Dp_)5Grj_UUBje<+lKf0EaWqlx)e0(s%7B64#l;N-X1>Q=3Zqa&t7AQ zmmKk{L9DbAbF9X-an!K6NP92W4W4Y}-L3JPoKYFL90l>wpd@bSOs5qk`|7+^`8$(` zw5&o)=7_C|phQSrO92m~@s6+00fG3g7Dcpfr45Hi%QjX=O05-8!GS0S9)ry;`Fo5K zh1rqUN_D*sMj(cEn>+${ATqO5m2TrduS@z99$+F@WdisXLpU1><_MSR$#c`^R%Ry^ zW5l=&L5DMt+~j zXPYneX-v}*FRw$8#H3Ys?uafp{BFQK%;gMmD6OEdpUf*phrEd&vb?t>x2v*uxg-0j z_{OEVjFv>U-o+oyVZV!D3r0ICc^uqwpVmq3(DD{CSNMY7rDz(vet5g1Y*g+fZ-DC)do^W69X zW+PrpPT0M3nf3yxXUbU8rvt?R$V8WHmKQ0^*MF~vZ}EYLMG^3bUdfo1q+*oeMh$hL z)1Lg!UdQ#B6QG)M*uf>KayV>WoMn8=G}s|+_cvs$EI2)D<~nyyuJEYP*6wA{4{uZP z^p%4IY1YoCqD%tpD2kmM=w7{E#sW@gVLSk@yd_%MaCEm)M`*_>A&GOvL2608&h1)y z99pdx3&Nlf51UN+u}H;-T}N+LC3C&%Ov69B3LSZT6@ay>5Fb8su#$xDH(%b-l7-XA zO_-U3FJXwwnR!mHh8p8gfxDyg>?vh0DyEtp1TKp-Mgm}|=q$dU^0?=+G=+89&LPHP z)UA)h8#&xZxzzb6^3X6r2&us3AMezRS)J=6<7Zo)lIgh#JZaFqJ`5sdlc7uPyRsg|Qqr0PdsSYQvn^D#(qENsM26q?yPDQ^M|+$+IZ-m~FPcQRoY zzMb~cqVqQE+mc76kTD#&S_a4GvooxXLEsV?HqGcNqfNVvY$odfo+Z#(#^|>U-_;($ ztZ}80Ru+fAHs#?#mbXJ!ib*VQAU)7F zXmrj|qVrb9)s=bxp{{|CrZqonaj!2MVql~5hz(#iPP}<8y<3X}fj+N4VFisv!{UI*lBR0JvvhEZba88#Hr+P2SszJ6X-3!ZoK83}p6zOD;*vH^xV)i<8>w$}ju28A5 z^0bN?J|B*0Bfi#Co{v*D9X;I4H4&b_1zt(f@xV+V9{4&3cnlJ0ipLRvKB*4&4C8u- zod=SmH)6jJ2eK-aAmHiDA9`mx%|U%F#Z?+_xSJCvB8d0K|6CMKa_xx;7(UCri0*lv zyd<$VVD}IhxzQ(MA!qMx6k7#hVsDDk>FnpBgGTc%5tZac#^gRtT4)!8z+$idUoKc? zdfc5Ybz9*ik!e^v{>okhr-(B%NBPNN>+V%z)cxi|e2G>H$)`neAq~FxTLzFpzc-b= zjPX`z1cZ}fI=Jl026XO+6?gs(=FYc~YC4CSyXhAbeNGy(vwSF1Y(TD;kjg6l{|$vju%W6iq|!B&-l;i5ZLViIpVz zsUV<4WVITU^0h9k;!uEd7K7{k6LgQUW~&nfDRc-W==KslgCHU5t3{-jC(ms3h`Vgod!fw|P(KFP=3GD%10FKe zIvqHdTt<(0I*xbVT|9Xvg{nz$*1r))%~RMzN@Eu(fas0dy)uIB7XZMDdyG_D69Nin zM1?`oA){KgVu-$wvLomjlySP=ZhXKdW*nKeNFUVecaX0p9@$Ad?R>}AS;Nz*k#8P2 z1W4dL11;|$6Pw&fI#)CdXrk@)e3Uej@+j!Xf+vQCGNrSs>YYfsZf58WSrqA<^;rj@^viy1Wam_u?0cOg(q z*>&8gtv~%L_tmY>IbLbyR$*jyaI0r3gvVbgN~pYn|;t-sp~)u#hJ;$Wd5?Nr$wl6>&V zrFO&+gX+S$Z9eiy3+#P7qvocPe_P@H8RZnTF7%mri8)Y1lwzlF7&tqCK}$8e9O7?3 zw4)8}oCGXU)q-mPm8oM!QPdP(s3 zhfC4M#{M>Eq7vH3^^RS+m$=x!KM>zG%m< zg)L?GJKte`whN$ojbYN{4U~B_85ymr6tobkW2{uswGY)lT&rxGw=Fv~6D!GvQ-Vcq z`r5BgiL&ZNZ(NA3U=Sl|PAH2FY1F%s12I7LP=K!cRzcD%J?@y(B1-3v&(jq##voY{ z{H?;*!D&5v*vw2s9qkx6mrfUs$jc*=9C}?WT>5IeG`=2vvcn?u^*9;9-z*l}7`DjQ z*~p%FvA#WfS}yRbXQLtM>p6bmi|^HO-ZKEWEHGxe$tW}0%d2lzQ0%OYC4`Kj!Bgtc z$3Htwz9!_RqE3X5o64U1a<_nI+7SC1`Br6}W+PWoP?W6S>7B5)pzOI4UJ}c)AXcVn zNhFPZNL9HGFIuAXabP(x%?5jluZB=Qmp` zmsdZ#n;@-BcTL!JUL*vh6We`zvmL#R-0CHM!&}>N2jexaX7el$FJ7UsKtW~y%A0Rt z&!Ey8!O?tRv$)F`<@BsH7Mwan?HhLfJ%TL*?e=}wU@=JIo3zS>oMOl|?xg?umH|HE z8lS$P(5U-X#eW5%Z?b0b3T;%Q$2Li^gj0 zOqY9w%SI>X@^a%c3sK%D{$f!Ueb3h^FLm<_LOl(NCPfN30PnYKa`LcXrjrvhQrb}X zw@fkM5HB!#u!#mi$i&gh(4d@= zDF=4SHCN6lU@;1;7WnJ)7Abp9W>e6WJM%$2d}f9v;##~eM#fVEH9XrSkShsa1_?)p z%y+Y<7<~czI)!rHFZA{)zaa-*?Vh2t06rOXglLO?pM@WoLBBd^Rcgq6>Iz5^xfX$Z!pDRBLn#(`xAuB3 z0Ztp-8ktPeWp>&lbUX~(D82?bQq{`bAn=MN(Kxk&O0SYo(KzKYiTFJCIe=s|(dN$i z-F0r{bo~H`r}Pu6;ZrD_zaT`7F6=LOdso^E@OncK`0eWm^EMS_7GwJXIZy>yR$uW;%!vbfdSfep7A5d!wkK?fNqdhx01Wo2Mgx zF$xUy$yXDI9U4-@rlnb)$b;)iArRws@atH-fMi>>lb$KS6{(~0$zL{jGjn~PwM=H- z6s%9XCzM(oDi{cXr1jYM3pXYP4%1S3w{F9ws*pESYb)R7e)Is-1S(UUj~0%^b;2OG zjl+DUL!x7>XcJ2IBwxY?hpe)eN&ud`A*+!k^t5(`-${5H&`axQZ(s%3U~Y1mBo>cB z^L;5>BM(LR7UIk3i~xE%K^~fSGw(6qj^w0nqN4Va`faLBf#zN&;c}kedfSS*5pfu4 z6#D7qOav5BiFWX*+SZeGcEPY1kA%E9E8hL^DQuBecAnW6U3WXQAVKHTY~-tE2b1*c z4yaMj<$=G+b;$*s#`Dyi5%?INBaJ}xs1wYpA$w`HS5k$_?cov9>v`v9Hr%)|W{zj) z;249KuJGdv8ecM*Afzxqev&+i+d!$6>$m2!xp48J0IPJy3-dQyYd%pTvG&v5UJP+g zPl9>*L>}ZH@fDa}SX|hLjK^9#cn29l8~v-u$b!f|Uj#%PD*qI8*~^V5=d8!h&RNJ5m(0H()At)?AM zBoxz4fW9>rCIh`hA(KF40=t$oUUBSw(lD0s7?pr6bG2#|$Kr}t<5S^9Ua6G+3ncGT zPcmjTm#jEzH)jM2K>a8W!U1%%Ha1dZ(B~e5a}LqYTjqai`lh6?38J2fj8YjA0<>*? zR^pHi29mco`gA1GFO&jr8o|fyNhJ%Mnst}twLE0%B8fP;utA@1y&=e^V4PBLP?iRi zdnCZjySOH}@RouO!a-`{GN(Ag(r>I$Nfx{><#_R4!DNNyz=Mee!pwo)pn`@;2!Dof z%OudkRb)8)qe9+R;7T=R;zpC zSi4>r8S~f62mS9YtVvmh0d_3fNVV2+rty{{6Mr%{WR4Db8!%@P^;JIW+C7gWrC1Bo z^VtIGyJy9&v@ba|@kit*`&eou-!oYz%&>Qp!TCL3x20pXax5Amp=@|l!ozpOl zz=-Ksq5xn%m^AInumBTVHgZm9(%j<4cYDRHC1qC z!P)ifH-qL)9u!zG8!9gVny6!8 zw*Xm;?AnO|Mi8ZOY25O(rX)@SQexcsH;HHkCvu>jK$Jsn%5zt0QgixbPeS7`t($HX z24n6RO$H_bc;=|t7`e8>WscS&=le^D@l?XEbX&M37h?0khKkZ8f$6C)Eh@B+SsMyA z@1>-EEK6@+OJv_0@A*gfp0!MPU3N=fO6#At-Yh9gBroNnHeXR}G1H2p2a|fu7<|E& z@ApMILa4$3_^m`7cuQH6X&8O+%Pvok^Wz*mpraV~ZepZ_v>n5JKFazeuRBY`+#uWC=-9Y;2ARL)|4@iquzz@>!;^Dn6 z9J#=G#T4t!y>AqhFTXJGEyEX90MIokQD9Eq=MtQ);)i@DbhEYuLM<0EM9Y)6$t))u z!`2*SGy?aRa%nAOAcDv;0G5uL4jxzM&9_I{vrsX8&jkjuOwi)$Xifb1u5Qk(={gUL zj0479gSyrsP&a8aEC35u5y%TM&da}Lqeoybw(!^P7H1Rs?7paq-{#+) z7&A`RxCfcIhZ`y+r5|ErQ4Q0oywWf^x*MxGKkU;eb&;zhJ2+|~1=R;|Q>s~=xYnLw z&0aPUy2VYpKAR~SZB7Zg3U3)eT%FGBs>^L_m&Q7)W0j@bjLmywwlNRyP|iT8!RRL@ zOKE%OduzGwh>(L)C?$wQZz4ZsvwXgza2o-RVHXfV!`mM5E_4`H7bo7vs?kpgsPP9f zEMGY+KbJ5HOVnaujX=>x7M#0vHsp7!*Z%OHFrQLC_nr$y*Ym*SD9xjiTP0mX2HD>#|J7H0zp_2 zn0Lf3BSYxdt;Zbc$Cf1!)c%NP1f|$VZ0QG#4*)qmRbT#wQB5HWZv)i@pAAvNF2}EC z?JzMqxQ2_@S1PxTmQ}}l%F>kQG9U0^0SD~t*9U44FiMs4|2sIX$6t6jd0p8L7*kG) zBNyF0<|PleY)xMwo$O^S5&&}zhMZ%vM?CR%RmgnLk}~~;YtYXEuY&(E$UFSPiJtfrfO3u1sSFJ}326&c8xc?v@byrd+2d&okZ&;pYtfzB z*|K7nF$1w_*sJSKeOo*DEw5A})D;O`y{dPDqv?#b96<@rUvhtl7S5u~ZxHLsE$Pmn z=wdrjm{WA(7tBoYJ{EthmfD%8V?KDUn1+rQ0U96b>jF(M@8?<}9nthR5SpJyIeQ{vrW>HKXBJK~6;+QhbOT$EfX~7@2d*f$)#}`d!Q0fc zI_5e7jehm4I`-0h=LI3ub{`Y>p?m5(yp=0-HExFwtsDT^0%h5iya(IbTojzi?7byJkH#y89q@8gr>GHL zEkOY)s7)3dUFQa_K~k+>zCQIJs{7a?Y6asq$4_80EZ67VgSH`ivtAgxoV_6TJj&(5 z*LQn?WKC8zTB+8hden;T(a6q?!tQ<}{-j+Ulc#Nv$W4CNRgZ9ZB{Q5^eDMtRx;8sn zp)Jz+hY|+vG}b0l{FMF5j6`GB2wF(|G6Z=CcOb}WEC+fVBQfXC@iNYBFjDx_=?Yj` z7gjyliOUmu@M#_nQ%f4LKhpuOPD9j`dlNZy`69dyi z0e|wGr3&jV+oVf&Ag`>} zLZr)mn4rq7@&fa#+mVzAYAk+1^!*vAk|34#Fx_rX2QqBqVOaVg-(CYxny%QiItCUD z+LL`1kQAqtO6NQX)A=EmeAZ-H;_?PPoC-6KZ``%Xd~F&(W)6*;U|48pro(NYEs5}1 zPqe+vfW+c1Vc&0q{`MNl-UZ$`RxAXJJ?)gmMr(oIxhSKl0=2u^Gq53}?n}p{-WbgY zb}`3uZ5}ejlhOMTux9KwysrL!hDD`GK93=nCu%qfE(jPRDX25aFJM49$C=*eq^i$U z{hVcOMxOqmXP1snU5YqLO-gWWGdpfMF5hbkvqk3+*~H3OnW3w)Y}TCd*rFeFT&}Is zh!-sPN`Gy_fl1CTb9Mm9Z1|LZU?0wOeg5U3uT4_4C{U0);+8y3+2m6yaW+e-r1J-Z z;&H0+_!8^;ZkFb~Z%WbIVCL>4@YF^S0>7ZHE-+z&m}S?+OL@8u(oJZ|>RS>zIt%vZ z@P=z64(e6(z_ygySakX7m({W9b0+Bbx00CkJME(!ZKNcjU`jQ>A=+#7-PDMHdYiIvH{^-mz5AuCF|;L6UFj{j;$P6 zw0ffZgL!bQg~ z=Wlmlb<456xnYwB<|FTuna`!%RT?gPukHO2D!Y_MeNKs0NcKRBRQuu-Tqy#s20RXU zj;}+@H7mZzr@d~~I#@Pj?99b!)OLQxbi}A7+i9FAy)G!w_oy*KRN{&;f8`r-+LD-W$ZNVA?PDkQBYU17^55 z8gyn~MMp2J7qi0h=(}=_%`S6W8%zTOg%`!GZm>Q?9)*Id2(us*fb6Y=+*qH;9Om8S za4F28uiw1691Tn}C3k~4JD^NBb;f$Ugde#W-r#E)$aC05Kxzs{F@8Q=XS!S9J;y-v zL>|xf$W@%S-L))MfkGUTIB#3(4VDv2%Sey$!hjF8hmD@F9SG0D_UE~aq;$BoEUb5s z1u7@viG0^}gD!9@C9S|40E%ELGhdV#ohVWM)`kGPvf%mJfU zL73vdU{d`?;f=x(Ev5mjxI>VTz2Z{&V$uaLa^0P4w5wg@G5zF@P2JRC$!u#;X~R%N z2|<*~?11CIb#lFgh}n?V9e@_9R2jOkAKJJL)ga0gwf8Yu2)zdS9cDb}Gu9@%)91l2 z#1Glu^p)_9p8en~h5`LFBY^M-h3}ow2F2rF| zW>RCVfC!EPS1#D2l+`X3gK2X~czLz|P1;8!GX|sW+Uk8G`-fKJ6F#axom(>Sbr$&w~Eb7D~?D{d7v9xP=sO7O;GkZn$cETv#m+kiwp?g zlGe`Yg#4%ob8g@h;6An2JvY2=Bf`IDE^kF!S(OmgGpf+uGtOUEl7-_PbJTeTwR~C? zYZ1^bV{#wzo0^FGA8dX!J{PsTY>8%!4SPeH_-CWII zcpw^ocJ_ODE;LL9$-rgg)P$T6QvGrmf^N zSQTu87WM&n@w#nT|~Bf9&4~(%XQBgrGSn- zllRffFA&_&3c?7NDPVp==Ql&ph&f~@}$37 z7fp`)781;th<)yph--qo9qpFf1EDtbtfi1@^w!ziMulizx~)^ZF-~Z2Tf1h(W(eij>gB>!mIM9B@sS4(n{hzOO$9juR4b34JX3TU1T1uVl|D;` zAcD~Q;FS1vSLn%k*(Q=$__!?VUY}?xD&&HJf^L^O4_Xz?;N(9hy*usN_C{LE(^5tm z>!?S&oof0*a@YH+!m!~=tWCqoYMV5zvT;wD^}s8|jz)nZ-#dbs&0L3W)zMX=4mKwEwM3ifx&C}q6kYo7F}@E#rVA?xFb?fU0mZ1G5HeS zfW(!`WUVqzb3^qCJDvAOev!G-hu8kGKHISZBW2TX6g1NunC^*&#~m=>w%QG6rD^qY z)1J=!Xn*DB35jgeq*G8RS=WF)@z8!p8+nbLdpBMpt)k?_wAU$f?0h|Ir1wa)q2&(H zjr?RilIE)d-GWg>m~)O=&a8X97fHn5!Thvo}! z$J#ezZwkIVnqw25s9Wry8k$<--4Dttrv$b}<|i+BIx71rZvMr9Bp4X6mwR-mUgY?|nj}^p(ABj6oeySX7*HbG{250DWA) zk7C>>TmhS~9-MRE8MKVsJub2Vqkv8YdBh8Ho`9#7Xg;hZD9DRo4Q!Dp^{X=Q@ zz}$7QzvQw=rIpy)3ZJ;!$>n9T(8I8yO?EBo&w;fDzsUe+la(6tGEbV(PJhu3)OBtN z3h5dKGtH)%N4LTw&>3%ia^Knp#$VP z*q(hAje#`fC8`F0WbH&F&Yk!y&O@x;MDum)F7tEbT4ui?q;k^isXcwQcJF;!N&mbFftM1P@2&2>c4L zM(h^@9oTu3cowb;EG}WueVJLb`AWdDVz0Y9H$|S3Y){1ylXJMi>1}Riz0!)@IA+{pP z{ph+=N94m`7g;m&?Ec;nY)kNI^I6weJe5YF(gPd4FJzjW{TPRFZVFgVFwfnG6+iFeom*A0GBeykn$v8d3Sc}o_vK1>(JT$ZdAxW5I=;0M>>g1@a=YkZ zn>rW_!mgZ~Z^E3t5PwHe&2eegg7}Q{=hqH`S#slrJ|NC{0Vn87aUerxdV?Q6rYCI; zy(?csaIz6@F(aVdPwbYK?e{wD#R2it&1|@b@DJ!l-5k3NzPP{IauEz#7cwyWtQmN} z;EGF2Y5p6n(svgmaqr+eF7~ylSC?=s^IY)i$3lth0=poNIVTmN%n2QnkgO1r`Mz!F z#zx2YoQn=*U8k4R@1xo!cc+UBVNJ45=Y2#HA9H!K79M0$POQt)zn}kG0kDpR79tbK z1q_J)-F^YTZ^CM%*36y(m1>lS4~2_1BK&@rLooa35uoNN&`d$$euXw@gSco-Z-ca(o% zd4C7?D5OB66V?92;+J?s2eqdYYRQD_VRNt@yWbng=f*UB@4~{!@XseYlWo_SDlk@# zYdmmOa93ZzhqZkgLplD8@WVj-Wp~nIIZ*0>JLcoE)Fh@$=n{$qrPSocl8onSSLuXf zYiq4Ox^#MiY!eRDu&WipW`SI2-_&EPVZuOv;2Y7?!0w1UvT=$&J-~?i;!sGa{6{iw zM<|8xV}!r?5tw5j^dt=<);XckJ=e>Hdy$51tBvAltP{FmqWOjE#&+^tpa}hoIrJc+ z%}9#eWYzbwA;#7D?cQ&>@oj4*KARHCt;7E-atDj%Kb5770mYV~13#|uP=eCb+|6Dk zJMh#Dvi}QXH;3NNoDN<(nw(_EU&eX14N82dIPQfD8ZY$AvdqQNvhlkiZC6P$ydaXS zXQz9C(zU7Mla&RySU->K{)=(=Um-REZhJEv=DW4&o&kBDEir&69aaz&LkEIP5x#J1 z(!7n|XbjU}O~1BY9&5Z~C7qZ*z@hC$>a-$x?hgoans8(pe} zJWRF^=@wFu5+D0lOZ45eJ2x+Vi-u(O18w4!f}e2dv0P!M+#yUs=Y*Vevnrc`qMP=y z@8a*q{KccxDWbJ5vGoLO*k_J2wAf5@R*G|Jsn(_F@!EKko6SB+26udQod7L%{M)^| zPpGVGPZcOx3&HhzTD@<6FO6q4Czx4tu&G*0_IYqkAIsf!a#L$_I#iDhR%g zkq#6L*3fRg;ac&Ii294ZAh-Oyj{f%cCVVTt^vChd+rS~Vyp6H-Tnhb*W&F^Z)0Jg+ zB5l=6{PtKkqcX>Jne-1o*M&QPdn;$^4Pn;neS@BUpC1x->*_lntqlK&GfLCN$Yzc? z+K{@8guY_q2=>QB;d#qyUvo+{d8&EEG1Z zuDpKl;BXCulVT8Tk7p_0=3X16<1ZuiV1tWpZamO*C)v|K`*7q^8)r92)(Xg+F!*<| z_6J5r76R*e;*rBj%I@A-jljG~>-SpnpJzxpXl7Q}r4IZ@9#|i@$~Kyyb@juc01jgc z55eQ}zAP?xyzbDa4Bn46zJ;asF;7IbI8-Up+)0=wx}LV)t=wc72 z_E%s76d_Z`snQ-fZeyW!RQ+s@^2}d4NvP`plNW<}rO73k^jKPpK>R!z$qtqnT#E_s zuNYgV4EHO?+vPgKhvL?sN^|(N?{A?q_Gx5}0m$a;8rhgQiP(_E(1<@Nrr(3PMk5T5 z3PN2dv)twKMN%2r`aHV7Nz1qiIbecmJ}ga;t-n20bOgD zF(evZABbe@;!@3(GG~S*Apw)+1p1hmemwA?HH=9 zLFOV0jn4N|SeL&&7{r?+;fk#d_hA!^MzeX|n&VF13flcV9_fj%(9ZpW2*47MisHw> zFi`q6f$d2!{Tk@=;%V1GmG$KT+{rij*~j|CX@fuQ*1BR`VWK0N%E{?rWTUB{7zhaC zQ5)nek}yVb*D{@8uI1^j1d|LQ4c0=9y`6ogK~cO*7Vi% z#WGfj97Vp2{2AwO65sIhj@CX!HxR)xt-)@MQ=b@~Ax!5JJ%m#a?rU0%Fea3-(h$J#^Z?ns|d)1)=r^VEit|9F8^Qw58&-}(9U$koP z*GWlj5;-|LgNYSyM5p>`i>@)$f&?NiVFF{N*8s`Wv-I^QEefNY&l zXglxx{uS&mze_*j4Bjm|-{`P@?DORT(-Uv#crt~GOX8rlkJ?*EJKwgE=}Z0)JG1{gnKcEd#yP73bt z`yJd6Ls^0Fbs?HHK2{{MS5}1&_F1=B+?wbEe!}`3K#w?x0|ykL8n6@E7h#lrZo=9d ztFQ9`9o;@ItQ|yhi(}B(lZWX3Xm$;~Kta2vQ{FG)=W$DZ2!az3y*^Gf!`!}tg%d310Z zfZH+_o-tu?65ha%a?vlxyhL8Z9(ZUP&hS~LEvO)S3Po(rt^u8ESgT2RzR9G<|_A!Wa_8Cal;+yH(J_!I#lXs3Gvp{&`7 zn-i)D{8>=DnI3Y;^NAXF8TBA3?4)l%zYL2lV=&ZmRv z_vtl1a_~0_uHleH1SZ!f(P|4_CS7Qs@CrvC$y9l8O+>h4V~MvtXwmNv@k>khUYpy$ zCgHp^vX}&%wL7~h+>y5Xdb@pTEf~@_jiKPm-udryFl6lD*?m+7jtUrrWOo4PUiu!| zi4mMh9T4z%J#G_+sDn`GqE^aoO4t~zfG5fl=qVm{v$w#WN-^{A%RX2%uV5;R2NAD; z*+Yr zTjY`1lF?pls$NPfXJaIBxDycD5CH7;YEegiu4qDIJ}AQvwzL!6|H|gZA4p@Pp!7sK z28hjy>eCkdsn*GZKsKY-ZYWdb@<3<=OYP`ooyhS2C$tRaJ;BbW&0 z(aBYAv=0NY;_Q~{v~AJ=C@)=;oOpj}X zTUvy+FH(GS&pqFg-L&(MBk!b-d`Y%wGxrAZl8<$i^M7TmuFY1mLhRw=QCc0JpYo9` z%)$M+frE7hUevPN_=ZQIxJ9=_5SIH`=^bVCuVA?xPh?WdlMhEM2aOkxhXFPG8)@F!!0EF!%VZZy ztJcrg-YL{GqXi~Y7LMZ3yxEtNdun|-(6R+Ai0~>F!S4Z0br8@sk97XdJ%P@B}*m?PIWb?S+Tq z_Aij0+!PaoSQnPNLvT$&>L(2n!kOfJ!ufvW`{zpQ$$X30w88dSr=zx*%t<#wJZ9iQq^X2DzNGId^=103{3Lk4srICct{*(6{G@2&-Z^~*tDp2Cpp z&y0-|`M6>#&?{i=FTYC2Oo?0=0Imsbk#`!ICMx`> zZW+}T^UiyqATb-zzo#RZOekVHn@16NJ@dK+XO^`wu)YLtIqBj!jrGgf@!&ON2|#ko z6(?1*N6MeQ0_(n8#ZY!o{u?AQ;u zoMX77s6S&deKh!ZBtjPF$X82@b>R|31>mLir43sk3!y2$!3Y5tlu{d*z;cc~`TCS( z@NbzEU3#98f4gNS2T+0-_o1(|%#UZ=_gJc`G*9Lk**GUT zTBVk?(A`el)=gVJDDd)4S=t)Z&G_2tX$y_UwZ#MXPdWaxaCu-bHr(Koph` z?UOzAITx=ffpIWDBtX~e6NHB+*Ph9-P{o+d^{YgvmZ-EC80>8D;v}^RFxW_;c(CJB zri<|Q2ue<1%A>%u&RirTp{VL;h>olsUTvTyh6+K>?xklvjP5g#G8 zpu7s!Rc)Z$GDl*K4kn+*;bWTnyi z-U}ld_p80bOs=talN{s}bMwy!@;MIUn0X3s3`}Cb{0o?J!g1U<83$zUEswuAEmDz_ zi9LZbHiz>!J^~Lo!aKt9+bE+@wY5PT_O;uH?owxen_10ZBD>}+e!~phYOHGov^bHn7w9IB9Q$G+2CndR27glAIAUZ6{3iqN_L-+Oeg7+V~Y$e54w{N>YiRcG&JOPBYG##qxMpHV65cjQTgJYdBC zXu}wmqakb>^RHs5TnLU9>Z$Kd`2!yT)Z}RmlDPxJnLe%bo(O%L)gQNF^OOVmY!*UO zowvw8(Hoc}Hl4-sZN`oyUL9%ZUD;WtfMxYzaD8f=efS_C02DaLv)}j#auzY7E3zSD z`Y1|(U@tIVqVqlk6XJx!{phu2AplPW&-wp!tIu&#mocHpy34*;f`NTzCyF~_wA;B;3I4>cf{dCxH*&qm)b#}&hLg_ zzo-n&06xs2NBb)qlr3{dN^+*s?=Eun9%rXH82c=53x=y91iX({g6r(0^&Wv?&i4A` zH$K8+srZmb48CQ~_+?r{3&PpA{tRO)S9Dz%0_aTIy+#!Lo;;}6QHT(KyVg%tV=D!2 zi=u_*0X?Mp60RZ0gDay`P<-pJH}wM_AA+s4xIo|L()wF?Hax?q)6c*U<5w_9r8YIu1UGnWzAs!P>+BAe%?J^8M}lwqvBf=iM0 zIY4YJu>~(LSz7CI_=i;y0wxHygRcc3GPO@Vc$f zxi1-O5Wg^Iy&_^Q3(&i4KZ83RJeRGl_sDtopvM3GB7Wc_^qho}m{>6;fQU}36HF9z zCfe8E%BbTfdYG6IGDr8vHB;zfb=I&4gY&`ZzIrTTt$iB{>T3fStV?GeFiU9IntjBF z`N#D8_aA{kDPt*)AupD)h=;1K4eQ!N$%X<873*SjyqUcCtW(vAv~%7B)tlK}reDr7jgv{P(r6 ztKDD4A@nWEWgOoFhUU-OK3VHI)Pggf^t-j!oR<((V=)Rzpy?X@F~a^J#qt{;p*Xf1 zQ*0KFmqpit9nUu?$xts&Y-e-yyetx6ZZ{@=b%Y_@@MGIcgEu#buSIgIIHRUr)I+1{ z6p@cNAspQ{**#piP~S4(2R_1FbLwV~rpSaI%TS(N5K@D#!#9E*66OM23_6-2h!&>%q zrlN(ucaGoq2%5%)+#ox}mzA8s+6NkhfFCg=frNfPhi8Yo7`yiV8&9vD)cOZ9ra1!; zRnLftt69&I%wq6ks|NoaR+Xz>Q<)23SKZ(E2)MpcKPe2ShfQn(Ev+$ibV~?;;7Oip z^E41Fjl=9AS9Dk@uwzm7dtcj>#myvV9NW)kq^;a*deCzcvMNW~fpteZ{)0cq&<}hBzGve~ws2wT-9Vy!E^w-C>oaz+POo#=w%DyGo%iC>A07owmwhzL2>+xK6xt-E&8)s||_T~jVl`hZDJU`oYZXbJt-@a6UsA zSpshUBoW^EJaj+s5qNm|6^1W3uaz_WBq7q03QV&?UJ32sf%{$F+1*hBCI0k*;wat5 zo#6UM;V0Pbv`!D<5Wl7GP2@#;hq}N7n0pP8ZT&(;KkyOq%ZlVuJSz*XeIH}Tw~<{n z;hy$WGC$I7M>!Hbc0NotFzmH)ETLVuJT>6`+L&0q_Fne_G^Su3qq_8q?8E2TSH}L@ z((N}sLg$iYFfJ$`JlSOjQIJ1YQ?{ozntAj3XT*8>Vkq9Z=;y?-eg@&3_66JQ8s;~9 z53=F|{cmbHKouCp!)^H$1J7)IxE2WkfemcumOhr#wZ z&na;%ZRgqRKqT&*)dXIH81O}J+*UV0xyXf+`Uz--0=08H#$UwT7H;cA`w~4rVB-s& ztxesYG{Da7V8qAgHkZfT8}G3CB6Qu9RVDgup(lMmR`6j*JV~yG1GftYtyIZP*JpdN zC>Jd(iKY4dz=EGs)~@T{!dM=#;KETE06bkCB;Qm-ZC?@%v8A+xX5dQSj|6zNo*aiA zf>P4k-BaAV^0jyk&M{r}86^|wUNNpbi{hHH}nBRsO#TThmoZ0*PzD-;ugrb#~W zG;Fbrkfu~0bTIjeLIsBh)u&90_tkYEuTP%KJ1D0@i(fC~VIXIq*=p0pUK0X<-O;}0 zgz9P8TWeb3z)jDpztZV`z+-kO+EkCzG+RqRvr?byqrq_Tvp_opkfa4aT9lsZ zn&}F)bB?c1X;{kl^P`Z-E_{tge3?|f+na;`C#*9?;>fw+EVgY41(g zygN;zQA_gC6drW`S0_b7j6>m!RZf#RjRHSs$6**P=cLYz?+o1lWY~*h9j&ocTa93t z1)#XGfYU#^#=)(e>*}gAIXVKm!fQ^qS({3^xJMEOq3o(lQ@P`LYzk6?&mj@guWqWzOqHUk9; zttJ~;k=jQrh_LjJxmWN41tlLXst?2Tf(U|6o?lDPUqM_EFzF)qDwXKK&AfNud4f)t zjL~m=1R42R9iA?p(=%q@dZSUGnV-!>l@Z=n`Dlk72%NqbRg0YcrcHJ#B^x8Jdj=Y| z`;hm2rM}w*#7S@lJSevnGbMSO(D+*z|ND>7gv7n_oVNbCl?e)iHN72j7m+ovK3|8q zdP4>Bz11^|weiWMfDAh1|L&&GjfFuTAmZj-7-9_v-~c4mivL=CIuK34V7HuJWHg635?Zfa7dU6DrOX|<&+Ig+wU?SL@G!L@x1HBlnT#jp>Npgh*E*t6;&HTZt!?Pap zk=(ES#z)v2Szm^ki}0=7#sxK{Q3<;F@bCf)HBg&Fo|_7sI)n(yumg?kIKBW?SEz(l z_-DLJCm|Y3WH;yylWyS)nmA#vftc#Q@e$-Jew`uRU&iGX(keOmJ`w)zfbGY?17P5D z0i!;SW({}q^rC2ZuTSmPoAEl5_aR=|bzi}9W!M|5eJ!t#!sg&Fue9uDzwr^e4D{At ziJXfuQ$F@Nmnbt7M&F9%0{}a^BS)jR^u&R1dR+*ZaJ9Gc!l*+uy(o0XCYQx7xk~gR zbC6AKpUcTzMKkEiZ+wKH>*`8Hvv;8_(u6~MGQ`9Tah4F{-FJ5>Bd!icm!N*9M}e$B zH^r!qJeUPrz6ZnZ@OeRVyp6&uiPm?8hRs^CH$&?jzwr?kKhMJ7GD0b&a)~|}6Iyw1 zI=*E6-YQ>FmQoTA^L}2Dq?|z~#O*rPRt_tKu~>z@9kr5b8!8pwNDyfq@->h97^r~( z{Ed&m@g45b#<|CL3W(N30!bU;)r6Fo7+pVtC&r3tVB^@B&Si48U$;vV!1g)uHA@W{ z%t!1gH*VAZW=ol=6A=66iN-Lvy&w4q9g(YjcoUbH&~j<(e)fqy_lN5OT!sELBv3%? z2@-eM9r=3=%#@TmZ3#Yr277$zn<0=Wl!j9znFQpB#j) z{s>3NUKEdDI?QO(H_<{<%)7wsxY;D_u)NeyCFk&33wyTh8&BR8#tmPpXyIo$8;<=O zMt2#(u&i~dN5^k`1kYEN?{uL|p154`f9=+QTMU$O81(l~opp;_8G zzwr@JA7|3ig<6S1w{B;*2Zk8I!CUvt)GS|=W+#NnkTZC)n*$U6ddG7!7=cR(+5<<+ zE!hzE0mY*NV|0?s=L4!Llc`t#)?+{L5u*D0`fzVz^#-5I-hgh&>l=O_w)HM3p9ZSV zv15z_z-%{Z>6iZ^X?xgoYj$s5&G{fv-c1A7_G^9Z+WH}CK^-mJVZ5#V{>De(75%U= z9M@>PVEkZ(S!Y4AIinPZj0-x9^Lc4~CQLS_-!VWcH+oKmOQIdp+Ol=u?hPHAe!kr@ z1u{=+z@cJppC6tve&i#_t#RW-W7c{0Y6`Sq2*SZLbIPHdyY`^jYxt%&#`HLc0rfGx zxdR&QO*;P_84-DlPHx*c z_rVcw{KiLM{l9?8c8K<}uRLpgXC>di4n@o7u+Qe~h1)qNo2b(^QqQF+*dY*G7vRc) zey`<}7b8qp>AABH;yUBWW90Ae7TeWk&*e8h!j|;qV-`f@yi;LAv=Trh#^C zkB*zF<#zzfV2L{1SpZ((;o|2D7EGuJ)EB8{jN87^#xPe7aF4q6c4;x?;iLMEk8qEs zL#xqulQ;HbjWKTPcsY01sCM_G{kzDP3X+Xz%}L~g@t^6vjs5)I0l!8&FYW!nc`{IR znGM^{K>vEi;&up_%&wjHMJ|8fBmBT(=m$Q6oNhM+0(HX4NN)-2e!dhhhzh^MTR|qp5H#=KFg?}{ngN^(DMJvGNamF zxfwf~u5s@^f)bfyLJINe@9zv>82R$!f(#u$gY4v>VktdXa{FaRp&bB|5W16LU@K%d5H9VQ2N9%Op$!&q@Gya%YLUtMkg zwFj5cYqu@qa^$v8{OI~M%;6ZkvtA!!pPLwk21Yp{^aNdw2g`>cu6C-2vf~hL!y{O&WL-6R}PGy+__C_`n2R$O%%yB~a!=cL5<~w94w!^CaOuo|hQh>l)pSNSD zQx`n1)t~47-}9Ojvf@)z*sOqR9f-yogQE0K6d^Meg+;+h#F(e;ZI30a=&P$W{$`9Z zFikHyPv5Cs-MUXO>lo(QTQwhsDQh!D-q#e*0<`n4Lp8}XY!Ig!JfHI@O` z4UTcwZ$7it62}c;vy*uCu@lI;s0=*=<=V*yW}M~ChS}gNY`c3~<~U2o_ZR|^c`l>p z1NAYIWEjlTC%yV>KEMwQ=S!(Q?#;j(dS7F>OO0uKY;+>ynkrrZEE?&7dAP9lrxVQQ zM#KOv!p}mOK^Fr=jTrdCmDN|0NcwaF`gu@5pIT#Th$v`sWZ`?W#y+}WTx|}yTq4^m zco~?{A?3j%yl>w{D%F ziZD9l>-TW4$f|7zSMZ8))>-4yChr}IqwQ{${s?pEE7Nx2DjuIBf<*80$;@LWQPtg7?(Fl$`~^a?;5n=kgiE!FPVlxN-$wsym5b?tUl zZ0Mjp5i4l;iA#VOVId|p8c2|a$N)62`MN1;=X_rjyAveq*!K7>fT@ftJ@zqa<4Rwb zx0FA&;mZNHiRKw-joKQ$Z5ue?NS5dueg(7N;g_waz5&WO4Wn07V&VD!p*5S~wfyvF zS9)T}MBACJ{o`IiACIu?n;<7UsjhIY2;wx1W;^#M-OjImDu~dSPo-@1aqWXD^P-_- zcyR;b;naoByY=)--cQRvDz+Zj|Aro>QXGHLu}neVaA5rd`&&v99|WoDWoA`UmS@80 z>Qt9N&2!=s=0e}SEm|Ha2!USb1SF=~;K7f=KOFe$c6{KhF;5oiFT)YSU1{A#80nz! zAqh_)TK$P8_=&=D*4O!fr>_-gX4@;S*RyJpZvoLs5O)>kY-nGtMeMb(lOwn##0p$- ze=5ALwYmzO#n1r2Cb1hy8Qa$`nE}pF3lXdUHNdNbj+z@UuaXVjtAmxrV*@-=#i%s! zhG3bzd_dr#y|UWwpPYwI8w@Ft-#9hx<+?6$fiFVvKn}+-$<6=PSYyW~KWiiNC^XM6 zHF4BG6Flkruf@6QW)g1cxBK?tq>^cWZaq2gT!5r}j= z$Jp=9-Z51ezPgLZ;WzBP@JdI@@G4rV8+lx+9DgkTZk&|W3uI2$6s?sPvjgKl{;J7= zpN;fm^(<~wUGFzOy!*zMT7~!#En4??`U*~HIY{je&dR^>TtITQk%mKi=kNcnIkK|P ztfdo0ZHIxHf)Zx(M{UM{SDAz!+w8>kohb-;ELGu4x3*`<+eC?=CF^rqFGF*C*H-{! z8i1nwQXGS0DY^8`TB4qv<^`{j2RgQjD;o8w%+Qf<+u%R*Xe5IvB zm1GNH`88NcLzj@(j$TRt<9obMxGe33N6Xv=f7gT3u_7u*ZWa#dD}Y6cx4QJK2a)2eMhi)xcYgVs=*rH0itUFMWv(7A1e{5Z;5E^=Ubgon8y(f_5iS&9ocGNlR zZk_t@;rNc}6^`PN$UW>?k^27lvjMB@QvK`PcMPSU;61b{j&!e?Vse9^Es=6pK|N#d zGzHDPH#V8wDeeM6f!|MclWalVgR|rGtg9bq%HJGh7~jJ-BudYDVywT7Qzj4S`8xMy zaf{XFJ{Lp#8*)b;vi*BXUT88r>|u-2p#T7;EgoNi$!}^QAsZYJ7J>|v4d-E23WtQR8FwCF;kF&ZD6v6U2 z16K7qJybs#3lB|3Al=suFAQh6vog=n+fbE1zYFA;*h;ZaqZIYSzD+~xcp%yD)?i z**i8~2$?+m@=^_6Z{#BGcjeM77MVCZ#;zg!2IUET$Bjb?D@_Eyd2c1z00&Qe47d}X zjc|#3)z0pQ5KAYWx-WPdoJ&pOGDiDIyPSyG30W6YPEe+EBG%$xnSo?*qAdr-_Ihkty(P!cAm{2d=a0u(&whXaw@T7r?l6i%tBBQ7Wq!AXJ6 zk;Ok`_kFH!<->Ont3lThY*?CM(E`|xFiyEC9iW(RARo( z4L{a(@8J6#ZN=-bcA%5L+gv|wf$bMm&cUfyNaqcqf~*d$C=wYX56YE-87hK8ZkB6| zRitLhNA{x4EIwNA1~jEGPr2d zKW?s|Ty54()|0GJvwh{?w$9Qa`^1~973KmB!IAb|NhZ$BRJI5(_y_H&GlAOI+dSq zYJP)oQc>`yTQ4{UF3v1va*Zuv{Bg5DqaVcXCn=xvg6NF_dw}W<=z>-*bvAMK(B$ZB zW3ka6PI%_&(S-@@DK`Wu$c^L_IeNB+7T3uao^6%fgh{nE9HWSlA-q0Yc2l{ZdVeh7LwK1y?9x% z?AQocIXRJF9QH(Vb<}#1rz!T`#)1e?*V#++euW3UXvWXd&l7C>OxK6;=^aI&mW(N^ zNzAtpgnXI!0mi)_Ab5Z@F+CeK_Kt9z)!-v+{dv84n;hp|rekc}A=nFx!7(E_9?u69 zTcJgCe67;d@zIsf{Ji;~!JILSL&f|WpY|wqJ|)CBPH5}v z$_=SZ^32-do5tt#<240{Y0eb@Eu(Yom?$=Pu;M>!m5Xgek8A7LWFJa<_Ox@po+V$r z_r7Zu=N7N08`&t#;M%r_3?_l!ekdqkA!}PHioWe*`rR!^ArN4$ch=&IINM}f#Q%=t zhjXgh$>jqd+2;nGP*|Pwlnia&^cw*z!$C;aB;S}v&#U<|$lw-eMxI%NG&;H_ShpW~ z)^X|3kUm2yz?q%^v?a*rpYXN2j&>~D5zej+#dJbFIJIFKGZIKi7Ef%Sdg0E!`Jzk` z9jKEmZ&mtHg>B$P)HYN+K83}eegxm?!x*#7SgsrYmQ!8?RL0zF?%$qg=~QGT$?SDeb`&gbkC4rt@}j&YX{!tXA5oPGC);0Lw(!@P)n7DWB1&KWAM*sJ@-q@ z9xZkTj@!2fZf{}i6&yk8gQ4WM88eN1&po4&(7IfFeI$!&xl&L{%^Po|T&tutma?H1x~kPQhnK^t;4x!A zxBEC&i$fjd>dfS-8v{bY9cJ?QmE5nc!>IB0`R-$(82WG(E%voCzj^Y3kW_#1p+)la zYq0Y)A6};*VL=Z$-ui(J(fWD>{N|MAIQQCz;S3guHDAKR|C)nzt+C%a3ZCyx>0GjuU1(j zvBRCKf>|k;IDcSnk*$+`^6NrS?Z8&NL~9UJHL%h>;DJQT2Q`bU<~rPs-{Hyhq0>Cz z-kva`g!i#<`6^GXzXTdE9HY7vTi;G6uB90oPbjv#G6b2 zKO|6Hat!wbrtM2SImGx(K~!Z8?5pSOHm~me-c3PVjp!T!W)yBLZ&v zf%cAu$FP_kgQ?b9uYFH+;A>1t;^Fn<@%xu$QBsBN>Y2+y$k~iobRbQxSPj#{ofod4$`^ntHdZh)zdgvPbJu>^ByrE32TlUDouGR$$>RW#CAW9o-qBGSv*r>79QQEle{t0J$Tp^gyo zV$=2oU6aA0!w_$b01iL&(vW@O+>P(N+wuS5h~9f5okpiYj+eEq83hIY92dIo#$^YJ zI%dR$!KwJJz1!tu`*2?%6`E(q;-Cv%_;mJLzWiby2JZr|-^SYCeAzyUX3`c0{e z$9CBjc#Ufce-GcEA-;8P%syDq#prmS<{AK^o>_lUlB{TV-8lP;P<%>l zHlE3Loe?PfV&-*mmoFomVex3%|^ zxCFkT=io|@K(=+;EESv29=$BMI6hwqcV+TVaSS7y^LHm|#|w8`gYf}xAod$xDL6^6 z6Xr)qrxCJs+2$OS4BR+SdC}0~53VC&JL9$Kq!OwvhSEScw;43*3tCgl6>0B= zq;>nT3SM1UajdshOIOW9jSUm0_~3HCuA8(k3?;WnOZ3`@nDvMA>}b^P0VS`8gpVxq zZ_0ipXZGdJTVEXy^@?nM6;#ST^tEP~y{qW?w)&+?(Y`2aQ zlQ&_^!4Bxre`q{O`3mB%_uXZU+ZR-Fwob*?aMt|h*?O2EKLTJlE-_@9)*tzF9OUG{rb+^BM85b!&hA~F6ks{st{8$cOoOcj_ zwEGHL3a6Hy^Lz<7(uindSd)Bv%J&&R07eUEm&Nb6!xNT-dM!C3jdcC-#}{(YUx=hJpu#Mex`dEh(dT^` z4Sf#uvf@1AQT4_xHIW3B;_urYvqyOx3{%gWYad=r>`e@ERIU# z+$DG(U+}yKr_0N!w*lsFOvZ?6gd$fTU(9Z8GW{fSR%+8P0>bWN(XuHH&ZdL0zgg?@ zP5OFwG73jT)?D8U>pU4{S1(#&32u!=tDoh@fgcTZr(+luzI@QSy3GCFN6XL40c;QU zaVPi8I-}3?bt!Um#OPQn@0=9AI(#Z3SOWy;)=`ZJG`(PMnbQ^tR9O49h99BVcMLXI zF*P|GZ9pTRw;1`Bep?yf=au~OZf#@QGQaT|mFz}ZURk^Weml1A?rY~=Z+5-O$)S;K z_T=;AeULy@f&zIYsV(YXk5%GnhieE7;xQY*#xs}wNHbt|LpZ=lP-?TAW1~)!O3s0i z@zOs0elheX+^AC$A(MQdEwLkMjmx`Psyn7g%Zc*~yrJ79aw3#)qV@v!wq)R}V9XSei~To_KfE;7Q8G z`>zV^``brQU}FD6Lm{Z(jI+u^3)MCn5`uHIb1|RKTQZq}?w!`Kwy+sBXX7k6-pv`X z(1n_BHnZL-ZwBGwuKN;R7Kr+gLlB?5FLL?WPc}6X=_=A_5Ov^6b@;=bAMy?tB94DA~+s47x=00fap5kMYbbiiXv}*Eq^{g;{ zDer4p$|{iYQgUr?0>h-mNT4@&Ua`!{Yu8wFKlSriR*+$(fH1peN2-P>VNVzvPi|x6 z;&-r(Kxe+%)qW~itH-@BPOY3b=Ug)K8x08?-Vf4_6yP3VaO5`;Hu5yg^XB)9E897f zLL_`J3Rdt#L;bJLFmfTHZ|$&fFuV~b=7qlYd@f?6<>;@tqK-PR-`;EsghGEK^vg9B z=}|2@+=*mr^DC%Wq~V&^ZPO?|HdJ#21-HOo2LLIvqZ1=|SoC8-wFN0C%5Ga1MN*;! zCpX*OaWsdv$zqoPrtCJq3telS4fGS8V4{+DUVB0OY(!)IzLf8BP;lW46D<77mc0$A zS-WT5&vvyK>CwJh)uQ(NDz`K*s$WVSQ2Rz^+Z$aJxWS!&w0yww6@6wi?I2WwCj=fO zd)x@7Pp6!|1-A2`#ITd@%=y^BMZ1X_efywQn>%+}JIh;~=!dVDW=lyLaBM1c1Mz2EJJ{OsvM|7R~lDZ={cHxHaf}3^iQ(TWYU&!R(#ay-Vqv5fP_Mm*3T$eG2W}el_ z+rX$4d5?M3*GSoO4#ooLfjC5y$0KHkF*Ran>AJ1!>DBjlNYKR2jc$B5~2 zm1JxCUXJfg`3rqYJNd9_`}>YJgn}$eAv?uHV?t;j2kvRB@)L?c<)GAX*l*0a@|}I> zd0u(sBXQ}k@WHR5W>aRQSN{@zjktReyWJ191rLICQiuCyHQ-3A z&k!>6f@R9=G0Nhmj`*j2iJp7s-EYZO7Ha&HBiqSXin1qQ2Mw zNe~=HTGDio^Bls0YOz2DNz4M?$KYPqp*dSSyL;VXqzpoSV-oL=NaY^qzK_4mdi;E| zFz=7;>N@;o&c5K(P$HmZ46x`*u`A1cNiGTr6i0QJkAyz8&z|R8VC2bkahx*yZQ-m+W^sv~&U^Q&#mTLd`}UOlnHa=n z!+F(Mz|0egJGk%`2C}EFHnf#p$X8Tdg*gbSxN1Pg*RXkXGq&X9R=V8Xuh~K-I__m_ zlp{7Wr(hkKpeCrl@N{IBwm_p4>aWlZN;@s2A@2-5)UvFG6_ec?g^XF(Zfn}6f7nT; z%~~f?nB1k6=r<{6GLOkVdB@&@0bauieh|T>oXo!JogFt(LL$nk+GDg5Wg*L~9PAqd z6B@OiC_`IiZ8^;DYd3UoNjE5PMKm^ch&+}>6QcF=qI3!fKMZI4=^$!2cFEclGFZ*j zuhAqtaW9pdmkw{{Wo-==FKbz_nzQYfO|10>aIiPJF@;c7drX;nY+hPiqqW}Vxq!SW za)JA=r>7{GP5wS}B-PkgCaLU?d-)=JN~-meqqpX11QhE;Vgoa9ozZ-6bQ5#F#!!0; zU8UTt#%mft2A#f)o8e9iwX9NzzuHJ>!J0yd_xZEjHUcpZ6v2JpqM`gek{xGhA9Hz!}tK4jK8#L=Qf zmO`QMZE4xXb@oz+(-vs8f#;z|I*IxUu0VFDZ#0pr^Ok>oj#4}E42yA=GHT;Q+Fx&q zpr+hG7P8%7d|o=6zJ^M37NyhL8&d9kte&%o>p^okJLGon!U_6D-)_p*y&fVTNH4E$ z5@;KW>eQ2nD?{$wkIjVI>@oe)j!y})PQ5L5zArtZkXW4!=8f((yO<5_t?iN=*}I(~ z8`T);b-gnOa&0b{vv;OR^xkEV=40+CVD1KxdP0fWQ{FJ~@<-_W+34~QKl_ftg}O~N zR75aBZzD!kX2IE^Ny-xgE3kvE#1GU8H2mD7(0fmL}0 z4aOO-(%GTXv-Ty(vg5Kbtaf(SLDW7Ob1DTg6?k+UCP>9*a{N5watTucdf>f96cePr znLyADGHO(>2Gj!T(86WVH4Ywy+B7>ZCQX7DCpg`a0jn1hLVe=j|Wiad~?`6_+TTI91padCvc|2E;f z?W7wWz%t1cz(aVY1uru7PBxxda5wB$aN8ZLJkgTf_k)RD2vIYT!~~VM+v1E-S_2~@ z+?X#ZAt6?#uhQ9HgJn=}mazt0^Sy~qa)G1ol5}6A&$2qLxzULGu>Y63IQp~=a81GC zjwNN*K`3{Qw<>+4MJ@uB|0^TZsb;}vW<@DV9Odj* zMc3FI1qw&uwpOW&fsn!_Q{xRYW;wo#Z)g0B)7qO6%*|e)D|-1pos+W-cH)r;IjBOS*`d1rrP?Vk+wSU z#nNY6xjPjd7+J4Qwe_>rUVOBRdF$BC#={U0h3#|+pChX&augX2)I#L|8^mQ>L26l+ zyWzWRU*k>55zmYjnlZJLoP9uAKG8{b-aV3|$bkaw z<(x$dd@&wZu45H>-jK4M+H61MZC(?%HUzdeT@Ny~IeLZlNCR~3YZODR>3AQ=Bw z14HYGoD7&TDckNlWc6*yGMetD%{9qo(kx{RV8UhDdQ;=Q#)J~fo!qyDT2JF>3McUF z2R}H@7D*{}jt*km7L~toM~*vRgM44*!R4nBw$OSG)>nqi9bO0-9v%q3{OwZio*<|h zrtGffWScgZL53zrX$VZFezD%FlmgoBgzC%)32>EnMF>0B=xZ32mQwjy@Y9;W)zB+*C~x>C-WbSM~wmHP+pzn5B1vF$&931VVA{pi@N+}t$@e_ z3i`$f;UBW$;KFVl<;ytdn0pWt$uSk?MkCUHOLA&k+9=gj4zyl*r(?_%?LOtndVz#=C10ubjaR`fdm@O}E!tq7Z1H<+H7I6a?IF+vz$2Wr0aGnTHl`9HPREznLIiPcWLa=Z15LI9Onvh^FPwVvIX z;NK~K%eB=$%eI!AHEsTx%NqzDVyvii95_Tyd9g!5F z*)WxUl7QAYjpyNL5^7Rf9WaD~C4sRU9{3EIAWktwXvLrG@p=19*DvtU#sHtDB|~-Epd_{r`X2p=vZ2!9X(#f(ebuYfP-uGM}eyDN88!w19ik77NM&*y!3EY)Q zFd;y0xy7XY9M>y3u=8H8%(3j5%QxqtyLxSDoqyw28|7$JVnxO=H|Vk}k?*^bR4bcT-{H1S zb+26>Il63luXU1qUxjns>)c0S?$4E>pk#el4Z98iiP~-!>AJl6?YrN*AR=)vHIkSH zl$m$Gx1pG8=^&3aj}>?6x{J|w>q<6gE2vJqemAyS(-SttJ}>JF1D|T@z)F86m_e>( z48Rjt`(BeOjvIkrF_eFhL29{-cW1?T!Mh5YRcpMMX%wwniE@#)Y(DSo2hPci$F%X+ zw)~WqA_t-zKQs%$)B76~Dd>Eet*mSNj$^W%PsNEl?zPT@LY?@xW7f*Oq@U6z$n7Gv zx7*eNBPEL$=bb=sy6nQRdXeUK+C=)m+~`hGx7E#fn^AjVsLI7|C$xvmi$HmRRs~py z6>ZU;-66Zi4vO9lpI4Zay|~~`6J|ioud9M2cxU=kF6?yviAK(bP(7p1(qKRbGR=q7q({PnFX-h&#+)x~rG8Fh(9|fXe&7GiZ!}v~CK5cko-u zOHQOTFLo=mb|&)9N|l@EidN~b-(>&aK+KE&A6C>_ zcbUxHm|<|i4CXH{kJ(Fl<*VfeW@j;eTXG5b0TI0+7+H8(^9F3oFCv0itT3h(dP&Y_ zDH}+yrD^Q9L~9f=pzKGo>{~kU3Pz^P+kwqTX$zzer2lGmK3>rBzxAR=LDu+Bu|rykR8*AqH?N}DG^aAJUQA{x84|O!BUsE4G)S#G8}r+}XG4)A^yn+YfWx3_QHRdd z)n^1jp*;4H#?k_gP=cH7Db>6lqp0NWh9~OeiLbW{lTa`BRh|;kX@#yA|PD*Vim8i}fY0Xi29@m8j zfF&C2GEk20#(9WGqLZ;AV#gDIiF&1NW~Qt-_klr0ldpGp>^!`k z5JUR5fZ_}l zeTD`brVh1II>-*fWiTn>5MIk za1mYbCD4Vqfc7HEWF*OPT=%Zkk?O_S~>4_sIxq^XykNb zs#%_*FQ?Lb-^@Q0VWVr)k-b)m3Vgm8CUFhM#9&#NufPN34P zC4e-(doT6L2P`Tp!8gtFTZ5)sVz`)WW#boc|6II1cs#&iq#Bfqs_$&)yT`T}t<55R!O2KND@506{K zs{DQREVOo1iEgXZHP4{^FoMvA_X!sDngzK(w+h%(2Q` zt*O*q8Xbc*Ipn;S2%Q3MWwqNeE_y^IglT%+D4+N-&cgWJ346X_)~SaoTaS^sLmO}q z9JQ=UOTUROjnVtKeUY(4S0uK4RaUfv|M<l5L zDy(748Bhq=CyO!z%ea;~JQ{Rb^s=1mIdypf5i!Vb&^u>N8S7A)raAPottCg_uT>gM zOx&<_6y{!`MWqCzLiC~pK<@-~%OH)k682hPWR1iw6-1nZ%h_J=lAG}KrNe9JT_8fj1aerWf_3xd-ZLs6$F_Kn67jt7(j+@?eIE3)#X^})WqwSl3c#5j{O*m)>H9NK z{=QY<;t!CK!&w^gC2GJI)`n?JaHV1uV0qVS=T|@wviW>NKkvLBxIP@#5!M?($}@$6 z6AWS_ITNjR-|sC62TzaBD+Cvs@uWv*$*`YH(Q9RQkXp9SBn--`bn3#KQ(sy=73w~_ zwfCCZ{9@O2Lat+C=tA3emQzRP{Bnfp(Kuk5awj-EMm%KgD31hgK4o)h;J*Uis}&m@ zRY4m`S;ZqaC|690dK zMxkiy?(0(~LzVt?n0GUJqchEpW((1WJMQksE2YG-?xyOw?(MHj3~W#4iUMczY~tfI z6ZR{Zt^~jz(gmg0+R>Ws!7`y{Y7#cJ#h{Yk<|zR_{yP72f@MIgHU&-l zIkeZh(Ma>V5zn+rV+O|`L5N|fdOlW8GRsx6wK1p;N-nqzD<;`*+N2a0!B%>+^LAN$ zlepPo_duG6$a0@I?&@fi0TH-(p9f&T2=_^~8hqe=4Oq{2ivwT#jDPqr$rlr_W;ORI(Ym&PfbhjSsWK>-ovh75ZHYt zXBIT2^yF9$tBBpf9Q_PfK)Y#&QNX0P1>fzu4pKU1)#%3$0ndjasiWc@-Ug`Qj&r+u;zLXIJu6}wves{Hp1dGO*~l=6N)DyQ zvC19^v22B-PJ^L8H@=hMch|Of{y{YfrJ2_okK{{9 zm16S9pEN`-ays$N3Upt{@Oj+s^W6e~9xYfs>V^SGv&&_by&HVpgth7C5z>orPbCpU zy+6E{+2PG#u4*{zFYOhso`90Vd_O`;P+yIHcuOCME5cN$HFWSXo$P!Nh~S{z_~+8* zV20T{0aWlRoF@1qFevRo#GUIz(qw^61=)!`OG!$9{hE?8X^=qH*r=TTME56J-DX zSUT5f1uJq9Zf%$km#{0eHT9)K6F;yLLc6QoJxb*?x2mHWpe)kBZdQC#rC(NW$TvRB z)vh`!gmflP>je?Yn_NxuCuhYcJTRm^I$7D{7G#=clTjp^xvG^tVQIFo1?N4rG6t#3 z=*{1D7qdj@%TdH6;%8lMF@1cbT}x3~MA z+ZCF)Vm#GzxZ`!^}@kBEF9uMmE+^ z8L=p!oOhx>B8ko9nkKpho4bKbkx!4JN9+aRLZoZGw@fo+T^pE*4vzk{>hN>n6HUdv zR$4jjjuoWFMqf1b#SL{>X@Sm^NRXO@UUD*_hRZI%_=er(~jti+k!3;;sdOri(7ue7# z0}AG{%DKwU)TzUL=fuGIuEoP}6QXKuGQx;s-=y_?y4KTP{_Z9ru~{8*-GI4ckBx@5 zVH$JslAA+DXhCsaRQWr;&%zg&#G?u(=Q!3OQ9f4zqb+UnVTKwNb#vP5k1Po}7atuZ zz{xnkq_tlw;AbqV%h`t?=6i*nk23fQzuRlDSiTHRqNL@-*nkX?Be-76@TMDWpv_jZW zsqzUeazhMm6ziSH1=$q=-YKXo+oYv8I`QH|9YIMYz4e$KUv}2)A~%EE%Y0E|)k>mL zI^yt!?nlQ214LMxmy{p_G8PqsO@1GQqq7VY$5I%LcN4NG0j+t}HXS8(FE;8KSQBWl z@QpZys_QVug@BaDo|W+EELPBK3NtD|?PH&Q$!5d$-bU0ld)8UsO>}c-j`0Ltkk6~$ ze)fAGZ${73)RV=|c{H-clV)pq$JYx9ovVoY3$ksg94!{#%MST`&?ztb0D%(d626u> zMdwAl9b%!rjZ#n-+!CvvX05Vj9}n%nZxQ^@(5QeF778se7|I)QEHDH!L!+)k)Yrkc zx5bQ%r2jq5`UCPCIK?t#!1&(ych;~W$<&_E3^?8gxL&jIQe!oQ$W@i+#YH*ACZLV> z5^r;zk#9YQQ2B`L)3F=^g$LcFe2V9CxM+LOM(>l3@CzqT3P^jEIpIWIpSri3$lHN?$hHmhu)u(r0T8&Z@VUIX&@2Qmd{+B}aq|e@9;6 zjD))A>g{LUp#buv_4`qOYa96GWwlQ0gBlM3_|eqORMCiy)c~RED4^ea-4D`!rI_(3 z>5C``M^3((^DSgGTdgW@WV{DY^Xz9cGkaFMH4vwVh#zffbmpXKRHkX!iG||!@HD51 z1Ri*Q086wuE0e9~tz}ODz~cqd#blAC5I!$L0yH3V!&ii6AsjB-a~h6wIhe7uKADOZ z3BcZr&NW3dnZGi~t%Q}e@1C7MPYeMJqht5X!;!`BEOo!+T(IrBG#92cWOeXQ1-R>Z z{t?TxmRf2l-FElnCIO8Dslw#}(GAhxgs|xcr=U^0JzkKCWM73-qI>HD|0do4`89qD z6&WXf?cJbc^~Z4NIsCwBRaTpo8BJ^^GyDcef^m574~0cY^URxE1`K{VGEq69MlHoL z1wrl?E!q&hw^LSw`NDI2j{7z4l&lb`IpRI+WXk%zlNVQeqKyePHVD8Kx>rf$yVeT+ zu!8}~nj8lbJKlm=atH0|$&3N;A;N{RHU+x*?0ToG^Ye|A81d9Lu^47HO$@0P$xcpmgDwX%=-HfV8DHkBUix`-+a} zfd~MV;3vhg@vEurSbH>v><9ciZ=%Az4%wEWA+Nmu|i-VhY^QO;T~iY8m|)Lm0~;P^{l@@0vP6ogi5yTclBNLXaM z_ehX&%%Z}fuP8qIRmDc!A_UvfQx7XDVNRa`?mech)Co4 zjAmzERP10r;Py&?6d}@Bdi`*QXmM+3C zPZ0T3#?QHktPe3H+U;7soU8<@*WkU1Lzds-ym8}ZE~Ldes63A+)9d_D%lv4Rr7S+p zt2uB?ZU#ikyZWF6Tj*;9A!E4yn7}O+el(FUbYXPf2cz2Cy3;MTqn3-n2Y3Q#5ght& zujx7vi7%AK{sQUu%?E=7bKz5R=pxdz;fFZu!wU1B!3C>!PGGX8IhdX~?mHvH zikaHR$UV*cDVbwDDi!-s2l!9PQG)^!WdAjTlgj-fo_o}{=lOFsZ%jUPJmP;AzL9JzcF z!2kMfbMLEjYcBLytXsMDfzwWcQ15zPs3&F~?F}NVr*MuBg0wUiT8TIAnse@ph5>RBk4%auVMz)FXc4CO3v8cli5SD; zqjQ~O=5udNH$YcF118}xRCnF|z-b_E;!k1=el7tt^8cdMx&^F$e==z(j=Vd7CPdZ# zQUrVHS&-4A9Al+DgIR3xMmLJ6H$930G@{N`QLfJRmij#QeGsEV;mky#cnIwADYNiF z>b3NF1G3V(uRZn!I&=iR;ra1+wtm)O6vKjM8H4sK#7omQxYR zd5&Hb%dA`G5QSjMpSo#TR(OX2S=s_+wI^AD!n8yCtFmi<*e*(PQFQ5*x2?jHZ7*!t z5Z?^8Yx*VPq(#Y;jDqsR($_sFI7p)Jw&6iWR zw&}b|g^Cz4$Au{~jF)@g4<$Diy9!*eqw~X$VD|RfCRux1r`9)w!D-Cdx(qVVrpmkH z^u20F^3Z)iLErsW1Ph~oES%=1P-`WHU-bLcWJ>+ZjBih22drP`Q zN9V?NAhI%o(9AjI0)DNii!dVJ({%9pX>2n)aj#6%9x-6i;z|t$LfpT!j=V!}RF2wZ zSoa&YvQ-@%4hc+sjY)jjK}`Mad!DEnI-XWSa;IScN4wk#7;j_-G4_jqq8+;U%A$dq zCG|j0`79&IUdO6atO1@ibn8~C+?@QyV&A=w9tWuh zuPLZOS~nvQrYV@OlPh+H>4q!_jHe(9x)V0K4dK7R+ov2_QZybz3yKrL(urOPe%tnC zYdi8P2;rl#mDrqT)$z$MZ#mm%AJHIBo!X0S{$qq5c>%KP!o_`fT=dg-qs+;cx)6H< zTl_AYBBWovTtt;?!Hpdhvv^@j`k1>Y5K*n1YG!3VHy3{TRW7%wmUHC_C`MB@zWI9-x*LZbB}V06)L5LINP+nHX-+M`Bn2(uKi%9 zg;YDLW#R7fxGZPP9)$MMwc{;pmkn#3_|+N4f%q)6rJ$ruFuir^d^^w0ly&tTm@&3# z2&i6WBL_BMWfUodO>m6?FR`{^sfhw~u!BwPeJQ227X?=`GHr_B&($RqU_eawHjOC? zaR37)J4@}V{0r?BJ*oK7C^DR|jUZhw;J!^NUbA(Dj>1&1XF=c6z0$jAP0 zz#d+LEcATneNO(@TR#P=AY}qYP$4f=fcthnyW)l47l*Yx%__dzMTv#nBO$`M0)1)T zT;TWfTGY3qS!Z)R{4koqFy} z=R7luvo%VY%Skx3dvJlTI*G%~HIJZ+VHr-3?z}L~%f$1(!(0aT_|SqsT-M#zZcz!k zl=fV?gVS2Axj##drY-dq?N6Ir;yFH-weqgLoRORE!mbqlV_}k|`han;^4N;!Y;POD zscG3b(C@t2+6m20cs`yfZHTmQZ6!Pwd3fLVgdso?& zgT{&)Lf*#J?`@ZWSMxIi*BeE35%c0Z_ZmBtB z=yhV~bM9+->&a)f9MbvEvX}F;57g!7y^V3b^VIiy;csN2&VJ#mxW zJxMH#xyn{jYkOr(L;`}3?=s7o!?>KR>Ryp19OM|f>t;7}^I-#alMn`4i@#&TB#`<% z-xha489FZ7$fhWO<)^UVk=hH-!6D(h+FW~p7@JuX z9YlzuA?tB(2j4%*c{enOO1bmN8%8^aY=-r*eU7xaz@t}QOfm3sZakA$*HItDh0))P zao3%23Z&hR+qqsB88ORdiQV~YonDCF(;D!?dksEMqdbxBYnJxeM`$NkvGdgn5`T}h zC*n~)5U2}szVXmxJ=Sx=uL7b@F;U5;9x4)pR%eyg$YC*R1~4)V@JD6+3GFclr@NB+ z?0{0wSAhGKnaj3|UyJ6gJ3(d^ zibl7Hxcg!G`BJn!l(JkiRHcUC@bYu&AqK7SrNKE33tbi2sk@M|L<`+vepR0&tSZ>Y zS$oGLj3tK@LR(iT)(5fr~kJj95} z@zLAxI{DFOy%b4#^@ua2FW!kdQ=O}J+ia+u$;37a_1uNJ;iB`rfl_wbNT#IkDl_uRS?82mYibOAc7(!ao?ePyD)T)iq7zz-r#8uoiy&n% zTkOdW-%Y)~2vI*gho|B0@D)IG1aDW_wYpHEBB$FSNW59o$4mTtu*e$1`{YZg$ZxeZ&4LOH#CLhehZ>M?k}bP0yvaQ&~UUVNy!JFEDjqqhOSK z+LJxCQ|mpGra!{=#>=6?{iR(UZ)OsRs2caYrdK`%tYs^^^jHX3SdH4jk{5 zIzDwK)K-lTe-U=}z0{Y52hB*>=qa_OhHAb;YNGcQFa1TfEU)u2RssX$ao-WQA;2tZK+$n+aky;;a);IP;xdp2!XjA;wHa`(OXOh+5DaeHrC ztP+g1=M2zWyTkj~*L;|P6PR#P9mQY2@H1Wmfa;eqPdnk<)LyI7;XGs+cA6aL?l@w7 zu5LU?nX+{4huQ2TkG$xb6*hc;6PxmlVBmt8pb{-3)VJC2}yeo#)m^jQzr#l^j;dxA|woN83p&ZHEd_An7@*@l%5JZLb z-K{+#bP?aK-DKcoAGv_A-K>3aQzDa=kt{|wUmk{@HFiyAzT@UT#|6k?>$^q4%Nz7F zqS3$J)(Alqv3b76AHfNWbuHEAb-ncA`R9&8Z*mak-NI^Z)QXGbJSE#KEQ2;GDVmBN zjR+_1jR@Hja;XP*h1jbPRc@C3G8sG0(&6pBpgWxU+JrpL`J_(F~n>wj&q8lGhS9w*}zpWC{hwl&*eeM+(k6 zw59{!8%Fi2A(2^qRjt#{-Y`E1$HcqJ(4U$zd*0~xoV*Y1gW-IZjpjv!3D=H|186oD z4y<0cZDcPRudJYMZ5f6D(lto}pd5r8Kh8W~ojIoRZ9uAp2ThVa1d= zud5i>3wH8?TDdJDRMdrC()&eJCq#y%vyZk*6$Gse$Wo!ozXfXE+bbGC0SY`s#(kpe zOGe_n17_WFiC&KG3WkJE;kc=pqXI}@4ZR)&{@O~b$GeYYT@0* z3Cu#Femv-DbG!Iji{tvHYB{17rJc;tiOfEZu5~+SqXi3(8D1ir>kMDi-b;2vbm2OF zFTnBIvN8_i%2%6F5a2|ud?x{>r2sWsPk9x2!aVShdWWVM2b2Mu#vc7$`!B=AfChk2 zvtD89-h+GWRlEqRHI#aa^_awjAr9XSZZ338%*gi{jFF{BfPzACs`=|L0{#iTD%gO0 z_Uy=sRr_JEqU3GXf?C7N9HPb^3gYJMo{QsY5Z2GbOR_Cmprj5)j>4i(f%p?G<9S%D9L=b7gD%%J<+H zpXn9RPvd(~SLB;WAQp8RmB@N(^G`yCvVkdCTnPe{P4U)l)fcDb=0(~pjeHo6&9kota2~3l)$m ztN%xlJc4$z(SpjcdlBw+Dnbtl$AZGv~GzwT(gx(+{ie5Oc&BP20zWg2B z?#z9ivv8bRT*$?sKu6;1*U1L9MKR@eThzOU2{Qu1;=mCWd7=$_es5NSD$c8v9OOL% zX8!7PM$mekvKvLK{XX%dly{FH4^*g2@Lo9dEoh&N8{$1UIs1%z92RDlc6Z@A{O0c1 zt%9~xzxWw6QEgPN55oZY$^-|aAxnzQ>FR5aIsOQ`P#rlL-km=ymcfLp432G$3 ze6?k7fmCzJ0p8-Kr>xkd6GqlZrTy~u5xN%E`bCd{gJL=R95R}R6|HCzdl{HgXD#@z z7-V(w*aWQR9nSlG)XB26j?b+ov33$eRV{3D56n@hW?+~o!H(8^w5<=2!>chCgi|O! z;Vm~@w^pc6Jy6YQFWNM_C_`q@ZFhrtY!K&I&p34qzDMOYZZoxE0R&4ZuG<#@(3_;( z+jMd(e0wWnBl#Ndh(g2-Mix;j2CqIg8bN*M4xh8mo}?|Ggqp|0-NoLRwB}nz(W%&Z zCesUH83PrGfAfx!la_H!B9L<$$4FWTMA9TU-|nyRjwlQxVZ+bm5Vp;if>VT(ovRoS z8lEM|X<%4^%Oj>sJI@n^ zeu1Atl}08KXQr=R*lN^5Kg8Z0^Auwwly%Re)Kq9PJyN;i_mD$7nM&I=NNl(~mdNWA z2zAd!BdPgbFy!diW8_GdB6U%i*PKC{;c_+OV&67VP;Wcw z;^K=f{!GFYx{5aNcy=_HvU5nU=46A|Zo#PdR64ap=c6T^&fa+8{j+GBoQeiG`37#v zIc2~gBn!|d(7So|B$X|?iHCDsCos#P67k*SJE=6qIf0>)gaBFqSvAlz*tK{~1tEky z*+S>W^o!9*31nDngqo{a3z%S((YYL3?Mwn$Dwa^aLS3-1zMKPF)ZCMcG(ca}QOR=< zypb#$&y<~s}O}VQ6LFHGoXIGQy!Uh&fIN!5Lq3aI&_7kUe4XU zmWEK&E5`}cJCUWvWNXzqMsjc@f02WoFA8!>rWkQ*e-bzZaim}TP|YvdMkZ|2fa#V? zZ*RBomjI)67G86nZY4`#|#>b&GDlHLFxG}3SU0r=8$X$QEB;urYx3EIzOhhxvA*}OO+ z-X&Jct7^6C15Ezp(YGwLa;H3`v1-k!Gt4i{8I{1uW=NrZk z{)Qz94t_#CiS4r-E|TNwY>f~9czJ*cs25Yqhxd;mlY)_z{_tT+jCcdOnRAy`FGyfK z5fcw%mjD%)^NnFE)4!^aJiOJX+XgjEZie0dlCsGajG<*7S|;Xg_o;{=h!HBfxzqV8 zzAo0jPnXJObhdT@mcUb;nuO1z(R|{+ooidan`ctD7bSmJ!|G)xy^7k|(vL&zboeN_ zR!RQFqUCm&gN7bE!Kv2dS!S-!^u%cAe2s}4!3&(UA+|yRpZcWlcN}Rh;|3*Qa*YG&g*XOT z+9cbo4EEYgd-C}sc&AWX?c{!e>-1I2ddlB@{aCKMNMIu3KCDC0DeY;G76wCXe6p-4 zK(_R55tyv{f|*r2C8;7DE*L@4?3sAe01DHfm(Ma_Oh`m3xNQ362L5U-?QXe zJF5lJ$T;c#RHZ)U(x_HC=}V~?AKM^&NbA@_V@cAtuL&>zQ*7;tiGuG4r;kD|q_4Ke zQ^;$7ygT!J5WS=+i}Hj%41c|a)0xR($neDXMyi6WjZ?+lsDJi`dP}+yX#=TYycSSy zKOe{Qa{r8-&pSj`e#+!@c(4E^@2^JsQloi0)!u2By%bP!N!!F*Xf{?mOlz9^@zM>9 zJM|H^Ryeu`9J|&DnUKRNPy%oH8c)ZTB=oMczOR*a%&iaI)QCgmtXF4^^gT{jCgXq( zS3yCHiupwB(rs*DRuKcJb(l0fn|Tr0rCZ|c1%$#^A%e$ed%)z)abZG z2Zx`!t8dtTKnQm%&fAyK_tWXVfrc6<8K7~S|EkjtXXp|Hh`Itl8Gx1WXx-C;_TR39 zIY1!OJ>A!Rx>SlYjZrtVD+(;78-Pa9qa@r{X9|Bb%b7Rh@@)dS!t~V_wrHfJq)y1C z#cRiVlR6$wZ|l2Ap4LY|hugt*%r1p8<1*D=6nn_aEN+%q1xHlNW5zk>gyH?lXBwov zKl~Zwhwpi}_I@=}9tQbg7v?E=M|i%0%Q~pNaoNzXgB8W|oFDg?lR#nT3i~c}w{xl- zx@1H4ZdbEgiMiIX!I%M{-9~wZo7DY{5{lGW$`sHuFSk*0TlX0Z5LqwAs?#S13f`eC zj!%pI9DN2}n9?c0!FPzSd2Y)`G-iblw%iP>Ktrg+X@4L>!K5H}pM)f78){Rl+HUca zyz8SG-f_g`_2LFx9P&%amw}0LNG!BI*&`n44R?)OpFp_r_cS0RS9r1}PhM`wFr7-? zTFQoASb6jq`R8LJ?W7(V@W3+&htek*f!dvtz*`DE*pEREv3($dtul+fGO2Mn8|u%r zgq(^xu4+5WgRd66_bD9b{gF+=9nz#3qjH?G^??^O4>bPG%+wiP^BACF*;-8FL{Da1 z7-mA01nkipa-mUjq_l#%za8%c%>Tl9^F2=LtQr4q;kc6_IkZv)$tl*Z8}5WwI{ zX#T5>uTx0w*qonvY_pgWIlvR!;eP}2oH0wwQV`SmOpV3UIG)31Z|`(J&jVe)u~FX+ zXMneNOGxUZ<0Zvrt64ax3P6r$RPp!!z4u_O=gjgzzg-)(V6ot__{&R# z!Cge*$cv5)IV)C-a1zK9+VFyS>^JM47fQ7-LUt5TZ=6qBpA@~$|IUN zk_VQ)@PH8>6t;Q$?lE-ZqH52o(Hgg^A)rEqdu#pBFAqy3;CrJk(kFATSA$`c`KUT1 zQEO7C<%DwB!pqQPT47SRSE$~*`gnax>%&w?`N25d!1Wnyc4PrQ9_38m%pP$l8!{bIs2U;4gRw`G}Y2iX(D z#^qKBN<%mpHKkL~nTM2-2iHBc+R>}@Sv$h$koKB{0|5>92i|5|!S&askrTtm?p|a2 zyl7j3*`sokTRTIn9`Cnoy>qt;q?dKm&@M$8+;SUST{=#!SUt!pS`>b`LHA&cO0DjF z9Qo6(3Km9((1nNht|uSG^U(Z<0_TGkB$Ht8ofSt>vNfql9f!d<8I9V?M)jl4i5O0F zau%F(ENi$aPX-B!jR-OzfaGMCS^lVl$z zRFCDdZakV@OsSsFMN`8cXbFt92Bc1q1&QHk(pRdjX|RLV$#r3S|$ zojRqNXqXM&qlUzIKz<`mInQ}0Y#}7eCbG8?XST~9ol4y#^IkTfiKtfn3;Y!R@qhm2 z+u!~2=N~_x{hxFFA%A~<`FF3{S6PP!ku*Bcp=nSP>Nxw9Nk+|vl}UB9Z0fWvhUOG% z`E86Iy?enm*L|;Ah$5fh#hO4g{I0{ zD-jEJE=G79-1;6J`5oVc*~;b=UMB)qhRrO-p-apT;CG#hKy0@60z74r7OwqeHL5(* zA#FiTqKSw3(SckVOKWG7(&!$DfBVZ{){j4(^6f9a=YKoj{{H75KmPm=|MKJKKm78i zT<0H1E2w?@n?L?o`R5-$|N4ji*ZvuP`_0eio}bV6b-w-0|Nq1O<8QzH)qg)f|MJt1 z@8ABi{I>kIeEZu!=J((KbN>GPNB(ku_0Qk`@cqZXeE;^>fBfnDAO7io{ONrAi~sVU z{{26F`#0;y_x;nKfBNzLm-6jz_xaQLzR&md)8`Xoz8dTyw9Z`tG!N{I2v4*$oIxLS z`u27)*b@{(W8@2SkoV=Wc9&y(r$Lt*i_JSTz#b{i0>_@Xek3t^(u0ZA$Dlyc1QpMCkba zJ!@QQHSvdzdZcUK!jNMf^yh3o$M634-?M5R2XC8>f^@>?De!ae0gQum3}w;b_sB<; z_&i40#)F7wXgjhB-9Ha94*-kI=4=!90cD1k^wOCZ(L{M88&=8nYEx;$^LPJ;KLwR3 zn@CZTb2n3*L-~rKK+LonTPW#OfJ#$eO2s!%UEJR5<>Eg!3FWHg9)b6Viy0r15P z_|SVMU1JGoOI95_)0VjW?*H4Y{HKJkG(hh^(@Qs zyX=~~x?FS?-Qoo#lNJcIl+kPLaqTc|*^(c4;RW%AbW3aRy>@ljIVmEl2e%)XCo#`6 z{9imEfrOZ68?dpBKIcYcM*iYPHbqx+vqaWQ=Djx}>)dnB@0`8Y`mWC>({m{jU}X<# z2x2=`shH@T>H~ev1%8f$u4#}V=?EdgER42zD&ru*jtju6N*gEN{ioa)didzmB`VaV zckP5HPCf{Q2Lz>i*eIow#*$Xu!GTv=9i+sC(t_9q=ucBQ1G_~#)oR~w9#F->WXE4A+n1BG}A*(Q{sGWIkP z+%{S9Sls?r&aq=RC0#FY^Yzk!d!Ks(FlEWFI2*vZ2q_ zyfTzO!2siP9cRyTjod6oSPNu`)$?_3FRk%$%HF;;6PQ`}M z{c0{w=?#)=ZbXq-JQ2AlLvuTK|Hb`#WD6CDDGg6>lRcq>Nd(?9n9ue|x@{RiWv^UYtq{gbbM@Xh(`<3IiMkNy4+Sw&$vt$V|4CS?kM z*D>}2%ABd90+j5=vjBAj#c6Mi&>Lg0>uT{qMQlDSa0Kxr>5c}Gofqux!>N+GDS=$J zGcQ?2zoLLQi@L{tGrU^Vz5o65$;U5WeDc%hD_*VdzVrN(`N_*qZWnZqeg58D(0%{o zPd|EEpQI-$pReb>^XeO4T+n^%<4<C>D9tmhBL~;3P}XCMCt|MI<;FJ8p+-;U?+|KR>x_g_8z)^%Ho)JF3{ zVN7LP-ta;n?|7#oSxv{8PRyXqm_N#64UA{27FLMk8njoT-I97@7wwHf8((qTy*(fM z1ip29jwkv=-?%;Rzy3qso?IH5@N9;pF#18IQYahu?pQ1-88YTaOn_c6e6Mxs4G24K z-~h-ZNPZSt|Hl}zHpJf6vrnBW?qx4vu8k&!*vXOBD)Rtfy!$WTd-{zBJ|tg(UF_{m z{K$v%z)k$U&u-rz?pM#*&#QvFgJ^AY3Groe++^dLu8GHgI0ZSS`mcN5sw|t|X+wqj{SUkIAAq4-rD(wS(Xs#!V_W*YvRu=fP|G z?fZ52+t;!<9>eCb)5=4M*e3JJQxyu>7!7pIhkCEbj zBYo1L9$kh+;3p$NU*;(vs0JZAeq zr*x}&9DY_k*Y;Mgr{=kRhCFh~`1aoN-+lJUi`y0IW1q9PibVQE?ad|XcV2zt55GqB zI;2-uY9ook0{Ezv!MO_CIf`pXJvNRcQgRjcjl?=Bcipl0)#-%y+|$_Y7)8-q33xTm zoLwTP2C&yAlnY2cdv2+RZn)h2)vKK`rtN~7IISZ<<3YE9f-LZZ5HXEv?&u#6Vb(J% zGwwz+G8WaEJYY4qg#U&e1!TCDoUH_H$-R$Ui$DNmNL&d8;JG#_jIEd5;Iy&$pIS0Q#+6 zaD=yxtb_bbWcWQWXkL8Q+CAwFIi^2NLS59smg#W z3uuRZ<{1()x_XyGg6Vd@@yI)~&sH+@!9RTUEc)*ApML!E*++5vGQ!wmr zJdIv`_x3Kz$Vu*jFo(w3>}W4**2cVw3#g=kPUdI z90CvyE4FzJScHUidgqUd2F6X2I#$?oMx1$6=UWxTM-Dc;zU#g_{Y8B6*-rP{4_2-p z``o=%rO_wt$s2u=Z{L6Yi(jSrg?cnSun6acs)J#vA-Z_`6kpPSALq#+Ai1j6y*d<( z;1(~;@|6Q~5(KovJuXGZ5K{V}N~e-oUW7Sm$)2Tw=VXV-t^%s8#u{c}uNUE0cjNAQ z5~XWXRp|Dk>`blhq;2^wq_h`0$DP(%YUF22b6L?qs_!FEL&$CSBdyHdFf&|W`HKlU zTQy0DybBXAo3u^aE3Ir~MhnJE2JRS*xchIfH3j5wA2VMe+tjYg*Rvx&fdsj_&g=RRwVJ?{Ry z_b$yVcDt2UKV{6i^(s8M0fRU$^v*(=ltV94%2~MGdiBJt6%)xLDGYVQIoD>0pnrkf zOEAh##qz-hiP>-1ru!OqVtz7akGT8qISQ;&qd@VENT9X4u}&Uqre3W1$+ZMhmbz*t z+zw00T0*K_Ob%`*CG@{BLn0j8gZX@9Sj_}{g5}<}U9NQ5V@9V*+}5CLp?Ckodr!ar za6L53asXr0Y*<%SxVKG@)2guKIX&LETJB!y;W5Ql_rKva+=Z1Pd4Q zc*G?*W4uulNPyf#nWJnQD2ylbbX#e8?8ABe5cuBqm+`^*_;s=68!!LT1CM~lS_0m> ztiz)yX3Q*lE){)cXocdt2?ni(VS?!fxbz7dTU*Wj&?s}M0CU(^WINX;9%Wk^PAdF> zmpMthSKu;H61%Z8OMG4q)hFq7Nu}-6Md~u5hs>W05m$J>hI_HZCFX#6NDzlWhY5wM zgam5%uSi(HVPpTeQ}0ODd0iI1iT2KEJwe zUsD+}f!*lYN%*`CvbT0Dl`uwpGMK@6c1{6Ko*4_`@Px=0BM7uh1MtC_eO$2OSx9K( z#@l0Qf;hLYatwS(^-?axivv)OdQ%An`mpmccUqT5va~nKFr#$@Wv0=zpOm$MOH@qB z+fu2An>;7wbQIp0)$=%=`P(!XdE6$9MUPfv(1Epiafd2`zcg@dGkJ7#IUoCQ9=x1C zczrp4{No2drp&2<*2WW`i5c*$*2|lTLoW;Tu7dD$uTBjhi-9lNKw@cbH*Dh_^U^xizp2Yv=ZLv*PF1tPqW|4y)&3gL&P4 z#Htl6O$$?1Wu6~QRd}5#)iD%&)-@gqjfPx_?3pHuhBNA7-E|yDGT@0AT|Dn(Wm=Qd z>w;{bds(R#ZJ)hD-@DWPs*L@rgnj?`Z5=NLu7?qqc_Ce7gv@IRjj6y%RXhX}*cQ-e z{5@UZj-y(d5S4^w-z)5ES5DIljC&;Bxzm+ptOPHoo{(#TvV|VU;K^uuwof-yqrdUY^&$$i0u?~+} zl-=z{i7^(S7OHTJxn6<`#bgbuN4HPCP~MsLlqxLK393qu?P3fPfw6)avQ%-Fr%C&9 z+Lv9`r@!(uHV&9Uwu}xjgLOzl)X+Hzj*n3AI83| z**^Bkdpm8cPqe(*xcu(x@BHG|ZSVfaYxt7tk`ulPu(2#;) zHH4rdfXCy~J7cS>A+0|RX`A3fE^2 z24(w7t&9%%sPW1cv3~czauhJvTbp%MG<@?AF|skTMak5`4j-(|8Wjx+6!UZP%v3>H z)!R8UB_h_QMcS@xJ8Fh0R-kxb>A`Y4QD;ATK5M3az@F~9Ys2z+3@gFmeb)M3D2-MmUe|LB)`I_Ge+NgjO}O# zqje*>bVXgQvH{%0E&%SG?bdB9st3$!)4bx_W;q?j6LlfDs=?fPtJQCAmbrSovXn>q0Yqnf(8u#bH>5AMK!`06VE_{Z;F3~FGin`!H17}jy1btW$`BU3vGC|E5_ zs^v6b_Se~$k3OsL9vtq~`kr$wSp^JDOKTs?nQ<_%V+e6`EgyS7^b5K@E49|rs?#D_VHx6`I+k?QwjvY0 zRVgeo`hlO13jBx&+0NV@3dQUP@gW9~v*(!t($(RcDJB|=btT*^kjB?BBkk3kwpRbhYmbX-Q>|IL$9nU9)keS4P(Fd@{ zy3$S)jA0v!1pp$}WJfa_rYD$}o+c6;*}kft(ieH~Ml4}Q>6VNXNXhx`f4|=f6vY{y z9679xl2(~Z*37Pr9hju+nF^s}lr*;2(dQw3$AKS+WIJ{k^g!PQv>o0y&mG|X8pNb$ zoI~W;8Xf^(bl?yB#^ZPY$8{85laxTTsJ3-M31i&!VqJL~DS9FyJuv0gURKGGK^o#^ zKBc9iE-Pu%N-Yw%Hdw}VL5vtJMQtW2H7QusTN;Nw8l0x&rJTF}^SUDJ@{SQ+OwJ$% zv&^gDr5$V}ouc?2u~KQ{py5QF(rcbnERNTN3M5kH%}t_rmN`7s=4H$fTy`X14om$6 zuKeKfpe4QsWQf1UQ7j>IJ~S%F8;$^LHr60`OnlCMO45D?P49KsbSpwyccoe{k$6tz z6&dL%zkwsCmp%5q$~;>Sh;LBg43K(WU<2{SxRrMI*WY{k!-qF#9cHaTG06+WDL(78 zi_NxbVowRj8jL7Q&q=IFv(Qa1WA!?K_iiT#RA8RqYfROnPp!3$orsCD`(Be1)S@?L z?2?O}d3f)=1?_s=!+CJI_pQJ1?B%lu)(OC+j?dEIbsxq<^(2z9hW8!9DZ=|)OIfv9 zRM+L3sD8Ghi*kh=%sf~U=T-;Xc!sAd1P-7SNyn}YrB$DFjZtku@C3rOZj2Ec&Kfrs8hV=7;{J~8$-1~)n)`(#@TJ2Dms8< z8#BJe74GDjjVb(^ENShEN*ziB6mIc`b&I8YK|K*FbBd%zeCALdbT?sMaldsbY1+Zt zS#vWDP@|}!F33Bo)VXL+3BK{Y8M}{K%tyDe)0ADhBR&%ka(vUaXbyK&4lur5Zz%D2%#V zx)h{3*5vk*S|{;RZB6$blX`0p$tBO^^KjSk$d^h6XL-#i4i$8}boRFkycQZB)_GJc zcXw+kV#>@{!>G1WkCh`kTr32t@1YfKC$AGXm-Mj@=iyK1wf=njQpRj{7^Yig;j7<# zfPjwBxHZfdD-CZuPxetjjjNwUU%u7mr50Uu5PFPWm&KfN?1j>&^vMB#RXh zNgL)Mdja&RT** zuCA+~HO;)DNkq7&V;x9i&6cf`Kg7!(#+AUnge>PGBse=7l&I~TF)*PrZvpb-w#fO| zhx70_^b3FS;)D2T#@?|XDs^V-kj-bXwa$IvMVlIH`o_8=JMA5Vb#jd}Q-uw?f$wNo z)*Q#$S{1s4u~^SJb!?eq_C>hDv^PLY=OmK5$3Xy(&3HkVG;Tk#?9*bR1CUNbZO-0B z``Myn^)+;2F)8_AHbo7BMJl_*WilE8&03Naa%wfD-RmmX!o4qY*~|N>6kfN&#b6@N zWfXi|#vDYxErmVu;XM42<(fVe{v)=XQ3Em5HyXOrKn6RH5#Z01LI%jK%IbjN(#4$ z=M4gcty&rAyPZmX?8ABRQeI8opFVUkachY>+Yj%#^pz5pVq7PHd>YUTc3J{LN}>;1 zWfs9cbM|PBd_DaBITc}w!+39oNt~otO3_Cu=h>&m@vrol(k!vqqe2`R5GK#D;&&-;K^b^!iB8BYZHdafCEJ9s4= z9mUqs(vrc%(8Nj5$~Y^H;HjdTimrTHDSqt3dGKO>^W}@*eW;pHm5Q4ffyBsV)(FNG zTN$wxi;;pu%Xsc>(CD`^DMv-oTq>TCod+`B1A2ZpdiT=R=UHJ;vMY{GkoNbhYvMt2pCpTV^1;XZZnsfo36oN zk(<_`QIfN~%tv&3_D%3R^Hi|uK9jl5DSO0QAIrx+oQD@bzvmx4g!Rew>SWCggoqTB z_dPpP5W;G?zfe?No^P=keb_qkR+XEXo_ zW9H#riY!85@;R^R^%IuqpRqM6YB$k^!qTXOj>dm#TFGm7ELtr}E;5{Cv$s5P)Ch=+ zHO8978TXwlO2)s1-*bkyjd_RE#HkI?u^IcUxh&c?owx7H$3C3f_RTx0dyE{=qEXeo zj`g)P!^Ii z*I00P*IXMd`rc_(oj1FHPm;dcXR-|TQm6{zd9N-fR1=Zy&L_JZrLeTUd2OAEuc5VM zJ;%wVm6`~ab?ap{t1Zi(>yiPY1B_I26Zm#4X zRNZSan5^E#yiLHgEZ8WVkIcT(w9k|B$Xn)K#W61(#LR6q&6dz`r#05uBSzaj691KK zMf7AzJ=a1tBgQI~?n4XGljRT8C^!r-)Yq@$DenYKcdf_Y;-4Zl$9GnLzo z$s-@m%_aQ<%RhFkbY6k^>}8f`z)y3XyB?=>!;Pf52G-bh(rSeXUzOIPtm~nik2T1* z)_1eRBPn)jviC6XGzhRNe{!5L#@@LL0_0usDW*5CY5#0^Wvn>c+GGGf$cGv^$`kwW z6z?eMhmqq=)R49K=nP)U$|WN->8FO~vc!+H{D zH#!XBL~xR!xVLT1HTE7}dt}>(Nhws0(R(F{mrvRz>GM727cM1xn@m--lGL=mrA4kh z*iV)PASDo5Bn;rWFDIEk%bfV%7YbF2nn@Y?1)P^k&8=Kmu9)z;Fyy7vLlak~D%{Bv zqH{|$z5RGT_Tk(T#ot-}vAvdV2NvF`qc_AI<;>3e{@N`YVPdf$bm}NQWavKqDk$$v z5HYKJ^^)dcUp*?dJ8Ltnt*gxI=A|gI*~+qDjFs5ySoJUDq2x&|Pwc*=$6W=OvkcmA z-j}yt<4~-|^~OB^*hXujOzC}e-DhnEDXs^6u7Xo;tx}m`TZ9SMnxhs}Y@)r#(xpR4 zqqmVWfKAr$kvbf!+mhZRAI{Cy{F3_5(vxISNcP$BSq;xs!8A*4nL$s|&i$0?)ub8Y z)u|C)*-GhdVk$Q2r<_4(m>j+Bvlt(Tnw+TmXdG#~4^1KRz8I>XErwP| z8y)>!mRZPO6b1+yoZWJQ9*2A!|6^ss#97E#L?Sf5-= zGE8+0`|rGJ3>5TjBLoJpIo_tpKJMY%el*`%{%JO#aZrxCY|CxYUuFcc@`39axqGdJ zoPtPBWr44rBkW*14zi_fTSTUKPEoIWZYI^Yo&raHibhYqNA8QUmoi!BcP&bx>GS7o zeWLC4%621UOkN36GKLD=GEwX@bO*V&zM+BSnNQ?BWp&CH24KsS zuhH-2YauZ*!J$R&X)}ACd!Mzdk80S_ZdbOCd^k53^Bv_M0Mi}@8YMer|IA`~?uC`X z+zUYI1Hi~BLZ;LPx=lB!IYrVWGj(67wrXRgq+_2=FTPrrW`64BscWrQ1|5`XomJL| zK%(hi*rM1g#`7pUojgE;9I;ZldFr4Mga2ryXx2(%H9;M!jmGn2wQ-NDb&6w&=f}KE zz$?avy=9fYzwT3|5)3F=OHErBM z-Fj1US}K0IXCMZWDAsNLhh{w0n)Qc>1iUg(AGJb zwXx>9SiikFf}Nfe;8ah4{ekfC``4!i4$xmYc`1im0^czpV@vgA(FTV;D)4adQ8eg@Q+wZYQznv6)bGLW<=UHOjeD8}} ziJKq3TFBgd_w@_$_7C4bT5rC~XY}?kxY{@0d;Oa~@LRtA(F4Ei>k-#4`JG???FWAK zUwz|8?>Ym2;`N_-=tTVR^$#CBAFu!FgQw;DuYdT~*?E1yZ=a;6zy8X3@hT>b;evmA z@)uq_{l=9pH*Hav`2<`rjvEA*QD6^LJsPPI`HRML9Fo{vIqhv})`W4r*ED(6QTrYA z-U?%ey_ioci7;(vJD-X(3PANP#q4wq}^DF0*4?q0mcRqL?``PnY zFW-U(KlbT+2p;?ea^iPhedCV;*LjZ_nulor0sp0AwmPKclWhY>7zQ5QdhMGrP6nc} z;m*2Oy9j@H6)Gi6HK;ag!rk961V>*%c5j1Ss#4NOjQ~<_P$Hy`9(~`cB_8{59v)cQ zF@O4#hXe#=3@$c*mpITKR`#07RP02}MP_UQ&j3)Y%$CKQ@2-d7g-HRW*#oiKO1tz^ z2yA;RO5L5I?u;q=Fmn-o<*0gq*5|-EoaSxrG1V<~4mBXL)tn(L4Ls3a!fII}WqWU@ zr7F`-O*;B1T?RD3h+(A@3nEeI3LQ%}>Ff<*aOAy-pXNlRkcwpQyD+5CTAoM!cER!3 zhjTly^scLzm^Pwb=b4lyAsNCnDVVsJZCt7TLwYDpdPHi04xT>{rajh5Ohwd-q{md; zwJfHEoM}rjQ@J#6)VtJ@)+MH2y_q_j(l1=ar{DUSCYA1gr+0uO9{AZUZJwdlBZUq@ zNqKpyq@A!Wb1NzpY*dTMt}E5>+bTe+`t zoFSZXC=#~>jqbR<6$N>0miEmJ^TSV{fAYJ(_rZDo$wwc=$G`m+cK(r1-di(D>4|;; zxqJWhR}S->`n@GerB6a2%o{vzG z+#B%1Nn^}ClcutdrD!gVOeN|0%~a83&f`?Qjq-lA2ikA$xyL?t??8sgTgZ^FQO}Q# zdfvoroJ9ACx(SvuJGEq~_89d_-bcY@$yD%Z_B|WWB`P`>uWOwkfb7rF86kJC9?vHXYNnbm)YI=6aojzj{uTCN12m z_H>1Ykt1yxr8A?ISCnnVORXe9YRm9qKLcA_mzPg{ep2tVPYwcc6P9ylc2G2O&805! zT6e0~h`NOJa6FtTq#rn3YJL&Bne$V%6ig}#QjrP!;^&?qxqc8$&Sz~G`o(u#UI zn1gJ0f8(owx4FH`9{F(IahLtli_1y$>@Pj^1VIikfmpM|f^66YdX{x-%jiY{%&D21 za4`JgndwSd*3!vKM)Xp&H!>o-EB(1q4j#VbHVdD34nFombc?}>sO~fJULI>oB(S78c{@E{^M))OpcPkIZy+$421>+Xn2@0m zyrPv;Q|U$`@CbQe==Wz+Aj)l!Zt8X3Ui8-^LXVATy3NKu^5MK|+4$3!&pv#xZMjF! zu@a-_Xh+Z_GSKasOG&#li*V!BU8c6WQD2MJscp#A)^^0IrVc83wZ77nT2{D$aGhh& zD{r}_GLgX7lt#c?Y*tRKOXK#kmRH^f1yPV$ZnQJ|r0v`6v?Ww{a~HJ)*TNhsT7s?Snq~N$%@EGHx7AJ#^!31dVzhDY{^ms?TdQPU zyH8kq2X{hVxs8S-zSWRX6XtQ!YR!*$t}PM45HHbEPj&GBl!lI+f!;5r0Y)IU?IS!X zOV@m)Fx852x@XVEQ*S}_zx!M7L5_T=K=;@PpRb8RUlWDC0DeG$za|R3MHKqk>U3X1 z6ngrNFG{e^l(jb_M1743O1cp_lEwVVA)DtXB?k?;W1kQqDN+Fxi&$wQxmR@_sO1!s z8HEuG5neu$yp=AMD4P$aHX;rq6UTQEm3?c%zzfmkc+*pANb4ku(<-?n&qY|idr#8~ zQ*{?uXXb<*Bq{L+!h|bVaOV{nN|{~2jxheQtYs5oFVdSeh(7FC(sB>FzC&}n6+nLf zI*r%e@s*?nQ`)5D?^rOEg|GD-=p5#CE`r`lHSJ(L2$AAC& z?%-O~uHLFB@KbcqJUWpgFsYu+|~8 zS3PTDEK#6P{bKjEToyU30j$p&eY<^HEzr4hrzR2G(LNm>X}9aS$968gey{!V`S25e z`RwDLykUI1U(?;(?~i@{-fCRRlk`O2w4T2D##iV5d|iO1kb9c8-IWK0kCb*38w_Yh zs*}Dld9Ezda!NF*cAJ(OiOaxKFuY9I^(|XYJ+g{^18NUVifYEkxU6pT+-gjDzoLn?Lq4 z`0G{q*Q@f!)-aUFtn0WoeMveCXyI79U~9xg4H-Jb?_?xc1WKgrv&mxz9-`)M9{NBOvpv2x6_WnW=r3 zmO>b>&lN4zE;F?P`d`|9OWQs&q0Y1b}J(?rD*3+Yq>T)Sldw&z^dlx5ywYq zv!8tM>4UA!$3BG*wA1CLoi0C@wq~iTQOZR)f$)nh#pzmjUP)`yo6%fzkXTy?oS#m1 z#FOTo5e7;UC-Y8q=V$6<-^`B@6uT0`Q1PIqibWwAaR2A zWXM!5?DtBo8(9nQdCh!XC$YMIS=$!E#!zdT=y|gay{cJFI46oyJ%L_&E8ParQFDyCq6Y}u&fi_U_A#l zUx4$~l3quXv$THqPyFb@bR7sLa%PIb9fG~1eLfw3h zHf;la8ViMd={;{8+ZTgkDmVM;Z^WDs(e=J$ySdMX`HP5 z>*#O_XOkSZx&BOaq_U{3!?Ep1aZAZv=JGys85`Rd{oz9TQ!Ye9>V?6t08%gwdC%e{ z#`Hn+to;_-_SlE>Fns3z<@XR5irYS9og6L0fmD`Yg9pVP@R(zz+S^LWjuDAG08`S! zMVjZRw2SEnH}SkC&Dj;;pEqSJ;F4YGnTwu&Ab8-qM2fYWC^(i|E)*XCn;llO6o)iD zv<&OJ-V>CHc#gaHHph&fJyY_RvD)itJ5%hQo8a3#a!oN=9 zawn3(Ntig7brtIL=}Z?dt=oVtnQ}xc76r@uuBqIP96q+V{Y%PsZx{-1OL&ib4j)XA z+D(Ggehy1sf~;vr&6EB5X(Ip%jkFi+>f4q;~jdXuf4`!dyT&?%zY&bbC0c> z{RKAP&SY&?UAvC8>P{_d%+*J-Ax%OAwMM1@ge#z2HG7+sBzV?VvWL@CVL;Z-hTH{G z;}~wuQ4^bT$cRFrVjwbPAJlAnIKGYiK+F6qP}=+jt+aj>^AA5iqtYK_oc-d+k{j)x zJ?xqe9CfF2_JOD}#n!YI4x7A?do2>C(_AX=M%{Ufq-?Eustk41NQN%1*12J__vw3r zJTj7Kl)1F!;zHK##3=6lb|~N%Is19D8hz|D`#?i4-8A&l*A2a|*9~7c^!|VJn)#z@ z*d?ZK4iPbi5mxO22snz)Qf!>O#C0`8|6>hJLjIL;BmL^iqqXJQ-V+s6m zjf#?VS?|5gQex@IU>{3G#@rnl%54VZtDPplO@2J`xqIM6QJ$nPyeRnkE0;SeiINhX z2UKn1^RP|cwz&OUZllm;<@sI}=5!R(hD2ZT{cImxXMV{UE26rwMh^dm$rb(VH@yi*j&Vg_zRRydkR(W!e#pVeke zv3Z(%YpnvstV}H-nMiGCOD;8NN0hx)sjN*F4kJmHRKYj7R{mixh zBtCwtL;Tq1@2&d|0NWdZw{PEn{f94?W%h-wCANv1*8Q3>8HdkDM;j4dsx4%7HS5m& zrWYZ0scT5z<6_0ap1bH}0oj+kfBr{b0er*V zU->m2|3BZ);M|R;7iC7`1|xKzGb#u^H4zn-9h;+Fm>;9o*(J}Di{Tqcfcu6Xn*}4s z=&MdED?^`&UPoC_soI{ccQ0j*O7A_ll#5wazui8}y})#@jMAemiKJd}?1%v5Y=UL7 z*0!s)fq!fAjg)9v&Fmf7ILgC@Y;_1zm#Xk3p-AqPd=26cb++xf?=to@5tlNv#`%mf z`~G)cWiswRiog8n^LP<2KX}N@`q(G%t=MULqVlGi^*gV=@rVByUWp}oyrD%qzJp!t zSY2zK&~8=h+@p=%bT6gz54xN*%+x)p0O76e79i42K%{_jiSz?b9)O|R#P{xKB_vm? zEYrJ?>z$|G{R`K}u=+^5$nruML|AI0);PPS%z*657ofmEkwY#jd;FZOs4)Z2CKH=H(5|HyLvRj2=Y}ZzE zwPMYz-u+8gEMV7CaUm^cg&j&}P5tcDchR%)xC4UJ#-l9KJT{x!QCzexVKWxqQl3xr z-3_F}p_|a^;JKDOAO*%;}SId-fR7M=xhDMFc!f zhW$UrGJ(aFj9(60HzUml8BErP}3eJQe;(lcss50R4{C7ye#`^;zZ&U!oVeU&~olwnqk3*Y@kp`8WHM z-@P|-&Y0C3%3d?VL<{_D36u`D62{;&2&tGsJMvs%%rHhgxRY}s#y5P=%Sv}5oh%mC znbndxonhNOx+$3}5ogIUG(mr6{`aV8QH{uPgiGAHU<8%B*VxweyUk`1Dy+ z&4(n?S03WxQ~+i{=oe8ZICs3`XN{dY4-R+uyDeF=D=WRitmaILZ){*$kxw1VnQeoq zkVI#PvpdVJ=%x(UqA?VCX*iNXsKPA)1gbQ~=A_ zvgT%-Jgvwm&$LjH%9gLR9r#8=yoh%L;*Pid80x9quHvh=*mR@hc8T*pB{N;IUTDkmY%sfN;u zHJOi;GdL2dyUE(drlVb6*FB(e_C-F$Jl4^i_(gjjYs%K!;kw5@oLltpJ1$}d-7^qm z09qNN_L#wvutfC9Ck@R4{}U~HmF`(uiIN~(lsau^7pYi`XRF{zPpe~|8CF?{fDL$YQvsPBhbciPcm82YhpvP-_?!# z6VI-?)~6r*wtx6+zm)=eqN^%BriRT4t_ot>(V8 z9&nor%D$CVf!ie{Lrfj8W`X!GZIcqKeeAJkPisml1)>L?M{<@%6pT;juq8X`X?pi> zJ)8pjLlu<3{<-W}J+Gb<8BUw9(8_`+R?CU%=d=vWJhioD^#NsG3OlM^>qy6TbeGy& zv6^?4ffvXMj|?Q++Slqr)Sq5n^|fn?#UgLtre<^H9Y`$`iC!5ALZDZ6+%g!o(9@$P z21;R;uF0{ERvJ0GJo8Sw@b}J~SClmvMfFQ%6#Y^# zTW3Fe{uXlikx$uMH+*|izi`9ffBi?)Xg)Uc4wJ$#1zA;-ZYz}H`3{>5Xi>>c(@L{` zO~viikDWu17?wRo#?!J@70~!OvU-3Ew9C?2Q^ggM*Q^YG&!kPSj%$x?w~*e)KAeXG zho3%MpL_&E;US-nv$x9I42AiLYH3@ZzAJ8JCc#dw?p|tCh{-i4+c;^x?3A`*d7jO7 zJ$iCKX?HYEHSa41T%|6kzwR=F6jUj#*}>8vuoqU zBI#=7Qn(!@jSc2%9>T8uA`3fxF}zV*w(k-vM9*%XyHfcDs9(N}1brr(vO}Fo7L>)^NVdS7^Tc%nj$yf4z5vn%?pA zn`Km3+J)K`eH<2pyw22fZ_?Xfm?2S>s&Z=KF}xM8YH28~rsbCEAqj4|RofY#ZjNG< z{e&@l+!-<_%C-@5nat-z+-FWLrdXIey-@5hWX4Nh~ zk5&86|JGYE&XjXJ)Qz-=x7^3-uwju_&N#VSQkj;GmwGZjo7UWX>%QjNd}N^Rihap) zXz!_>*oH?;XPe-dI=hBLwgr;PC`V%vOS!%EiaCU9o?A?vtVJ+-2c4!sT9r=>qORtnZ!mnyR@OWTJW zkJ9Sa!AEXc8a}RcgC$b4yR6C6`dG1%<`LFz$uP6!(&DqwhXJBF72tQRjYNxb$jJ> zda9{$-_5ngfO9Q~)-sRlt)tAyDKndBZC(Sm?JBrvl4Lp0l1fR4*TNAsG61Bb?KF$; z%`)w?+}Srj`fOb8dms7Bi%I-;{O55`-CG}l@kGB6JG=k-YwrCcbMMQDYC1};GDH_r zkm5_)T<&=ap$mLK%$Kos4KefL22sErLttATRNRUV=G8jchBY-s_!^crmFcrI^fC^K zP<^Pi)L6qT?3R0<#w*lqw~=y}t+btYFy1Nsdex*Y8!u3r+Y-Ppf+C)M9t4F^bt=YE z5xe%|wxn&ObyFCLc17@gsQaY~t+XWAU4F834=PmK8J-M@2zKY%h2!PODWy7T#= zrBx(de}A4dB^h!KTaYal;TwzlOR#$D{3o2?#W^L_XnB`I z5lex>>y$dHq=pq)n{VGJ9(6VaiU7JlqP5Zc+&*fzyMOQMm9x*E!>)&1pLv|sGvTE( z8iAd((r7_Ue$qpSbI$PmG1DM#n-=4i6^1<&^upW&^$~VP;cF&tihSxMBddrNdHn3t zXVNL{-2M9(1jYMIeXMD48OF+W6QlBISBGOYg9MNYBVvo5^GdD@fkOaIX%$rd#05>8 zl63fSd!c zt8|xFofYruurdr~RhDTwCZLIFJ3&MwhBh(XULP(1pq}O^elAAEc6UNPrXhR|YdW!- z-2I2wQS1#S#wza?U9C(463oo?zB{|I+DaW#yTV+VB;1fGlw>WttjTAFnOCDnwnBQY z;i3bh1wGa&h_5#c^Hz1D)*>|>Qu3<9@BX9fC?dwB)Tk+iBu`{)Hutv89P^~IThk~B z`o{7>ue{~V%Zcy`c^;!hzq$xQ-#qj*8g)V#BThh4-6)_4efi~6z;C?rIJrx{`;V_w zi>Da5si(wF!2^8}hTAJNW#xFAE01JKi{7l;Tq*|9*r%{>>DK-3Ke>*AzB2^yb7ortQKB5{f(N5&%B(wEb1AD8f~d?B zr|e^3xhZqVN?I5mlAxVFcw3~!Jmg$%Wz2&FSo^8QT(dILLf~<D^qMFFA%bG`p+E(g z_`GD3|4`%atye7H`nMAtXLZa*?-1sn+*Vch6hVahjpjy6IOy3Y2stb0P= z|2nGExMNDV;JlTF86n(Di&4iecEDc{g%Nt%@U_eAfcg%-CFDe;09(}_Kp9jpEc)Wn zm1#4-TURdR2tSc0A8Qkx=X5VKu$Qr|~g+lXENN>jIruCY^t$EMc zIs#nnx++d#mAt$U1^y$7gaH$6TbOYFETb8BuE(@(-~Ak9Ekc5mV5KaFPBD`d!Y`A) zYGHR%SRw;K=2j7oIMDz_8OFS6=fb`e66!HHgp5QXC>^VNp)46pSfiVEDn$BAeejbk z!+XD+XXk3a{`&L#JHPW*s3-hal_xks1{?twuh_U`%0)a6X6+eFjVDKL*i+#@z`;83#H zMFCw0>gC39zy)p>DG8DR>x=XPDYea0$J*-ByEEsu%Bk>Zv+hz19?&6!gs$KVT6El3 zn+RqN^;;+By5^PNwn>Qz= z%xn#rU)gMRCE>0RNSW!dGo55 zZ-~)*rqX++(mTUO=&rKu>UC{F?jc+s4l5@Hen<qaD7(`mtG^`R<&!AO@l|6 zueP&Vu6c0!QzGgR3;PT<4n2uBZ2|U!!mxEiR62bna`=lshmHLX0FJ)Lyrq?_qoZTn zX%pH#d!3!*C|b6oI+Ted3ms+?pQ~W+;XND1y~(ml22bE@R}&~(AYD%_K#oJ8Ty^1d zNDEMG9x-q#`Q>C1pTEGnd~Y1Z_mz%8w6o@+H62QV9`KO&f#U!(dK&x4T1PNQjp2{| zN)Q_+`Wdrf-Vaj7qpb~A9_@56h?s5krG1>?6#Yt%fkjXIAl_?XblmE1_8o@#>K9Nj z{rX>hT|Pd`X8Mh<{`Rr9y!q?j`m3M(^rOG>T#@pYNc!h~#-INZI{L=l^bI9sMke^sRL(^#ze__Cb>;=*@F`c3PJ{ z8X)z(Hz|c!pWb%O(W)o#2gk}}uhYN*om&L{LG*dVcU<|qh7L^|M-zRdiGHoB)R#Ss$ z1?sKoQNcTnW{^qj{pNf7m`?WCWg6=6yQ*zN5-j2z02!B9n68I61%9PX$nv-?L|jNf zL5}DG;)+19TBNjvRE{k zJem&ewbi#*$_SZP8f7_r;KPh;fq>TtX)y;uvn_+eDPc3*IINDRE+q_2Z8g6{rGWtZ zHTFUSdvyR@Xx7i76llG^U%kFtz3-2Fv;GM6K;j0_0|u-guSsyFQXKepD@9e#s z5Z}|D2v;41hb=Iv);ST83h@+~S9C%VnTqV$-Ai-yAQKcuE0lS{O7ppz2%N4=|eBUIN45HaTlD0zu%lLK5Q(9I7YUbR$Z-qN~r+i$fzP)1>#MZS*<4SM}k?t`I4_k&az?^VNR}wF4SwyIo5t zXoYqnXc2iwT8!Kxo1Qf0sAhw^0&jvM^)#0;xt(0idrjnk84NVQd5SPpC8Q9RK%bbW zaRk6)a$1Mh8Y$pQTr|1W-u?vh_;>yI)6H-onAMl8F^$I!`(qG-h z!sa_f7?^RBs||Hmr+ts3l zAJMR}wlSjZc6(Bum!E&~Vfq*TBn0!$&+S=5-5A{J{s)w1jXFSsYZVF$s+em+c6hnBprFFhX0%mD#xaeYAQRM;BqeNIZsb| z_@^!{e6G2?D;-y0Gq!W$H5>Ruwy={9FZ4WmuZh}l^4x>B&aD->ZM8XF;A9XnJ2{%P zwx-)$iuSEHbdPC-U8*Hqx9N0oS4rWAzkV_Fmiy_#r!Fqzr~zL;dOl-ECKkr~%I^!Vv%gs!9srG1FUs(9taR@xVPTI#l@^L7xP)i%xSn z5gE-XkkV3@982aB6Xz&Uf!P*PHYAw_fK_fA;ZDfArCp zb?A>@zI>XAa_{H(408O-%`uyT`lsVU7fWzGMW`*qD*>Slc<8 z!Qjx&raXqvybk6OizSM+7(R-V2WbNBTsAT5nG8?ZN+yV9y$3}@D#B9aqt6-F0;O$N zCojHy8~>pP`AX~2zxvbo>QD2lKmAM|a;ZZ;Y=1n7uvU=CuG2e@fw}&ISHaZ5OP|*? zC^x`Ni?$&M0?D0;S`MQn@HkEfuI`{*ZTJxPJ=(Z?^tp9&-H{nVb+ICMip`vHA-IJ9rpW8jUHb)&T$N_0WE@7N3N zqCgdQY{C_rR{cVDaCDQcv89Hdv1p7@!rq~a*^2ZGVJHgJ_JpnU*kM{mH089l&4<@n z^JL?uE=AZHM)T~<7EeGv_YP&a z`S|^Pm)_~i8^#x(`=_t2rXOw@AL3s;jbFU;^Lz#a+ip^|+IN(y^$xK3zt7PCco*C5 z6Ze5dXHJ23SQ+y^^pLd!xznjj5GC>1C969l8h+=rRkkrU&pCTQ?y_W`yk6Q#Tg(Kl zL-Yv+L}t)%=j{_|7pG1A8AfrvAf)fS&jM6B)LR(oeTk5K@A2 z!#)j5W&?W0Z*Qmf4wShq=0L#QFF$_y`IBSg-Vg4XV}srhRzH6I&fOlIHv+KcI0QyW zgXri~!{rX~L#u!i1KiJuYo1CxUsSo<{7^AyqHT)>%Vbs9B$pKgkFzoG)`A7F7A)%# zb_z+JbTHBdj`9`;aPQQfn+5l0{^5^4`J_HSpI=|x6e@Rqa?h@~ezW4)|e4+TxSZ`&;_275J)T&7m;#BQ*+i_F#E#6 zOF&d{4AhHiOGi5-L+Q3)M$nvwAUF&ZDN3fccnnl28kBP)If$*{ z+GJakE1=&#NwkNMkANS#mTmOeR@bvQtAI9}(Bq14lu)+q*%IgPd0jBS`omAZ@IUx) zf9$UwqZ1Hh{s*S~g&HRL7We9{PIqeszoASMTqu_g}DjS6zX1 ziW&enp z(s;oDM0=1R+HxDq?0~n7G&6%Ard|0JQph5Uo;H-}I^qN{%V$6Tf9IP=+fQEo!P8un z`#!}dec8+Y_VvE(>u>xCILrRI_h;Grv+Vs@_Wmq;dY09!Iu=luoViN955x>nnJcvK z_+2c0apReBsH$2+G-jc&QI;h*`+VW3;KF2{OfOg z^RsK5C9u#mSc9Sa&bFceNA5V(T8hX@MA`RU2S!P&iIhr2k{EC444%uf?A{LyI;+E~ zG#bW}sd1{okloIZHoO5pPd?!Sfbe%b{PXWZdux zkijK02a#=oQfum|$TIM?J4lBBbRzFjtU)7WR1$>q&$2Y|ZZTEH-ibP;I? z6+2t&)*$>P!ct&T2B+ZgZcx8J7xF1%WZP&_OW%d`B`8Icl1|UnEf*oiYte;4XS$f66KU(#O5BY+RJb}k zimJvClLFpmwF zTbRNHrc1 zEK7YHX?7GT72}Lib2d$|F1Y6yyCMG?u_XkvmA7HhrmLm1fgHLHFIp*2G?@2(#^siB*!qITnyKf)#bE<-GIDc^=;V>ZhN5_VV*DUVV5Kw$J6)7a8-`n2wB@HJp}C zCmkCh%DK;;#{?4kSP-+rx#)#!+93Cf&0v9$-+;0(Ph!=F5JPzEP)-7ONEDsN&dPlt zzh5G2tUc+*aWE}T?vi7pHG$uMyAXu@0wZ=EJ~=0REzd7VK5-ex!L)D5<7kQKSDb$dm*_shB2jDG&x8C7Sj)ojV^V{jpv zl&p2$Tsx?O5tj{(XkIPvjw`;-J(E`U))ax7*5KM46Mbw3j^RXlb4FE)PN57?GTPex zO4wKui{@T?^>5I0x%uVZLVWzA{?QFoA>?x0w&lS@tF3hq7lEMA*0lTBs-Bl8d%A=+ z#J!DH!W$maqLJfjl+aq?;suz=DELH)U{AEpXJP`L-B#PcW6UA&W#9+h8rnvq-W<2B zEG`4zih|L56*kx;8^|m|#WaT>F$ofoPhitU+hcET(P8hQh23LKz@pvH6!@u;wJ8;YVo?UvMIm*BeInJagtSCVL@E$S)_!k53L#39Cme8+R8DiW! zZb4m30}OlAj|fbuxvQNvJw~Gcb{aw|TxP}2kbX*-4`Oz&NQ%Cz=*1}&m<1O;c6ym!JpIU5c2*8;KLZT90NHe zkOm7AUFboORyPEn^@e=xJUk>8_dYtbf+tB)v5E~D+q@H4L}ySJWWzqm3%~End0XVv z+dz~%Z2|cL&%~fTr)QfK%Sn3Y?8p~&>=Ds}=Ewz&J&mAg4Wt&#VulhrDKH&ujt0@a zYZvA~mK!6sicv<57|d269!>3Mj7?AafBiLM^zN~9|H^j&KY(yie4jWS>v-2VV9_+) zV4c*#7-)?{3Pe#)2lZyaj|DVoLQKz+acn zvO4!*3dulH5e+a+a-sjx@SwrW!;!c(&Ukj7`u9Kai9CAJfAZ=NKFs>P`uOE%AXq<9 zV&3`D{xJ#$(2?ToZF|R%yAg`C5E8`5nwUn%RXb`Ww+3s;gpn#>NkKLx;a^6;;H2cSPbV|0aJ z(IJA^u+kbOFEuS5(g<^C$99c6${FF5tq_h=6Q9@v5N)2`#P{4Cc@0amhIX@Nh9o4- z$Q~M_HCJ#D=cN(gQ*}FMv$=({h6EH7XPQ(;diMbS7`X3fERkxv3msma;VJRG?Pz(&tT2IQhq*z#sAv?#=Tkp_kMcM zbY<2XxWC7*zxmqFu8mLEy$vBrV~-|dMl*dyweiI@q#s^iB1%wDtrt!&-&xX?KX-h)Zs zgdCEVx|sKz){&rXhR)p3Z%oF#?0tcWiWSpZk>-1r7}Vpa2<67k-4@} zgMvin#VN4GYl4S~WaVRPBius8%y7^yJH1D?sXMHXjr93yI~Bc~XR?BS6NS--`SSNa z{rIKlE8Jc8@7Cu}f`9J(AfIe;NDThEp5XE8cTT`^2-;2}Z*#3c@Ghc}jB5lsoyT9R0ic%uPNfK zTMz}xvWgpfVlz4e-b_{A@mv z)@DOO!9<*0`4s}SJbj4J3W_tm$(IZ8mp^;?*=P0nPhP!ovAhM`-1*r(>5E{OdZAzI zi@g5EJGbg`Y2<}M7FbA{<2*(D}E~1Lp8s|6( z;x%x?2STDlPRR?s^XY=_{&thRkW}8q^$fW+@`#+dK=F(c-N<_%tn8zmv3l|z0@*FD zCSyj5X*Yn{4(76C0g6{>GLFoY+<}CaD>G_9qr_p|&jkQW%mZA9QZ>X&4L)F~JbUx~ z&Bxx{)vLSSmk)pR`OBYv_5@yf=STTu5kf{nU)%Y9@cJ9y5z*z|$s^zEAQVD>Gup(B zWn(naSaO4Y?Q0->2K}F2xq1uhJv;np2efZ%H0tzFD45P{h(cQ8x%OdbsN?XMyU@cu zXbG-;=4QEkWws6t#TfIA_Q@}OgAK(dA-qc{ z9293$!&s|Ymp$wjv+$?($4_m5_kLtgDki=mdhokR^jMwR5bhmX_{_G{h6UK~0D*S& z1R5x?dtjuE!CKG;j?;ORlupFDqcu6U9o5FG4G=RHSgT9>Cm_11VJ6|J~ z-S*+`JM$LSTy(l)3kLv8ZT83J^WDrw)cD;Rem+1pln#KwpCni%WESyAg2 zA7dL*U}P$|A_9tLv2LDAwbFda4z%mqI!R5im^x7!Ea?M!qG^MOmUC^WVmg;>-Z?hH zHLv*DUTa7XQVj5h_lc8R^lX^0`m&w z>fVqaXKU%nu^#>n^jn7)TLpIxjMl-}ksza48SsLho}=6rf1Za6m3_-i>s&!}fiM^)4t8#X3Dpf0DzpgGn=Zpk5P zw3P^<7QNyB`d3f&+QqYzLEY*gEV6qCm*(hotsq!;g%1AhXQ z1MfiS#QO}4_Zb*>&%jvdp9WId&>v|-8OLHx+0KK9?ovVt-$hRx>Wz{#;3PhX=RKRl z_T8r9Y%@J9$W{=j^JSME3ltZCTKJF2q{B}Qt%rOJ?%XFJ9rg) zB52e1pbe#$933{CYTD}H_HR;O=(rEb(M4Km$z)!|z}L?imS@0zu~zHSqMR`s0TH2D ziwW2WOu}&VHSJc?(Q=T2%b?f8zkA&aN=>=BpG;nBYG+?=Z6c8eqHPz_O-T4bgQ_y@BZ_;Hs9=&He;ZItQu6ZOU?02n; z4W31FuC0BR^E&O}KfInr*g(H>2cxq^)eWcv@v$1gP#bO6K@NnX-8vUcZml_5rhCB$ zwL5H@Q*!L^z8gY6R6$%OZY;-05N@1;pL<=$mrufPLDuNuKf1I^1Kh&V5qw%5K5`xN z(4>hrEl<(bZTNMG2B~ld3yFqD3{shclW}j=v34Gx#l9xDh5(f2J6QL+FcfPd1Vg%G zl(y*L z4%+CpaUF?}okx1%hP>S1DxXk#_Idq#W3}ofuKe;|5B?mzlIS0wy(TLA!Ezlo; zoiAlME(z-JrY&!f9ZVX~_3+k*U+4LWeE2V})9ei6b4H~nZmO{7^Xyw%!_A^;ge>26(5Qi_ zrQ?pLGa(g3M;tL(vrj=e04YbYcW;c>eb6Z{L{Bc?twUIQ7S`!PciiiL5o#-$9 zS0DWLU;5VhIVYht3>-xhwqS(QbuT;C8%&qh6V*Ujw!LD*LAk?cYMtYeGZiUmr!zib zr$zFd$Q^3~pVc`KI9rDRg+O}0P77@GND6*@JOJD)-#QHO#HpXHwhe*y0JP$cgy?Eu z*t{ulI&Cr?;H(u4pwVyb$?)}*Am>2rZOoA3B%Fz#0So3uBbbU_rG+1o`#!)L9v}CqS{8r`xEM(GCmxFL$u#ZWkL`(n zg60d7uiu}3_~m!rxh044M~4o`VX*NIkZ*9S*;fq$jpE*hQw(BfTB|qL*%)$I&49KR zJ~a57xsU69U z){CsU4pQPquf0$g0s)qVh8?aVr0K&UW7kci9lN=;;;HvxhX+A@Q^hH;B% zHBD}nDZlKm{_xZNyB|H-;qLv|o&nPJ8z5bO7k4<70R8b8#?Z}WAX&6kl)$XhP|EQ+ zsE_Nw+%pE$9k{H!7ZN%O^dSLxYUzMQYwqbhvTA|F&`u*#KG+7PP3os`FDKZcM(!tZ zdF};Cq-}FFQm=sa0Z%YG!pUQ%(Qc&+3*BN$1--HAe)#2gzImhQ-mH%I z=#cLS9fEs&?$gUs1*kN!316DeHqxPwIF$w(Mh=3!#XLndozOM#RTk|CIKq06b4g`o zAm$zMHe)mFRESz_raRF2nw^B#+Pm+Z^WndKj}G}0iw?m-s{+-@Jm?TQ$W8~~O=;(B z{M^wQ2GQjV_M9qOFsHgeXxOk^s`nzUu4^F5t=j?eXV7tgGg8t+#P$Z3qwf_HlhLvR4X3a|cHL&)ZXNyg*1=hfNLbyF zX+s6$gPQc%bha5x&J7M03~;uWpT>RD+RH3r>^%__vUoME$><*t!FLKGhRjYImTR_<8Cx0@{Gvov0_*^sA?m2yvNv zUEETU(tWzZAfEz*kF}(|=4yL4$EWz5&gcaurWY!N5{ROW7>(!2l{7t}GoMB=33>Ch ztO{oBwIbcd(q}AouZQe6)zH14+p~^3x^dKf8zVE?-Z~HMtU1vqng19NjUD*zOVyoFanP$%ileC!4Bw*OmRa zH_I`%mnwLq*OEu0Ty_u_5cSG=;Jn;agwEAv#cl=&Wo=U}ebcIYNgMgmP4eC@^ex+k zx~pJpP{|Ni@5T$-H7q%b-pytOD|+dP0;^iMfDO=VmC2e79pw?`tL-dIl~44sC~;Lo zXvG<99D0y8z_mxR@}UM=Eb^MZe5?QB1Ff%Q8T2!S27M{f_=T)QfB9Em3ox!<`;TO> zjM+}|f+1>K#sI8K?3%~w3|Ubf%mc?HyReD(6+)+BsM}!L;c%K>H2YqTcG!qc1{11_ z>f+rcCWgcrYg3(B%E&u~h{f71WDMT*vBVl;BHXDkKwEf)+3BPYT|BeX1fab*j>beZ zC1kGNN~5-sCInHn=hlt53cx7lFu=3f%lm8<7?fr3z&OxqqlnI0Uu_jX`26L^AOG~T zFNJrHl(EOs_V!S@^8u0f2bt@G}&+YWJpy*?YG>sTG?%FcKnw)V>?DVBif}R8#py?GF7CoWIC)@Y9v z$OY(gu`Z(Hy>HDeX)>Q&PVfA3Ze^EmeH#z&qK41Bx5Q|&ra=oJ;!raPkCS!@e1`At zdF6Caclh#Xn`4kYchv6a^;d#h2|i>qnd4+4m%v&T+eW)I`oOTk zxV>n9?XNxXi^u{1(0CbANfGw?v_x9eroy)zn_PQz?zXJL1tB z?=|A+qQzG{I!t3m2Z8qzV;dxgXcjH8T6-`bl1hava-!G;FN`SHPPXA|w>UssOqqb| z-@5O3&8RJ!&5o2cXws|Iu?BHdpHoh1bUAemHaPoPi~X#1QMpBQ+7ZzB7m^tg0TXg2 z=%O%y)(Vq?#TS|gPDURwDdh}>k$2y$sNdKxKZ%b%tps+h{0VmI-cRot>{R1T~g>NYxU$gX&j4v4zgI#}nOCmjGp z_#9@4GbXar3uXSOBR;`VpTeX~CI>Y7@$f%<2go%%{JCwjub6G9CF9o~6W)FCw{v2RT5Muli@FRX5MXXl6Y8nSa}S(wTPt$gYIC{(VQk<5VqQwnYxOA0)q!;&j)J>P1 zx)K49m7(1o8rtRz!E41h5C7wLu;deSYHY0x^JU4pEb6=ZAs?mZ^gf0SYBbWvX-Yx3 zQ;!0q0XG=()`m4k)a7n&C#%nPLGUII@A%Aufm|d5rS7JtGFOR@_M{V}%l&lWQ`e3x3TxRUZB;%dO*5Wv%eKN9LFu82GtbuA~1H4*gAQeesln`Ynh_pa9-3A*D=#Rc2-Rj|E4ptJhK_BsUgYw|euC_YH z5(@cqPJj5HzJrAy&?%Ay^4w6NZJDuPS6jXp*{pOpg!+}Zgh6r5GC``H%gpZ#%t{8@ee;cJHa zv+a$0KgT~V>-V>>TWQV7LNVZyk#RO8lWhc4ZLZtKR1(m(xX|;+F`^qC>A-*Fl$p{5 z?k-qH7Pr>tR-=*77H_uJuHlL;U_jTL0}IMJtpgv1-U43l9lm>8ZG7sVzWgYkM9SUy zp*>k{@RrcXSsd#D1SXZ`t+|n{`tlJ$*bS~rN@oX9QxOhp{9>}KNKo9zs>^xwXDwDHg zM7DFaH*euScTVcPS%$y%>g7*A-}T`q{@I5=dAj-C`Pn^l-Qza~hL2yrJ8SVv$sU~} z`}lQRhJ&p`ZKgKXJ}wS%iXd=uXooQ-X~0!K&YEr5h6-~`&QrL<6Fl_k&Zmu5XbkSu z*>@9xdh=X}({705fcdTYpxfl)d&f84thrzM4_y;{?*(MXm*wztr0!{5H z=7QlbmQB%K+=q&`oqT)7-aA6=E#jR&^<%ueTY~zXAKkP0*nE?Z{SM-VBWYYRUWfu5 z4ZiGDEWI0QZ|-q%@)>!5eS*1~sTHe9GQ3uKXu(6ec0;S90)k0D3xl%)@-6yALpjD{ zt||E#6AHYU+*EGy!uO6aaeZW$@V2&~= zISGsWQH0rp^Q^&hp*M>jMcwK=?j6eU<-+@wpM3sN{-}PxKK}Ar`x}on9ZI_WGHXAX z*x&g3lOqMDt!DMf)-S}jfN$(axn^?%NfN<7bn#gv7+a8fKme= z)euRu;C#Pm`obl4xXx)HPiw5X1|ktoMAs>`axp{l9+%tT7U%=aKByeATMY?JOL&A08qhz5p18*Ay<;3nxP0`V$Xb{7a52g1x6QNslw zPoFZ^()Fa5_}S+#KYPBHc<%@I6x}#p=-2NNKY0C(Z{AB(W&?8ou&XKk$aPs;q5-iE zf$cf%Hzaq%?}|!WbRN*c;|K4v*|Mz%v+|+Co=st-#b|Y(5Q03@`4< zwAy_5pFg+?{(@~kU^av$VGMK<81!)T321s)odauB?F%E+1g(&=>mU+7ZIW)x=ZUFW zgG=VfqH+D;@V$8}^`$;sM#orB)4b2sMj!3rZ+!3$cp)GDm*+(y->|PbMst~D6TeF| z7z&hU;SE`wy5P#dTzuO0HkANzI4L#V;rM{C=_qCM*}Bx4K5~yNUc@^XH)jgxBuFtX z#}tIVEu%wed3&|Hce>%TebvA4_E5^F?bZ7}&Ob)7W;;-}jocH2vIfE+xq=x=mNN)Y znu5Mt&|btCU)$P)v}DxeqqdKqYAaP_gsrYK+pM;s;08%^>xi@PacT4Pg|=fv4Nyzm z$HV{n!3E?p(Az+6$F{H*EfdPt4DnS9;~Z*)fhqzKJ0uCCr_ZT`*1dTXIju2(433z3 z-z;Hf>4y)yC6QO*4Z=m7lxY|~ue>FT`@{eC!8F~x-lF(9Ory^>Z;_@5g5Y~VN{U@JiP8QhM=VW(rwGWL)L;4BG& zP=ioHyqei(+ZX1;3~7B0*#%1qMy}{-1GZs~sRA3u!~gzHFnRuu=M6CL0Bi00gMND- z|N0){`X?{`^#lU76Z|~r-lksYmgY(L6apC3Q1do`^`axBqZck=Z6pM`NE8`!b#1$~ zt!Fi<4W6A%1SbrT+ko?=R3r+e_iS!5z}pJ#ub%1y#Q~ z1b_Ln&+B|%uYUaH7Vvu?eesn3c;{#Lj6CHgBZ=s%)Iksb*Yzs09Lc4rnqyShktoFxp1Q$pD@}%U8Z+?|S?97nv=e@)k1b1& zj0NIahgIRi60o7Y7EBX!O`5}nvAZ4Sw#`n5ojf@+;#IOopKP224n$RXlTY_dA zSn-I}$RGZn58eT*(8K@x*2)H0G~Z;4E#_$g1Q*&AKKI!<3URJ^kOm6QoB>W?v=k!Q zeqeRh78@)ypg&-Dg+(x3_3EPb0`ks*p-vg6F>xKl5QR5*qUFiV{mw7vc@M^CZ}a5k zM2MS&9zpdAs-V!Ch2p)rZeCy-^Z?XG0lom45=$NtJ8HJf`z0U;yi0~3m|oHLQ5kH|KpzFZy5LUeJ@(_Hl-i)4Cv1`78)l(JvxHTrWTc$NN_Ijc$>F{i=MbE4qb)7UIvyZq1JOemS?2 zthat5Ti<<*vvA-Pb(ta%0P^aPcFq`+rw^ouGzNMqPqqQWR@9`YT+kMI?aVD5U8 zwj_H}k&Rh?-FM16Si(FST-X5k1M+|h4Q&eWh(VQ^$nR}eLaRdrhoN?@T^gbeGodh+ z@DkhTT;Iw)@BMOa)AHW(@vM$)@V=w1e)*@basP~dbmJ|Yc?5pFpie&OX{f3!Y=B$=t|AXmiiZ=z^TkM8#o8yzgv{7x>rN8hy3X{_r3C2l#IZMgOJo z>9c2y&VTvOy#7o4@_(c!Y71$@5YmPrwxNKve6`XsF-& z=+#GGy!`yb->pAizHi~1d=~^t4nyd?uX)-v;jr&oHgh_Mr8oN)@6$!O1(mHV?tHsndcAtrU ziU9Uvf^W8Q;`Xv~Z+!c+_3aOTRG$LtdAk(v{p_CggN_?N=sPGSSsoK=9=IL}X_H1d zqRrI-SS>VSfI;j>HTnb}Fc-jYjt2ys{h7pjk1YzN(Q@YrF>D*iBttAX08AS>PXnd} zpWfj#NsFy#-rlM14eP(z_deJ!KmEP>{EH8NCQg6i%DnRfeAboOZd{q~;DHOIhZUgs z7Sbm&Kt>5bg2Aw4TX)~(V5{f?ivWtk*37By!(8sJY{ z(N5uf+vmS`5XWt@_Iq~Kdym>TXWQ?8xvRD(k+1!m3iThn^X-pr?wyt!rH3I+p}?J< zpgQ=Jj@%QJO2JSQr{I}FMR2{hGmoB;@Ktd`3>LBxy$c;EvNMnOQ$RE{5M0EvLl-WS zhcWp+u=RG?`?lD1@A#G5TkW&YzIgHS^^?!?wLf{8uUe5(6#Q{! zQW#>MMVgM;cn2+A(k~N>u2CztBk2P!cV!{&guc*VMgeMcq26Oo32QP0`Cg08mc|$5 zx(-XDLIR1a={RNRg?EslMO#yOknn!*$eo*+_Zxrf)r-&NcCOuf%pTcc`;7yve^d^z zFURq>pFfK~-p`+XeW8`60EZ&3tqEJsHgriyV(m~lJ1BbNd2zCpt7T*2b_D(94eu~} ztU+V*(S=@$PH-EyBnasnhQL(fB_#{8L5EkXy7x6@+HFzg-dRhxwcr==v!6V$MBI7E zzN`L2U1D=Zl+~FXe2Y*oT-LXMaGiygbK%6jAsWtBRVZ9`V6lPJpJ#H9SdL<>U0F*D zs62oX+%|)g05=}AMx8tzfy1(B7qx!7(tS7TclRE&2a`=dUGEf4-hBP>OtxQKzjNdj zZ2>EN%2{Cy)cIv?*?aHKt2t-WI47brhn+nnX(3M{O%_o}!Eny4QM#afH6b=1TPMDs zC&8zh2qRIFXo$<4C+GG#Zd+f6SL+2yf${JFCuzt=!UE(-vt0?N)XChe_8lv(GOJ@{6lrTLU?g`jcZfAmD`oL?|c-kV`D zOA;~}ULETSWEAjS*$KSM3vvX205<}Ml;ApfL8cTt$73df!+fK|K$$wE1k0pitYxn5PlRVnyq0YfISn3 zYTUXKjc13*X06MUV$i)MfG~TGWy6+xMFk=7<{&oKWf-S`?>2#QZL(ovQwG7#VZ^$X zyf8@0$SX+-h0`L|7=?oD+#rM-4!iS&^Z?@JB((a8eWFA8mBWmU!Clu&@h)KhL-EhJ z9zuU$(64K?-VB9z&=}cx>mDs`yXk-Q#?5oNd#+F0lb^hN@v{dd+ItV;BezF>XJL8s z^>;sQ;OW0}Nh3#hF)5N72pUm{gHl&*C_qu~VKzddM{b$J8ZP6?6&JUiyc=0Nq z$PUld7855oi=pvO!g82IyR9 zh>x-ZpO7oAXG($m8I(%9!yXzc9L-#kNa1W_rqa0t#k57T^=*rYWu-4l%_bPYL$6Gwpa zM2?CM7>SH|0|}csuyxHLqGmv*N*C1i2BOo@tL~gM5i#VNJ+uWyE+){z=P4}kW8O#< z?;W4Uw8@sQneh!q`!dI{D^g(fQ5|RmUnjO7&iU}bq^rSI0mHF_Laz0d4eB@l`k&DJbiUmOVz@Pkm=TW6=YkH} z90tyow>DSB_M=w<=zts(2bg&!L5zOFoy1@Tg+(%*z}K-kyCB}9I_Qic3%B7wfMWGi zZ9tJdy`NR{cCo$pRY6Z0HDW z3=l6?FHe|UbxoR#dOecCY#$rZ5q>xtI@)bd6cAP}&Y+XEkS?@$+Qj-=o%ytbIL9$? zqS1CWBN|L=y_>;f-fXWGJ$E}2!flR~5LA&jdjMo!8zEF|2cnUJ?=UU_uR&j`GEVGj zB4_2nWmb@nwEVzksC5jzf8{!xkV}FP1c0q=FYk`j!O$X;)`CmsTv|h9z!8rE;ELNd z;SZtJee%UiTwBgp-tPw`n>&x;BMd2d7ZUpR8^8SBY9e}O`-s6 zaP@fxN~sQ)i;Rq26VW8&pr6_pbQ!c42SHh~Ex>Tk4VRUHA(-^0IxHReki~r|!y~j* zp8oq6$%LZAgib6z4+2>#aP?#{UFbeVaO<>IAIBTMClC)I_^-HmCGHf~-Et}ol2`+R zlD;KoEbya;^C>u00?NLnS?k#Id$FWhDOcaz1Rm>FjQMq?RLby87@W z;>|p5i)!yen`X^uL5^BxYub@ByaJX_-l8Pa#+(7)sLo{*ee_s`9;)c>{`5b-jDTx< zgI7y0N5YtG^MH2Dk!vxmkOAX}(Uc8mI+w>h){>>ulA&4~SUCe&Zi3o|lUi1%g;E~H z9tr?)HSkerEu8gNM|z}!68-c)`Q*nxcn@6Q*RHL9P+VL0Hq(4Zy*(kD2u);2q-{>P zBdrzC*@n7l7o%vXi6BEex5F`wB;j^oOisPvJU!WVC0CD^FU=SD1%95JOv84R2NE3Gu*StM;9SB6 zK$~(y;W63(83OxKHn?F{BRw5U-FDbUO;Fca<6E1^dmYeY8Nwi3@GPTS|o(S2Zq$F0%?CBVh7n{P*91r{1@EM&MJOBoReMtw%rQ3k#9{czlBZf07rxHv0oU3vz z?z>xW1(Fh+bqtpr;t!zKMI(B4S$$k=`tAAjKfQ|AvSi~F6(}+8Nz@TVv(V^vY#0S2=i*kXf<63o!m>Z=Uj%hJP8K9UF=kAa`ela&FDl8^z+-( z|Li(c6tEUGg@{k;oaoXLvaJd?wm!QLATy=AFFG2D$Pa7LoO>pGroQ?JOiug@2vYV& z@X~|mAG2j^02|j-8`~#>4mZtCGq(mm{m=0fwDN*EEa*4)1ZRy7NQN5?h1Q)x;+||A zbD+hq=_WQi!rm75T1^R;pgduCPaB%mJh__ZmW1rpw}klsX}uI%3m$`d?g6 z!SH7w!C;<+3#V1|2_eM^3?AAAc4!Nz5gdDsevXCP2Kc>qvOK`pt_qv64$euoCnz+k z39iG)kb@OBTMYaiGvLuceu!yL|I6!uwI^7RAi&KoU04~q+C4R*mVod8yBwX-mQDt% zgqO@{*qgc`$qq)C;R~{Vp4L#qp`FmTxh*0nCS-zlILd&YI5bHHjCQB=>3{XfM<6SC z`d@$Y7(ty+_>WC+0zH6AE%8wxvgKqTP)fvSvomR>oASnxryu1#P&OdE3A_ zQoFe7Ya4E4+%A-joy^`_%i{?^Q}RZHgpLLSEKt$6YWaIV&aIm2y{{4Ysi`wOno~!G z7nkNaDc5Y9c3*gESqQ44gVK%(qT^UMGCMbSIjUH%IT}cq6LS3pzA-vdW9wR!yjo=X zXw}HMT4g`&0FUzJYy4;5gj!zieEI5E^Q&KdopAkiz_ooHb>05H5;4EDfWH}?zYB0` z@>$h;FEnW`Ozzs&298U(L=RksuaxgfN`MU-9qE}f;C|oBd1N)jNleAHc}_WVVG_*E zmPFL|?2Wqu20iePSx={)lh^J1g1-@)avFrVJln7-Xd2;G;C(ZA)D{acQ##tG`59{+ zCxG`HRSck74)i3=PeaBCDs)uC5mw(Jx-tj-Xzi#o+hiIY#|h+aec7D7MYsRPtDj~* zI1t`@>>iOxy&H2)A0p=Z!z)B*G%ccS=3^b%ymS#kV6e_05S#aMWHaf)?Me0$r{Y=7 zn$A#w#kM8#7^)}J0?A(71?J=nz<}srH&D^LJBCYJmm17)j@=3ZI%=Ced~I~D00wZO zHaIrbHh_+(A=(>v!R_hQI&bi+%_309L0Xb_Z7XNTK20PH1iHkSOuJ60p9Sc#ry%e< zLCk}eW1<24Kq312FP=YpfD^d)pnX@37l1C{L|g?(ptVAB(l`+$tEL80#6uS{nr8vO z+aXiit;E#?`}XP8!Y85sNybuL$s8dIDdw9KFi{8W4$358o&-*XjTra`kz@BxjDO#0 z==IBdAOpSk&^_wpwi_q6eSA~ypnKG73TVLtBuZj|4o910gQX@1qsWV-q#}tctVG5P zoOiA2_)a*2BSVf^rh0_W@wp zMClo6Ox$wX(j-NO`DQ7g8|Ofo?QE1}376Mpa&licMhk*+IiQ?sfQyaY+tJa^fho3g ztcsX@HKHlEUZ216X0ko`Gk^Z44~6je9=k_fwf)9b`w==DIYqR|8D-p&g9SpwI+x)Y z8X=^=LOLdWBUdYTW;HEnF8Q>rDtox04CT<4^%M{tmleVX2Zt1x5{+#le;#FQSp9*5 z4H4S68X3OMYpwd;NgCP%#CS@LKBa4}cw;@tpcEq9j&P_BTH>Z>E+cPdC8o{p9tFSFc|_`}`-b{ej)*-UImU z;CfKGI5w1eo`Eo{smSq*LVUJvjN{QgPg^lg&_$N-bZq22IuKj6z&@Nj7ksMJGc^v* zzU`cp4Kj!4+;TcVYzegjY2y(xOo6zkr~eJ=C&3IXYg=pi6+3efEr9`DH4n;K+>02Y z5AY(u#%BY?lRQ_Oe9zFc_OT?^p-^xn#f0^*orG~&2jsR*D+4G8#p}|wb~g~~pZ>R( zH1!aifHr{4#BY5getGWt-Or!x7tdcjdHF2-XXnM+_35v^?LS<9 z=7~Ic_WA34`ME!g9=`Xeesh)j0ahvbls=^=KmSG>;y1tg)-S(SZPY^zAJ8y|s~6^9 zK>rakUlTob;E+Z^#1Xc>q8)ZK7xpfTLa^rALr3I^7ab*h-HEsB-R^R z`n3@ryrGnrp_^ogB19lYwUdB93zV@vH)t-QkVtpxI0E93b9xQc2I1{S|G5!T?9Ldt zYad^TDe9y70tF#CMEcQpEfec)3HQUTBVTw%sn=2I;H{Nd0V=5LJz)pG7=`8(cyK4)Pg7xj)9Nsk;8#D8jcsIL92qe zn+*rDF%km>G~8;p5)mNJH%*fQ5?;{=9}BLdPCH0OTPvGRCbSX3fEy6&2#I7Ju8!0) z>`w{e9m5v}NW-A*R&AZEgNhY8mps?*wTPuoN4EJuR`z=;yFYk4c#n!I?>&UyTy8FZ zBhjZczG+zd{+HkR<(Hhhr$GIWpL_(yxm$n0oge4Xh41?>fA;z7XP-T$a5{!%DfV3~j$cC#$^?lkdh2z%1wVueoNgQg{QALY0n{J0PwgqpX^bQis1PrS4 z?v8e)P`@z&E{|&HGMLmAoH3cVpnJ-QOo7PPH%ZO%+Q`XXyah$QZu96|4S6!q*;<>x z`2iqs>;woZtus&t$RGeD9n>DhCns%fBv#hEeXI9=ocFxd?|+t`y?FMwAN#z51jFSW zSH{^W+9-C8F=H$k4zj^lr^pOWZQGEG;+q9so&|C8LY8M5Lo+jh1!>bmj`ckXqDuEM zGxmwWl>_OB*fo*e!8?;4zSuXe9%;nTD$P9E)AmXLR}mvKI+8x3!8SDrdQI^fHiAYN zCu(*rlQw2PLkIzU-Wg)JPc^fS+X565;1lCj>7L=m2wYj4riM4Vy`$Xwao+P{f9qAg zeCE#|f3^K;D)yS3&6+hxLExECRBarr7BPr~!;c}<#>YlwXs_98>}ILV0MCyxj#8UB z42F@|-4_U~Sd*HHGGZcIy7~4JA~L-atZt3FudVjX;s9c^oaOb~=cLX0g;Z>ZIe;>|hP-q7DOAL%Gj=bX(); z|Mba6fR}yxKVS8~q+&$8xdA?v$%O`Kt)3XdeSF4>)GtqLzJm`}| zEQpB?%)du#Bg^NC4Puy%5ZJ~rUC)46bE2KwMm6jfW||YH=+3j3w@6&LfUt@l$(Z{{ zt2|Ht*N?(J@xOiY5j5k!8`^+JP6+pw2fSTvzLp03o!|KJAARW3*%oJnkv7QxZDWCS zRA`aQ#I<~*%el9~U%e)Z+``#8o997}m$U{jR^evIE<>XGk>R!Ag9=mcjZr4ZJz_UL z;;@!&NpKSBwx|s9rP-QBzH?UFGJFh}ym{?f&TT@ju2ft=LTGhi+Az)aNlQ>5>BcYx zBN?KQF4bX)Lfv5wS)Q!LFFyR?src<_rJ*V1PxaI?7?mJ&V%=8 zJHOqu^FKlb36}MMuxwm`TiA&dDz72A2BJi?vBJiwiMS#`V%-APXhUUYi%~kWu&VAJ zy0fdQfX^_luu_v{#Jl&2R+ZG4(0=U0;CZ$7Ah}FbA%u^;9BkDzR%oQpTr^u)uQ&&3 zzQ%@tVrc{)ajoTTo@gyVfL*yejm~^|n8q2?eb#bYIw~d6aGIBP+->#N&_EMpht_R7 zzkc@lzKB2Z?DO-G$$sCldt}bhJMH{8Uw?FSE@UW(^rv^|PDhO+I;bzZnt}n>IoQw2 zg?kzttI=bv09M2gA0P`l&ak@0&(3}Z@nYjuqjDX&Ub-!c6|G6HHDaIH8~Q-~cFtMl zY!1)}Ai}HE(XmB*Ve}%GM!W6qNQw3B8K~w;4x+=ZES-;xDc=B*|A`=34gET5csm>hrKQF~y5rcdP^k=*y*e&eH?Z!@Oi z$JD-iYvtI``Wf4RjufCOuETj7gbs5fU2B})TqvkCY@yCHH|?F$;w;x}SE4ZDQP0{d z&eGOvuYG;Q6SV$5+5s=a_X8{kFIRxsdCZMM%=Xz4kbZD52BpVk9 z+|;MhhE{va0BEqs94Z4;C+`99aXTQK6)Vt+YmO5ul6Cdv=FH>P9`>8{Du14zzkWoN zdEa6C=7js_zVO%kr$7GkQUAv0UwrmYj(?`(-uF*@ssH}R<7dyFzkc@lKmEqx_QzlT z;lKXlAHSWVe{%hWe+qS|KLLfb-c1x3e|h5UkACaLt3NsZ^3R@q{z!wD=K#VNd0pt3 zBVc3oA(FeXz)6QZ4RV3gvQ+D;fQ7mP=L{FGQbEXG-t}Qr;r?QJAI?- z*k`u2Y(td3)@aLGW%LuMnU6YPDviRf?Y6dtfT~@f^yDGQDYsgz0Ji1|ADGA^omz-8 zAE!@f(#ux|2qu>`+rvFZZrZZSJ)-+H2VvshyDw=pEBol)j!qk39n5_SeyO$_!x_i2 zvmubf$~tUdkJhk%d%rmOq+VX}-!~|WI}hKt*5vIO$ZnEp*i@|wY?^ZPBypFv9M%%2 z{%Fw`2#FngRI9TDx}(VsTGoVHes_t{p>DF(*ikhoK>U_4d{(OCs%0bTQp6oOukrMM zf8(bE8VWp<>bbZHiK72TTNk{VgB=|Kogm*qd=%0SbbY9e4(ie}0B%qJk56E4`M@C~MwQ6%MMk~rsL)>9!LUHuAJC*Q ze+wk4h5jvDRm|WmYo~ETkl?b@`sP3p^{{MT+Pti*^aA~(L@R+|1NcRH#qb!IP2)Dx z#uI>_=3WQkFLN>SoUKg`0>HjZXz|4)GzCS>Bw{J9P`E0##d}dMh#_H-KYU~gLP?@e z!@=BLbd?NLs6<&>lu9ppz+-KspXT!~^5ug~?cQVe?TIX;%A3pF=mo_@a*v%Y zAP;EuV<28C*y zRv{-7eHGM~;ga3()^^Pt5Mqzh0?6_VQSe`k_QlQw%dpZqoUsV2uV6io>MTA2waTx> zGap<$^T9WW5rf9%AUIdMtU1cx6CNBiU z8R(U@PY7ytXa%oq$(=STtZ6+H8{qJ00+!QvXpY=$5BDCqZ*6-3eO#SR&$glcIi&16 zLCIdZqiWH>6;EtN6)XwDT^-1gV{KUPh#K!#Axer5ljLY38!c+uf>f|9kjDf}L36}< zwss}4_CfOW|NP`5I3zwu=ezIYJUUVT+MAQilb`$ZX9rXD$@R$3>RG;g6scS~E|zM6 zLp(rqnh0U{wkXcAg6xG65qQyx+1qAGLq#5~FPIeK%&Y?dml6R~<{;Wa^qMIfuJh;& zbXqcLX9txE%_7R>-_jB%0PORUg-ivgv69f}&E6IEfb4K~VC{w-L0JaY3a7-1GZM!3 z0n0r)cF@X?vt17QQYeh|WR=5~+eiRq1{N^KJiDN$7jODNax>k-R-YA3(dpef&UH;h z7=VBgGZWm~Nca~07?=nJpMCEPG9Dq97@)fz&LNOv`AMFX2(e|s&mz~!ff$tJ1AHs8 zJfqDo>()Q|hd#RvHMr&c+fCCygvQ9Vix(J_XRLhl&u(}tfe(y5wTe6PFArDk z1+JAlMMKJ3p9RG1^y8<4B^i^z`GH_Jb52t@!A$h_UUToqdF+G#zSFO^S!e`=A@$}A z-F?;QbMDjD^x`&Z%sozI$1bqMvA5Cjgn4_W64=*?a9SUly9KPX=@JbVFOFC!Jx&-; z`Ebfcw)bpA;X~@(t>OBhU#~O~4VD9vuk5+ScV~x2_gY6gSfPn1&~aQXY=>S1e}V8| zwTNQyuFDj(4~pW=n?C)&a26Toa7QXAMFc6u1zIK`PT|;F`Y;8f@-s4sSa=VDFW+065&)bVzz5gY5U;?x5XNX^B8Vl{$NBLbQIYh#5vf ztQNbsYR2GT&fK$PucbXF9p7!Nkwzg3<2R!q8#_0o???5uN4jyN)c>_L>!@N_q%TuhYy}S04e7e4TshJW1 zJrRO{8ca#^@ zH6txqh^!!_9LPKZ7ABog1ZY&kQB^jGovp=*CKEm3Sl3dayT_@ z=xku|NtkQfC(#P4V8L3|2ma3p>Bg(RfGOCnPhY)Y{*NV0U#YJDv8VJk|BJo`fRTMw z%e;48v+ zJ*_W>UQ$6KV_htDWn5n|dx+FqEY#84s$4DqUf=Lv672R1G8b;RZUj8vnMe(fPK7P< z?7oI4kb1>Nc_!!u2@!Giv2f<}tMR8}0j8UMjgjDEW+E|)eRWlr zHD;f^IoL$|0rm(i$L@jU9*zZ(sLfq_f#BZ>CnQvvD=hcL7i`FD8)94}i~+O25qMf|PYub=pU(!1j0Vv3mry z^=<)xKSTlG!;6SSw)Sm$xXYZa;j(Qo0F1e2r>r%P69h99-8zD3SQ;|P0^9-x9QDk> zh%Ug#(2qr*c~DA)Da+fEBdHDrAu?6bbViY5Kx%cs$uUpY z9$(cHe)Ef$SugX|Pyb#lr}rMi2Xhax9p6lye)IK5H}~Mv!?|IH!}nDU1Om;BVSrFU z12gtigs_CH4xP18cT+gQns)14(+{Vyr7>c^fpIUeg{CfVqeEJ6x-8;!csl?AQR>py ze&BX)ClQ~7d&&{Xuo{sIO`Nm#bOQ3WPwmTq-iVWR!M0k37qRT2tA?oeK|Gx1WoGLz zB}sIe20iu^A3ee$7;jK6a#f?#&pGkFx%X(?@4d(FG1=s&bR(O@H+~hf4s`@R-8Y${ zqgibr=LM0Ci1>mI0>RCv5OSOQfP*&#Fdtm*xDckZT5RB-4WO0Gt5kPutiO2UXY}zv;C<)Ec^nb=#ruw0XENeWV%0zwvq73om)g4@L=bh2)(*#{ zMhm9Neo#XF#0p|)h~L0hWLDdn-tyS0wXI}*1`d6n>1us?LcqK}>s z)ClP6ZGhc%^-5kie+VhcNo2SEvU@+yt%2yhuW>Xq!8*A9^X#Q#FIkCr=)s6G$aSWk zgRne?va7Yrbt(9fPBi6t2z_Q8=s^w(xNIeqmo_v|1DEEJ2G$mgnJG1`I(R%wQ@-L} z|G``6@tb4vWeIum_fJ6n;_rS^j&)i%`++nNaDuAS(fu)B3kpF7SIc5}USaAJkg$PB z#LHKlFnodjPqTs)FhoKz8r-m1$B10PZ||VjLEuXnjoX;}EVP0jw8^X{>*z}DfL1gD z)(wVAijGg4elpumT_}5ls=<3fiGL;^uQd0*bPQxyO+;Hspp!Zr73Y1>A%TV%9*JWE z$&C@nd6pibjr@H($K$=Sdk@|t{*HGuG3Y~NV*Cp9_5lCG%54a(AXUk8sT`O(Nygf# zD%I@_1geAPWd$rg(qZQ$DF%l?mZEwf zQTn*0XSb^RI}hHsra-y3a{Id`B!49FX~J7>O_Aq1B^-vGn#8@*FB-RqA%RxvLvePAozpj!WWHCTcyH+1cZmV_ z@U8mvNn7@41tDqB9C8#vj7U5@3smj74Zg45<=}dYT}JzWfU5}Cl(P;_D*+sZH3s3)n7oL9a!}I7Hc*uKK9Grk+ zf>te~kF;Ydb9Q9RfI~4gaeOmB9aL@P0&(90XZg%1gw}x|FykDEEBTUBBSi}z;xePQ z6U5%|vpkNJ&j$tl)w{)&zX&577nt6A>wwN6D#n`d&5fDJ^lJUM@I^>1fNu*s_KvZ*P8%=D_#BAXUYtxM6(7Z~`qLHC2_FJ8RLC;9o$pVePH}yJ42j+bx4Z5zAC=P*zaD-bZdDAwwjzX<`EtCv| zaO#__8z`@VFfB<5O2BH3M%%4(V)=;Jdx!5cja^|inZ8_00sd-=B))ZfU2hcv;owFz z@RerS=*oNyvNJ*2*_sd;4K8(95mwU;#o&;fy_W6ry0F<}fQi5hMdxgL=>g52_Yy?1 zqX96B72NX($P1xPlSh}#f8?#a)j$9I#cO|^PyE%BFMjs0j(6{|d{D=`G->*cI^NrF z{F;w?-<{S9|LS0%k5B;gIxUUBgGljMfch}P%g54LG&k}Wr9k;>Xp{uh&*+2WT*4KihZwMFlg91{&Gyx)y>}*5@dd+?G67uy0 zT~2njkw^waNMr!p%}G91QB4qZ27+KCumi^gQ*``A*LhUw?EHPP)-Vn(87D z@msE=b8`q{32pmAO&5|hMIf@H7S>IguLa%tCOZ)gWR&J-#_Vuw%Iu?nVevJ%+u>6) zaepT|tgfpeAyG(hIUmMsJW1GZ}g!IFkWb7+8 zGyt&c=)sLey=53sc6;_ACUJG^VN#D-93b7!2U50sC*40l;O1vPf0zt(??HPo+4R%( zDSu+|l0>2f-*ue_a<;v&N z7=?voQRCLVu@AF^#Ev|XvR+*mzLou*Q|;_GSJs9v~?5Nc|0 zokB#=0xs0O4jP@0SV+J3>Mvfs&Igd)dk@^B=J9@G9{;5my^p}H{cH31uf{w+`|7I$ z*VTP4KC?+d<=Y&()J@@9(rN<~ESgc`L3?qa<326AATWfzB9dl572AkbAg8cN77oU+ z$9Z<74LXelVw4<25H8lI|Ia5^8f!o*Y}rH+;bcgeUVW~kSpkO#fFg&Ds>21QX4K^YaNA75E5Z6Y?4%3;(`}ehfoLpV~#&Pp;V+1&@(0xrSft9AFbNpvQk zW@F1t+HFFqxfXFhWr*m#vg}S?WKj=`Bd6v@I)LsZ0w$vRge6WMK;-ZIIPVD!d#`7G z0a8C}!V)<6D%iq{9_=s!xoQr;^I)yOkr(&MRc#lpDGZ1SQ ztC~2fEKub89)wG560Hpe(G~;eEIQyr!-H2R1dzZ(i28O`cZL~-PbKYP#~s#?2SS@W zKhAsJ>6Ocr=P{~CY>+K>!6i3kYG~*XIR+2ko(%0?AW_ws6{au8S=eZ&bfn<=>MTgM zg-?Rpl&&yUuA=1`njzFSljR03-!rZ&54=8;*LwG*j<+w>H&>Azg01c};CbC)2|BdQ zWY}O$#r$8uafDG5%Ls>z1Y(r|@WZs4f@{Z7gcu4^4Rkpm9m<|K|41kN6dN&<8J4i; z_qwg_-1~7JH9Y?A+c*3-|K|HXuRSR#Penf@z9h)Xhe>zFiLB3pn0X3kR>1*IQY6Y1+mm2LYdK)=G@&7rnFo_ zN|2e>v<$}Dh3i+xVWEpD5!-B$Llj=eb7)Lld12C>i2*v=8!?G@_nF+JpPRROZ?Mj< zIX}PV{QR2p^UHI7e(;yFFaPe}c)L(NM*8{D?|t>VZ&tCJ-~I)VpdbC=+uwV4bG!LN ze{}nY9{Xp0{M+v|E%6c9$ZlJ5PDO>IhIkA@tqBFxK%S64MC4}NX@L~~!sJglp z-QGLF`ex$&LB87lMIwRr+2=ob@-lytfBsZL=Pv{mKH=T#s zVM09_j#~aX(RlB(3blIWofGgeWQx*II|!?jjEN?A4~9WwwMk4v4r0odn`L4jiQ8g_ zc1uRzr4Im0RY`5oY0WejYa>CR%k(i&zvZ+h!uSUlNv&nx21@w-h*x8~Ib zLka~1uu=o}NNDtd0v0~HqC4RPX-K9@yZmR;x}g|-y^FbQsZ=318?EPl1kEp+&0Qng zz6Iod%#-A1J-heFeT(ba-DBte`5%4+Id4z@g&%(S&tEI)E*aiy7gR|r*v>(EL~5@A z%ooh>9rTV29qD2|(s#E)S}(x18L0Eo0(q(fbk_;A*1kh&^1;+2IhM$3U%~9ybs(d9 z*vv*)g$`?b(sHLn`AF;Fszi0r8|?EiO&&Rb<5@8YPJ4&i8I_c6w2pDX1GE=(47Iw= zDK-I3_jI06J=oPilsQ(j+=AUa^{da{_g=nu{`_ZOeCeBg1Eziy_jvCCeB|cdZ^-B$ z0QZRM7}`cq5**taqxS)l?u2Q1jY-^c+R`K)C(mXn$B#F1Ul?cNMMI%i74V4s!VA(l zD0a*V9STU7y&WA59w;D+a5IhB5vn}pJpC8(A#96DTkYVrS_zh zVF!@_Q$|`*7Fe^YidMjGMJJ_=kXw7x5n!$2G^j_)aICi$G?){pckF{mewh~5voyx6 z*n4_1xZ93uZOU+i!qWmq5)kH)UCfku7Gz>5k`nUsl-~VlI!XM8H0;7rZGBb zP04BuCI*O#+2>?pV^n;#B;g4++<1Cx*jcTG$Q+VTN%Tp}pn*{;?x*WU1>%->B}+D; ztPefpoW?&;tZ>j8@Y%G;%`&k#pI|Dxe?r z>|&={lcQghakj&2!1H&T%kc;P>h+V)^0mV@|K!={m}d{He)k^2N2)99olWS?*B=1? zdS|@B(|_ex@Bui+YokpeK-lF5tZqs>wgkO0Z99;Ek$V!S5SSc$^+Jhn>H%L(tCIyU zi#)_pvZEQB zkKTd)(YG}oFeIKmcg&9`ul?mu@?oLp-oyE=v5?7e?Hl71D)lYFQxUk`11+w7wjy6B zry@BaWH20}YiwOLbwPn?geqM~;Ba;dxx8(0TFUVgE6%_VxiZ0$=Q|JP(OF~ zMMp6yd0C6*+%pjt;H!_o85JwC8!{LOSBAwJF*0(wq zxoZlLRbDYK~#WuhjD=mG|6WgEGUp#!4t+DJkPoQ4~z zjvX%jpi4MfAB>ESvML@cX7zDUJu-_84eCNAY@n|W`@k)+XdUWx7$F#KH`U9~UNT&4 zZk-)99vP<<+&KMED@c@&bMm5?n-M#<;R4oJ6UXDWn#$N!SFxt|sWc%Rfn!To`K*|N zr1IJ7K^(~M{nTGQdHv!|xBj*NAwtymf*6KHBt&b3B(@W(jpl6$~6>OfPZIzkb8gAW*c$!)15qZL)&fOG- zR2zpfdnd^mU>N}r$~glu9>t4|839ABnitFzNEh}P^Rz-dFDxSGc8k6@UHewI^0%-A z|7m{y;B0^IaeJ7{*4{nbfA8%#KDrrq7O5`ds%aetx-@vd<|#77jX1awf*rOU>Mp(K zJTjfJk5#rg0S`GxRzq8R1d{^?#JGTv3_q(MVmIxvZyrM9*En1aHBjvN9vFCQhrooh5kg`tHFkAmZf`S#eE%^W3u^o-zB z@!i=`*1CujeGkX{aUaLk!glB&vJ!YD7s`JOdk%CK9I#B%n$jvmK{4{yAd3LSuoh7a zFdq(4?Zdiy^Y*yI?wi)Bxv5CzsH z3J3<;2=kj7ICPOryxvP4C!KM++2%9|vLx&<+n4VnD4okd2nY}k<=2@VuW9WjHpj8z z6{@#uUmM-U1QPIZ(0#~`X5p$maKX)8%tm{ICn0kft_*x!)N!6`28yNxuWJ3!g#LpX z=aCa-Y%R_aI1GUdKEw8;0ZvJ@{pPMxH@ofcoEM)xd9(68470oQ$URu>)| zZ&=pTf9r=I0b1ibOZq@t5tUj@@IDw;a?2}je9a|>ZFR!e4kUH%1}l+~cS>|kh#T$# z7E#`{X5Ye!)6an(@!;ohhOY*xYbgt5$$d_)VuEtBwT?>Xro!(pLxI+z@`3C&454j^ zVI8!`)aS-Uk(ev6dFAM**YNrwm6dZ&%|3KO{cx zgH03V_9K(dMpkzw8pHdKeh z#Gt_of&LdE3a)uftK>-R-Ypu1`3KTEE z7a;z1BGo=88#An^+L1urL`CeZ%vfjbwcO3k{{Q>i+109Bg57A5}Pn-AVX_lCC~S9rg{ZQP4qH9!t#niVPVwUGDb!`AZ z1oF#zXL6>}{qR@)6x13?7*Gsk`sSGq9MD>Qi;H&eab$7mN&r}lMJT~cDn#%bWTdO&Xbfm+DpcEoGojifIV0JZC0^(o~ z>u6C!O$E(T3~(u%hN7ASehEsj4A3w3(QxzHHL2NX?ud}cvvy7b(Rv?5$vphkk24?z zyKI`Db}0f{rx@wfCehieqZhYK=8UF&FT8S4-fzTuwgbnncoIOsUvpCpD%EV;q?RWh$MkDG;52VwfI0 z$zd6e>ST-fQUcJ#Ct`+ooB2OD~^vC5KPLyJdE5L5LY} zlD(r_kSWFu?ns}9y}V=VfvmJ*%W{hpp#GtJZfBor!5FIBmDL<)%)(<1l|X>l=@a^g zGtnwQ0PMqGdx;dAUIGfZE}eWZ8dFdT8D2g;lP}RdI#TSLb`%df^Dv|bwvvZvMd-Mg z5y+f^`jw%PG~J-N!Y-}S!#hy$<8W_iJ?RMiO%Hz^u3~d5D3GFOTgwc9d15yO_7WbB zV1)N+V4g|H$&guz$f+vSTQ+8E2O7UVEfr;YMXkn4X=o1z6>7KD_QC&Y z`Qfj}RV=4n$=KT)N-HhcdU6SEsGVdAV{jV%;Iy=8WwF(KQ)+8G{0-M&o;as70&DRl=vu3%r5(2!1JVsR&v$Oo zZ54H-d$fbd>>PV%F594xg>;KL$8z?*iICBQ{-rIP9nhfJqK9EoC*Ng2fuyEA{EhFz zVE*B6!c{21T?iXi80JVv&pn`lkbSy3Tp&YLW{M67)9^IREe@f{%7MR1g8@RpuZ4j* z6-(<8-h8c%f?A!bkWMSG<&V@pT0u+_^zb+1DuTw2T%0Oml->t=zo6da_U?NROs@ul zN9_dq!JV}Nbpd>floB4?BB8{D^Cg_yAUa^)Z?v_*B?88RhRjxA-FqtzMdWq2hrb0^ z(VK;i6(GYlh+L#^9BN0vCFa-FaVvHPG;eW&Cpf0B$Q&2FHrFXmI7Jva->W$~Oemy*7dwpLFRyy|+g|+e54}B% z{#P5(ZvdqK#h<=H=`)g4HXxA*ic(5GXEV(0(ZS&e02es}r$?-Ywq>E@4D~$j<#T7| zoCg!}IWZ?kfykn;+qB(yG{B2yGXPhSK$9p;=D@IN-oncM{H4q0C2oKwb0#|J zI1--p9eYq7nNt#AG8zrgbI%c51?G?=sRXSkAynE0JKRBJ$g-f&#-WSKd@$_)C74LW zS|C+G1iCNF*TdibxR36>5ILw$LkAosF;|EPfE=sQ891cqI*4URSWu*P=ro+Y7WJUf z_CQFNmzE1z&`RwJ(lOhbHnCZh@uqok@EU|KYqBCL?BP#dP5jfujag4nH!7{^Ptuo4!K9c#?q)`kA<$smSusi9Z6eR-#vB=F3wGbE^Or$bou zG+=^o*EASx+9}!_;PM(Uf=g;cI!5k!MbCi5`|x+X0O9Q|OBd0NU7M#LXz<+R3>f** z;xygF%+dL*UC3htig9eHLY$by+o@)W4&|vCGI3g!wG^`+`^;CA)yu-)fmcBL2X)fiLi$T ziHx;7ALVQsbgE-sD~b>bWUl9KK=4v;=Sl1B`}z8#mmh!j{^Npjt6RMDt$U{b#y68Z zek+qa?E#7Tl-vlYvOzotIQ_d4c`65uk8miuN5S+A>D z=%hz9;1`{wAgGLRw03l?8G8Ys*FCmB{GE9HYARFiJ|tVg;b5Zx>xqFboy{wp3GqaL zt*DS9#F7yAJ1G=C6rkvW^Yj^8fP&=i&Tw{XD3|vERe?{Z7EMhTtx@|pvJxvF{;r=! z|E)D{0-D5bR}exRbr^{>r#t${yBDe)gBJ~r51yb2?kaB9xGx>sBgqBWLGRIEP&jG5 zl^sR5dU)qC06!QTebL0(PB)N3w_EqUF&EEn-M{?Vr;ca($qRVzoA)y-+jqA(=DdgD zh-0I~y0jz4XzBQrRb%B`w4%B1mcgNrKy4&{%nk46;0Qr~44vf$xFfVxy2i9Pg+xXQ z>Tq~;jij_IAVvV=yX6qx`Es6pN`CcgX4Yq>*#=(XqQNJRpv?BRIa^ov-qG*b9KfKE;z&n z{$e|W0sfV<&=T8AdMj^jQ~H56E+$2l47XtoqKtiLx22dT#ReRT7#eW)o(6TgPI>sd zU%Uec?4O_ae=6sFt#We3QR*6z<(73qCyg;4_hUNy*w|}QWvCdUEEO=st+NLtwpE37 zkB?5^G1h9-Pg~cyqvRUSK$2sFa}M<32r#u)8*_|vtQ&$cXP+D?u&@ex8P$>P(r~i$pk8T)tP7f>RCKzO-SSlL zeL1(maj*90KYGqM%5tp^TYY)0Kn(ms?VYq_j3EsJq_9(yJ!h>ZcuXB2RmQ+ab!R8c z(L^@#c(k{U8em{`X>DlQTCbJ|*bT0`b9M}oijY;fEUfBmhqqCBQbt`t9G3&`+b8Ma(*>eTG=?F0hW`x=l+5tmM+NjmyybRZEsYi&3(v|Ded3=fJ$ zu^?ZBcJJ)oWX)SO^owhwdH)ej_WqAOK7IA%$-DO*eDdVA8_aWi8<^*JLB9X@T*`{Q z6M+-GGSe>&70>~vcsnFit0hkg%itQ#XV`XO2_7p%Avr$2uDiRG)&^0-I|78@U-NAV zhDo69P-BEN?`NJl(YX&|gaJ z^fujF#~_qEgc4w@#k&k5^q42C8by(03uHn`oDG4EH4JgiNUt4N zTXM}BNTw_yv+XvE{W8U%l@D+807%4z8)D}b`jE9R0FS#GT3wL}YNA}?VyiZqkFl|| z0a=Cu2>TcW9Z)p!o0)UJ9VI zcb&{5qIGb}Q`kuSAbFLM|0nGl(@Z^4Q_tcC@ie@<9DPnqB%nuL(YUvWbLM0)Lj(3& z{1m`}wmLk?6y7Uj`v{aHKDs~r$v=XzM9u}`f!8@QhRu#KHNe-Kx6-VoJp1T0bB%fF zF7}?IV>s@DpAM3;xexMDFA}RF9=8i@RwH%0>zJhtIbIlo6MSLPo9!Cg`@=uBcn_pCj$k;iIP3e83t#X$8<$u4nZos^L;I7 zL40->pW9;%IKU5Lv`&ibjrrnU1?tV|y+-d3|LBW%AkFi;7cTnr5ra?`23xN3^jNZ>`00Ep*I%AwJ6V#Zti+w-*sXub{syhZR7}Uh*yG>GH z|M-klKkCvLILa;>`;u$u5a@teoYfa|_Rdwi;qAc#mXq zbl+(*JM)u6#=S4+)>i+c{P^|neH_m`R)Vnknyl#UAPjH0A`{eLo&#XMGCJOFIOY?Z z32I;?1n0>hxWb6{=$_X`Nga)pEDbqa#p6hEXQL^zYsU!%P0mEtkn7rC&XWJ^>#+iU zl-}R@nFE1xWnxa|(a<7xARqP+IodmXXZdi&Ds$V8;Bu)FoBC#LOtU(Rie`)|K~^|3zltwJU><)}&9 zN_mYC@XSpH?htTco>GGrrsKFK)E;SEOZ@}~RxX5b7d*bx&e+S4hONlKCE#uR%9t5s zP6^a@NA9s$N!QcT~X6`^GUE+9IK?# z9Lv=(FG4dNc?3OD$%fEXF2R%E3oMPDB|L@_bo_EK6h=pX0AAGFNL9Ph2-pYh(g^(d zZ@)E3S0RKY=A^>0(lW1%`6VOvO1Nby3nv~AJ=_i?OrX}EQ7wrqwMEAc1giX^qva%B zP}lbvmNM4an;OH0ExFG?Q+HG5xs{0CJ1^pk8uZWl@%i}6x$UQ~e&_X@Cn%oPLu{~pzoLD<|44Un1)uM~=3o<0K| zjs}wP^t|$c40P%<5{~KU!&QK%$+cOLQ2;7LYqY?cPz>+)O0~Sz8s0mg;n@?=ul;_{ z-JS2>ca?2g%TkI2M>W_B(}5o7L~V*JlvHif9M3*?f6kN9;HyvY^*p83-1lC7 zSD(RYV<8mVAWB-+8Y|dp2NN#eV>)Y3gPv^L+1Bz@Rf;CK7_*BEVnV*Sr;%6aQU;<0!Qr>h;GLsTZij*&efs(P;ql><8O^=#+fzCcf1qD? zM!xsvgLm$UTkhio7>V50kkuX9FkeVY>(wxRONZ_fuHomZ0sfJ#iRXh|$>$xxm=R_8wcgPCE@)D5zjANp~@iKC>khx63w+ zRWWimC1fT$P*0>7l5B?Cx~Y0W@Fb&5mViREZDrK0L+IY2Q@8%_Hz$kNAH972*^_1N z&bRK#GS@$l`E~Kbdv88?3!`YX$!9+b?~~^22~!>BorHdC#Hj_Yn(emB;><2x=CV3| z0f`j^C>{CeQ`eg<5%BaCm&Td#2vfQ+2$d~x}0ref$y`pU_74_*sq0TJIEH`i(p$D zgIcpRS$#vHrE}OgISPTIW1DhC;H&}+k&d}=yR}&>roQyypSZvrDm3<{BcL9PBn=sx zPhAZ)C^*oI+TPDm&^tgnh&%yH;psDb@xh#5xxh!PvWA(*ShIJqi<&^a(L7f50gq(^ z)uWFiq!D=@{>e)i+jc~A%x`P;vzg+kPJ(FBnhp+2-;->1gilc*jHxep3J`lqe8!~Y zy^x&BhcNYDzU06!VCd+BtJKc`5gjeRGK^cy6UVz=5C88Uev4^dH?RA9@zKk#2wQEB z=2Ast^hVA#BH#x?TJvaw3=9;=lc!p?>?doUv1nLf;v5~IPkCguAhFQ^@gIL5Pu-K}?cVq886oU9V?E?;#CrS`V%z4< zG0%dSVCp6i8ZPqUC=@WQZ|?Itr6EY0)Sw(YK9L2ku&z#DPGe%Qsxla~_KW(BvD1jv zU=U&kS*Vu}fPV->V}uf~xo=Or_vQ@WI@0oYKY8^r0_ZWePy4s*}K&tI&)Dp=}1M9Ik&GwIOKfG80h-1>)p6 zmnk*iw8TlSiWM=;;^=hciQe!mOq4sGIKPjDh@xwqk-9DB?u`b&RhE4I@p&09pRfh) zeAAwZG?MX+Y=<`=ymOCRJ5w&(BrSsSD|t8*qKk(Ssjsp6n>*)(UH<1~0RZnFdL49LBC`hGQEe;c^< z-Z$=<=3KjJ&b4>y5&WW_Gw1A~AP!pEaxzXxCoo1#=;7C_#bCInFGSTHIX=oet=-Ag z4MPHJ)EqgS(+;AFd0V!<#w;T0NW6g7$x_LSPOMol1?y9#@SStnZjY?jLzY*6?nzO1 z=R5c0iL;v%guNwH@DOSZn(Mt!Z_sS#_BBFRlkSUHeIMRB;IeRNANBZU_0ASob#WSu z!(1ecSG$|U8r}AR5vH9vI(PU9n?T+l3`c*=-GWzd^6*c+_~9?S^`LWLTExQI@dn>( zOtC&?Gck-Ww39IiMN)i+%(##z+9&&fx!D>cLfP7!v#&Y}WM2%?r$L9=mIhB`**2r_ z7@+Hkfc$}z;Gv|WCheYEDF1bHTA25?&v zfW5ShAPGo>0_E5j4d3oh>pG7VOl&=*I6hIBX`(#`L6Xu5_|86 zt=nSvcRqailuvT+d-k*G99==o#jPD_bD~0VJGFPCABjeHWrg%6CE;;zus=8x%Z}hKPwOa^*8eHAAR&{`%}f_y>H=n zRTZuP&F}TN?*u#+1;x! zCec-eq`B2sHPqG7S&zo)R#4|7VP+XN|FPa*oHkFWe#pTB(b z;QhuYpT7L#sKh_}Fn|2=<0tL>d*8t)Pu{u-&RK6MIOpCB&0F)-oiFFvRqA`6e*W=i zFP{zV0PS(&RH3wp0R>a2V{M0f+n^I0OSj?bfR80jSQ_Ry9o^h@)WUO41H59<;V~yv zp)BzFE#SQch;L3V-v`H0C152rW6hcK8Gyv20eft7-)oB1rU6DmjCL+^l2x+8(P-Jm z?x0op_Op%=*M#O(`jSvS9ex@Cg1Ccl!R!a;;`G>pOK7DROrCq}j%6tVKa6?FLQWi z!kB!n(>~2!ZadnN$q>lS2|+K@3Pz3{d92vp2;i^IN9bl{+|00HT@u%>%o&ht~MPt)VG=ayuj4SbC}5@4E< z44JOj8hH1P=GvACP{SEWyru1}r=Fg0t_~x3{dJ?m7AFCtt9?y&T^jz&g2svLSqEEH z1|Z6E>E8F$&R=@&|GWpjPELRHPyC5L`oQz6->$C$G@CDK2-UV6{qzC)x3#5!T@u*@ z-SrGR3vvWV*hh1_u$oQI_DjL#z^6gg$vzGU^P)C}mGIdHjxZDNo@phg&@tb~T!3G_ zrJvmUa&C{y-}((BQ#7r37!Jj)?==W%NwK>Pe1Cy-i~^ILw)z0I1nqb-BKV;i_p=U^ z**sg|SUo!zwrL~nV|FcoyE@Ee0@}^&%HZ;?%1QaB`wb(D?@zym|IP3JCD-%)Ti1{M z>NkJ+(JAX6{iT1!ANb)fe51Z++S7c_;SS;=I2FD3Ot1lJIGo~(NqSv5QD<~WIgvl* ztCkNR3L;FxpV1JdF?M199i^>K^#e!4zyul?#D#^}DT{b|PM z&kS|$ecygIL!EbE&i3%n{uEm5ImdOL0>4LO2+eI(KGH955DgCYyxPeO*9i697hh96 zuzKLERAddu#o-(ai7Y(0q=senz1Ahjr($ST`Lw-Y6!2+8S$eC6RHUKKJz@f%V#$8z~Z$M-hXo+ za_!8JLpJN@pgC9?u%XUgGgNwe_!qBeZW`xoPwMC%l>jg7NMoYTI%k1-0kR!q*q_J- z$Ma*_)}#&GEJ9NPwTeQhZb{r))aF$~fyke&X;X@EC`ZU5u7w%#T9nn};a|F7w7SrG z#K3cVRy44Mj;-o2EOBPT4W)F@_E{{h_U37`Mwkw*#*@3TT!`!HQXx_u%H(;??}Tx> zs-|OFTa9>|1HMNQO=o}jmoHQ@U>SZIAiu$NhKYz?evsAxk%d*IR<9Fh&W!==0ScHd z+v@ffew2!!<67lw%7|&RFTy6V&oWhS>KSn1k2YIbl3!KeG2w@Q<+_TQyw>!YxEshG zumLPa_!zxw*Rcqz8qDOfjnzfwbo4V1dMjbxy9Dwx+fcE|`lGx#t+PE#uxXEPMDjUR;?1?(m98DNpp|R$mIUQ^Ar_ zXY_?(1Pr^`fem5kC;Q~%jYK>&Lg3UxjfpqCwWhG|g{^ZKFl@{K_TY)OgcHILdjO*? z674+vn=jr4GUmVa_>FLZO3S_weV6QxL@C!z|Q)u?aw^7@x2{{U-noxa*$Ug3?jnKZ))x5~l= z`%$%mJ7w-sJ3WE%nZ z{M*+Gc*TG2%Rd?<*!9}x#g@=|I?@#tdn2E~o(JKSO%t0rjlGq^SkbVImvbB&v}ZRQ z@Go=ySusYk8ewtY2c;|UwGs|u2Jyqcb8!Mjb9BB>I$b9+4{^kTX!eVW&A1wB1`bcp z-I$`_iGVeh5tyfG3?SmX4vvf1#3ExeY~g^Bm3D$-wzl({y=WN}Fz#4a9{$~HPilRD zY*6RgLRV1-ouCbflehFrUL9XNN=W5VA_|sTnwUu)u9PEnWFyAYAO5}TUZf+EdjpIwQhp)+4*{VRh~P)DkWGv$qr3!Z+!gAD8O^=UKX|+soCzxYBxI-A$g|NIt~19(ozlq!VIO4VAmFgKt%-7Qal^d; zia>S0keY}_M|Uwda%a>#6m{3$4bFe@MD*4yOdt%h^Hb2AN6Mmy|L{$%a#dUtFu#EF zQ28J(CNPsC@jlmadxQYY(mB$XE))DzvwMg6HNEp`;hd|+@H)%UR(8hdQ1PTRq%0v! zt3&XQKiOzI_z7L`&X;pbD6W?upZ7n1Zs{%RRHkcLjSJR4TU$^JpqPT630&^J4WXL2Fp3PsdVjPQ(F%d4H!)=Z%AvLs+EI*=N)tfG!G0Q zwVY=+=;(TvwLs?0tG+)t?vd^G@E=_dH_8cYbx@} zVip&nF#vtWd%ThB*JXn+S(WAEGAqr%KurZkZ0*tphi~%08w!+UN1lW~{KqdY1i@0b zhSR6o#V~895ci0POAu5yGFL{cWSPdAWh9%UGwiy^A?zLXRDkaR5o}-GW-o;g6vydY zn_`HRz@vhhxg>cXpvKgk5C6#{C?-e~`d7(7r*Iy{zlcz?$>3E3dAOAY5|w$ zu)ten(T_huIDPFZydVpdI>9*(1Ii2Wv#&z44C#+r80dQ6rXUs$^q2?KHFM<}>An@x zn=oAC6|*v;^|6*c{AZ8b5NS-GjH7a%5JWgOY#+)K|K>iJpA6N3(-;~p9qZ!k?aFEC zLQHh<+?M4u(`iCYhCx2)t8Gsn8Y-kcaXJdr*8=NB}mw++`U(iu$JxK5Y` zRVE#b0|px}L;aFea~?n_0C|yIj3AW(zAi-`i>?s!)^#pyY?DqVZS6E-X2Y8{S*`c( zoi#c&JUgNL#ovDU*~{lPhBjJ3wS8!N0e!|LJt!~@SlgQW>e96LP@Abp zRXP}}w%IwZ@p>7E0gG!Nc7Zf#xj-~IN7qeY>Z|!ep!z^R6HC(^!@~0T7aPML_=_F` zR1Ti*!-)m`5J&Sh=P<2h13^_2@A^Qe12#O^E}Iwh$Gh)lM2IO`D|UAVvKy*ty&{En z+v#@JG({h+;Lb#r_Zk{IX4;j0b!*VN^X1$sx4-2}oCZ@>w&T^-b^t;a@9D^+*OBC7 zP}Z5HwPAjZ1Ajt`)v2KTvP77Z7ZcfGIA{VXl%oC8fSpkE?h!Nj*@M( zuYZYuhI6*-NBZV`?Kgkz&Ft;zKlzR`Pr(O~}pw4RT@|4QtMh7?9A9n9PTMQd4? z9fgRWKy@_(&o|4c-p3B`OrcM2QRusY^i9WPL+7w<%ouew|3HhDK+{f)4fKS)b9kY> ziO8$Pc5FRS+#v}>=7g-M$~_aiLj{!OO}lhBMzDfP;536S(%9&eU=VD~m3X0k-5S?x+F=1jgD`aC~`^TK#ytzKE@Uoa^2i=u2e1uSnse3x110E)s;)O`c`#lcz~hAES%8Fgw7j~Y{$f|?hke0?GGOJJ2j!{CWDyjHP?43xm!{Av*OZ6<_G*7t zTg#>IY~9ZV%i{s!+%c3i&@s&AwU}AbFCM$igDmlA)1?^lIfHE~WWq*>-j`o!PlRR> zAh2hHfGA-Kl!PJ$uZ+btc6<2mt~z)$JZ&)%(brlVIyhrARRk&^yuV-Tv>`BEZla#QkvFmI8Sv9+2VkvdD(J_eLej5FW!X-_WyvZ z7zZSLL`PnA_6mos8O{9wPi=6=tm7bTvZo<72%RTI_DameMhxt@H$tv0CMHLz;hy`l zF=_a4x|(4Mm#GTF=Y!Y)#~iTT3Uuy$IkzL{5B>G4-}(5N>LA1VX}p49z*&VP-+|z+ zjd%9ZjA%VN(n1lP=u@N-i;S@XDXAOPc%bFgYzZITh!SPNJajcQ&)cxhtdpanJdj|C zbd>3nqCE}0dQ`<;iwfelluk1@Y3*>~hBdrnb|pI^n-h$3mVruh5!sSPvj9;u0~%r(^umGuokgvdeiyvKfV)Zy#MKH^3hcd7G&vhH8caU z*;Zf=D=ouxtOoNL=oy?-(+!iLqsdL%5E?idp8}Yq_K-ybVW_^e zUzjr(hiIOqK**z$bOrcMhNo?&IcL6+nsn}jJszdR!U)& z-Zl<$Q-}ZrE!%s}CXS9vBqpd7akRz5|Ni0;Cc~1bZn-ZcVJt}D3|>9xJJ65TV|*qR z6H1fa=&)3uIM!wCHPdrIM}@V2s?9x#A(ZKR*%I`B=3#U}v^x8u5Cr-<4PJI0{*MHXKg!?9kG{-``%!+3Fyl|2@x|WzCO+xX5w^syp?u$a z^TAtSc2w=@TlS=MsQwPkcE;ot7(Q>|LgN4%8arZ74xE}3Vwgx&lm?wqhkx0&?J#yK z($*Jv;irunRB5&tocicW(6M4vxy2~j!~b~|ZnFD=P*@#jxgDW6MTj7@w^pMwkT`;% z0$V#5gd2q%3>)5TQ4bnzkLbL;6!}yZv=Wy5AfQC1O{V5$ylGy>r`EG!oT_JdJ^WuU z@Jha2B|kfQYePL`OC|+l2^~6>wRrjJnM;6n#SQjx)TyNH;bdemg;K}FYYb&WJ{>@v zEP%EyFLPwl?X$2Nuk3^w=EB$&L1caPTPEJU@A0?4ia+=ah~sa28Si}?pM4n{-@J_N zt=QBt?J5#NALM8ZkMh3qG-|6)RKoDvvs!V*;Ho-f6Yn`}DIr+pmnFYB3JQQ)L*5@3E z6Th8*-aE(XrnvfZx4+JhUVfbKf05w(Z7<`UZ{ycr#$S8nqcVNa=2vgy_rCb#-Qkt| zKDYP#=jH3qehc|V@#U12Ya{Lsc-%6JShB5kpkIJIo{zcgr!twv#$l?RYt%qGz_2Z{ zI;{*yNGF^qP?9$}RwBblW*Q9q;0KN9V}|)ap^m(sRdQ}s7xxbPx=n%$|M=zSuk-zn zUViq}`grGC_w~o~4?ad6(Fcu)c&zo+Gy45+eEjY_s9!`)8?^!a$fac+e0EJ<-p|0` zHBUhPw0gI`vDYl0%jF2G43oXB9lYBUF??Ww1czC|N#r{@NgYj&qN2(s+QIS?KNwj9 z&ev|c3ir-=dm_sJDC4tFUw!=kXRqFm4?lhNYoz(-hp3OFq45MU%n=!+E>$oZp9g697q&ZVE0Km~?10G?%FG!5q0nE(}GxFWWm zMMS;#iGTV!KYh|Jx$~`iM${zhgYgYf)AhkmenLBY>D(t{3oIp^9Y1^_Hj0?Xv`vw9 z&2a4+gb3O}pItzh`&20}_r&+o<1u!GVdLVM6+X>UX zFX!2($Y#}{Nt6FT*QMLE61neXw zn2|(`*y|iLqd0=#JPJQ>^=A!lIfIK7MA@9ypTUTs7yA}znP0phfB1vnf`0P4EAKyk z_BDKLy2ROFXMjOjsA~u?I6teOwab@W8W5ONk%xCY&m3yj0^(I5e;Z`?{e;hH1l^e- zG*5@)ZG-y0+9h3r4F+@VSd^saoTE>|U=q*{SxGu5s;{Y#RoXlw3&!D55Em?XFOW3O z@R*|s%YqoS$b{uh!`xsVgZDEyB(I$Kpiw7RyL<_21BT7AeCnCAfjstQR>IezWj}cR z+3$Un=l%TnM=w8qQsm$J{{5U<_;YIEPed);?s#Vc;9|@P56u0*_yz`^2M_@ey+GLk z8Z(xfE@jYe>M9AWIL=ks$-(EIc`5(z(J(?Mrgu_a8+t`~mkjraL9> zNV>N?DY;n_vMO^Y?m^``O+dx)yWz> z#xcDM#009KW1dy>ls8le6w?r6LMwr@0(P>sGng#f>ZOp6_}ti>WHpRG`sO2qhzZ1% zG4mP>Qpz`_D2&ejqo%TFKT$o`nXTh^e?dURFEJwMwuM-X3HddjA+|6YM4lt+C?9b8 zRnv3&EONYJD;Jmw)f`KbY-D^R>lDqdeCr6HsAyGgzrK4R*7RV|cT|kYV zW2@>skla%DK{yt4=@7l|Q6=6kP za{|R-)l3;zfY53TRC<=@W;qKqQNsdE1^6XI@o-QkY+OT-pECm?-PHX{X3Y0cLG?F+ zPb9|ljb+69YOq$eJfja7x?uT%<`3n-o<-^dL#g87(b!>SVxEDlgwPdqa)aTAq7Y-o z5cr)7F3gL!(X{}Ise}&Txc6Xv(q6gq<$TL``rhO5__^w72Oz{zc2OxVV=z2TXT>QE z>$#OSA#JGlQ7+3je0Gc|^tpEPDP1MU%tEDX3dGHr0GD{~kz1J{d(G$|spP&+{V?!i zM!UZ8rM5SFEaJ+G*I`Q#{;KwHmla5ZgU5ZfK62ps2NJOF#e{Ii?H%utf^q`*#Jboo zGtUU`rH+;-JVTK&cpm4w2=fPR|pB-+>E8vJ0j@+D!2D^jLlH9KzEm z02~=Hz4h)QC*W0_gOAA!;D-f4Z*JpQ?ta<;$7qoC%GlFyk2?3hoM*q(-}v%N{ni&& ztwb+nIe;*zcm~3d9NA5_X^ymzHKzlNxwVj_HEGo92_<<7ggiWv>CW7j(axr$Y}Gm3 z%mSp7K&Hp&I0pbjfMbFi&~kEaCCEQVvj6`_vNLx~+-&YRVZ7mGfmbe<4{c_rot_;V z2<_E7AX@()dvDsS*>U9g0k&J+EvdT)7DqNbZwv!|S#-vd8Ib~J;7@V~kr|OxO_MB6 zRZ(rdo3Y3HzAy0Zna}2Z-#vzH{7)6xs^_`XprN8}N#@I2EU?Z!&w27>M*QRV8*+H_ zWdj6e7KS&+<@-+#9u zYvr`}S+KEFLtzJ1rVM<&X6}X&qmDt!0$gtTNo$%1`TW;=d6GY+xCh^%cp++_F zv-)yWCV`*DUd{|#UQqV*41CgZH_TOzLn#c739*SQhs8v;gjNSZ0F&gVVA`2qocFcd z6vIiu;C>(i4{XVhVoJ@9cM+h3pzrn-(ald6Kqb31ZUC6E%0N^w^zrKV8?)G54B)Bn z-LJDF+s^@!3Ss2l*4VXp=I-9i>@Xk(Emsa()7!;E8&j6|sTmkH-T;N2b0Czb1P7JR zoYFL9US@A3$G{Ap_+1-@$}qTv9TH=ce0yYg;>&sTG5NjM_1PDn#_PulIe;$qsdUB? z1cnEOGB~3TUTzZ;iW5Ye7BTB=u)1v{(@bGIRTW<~=&99;XoIEYcxUcFWn zYKPo8Xrq^B_?lf+3=o`v^hK2Za^YYGw0d$P-L63c)eRYkxYP&8cas`eY(~S^t&q6; z$gCr$qiJaiAMNs$vXI6)U96D(%B|ih_rXkP+6Whk?TA`!M&|-BZk;n%p8+Ro_=-KP z3yoYGo>N9ju!7b+k^!FVG1YILvH1O$^$n5kr@n=E?R5TFevwG@J8ype)!!6PJ&X46 zpMMCWPQR&BL67u-aRlPdMNP($*+i){&Dtm(b%G|~yX)%bhMO!{m0y^)maTo$({WjJ(ApnO+z{A-?wwYvDVA_+3l+K)Hm&JRqHoW-Tr|}bscc9xT@UX{vZa=irFk^ zJWx!uH3gGM(d&}gCKC1Yq^{k?NVGiAkBv`%E6PmlmNX`mMMEL z>L>M9y7kmH?c1us^H=qc-38K~`kp-^+-f(%tq<~98=yp#47a4vIE@c_7Z@*UWdfSJ zja+o$GSgVvRaoyXkgG=3nt)MvE}h-?LVp?Iqyb8<^XZLvAD%gxool4-1~OA;1!dy4 z+UT@8&OHk5(Q0c_ty7(7d)fgbx&hjSP1sprC@1{RHV$Da$)~Z1A7I(vOW?&NWqF*7acQy!m-KTWeYJK%8L=fi83*y{- zHrstpv&*eL8uUWcuL{mkAy@K;|KgIAwALo}3awxevrABLfbN{2`zBCf@JwMW5-Hb) zgv(i=|AN3y7s^lwZ;%EAVP&D$+q7vU@R7bU*HW{TKo*1g26X}|E#b6>|MF7k2-;Ez z5rCJT7-yoL;6KAsWvFzH?&$oW%Y+6`m%h(j$R<)EOHZpsB;lNCpksh~qdUB7ix_P& zw>sO*XfB2LAqGSyhIENP{8w*u1r2Dj=xU%x)4>_U5V|XAr;oN*c$qEn$lgT(qEpoH zcUx`4XSE`5we(=MLffITc=xBcyD0Xay;C7EhrXFIt9kc zLuX8=89_6lxuf+d?cu-q(NDhr-uHQkz8tm%sv!7S^I!~o;^k5BD@~ZtMqB3~8Ip14 zx?q<%=EeZ@~Y~cy}3|WD9Ig?cO$;NOf@F|_AHN`*? zIw!zUnpG#%8fJU=Z?6?GY-EqX>LKUi{#ykydeg;wFva9!0VMI34TsIr-cbH*YOxHe zECNd9V98>yh%vWJG(F)==m@3`ZPGE{M2BST7Smx)(QzLByK61VDF!r`#6(OXf+nWr zy=*H(oO($Rm*5PD_4`^0YNQE9oO~CUlQ^UBM5^0X2K08Bn2)2jqXxvsD!vQ5P%`KY zx=fSR#$AWti7)3~5c{lNzI^fWvHIXOkJ_U#!zF+>q)wdM0MZ@AQ)oqPc5H>^^!N zPHQdnEy`mKbSS_i*n%)8FvGG~R8YER7mTm2K>uv5)y|rP7CY!`bCKT1Y~LoRMfWai zs7D53XyyoN+d(a2CSIW6r)D3@B9~TcUuI6Q_T0AQ7}Y~TvRjTJ4&t?}R5t@)32^Y# zwk5!0lL7r_E~F1N*oQs*_m@kto1sIqE-EP^d}`X0asW)aP}j+9hjr>4vv2H|ptM4t ze&lL+?ab+gkPoYhx^w}GH3pE$ZWpW>5ZiI-Y7nymU z(FcvLge^{E{HkWN=Sb){@np274MQgIT>AFghl}3MT}0Saa-$j$_icChUKUhJmu(?v zn<)Y|N(fHO;f-UDhT#aIZP-NTa0e~`-ifod6DkKN8Z5OqRu0FZ!2F!R3W9uyDiq?` z5C6mUaGj%IaF}VXz_jGtpqT4on*?49QV0;3&4p;#utm6i;)898^^wPS zMstgg1>u#Pp@R=5D4oX<25+{wLnmm*9{$H`1>YSS*)^6!AsEoCh9{~X1QpvP)ccXB zZ)39PD2X|I%fv7`go&2{uIZU-W*s#)vl;UY6MVY8H@6-Nh1G^)WyBlT9fVqu5C7A5 z%+%n>j%WzwW1`dvl zvl|Z65rdA+S!3lS_thX!%ykOoo~C^|gmGG;I_Cl7X9+}LzDDij7&d8)Y04P56o?lE zQJ35L>r*r1Z_5<*>h;UOKKHIJ_S84-kurtc)L`Gkru_Za#j+>`sPl0E-da2qNZw{} z$Z2iLgL!)_=|=$W1^E(;WV|GD4Gd#oA2)qP;RS%k43O^A(przUc=p1ZDKG&mrpnwg zSh8U{y{*9>Sujo@l69sg%nI4Nw|(g^yU~WK*4uE6K2ZS}*ozzo0PLC(HE%_03c+&O zvNUHvzmyYI_yHKFYvSEGU>QFHozDT?s4czSe*E~$FEU<#jZ%8`>GM~wpXIu1Yd-N! zeB?yPAIm!@Lj3$5ri1~{VghIz_PxXaDh5$U%PoddmiLyNXkRfUUPV)?s-f|@X9Mm7 zyS$M$8wRF_R5=`y-8(`Z6WO0Jr-s%w{k?R8Oo8Uv;C%RBuCtgs2)_$`Qf&u8Xl-qQ z)_Ybr=nVn$7r=WI0%+cCG)VXMiK)$xmLUrdwdvxKoaEBRTHx^|SQubhGh86cFX&45 zE-~O9?RndXf9lJ*o4a|wU+fp3K7JVU9=Z4!9y6Knl~TY0#%a?Vyj~+aVTT7U@$geC z5i--I$aiDHWDjzYvlFK!mX6;M&2ELp5q5&T@D3o3Y#jKNx3m$_&i1lF|iu- zfhvO7?f?!kcRVp_5V9ZMs_N9zF}|&^72tRR+3?yJgJDPAGs`jcjVQtDfan5!6pFBY zG$|u6?FQC#6e!n0a;SwdCe3aarzgIgMN{Kd8DvD9~O;yQQILCtqjZx~HxTxAU* zNo;NKE^iW&%S_0}(zb%TW4y$LMr~BFdJ6alQ+IEzmr#u{wx3g0puP-2?Lqq+h7r_; zyWhIuPW49UY@)7gV=%#7++jXqDjpnyCRqnth|*RCtIxJtC|Av97S2EmDsV0sIqneN zO}zhYEkwnjM#9-(%8qgNG}QF*JJ?-_=BY2|7C85J_%Q8q1sb0Nsiy)HC8$&E0TjN2 zYkgIJ_P%_(of%Ls&7GQ-M+n`(jy>GO0l(nlgzL0T!|YX<^r6;zVsIJWX`JUhtiefm zWPkNx{{CP3i~pd0%yfl=|7?8eAH5Cb{^D=?IA!`9-@e}i!|-dw3En~|wp(i!-EypX z@F)`{&4!}lm~1`5Fr|d(e!;UPjjI-woGUN@%Q8H`XkTHvXt#cnwMoscK+7|XSDn{p zK#LaUdYF~>?a0p<9c`E1=P}GfA5to07LjjV%PR$4rhNwVwLQBNEYb~HdtfZVoOei0_72~!L1=!^`>G-903|19#V*;%f|kr{aIL{~G*jqc8V!|p z228dW2w*LZ9m64~ef_850zyiYcya?(!=&jDB8rj?S(GzQxT)r3t5XY2u z^#p2S7b56c9tl3yqOl9j;_NQd*E$`n94{#F&cqa%-wjhGR9747aJa#b!Wp>}%fi+* zw>1S2z>qy9UnO%-{680>%KMVZ8`qe6@m??=ZV7E^%mhAar3@uLXttHl6a(Xzbnel* z*Y;of4F1l`dj0a}w@=0|*vor6BePA+y3B(ab{vH`D3^N{4uEpGP#ub5q5*(vx9N-b z?UNUU%nM`IWjCgx0qrKNaBF7R(d-q|U=t%?0~!w>3@gr{kkcofEm%BH(9U6PffUkc zT@{F&+pMUMh9z}@MmAc;;H%Wi?Y1%Ym8bP*&tE-%{o>`bKdztO4bVLG9egxCNH_7p z4{*&xGjU;PxKlNX4cMtPED;Vy#Yi7Uy_*g1607&yD*f+d@ccM&xV;7)V`79VW2Hmr7`FR z&fp6-NTK?{04d<*_=k}Qn84KQg2!2xC$@-!VJVo$=RP>N8)ieSM|F(H-)g3Rw_bhu z`uV4KPuo-9wMQcO?VWY*&Ceg)(`FOz1Gu<(6u{gVkwPp*`xPF}16tK+BNi2)rPriFe;<`wB9*dngkoKzRpF1J)hQ zwLl)Qn|6j+$b5;S|J531F36Fp?-+Z<9{r%q-7g*P^e$d5Ex=EKUC}feglFdHCW5x+ za}R99e3l>7A$U&Ceg)Qzr@qa5OUU zDF^;Lwd^*5tmVcW^H^1cyK`(eEcz?X^vS5a!I_1cA#ZBOoLvIEyv&Bt?r9ES8-@`a zsfyHXG^jy;h6ilj@hpZ;*#OIkR=-WeO;wjCnw+(H2R&qmzzo z2-~*;3j)ziWFAo@70VNIofFj1q|xA`a@iFxP08XEku%W$=m#v<&^0>9zXm#k=@nco zL>GblH3;JeB6WV|HvAfMj+-a$AO0(^UVQ%S)$3TF*0Wbgqki)I{QTLUJb(Su7hk@9 zhX4Bf+#O_}`kwx#mQXM{(-*poD4z*T-gH(Q7Hy)KMAdWC@&M=;7w8nd@XPpn@=+-FrhFl*n-O)LxTN)YUE&+HVzVM+L(-NHfjBVm{lfL04A= zAQQZE=9pM#+Hp_ux@HZyp!?`#x^1^z3G3BLS_jZh5gOjIs;v%ur6Ux-K*%4e8cKa@ z6WVm!3IC(d<5Sd=zli&H?o;2rN1i&p2}SFNn7lO;yL4$*xp?496ccYe}(ZwqjDfI^H4LA$kOlO|Ms3C+P!dM1ZbiWoC3<&v22o(-7 zlC~i+=Q=(Z(!6793BwtIq@&4|k>9sL{J;Bk+?9x*`i?!q8|fd@c!xJ~{lTvux7e6Z zIQtwTpx4&A(h(c&+B%M5er$@Ogt(ZoZ}!=v6d)KF1wq%0f(-m*?^zttVmW}R#Q;4; z)$}oG!3R1?cap6z8yca*9{$&B7zlxS)H5;ig)p~ZRGE?n=`k@NigdwAWk5TQ87k>m zb9l^Ie6%h0+*ul^Xt-8+Abv>2qzzwrwz8?=A|3gpU$3I zBhQ|CQTG%L1=6v`!~c$}sL|)5Aswck@IA-CYCIGpY$qo+edN`8?QrT#-Ig4^pi*ez z(cb8w!AE>B9W`YmP}dW)2~9^!_uyKKh9OPYDOT_@YJA2X{P2JL=-O_Ur$JfP=3vx> zrs5HZgG=t=3m@e%o~Uld#zgvF$W-pa;%*zdVxg=xcbcKYn0ZhPf-V_ZTu=)a4PA|= z;VuFh;=R}4Y!CnEw=j}~vR6BE4n9%XKZ9+eAYab56~$HrO7oP>nkdOipX5unuGo2z z16L2v@{14Q?PwI@HRGJc^JqJK2D`gVLPD%~53fVJKwZ2o=PeXb#x-z;5ZSPUfU6`A zD$L;^!)mkq(icH^S(|qE6R{Q!l?(a@1J>Moqj8Fb10aVf2+fY2X9s53nj&zZeOIdy z(BkmYwI5}$d>?&`XXoX09(i|JeCpfxYs4^dEyh?XRu}Pk4sdSRo{v7xShEBM4cD=- z@U*jyQ*&clzDJHd6x_oxR2JA%;0A4;)6pyKa~)+;Sh}sLnXE+)*`)Q3ioxJJebN(O z&ZAGtUwA|7diJyU^m*bjd3Ig$^Ygr3K8Dx^yC*{g?9S?SsxhKq6CfsmaWN5ZYk}2~ z+CB*Lx3Q~^dy5Mz3-5w0Wm+-9FgpO+GSq{Rv-@0%aa7hp=%ukx2Xd->h(6}8ctd8g z4a8yVJr9>FOd5u?CvB`sO+{mBUpDX#LrQ)jfVg*cL$jKB3g(|yU#CXjDh)Y@u?_j~ zO+EN#1YOyC9BQjwU7a!k9mhyUxl#Nlsa;_!R#9cIxAW4*cZ8ofvzqXfvkxpHmO zHtbABXU_W=ehGD{r!U9U6qvvp>#f8E%i0)b<<@w?l_t7WXhyeXllM7rPt4O!?*ml) z>~a@u%e4;dkIen#7!%{?82JXTl`t;|re_TEp8I%D^qfHJ51E8iG1vljRVM^9n;Z57 z8tuT{k|3)&Oe_N9d>g&(w5ZDkj18p5ql?nt|8`M&8v=R#GCqHGUcCJ5u1WROH}lu{ zGBch9BHm`H-j^BK6vAi>CTfv&Nov^83Q*cwv-PehOgZ)A7+w}Rt#Q`qG12hZENf28 z9Wz$tM2@-=qsh4@A-)Z+l=GG>zI|?<`f?t9ZvOnc&&`|g(4(WKgvqaB6z02c9<`d8 zT#OY))^?I1de#~;_>%A&(3~o+-C{1pj~p6t94i{_n3pScd+P^&n*s6R2A0{^SPQ<* zcDQnZb1>F7py)n;J;HZemS5kNWrIXzA#QW;W9LKl6-pC6=PxGx!%A! zQ!mRYG_Bkx&7G~l0>A>59D5E7)qB&GoNy*J1(bcjcVgQikY+o#S*)kNoNu6nel^GS z2y1OJLFK*GF&Gwkgwc%VGU4W8jPREN&f<7Bp%C=l0XimcI8+x}-{>^}_ZxVUkL?&x9f6IoS-`YwDN|e~^JqiYfh=4LD&8bwvv=6?Ek( z3q0!Dg(%9|5UQhQ9GCxKu(J=|G??I{v~bMJYl!bpM^65X z(+Pj?SJMf9`U^fjoba{2exc?(w_*IxF1gJJu^DH|l2L?lR4S+gAbBJ|rvdzf@n&s# zAuqw3QXaD!TpN;CLAM>!)E#S_qo5gMuGwuO{MTHh56(N^$Ole@z7y9!?ali&?((0y zn)sVm+ZVjX2i7x!qiimXTU0i$fEX` z(=j1#s|FI;d**<*a`WjEXW2!tsV&?f5N|T$o458)Y)}79lDR+ju5f6Qt1&u)n>+Wj zJdVwNu^Y7O!bFru_}H_A&x#WG2uF)i(s~UA3^PO&vQEN6Hr6hm9fA&7j#3_@sTl|J zNDzNSo>qtJJ0$%7kC5>1z34X?vmp5Q0pRI9`|&^mVoG2@n5IVd^{}I3mv`56l8Lex=KdV+_&F-{Lg`shWcD(Lw~bk zf;=g#m-#1<1nHm+Q0!>lGp^G?$rj*lQ?RttX-t4{=-@p~$I3=>5I|Q_93P=tQ0NtW zpN%dO+}F2Encw^3+4aJ|4~snUZTs~Ald;1I3_dajh=KcbcAn4%!%Dl_*|E`wr!l}a zRMmDe(%Kq1IH%2RGrP8Vba*IOnE`OBH%Y)#i_Vx9EQTt^4BIWX$dqZzlVm;o?H~Q* z?|Sc*?zNS*V|;Tp(V}9*fD}N;xc=cPHj7q)`~~t4!w0uonvDUPXi;f1fx$@E*nKU9 zc#DG4_eK^{PWL&F!mM^0%*)kOsP(w3Sd#4lQ+O+E|NF+#CKTnpCKHH_)_OZceH=R5 zpbkjrsKKpWozq6k85S4Vum!v%0AsnbENp#_HIPeL9sV=RL$gCe*iR+$S>H^R|G~?8 z_2Sc?)w3^OKEJDQKk-d`G!V}>f%p$Fqb!LLzup%VXNEbJQ9vn+P%s8Pv9iE>D}g$8 z)2^d!pBHF*OH&gW(It-_>?{yyg5Yq?Hc=eT-d3z>CZiH%V3mW>g1#q9r`x>L2VPve zoAG|yoA=#;>$?NjuYTZy;=?k~qm~hSjpP6(Z;!EXyfL491FVPMKg433+Q{R~$%2{P z21mo$1gCU%<5nVv9QDwip=})mySTVj_*9d|q=nC|`)Rkt%%{GbM?c!%|D-;zm-y;G zR$zzD`v^gVI1+@;(h1ehak{n<4T$Ycjbh{*_=E=F^KG?F8N^iW0Ad4_L{GoU6q>#0kCRwgi#msJ+m_Y*Z%~p+AIXRd;^)zkl=roS?ru z(0@Az`tRg@-^u&FtJM5PRBEv7anII~5a~1(&o|r&g#pyi@~*JzWY{=^ds}`w)3l@3 zCPcRgwyQB@+^X0J4LdD+KbjjaCCOBUtKsm<1AvVsBIgMJ$e~ydf8)nL`NMAkmH{*K zOsG&vkb`j#LvjW`Kz_bP2}bZ?l!Z{Yq_;VwFCOL+#`hSHvI6^m-A?|{CjU6 z;>Y&k7TK%qBQ>P2JqZHwImD2Jm6Nr(+W%)b6OU%O{G&MQ_0Nsc0iQ}9$?$=aFVd$k*1~Pe43Rt0=G(2x}t=(@&(VqBn zZdn80_%Zg@*49h7g;Y!+Sgvb&uZF#Al%}Ju2lU!3r?tIzEvp_TC6tE zLK~v_-i2rQ5L{_B0vhqX$OnWl%qZ99SbjS=i-L!vSwL9$74t$#rBb^RAR9^IPNXz7_Mc}Ik z=FQ{thx^6n=lLhkzCoh?)c5cafWUaCBl70wU;Sk!%`#V1)1mjh6moor%>|vg_qZE9NQoQ#D(={f{-Z|lwv(snN z>5#XS_CbNeg9R|SjiJ&bL2@%>g9FHfLxyDQvyD-n6BPgSe$uULmYP=UK7?QtR>gz_ zH}0TvNKYQOC-o2c8M$q&KJlG<6hu!qAo};QCqBexyI_*UM8e#QNu+m-t{kk2a5SuK zP_fOmTnw_0vvs8?cd;y-K^Jg&iR5b^DSYrmG|4BVxy* z0gYqrLE5xeo4P_H)xDuW*Coex!wA{PX&A5HjOsw1%A?g3PNrlKAQ}ow_dvV9`eogN zJD>WlJ@U-k4SB-e%d7LLWh@VW?W1oaOwcBbT`mVL#yWz&LV^i*{8DEFKR;HjYOQBm zSWZy})6rXNnRZa|aR#Vs$qR-U!~WNtl&*`0L-o!_Rva-eiJ-q>k567VJbGRDAJ5Cv}4rwWqYB<=W`;sG+UzUkok}~{)-`Bvj9A)2K@^7}lK zbt)eQ?G-2j6BPw6BS6WzLb52j7l;?u0(d>H>Ajyaiej;rqk;@EtbT%A$2j1V@SJpJ zuY*c0Ofsj9B{vWM4?g+y#d-$V(C2qn>ZiVQch5bJ-oF^1dGqtH{@h33tyddCTpQ8{ z&kk-KCiTFkMuRhL8NixzbMt;=Qk!XdYFG^e9mL7{rr4JqT;-aE8Dqc=zDcPuD@JZ< zE=fzkti!E90zlG<1FSmtSyHd*87ZEu};Fi*g1XZk&{pK`!aT60%c8x3djZL{#Xu()85#_;#c7{M9o&`ga?h zC%$Ws6ujRh_v-r~_g>708jFi!dv9yEl~Y%PF+(g4kYBJ)dW`JbXG6RdUt`)X?TDC; z8G~9!TeP%=qa0qTJS`U@r>Eyep>z|NcxRroYG(F1`|!0N{)unlnaAY;rNa!lB_Iee zZ4@0==ybq#B*KVe8=f1F93c)n*T$&*^1Tdj%S3_N;XWKZ51Orqcq_s++aPez4WIEU z>u1l=08Mj9BJVc$twZq&SK_DyXDYg2Q{KrDyja7voC(%P7i6b@Fo9p_C+=kI z&cG9A)Hw{c@GzdTsdlNOtc6O|SyEsemKTauRTp=z`Px;&E7PjAHhiGB9(0vML8=O4 z*LC1><~yV1kQB<^Hm|GbW$@?V;U5JuacJyL%vV?wc5DdVQQpOndm@Jiko%YhEsuLw zMK@D3eUNN8{Q!8!=ZBN1&RJjtw{COU8SQqD^Sf^&!gtNhC%$XH_|*U4Z6Sw0reE0M z{O(tO@*bZ1@7(IYZEkgDNTD0rqnLQ`epV#$Zj+~<4ky4GeV#T2^TzN`AL(Z`N8AGe zejVvX7Y}H9A?|@h&0uS-akI|O14ZdV7EEOB>V)?Z*WRNZ{>hIpe!&2TKzP5MDAjZn zjv#=>kH~080K)?Y5HU4qt;nREE^7qPhR3^6O9uRcszkFhqPS<{wd zM0(cP*?k*_gd&Si`{AF$RW#m^Wzle)Li3cM(PTjJ5XoRPW&7!5gpM8~&$CuvK}9S2INyy?FSpNvjpD@aaBP<5%4A_w?I*`r^YP7Ax?`0 zy6Ggw!NM$Wi=2LNa0=({S+(lKmI z*g?cOj^{0z7`TC8C>(VSOiOL{6qdaYzFD)w+yna9g&`oA7)DPu>Ih_>K^%SG9cX_q zUu;mE?^gS#zHN^tMv-mX-Dufw$|32g@7tr(Wc_BE?6=~G^v`??MV=#wt_ANvOP|$Q90pE=+h8ZVF`t+!!ZB{v-!R)1Me5FK70NqK6Crr zKlPovd+zP##cA*9#aa6--z+?_Rkf>-HFcT8d)OgX${IGjA+(XGdT^Z1@YVFnb28s# zST88jl-gLh`rH`dDsxbSXM>uU^D;2*-BPSDn5JtkfB0vylf?`M_-*K#E0}NB+rwP0 z&5wZO$6Gjx(ZJo_p}EkdA#DK&-e@E79zNs3O6}T%G5&y^H_sJ10pjCsXL$=4Xjf!A z&}0wt^YG8%Dh4dnr+X~ukdur1Jcw0pwM*26!4?dp3&s)EMR1~e1wj_f+4Mz&e2 zQd7~b>K$|V8|ZWI-Us^Al;9z%MvQ$`gJ<_CN2t65sGms?v>Vm^y znBZNu2JEoCAJ9s1sJ>PjGQ+6%o@2M8ZT61A=@w(C4~s6FVjX;CSh8inO#zrLREvIx z;Nm_}D*{kq1!7bvvFDga`_;cH*_%c~qpNq~u?5(x6i1DwTR%chI*2do8n%s_`RFw3 zm(=4hQJeb;Sqz!dXyFvT62p|;_3`}A_rLh`%TJzv{_KyR-#5pe`2IZ-CbV~&V{d-` zE=>4cnD91Ch?fl92dHOULS~GZE`-`NsU3+0`(O`5U7X@r|h-G>;V|b{uTi==r zTq}odMYs> zwlD?B4n`C0Yz9Sqi?Y2sFFu+KICY`p0sJ|`=beV8(b#Qwq1|UYuLws%@ z%g4mm2OKa=u^d2=t=rlgiIdID+1iffS9p89gW`2+rg*Dqt&FZqb^?NucGS{|$~ z5Rb$b9la-Z2yqIGUu2D<(pM-Coxq~GD70&*VZe6`Yp6P8TkQmm9VVN33>U|PXxCtP zHijM*&qlC0?Uwf+G5gz%wAvSYwF@dajRT+0s}bCcx`3-QF4b5nf#oxk#`UhT(D z5Bsd56ucSuRCkMBXPL1lV}jTNOz|45Ge|F8*H+;UC9J22QoCg$g zNT}?~hkU%x9#oiiIcLMl62`~1OLi4$IfgGqf!vCh(Z^u7HLy!AG~4Ep@jz|QvB>v;J|y}lcBeCpfzYuw0FSnz=t zla5M*?mT)L#ezq1=eFWlHEh$g)debGciHA=AnmrXg(A__*BkvXEa=U(CQewne5Jsd z=~b9|QJ#aY0;j@l()8h9{^S&B7E}f+^>ROE4=IXsj^-C51@G>8 z#%ZKhwaZVrAsag@a++eRfY(2VD4|<3ky8p$U7cJYP9J>vb?1qZi;eaKByf9EpC)p% z{nd|I--dij)qo4}ep-$N9|4{NTdQxu&T+$QX&p}OqLEm0qTy84Pho;A?9dRvL&~F1 z4@|f_M40uH3wCR8 z)?k7QCv@e)hOON7mt*ORCLkK5blmF}#dPJ5F*Tf$54GIZn0H%O*eyZKF_xMjr5% zy$$1b9TLS@(R~hIC~BKw!m>dv9waAV5duk24DWV&_YFR<>Hap};BwqfKRN4qx6o;0 zq)HgCU3LloPKmFaBLgTL#uoU}x}QC#?B3CF4ydwY?j-eUV*xRI;21s~!Qq1l22W4` zu+>IMoN^#XcfY?wv~UivEEwG?&@G0}tq^A$VhQ3jD&Xvt!;MO-ncwkX#7IuQ#`)Mo~Ur+DY&d@pS;IkjV7#l(>?9E44 z8vBehd5o!cIv~fOKtV2MWIhXrz7ubB)#xbq)fkrATTV!XBmEHwQiV(_HEwK~*fMVv zfJ2KZHk$tpqvaSC5eKSwTP)sdV)rz?NDmNHZStX^;aV}5ck~7OWXlmOh-@`ISqa19 z_=axH58rY^;^oV@8+Cr_J9xK!ZXdI}GYj$d58lHJkP@=#Oggk%fk@S7I#}w&lW-8s z1tW1m>{VDeV)s7P1>Todvz^6z0(Kmj-Zn;k1JQoShGdP#LkQE05cy%agb2GnVB#v~ z!@u#-hXA4bn?L>lVraiHskle>&dnMbPEb7O$k`66!e?bWir#Ditb>^KU`&Gw%Ah$# zMfW6!NDB?a9e{7il_vrMH%jFgqA!8jXym#FuyYQbRae9D0ULd8@9v$iNg@3rJy0oB6x9xdBpsBs)dIG>cJm zZ+L1@<2|jB%z0uuURuL-Hed^|%ji9@JHns?HbQbnA)f$_$KbCk(ZBoCFF%XV&sQk6 zHw)2icJhgD-6M-CjgS4EMfLiFUwu&>v0w)%b30o%SM9JCG3uZzi%L5CVcxZHEISQ? zz7D_p>A_yY#wlfuy|q0!dImnLNnKCm7>f=pZ^aGkEiz7nVzIiNSbabIo7aJjxn}Nl zWTN5H&p4QyB7majb?9)2xPk2$rrUO-JYbO=SZ0$oQH#d3He`Scn$kV6(G`|e*c|On zv61X|-gqGiI*jxl&-M#5>f>X9BRZnRIR-_-p&azx~nsUj}&S$~<^& zk}_;~5*!KW9C1l7Diuq|q0Hu@vsK3j6=J7R!!F)w4qv@{kEXRzl#12!_>$@~;a4xh zoJ|Pk2e7P)nRv>e+azi82zEqWI{C(J)!C&Xkl1&fG%y($E`wEy!T_m=s8fbC=Gc92 z&LZoL4S^aF>BuBt{y7O!YeL7_$l1vQTkEbHB}+!y=`Kn7^2MuH&t82IfAaa=*6NAx z+#^ZS_VIWpNs6D}14ttPi5xw!EjkKEZ*)yUz^J7Iv;KH;f@L(s8kt0wV?5Eg$}!t1c;wZZYBKqxOedZvxvA1N;6s;XX=b$0Fr*bwqx#CD?fQL4AJzcdT z!#5!?C?*Oh{h}^wXuNpW|#^ z6TS&R{%I`sJus^}`%d;)=#}lL4PJ)s0A#i!8??X>N1?O3YqQbd zv1>0VOOJ%?)3q(H!l4*1kv4}jod~Ql_ZZJFUe?_v;Hhug{ggQZaqSnU%-{UMuf70W z08}GhaI4A~*A_VpW~}O+`b3M7H>S#_pR;tH-Z$ECYt-Tf9ayamj{@q$y{@e>iV7_a zBhrh(prV)y6Q8Rm=fO^cS;ndH@V9<^rTkW%9S8?;fQ8Y*9o@r@Kk28I_+dx(_CQK5 zAp1Bza1O5`$eK-aMRr(nk_a(Gj>;1dq6J?r!%H#5jkx6!w8 z#Ofkb17nzxt79ga8@?%QVZ=eFmB}2jZR94^V|_$J<3UvR4`;X@%i;0(nUFTDMF z;z*5d?C2YtaTRPaV~9{c0rgjxTg>f3d(QHp$qq^PI&7Hi2lT zsQyG%5B0@_aC)4Xa`4_i0HUC-Aq_iyGxd@+1#i4&V@}?4;7xz_TGei+bbhy9tuLQ{ znsI;TOl$#>f=wbeRRf*pfG5sA&fWo4c^fc!Sevq# zaCqzs)h(LNOL%N2nq=Co0Z+n{D5JC;bdQW@DXpalxLJsaj;0U)!BsjYNYDH7eGLIn zO_00rTJ>z?V@nB*GqGo8IG1eA!*orgR$rn$OCmAh+9%!tWg8U~UkeAs<5Q+Am>KuP zW^r8IiKtOr%4}YZ#!m1|0kLUTD-%k^!GOE4@(?UVETw zByu~fOl#P~e~ha*bEu%KH>$NUA$nPbv!crYEU@d_0|W$ph}&bjLRwoGiYgt$O*bR? zK9e*~I@C(Ehjk)B%<{rA-v=n5zF^f>gwphcM z-`*3C))|RZ7QR57tFM7Mkg>dheE_&YLxaKF1(u(T21cLzYD~{!%Y_pd#=ANKK)Sb` zy*a3jhyV1t3YWIukg}z~)4=i`2C#`aQrws^7}t2I9x|D@JOl_D9frt}C{gB6(48WBSecbsRSDhjN9cN=NK=JrvZs5Zy9Wfs z^LymI_uhN2koVq8e?alB9t<$w-jK%ha5orp1@xZyzP)y>TD7V&-}iZacJ0`~JGhIj zH=hj#`I>|*DgBB`MV^0v%=qYJ$K~z1{r{xQfJ@vkad4@0GLY%=fM&*>h^@Nu>=u$;@s8* zoy9kf7y}^JIqv?(%UKwQv(Mhu`sA4)aqNJgP6k0ienwja^ME))<#kUjohU0Wf`iW( z4nJw02D3yIckc!$n^GL$SF5RHUZz8MS8Hu+Wy5JbguHUI$@21axR~boQ~= z<>kFuEpa@$<(FxMJ~61ow=s?4He=A}vO z>-avVU!|)uv`#auTMfH;?16!gzzbdO)k>U282gPE}0NI&ZfwV@Hx=h_Xf^SFpAwuICQ(1gGmzD)TIwz zJl7#FTGjgUOAU+c))sev*Hue9<`YXv>j0DBC4U)UMC7soK=>tahZo6gSllHI*&^ua z+T3RozH}l2IVf;6m{^mVqwWrI*62;${J_5fF8bM1T1E)qBIoY!zOKSTs3IKZ{?x|U z(J#);Sz_RNr)Z;vf|_*IiB@ha!V*M)By(i5&J1k(RGjMr4LGe{p?%|n5+Z!q9QREDap`tG(x$dbwt!nSxKnMf{Kx>u!Nrj!q4hnqmPah zsb;(ttC~(NvrY_DGPkC9g4UiBQG3|FNUTIYPXjXG?(e;JIYM^ax410R34j2Q8Pb|G zn4@Yy)C{9yrNMjzn=V)bVDc-tyA%Lg$p)Ak@#TeT*Emqlm@j!_J&y+Q7wVZO&pfNI z2{>F^cYoit%R!<{UnSBRdA}3b>ZpoBM!YA?nP)8s_^XU(te)MX{e)c8*<}dO@++O(0r?2t{U*aCW`Sh!9?T26T9)FqV z;rV|3MW^L&-hTMYJP$8E+RwlI^YG(OfBxV6+n@RD2mbQI7teq6g?{@_M*G#r&tJUy z0>Aqw*Zqf2pLhO}gZ<{SU*L)Qjhl~t?hF2&{QtrcKP`g-j`+zxK7k|J0QVA_5MQWj zkjYk^kWnMquU3q`N3X*ja7k!4VUO7<77!~qHQ!;$<-p?5>E;1v)$+b3SmJE}C_->p z*O~!M?TWSonz?-&?{eJsl7cV6f>z3fMi_hSt_ww>(_yGx2t$~op!3K}j6By#1diaq zi}TA`p?gCeYgSOAYg^W4s@ViWsG$djm^+=))*jMn3Eeu)z7sEAJPUtyKhx-uhwYC? zdW`MJTZZgkSp^;Z0`yB2d8atFLy#l|@lJEI4f^payD;@DyA-Un+}98psKg-&0|IsJ zqZ5euP4wunwkR!*F$x;%9EY4Iw+%U6iS!n-zglYsT5iM5@_Eq}kHi@UH)oahOK;m! zQxqpPLf;1kVMJ2U1?lXBoW2IQ=B|yxRg)%Oy)RkV+J?+o9W8w$O`uFF6XfPw*5Y^a z)vG6e_`!Xp`(qE=1IZG6lPtks9iH>{r&|Zff#p!12~EdYsvYIHZQdJ>t2(U`?(M!4 zq#%ZBqJb%OkulqG)njl=1)2?HFu!f6yG+nuKZf%fB!QA$nsUl0FuGUMcI%^E2sl)C z6dF5@`^)C`!2>dRU;xRD4>A{XWKWa=L$o1xy$R5WJcp5Iw*!_cukAi8yXCl;0>B?q zAJV!4eL;u%$mX_&?@JGa(3I> zpLlhaodXgy5faF3Ajc-5y_8VrcAfjh@4xuy zUQ_n5hwQ6!2>O&={KyqW6Bm`KyZnwXrj07=-cwo3#I@kE6m7@&tU!TwH?cBD!n8CAcbLlN z1xjt)`DUv9`iK7dgC|d)!%_C?Y2Gt`KlbQ7Fze`M*1ZK-=i8rkWTCA})~OD3XN*Go zqV}eKqK}0zKn3QUJE>#SEkt{|wZgEOWn|b?47{}2nqcsGwseB3wyj!xboPeeMIb?2 zwK!XSBed&Q+s}r`1LS3Z=TYdvYcoiRvQKR9m$u?^&jNkIV1h<@92}ao7H|=Uo>Ab6 z@j`uYFQnw@(rHw7F&uWijhvnWQM&ZXdgMIOr_;^FRybZa79qkJekPh)f(PhEFsDGmQqTd?Fqd9{ z%@PlTy;P9mP+6$PBj*#8R1<>KjL#t)cDKpg6M1m7W}n$FxrVR~y*;LWJ3n~whtKa3 z>K=R09++(HX0pALht!zeY2YX|$DFN=6i+A;!bWE;&@REDHJ>J$1(V$l(;8z14rDq3 zs)zU3X5WL9H<+rzAR-%hnb1YbrQt>>AYK)C%Z#1sbc=eej_wjC_VqL^5dVmdpMtRi zp9(fXEkVH(8r}`IkG3+(9B%&6tlLiDCXp@@3ktn981~(@1%R8X#j9kGI%zWO3|M^w zywA9`wtWZIwvYVP{kZr?9<~R$*Zqcj{gtEO-u`r3vvVP}B}YP)CKG6|Zhb1Cfk0t% z=_zOn7YY&cgxR>0P z;0B_LCx=@zPLg(GN>Nw;d z1CW-Uhpd8zAlGkVq5>VA|$hI;5fuP8lTZX?mCFihI+pBFp-*0 z=TOTvlx@s~UOR*%5x27qvPZ(ZP1a^c3}md?=AasL2PIF1gt2RklilFngh-JU)b!R+ z!rD2<%2+*)nPp=fJTGHB!!%0KjI6n$%drk5PQil+!>Oj%Jf~x`3}`$8 zjWFs9VTC>dq+1zNymgO;I2SE~JI->fa}hc_Dpa-Z{=rMN0V4`T*HXK(Ig}`yRi!tb zbr#^b-Q*-|KSvRpBsm?T0TzM`Q4O(*ikuC)z>%n~O&LCnvq662If83x;w5vTYrvSq zJ8IV5KXfS-oJY+@uqCVt9_S<-*UZ%b)leu5ebQOsQ2oa8fILg=fMvCT^2eTy!y(;* zH=EGhNMhixF73r01YTA|sb9E_Y#`P7=5_A=;Y;O(&7U{#R3n?T267sbFmg}8l^}9} z*Nuy`u3Y3g0HZ~)CUww?G!Uc$QE84|DE27BFx$kajo* zsWY$Tod7#&9v#_0#9@V9@ZCRlN%|ylrd$kDO~T%fkhRzuP@qkysgMv2#@jrQxlKX& z&4yl^IZZ1hJW9edS z0$NALb|%6r3HIdcc|ubV0XIz%6X4G6SbWw8CZA?eo~6`w$Yg|@?Ji>;crd{Kw<{op z+B)zoju^^K1I-qLAibqV6M=9$X_w%!ZoMUmJNZGPw$gE#UGRK+>)CavHG^f%qhy}j zs_kQ6&dn|TmHq1VOUIh>&^<+nw##5fmIL5MvpNKmK=UM_t_Dh#W2ZNqH%J|Lu7LEI z?Odr_$ftGd4!JraypaZ#?aIm{z68Os$3i$KOfTRzAl-6LK&$K4+sC-4Z~rYB^OAfn zys%YA=OHy2-Vr5-LbmG$AQxGvA&}y);?=RX?R|XGs<9W41-wS1D>K#|J(KC9TO-0k zv~)Q*CJ@J$Zg4!c5Rq`(E2oY3#p+=CISoQ4!%1KX2vnNsHFT8iguml#UkyoB6YWCn zava95Er@IDB?lubVZLcaKhQ%oN}T}?kqiW85GIY}s_cb8k=vTr%NNg{ef-h=BE;hk z+P%%XygxqED*yH;KX@D9lmyyo3yveF3)rsdq+9|uZIY8%TwH?1#m(9ndCXhxLO(eU zh*jM{tEd3Gz)%w03rt%A4Hq4Zz=m?7wbpvu=fH#p1nxX{|M(@PJ#0R7A zMWDpZ-fN7#5KZRp$YTgW+@l)9J93N_+yZs%lgE(Rc}6?PAu2(*H4h-SVda@9otDxO zUcyMWY7ha{-9K@Oo6iJWr8U4|wVjwkqiVABN$}i*()7k6VkejpvIoSNAg((51lfD< zxJ+ei1i1!iKXy{#SjHR#Gw;BRb<%@3diJ2G!1Seh_fNhFzS;`k)9wJCF@7&vL1Zwj zr_6~UR}8p!-xyN$k>7;ChIj)+>i1J4OC zaARbnyMO9BxU>b^MXdvjSU0|SV&i0khwNGwHyWUJv2G?v-lq)$tj~RbhaR=DUh0~Y zAQ&-59CsG6f{8`Bdvj~lldSR_D5H@*6^L~`cmMQd)md4v!~4qFvLUj72X@AE5Ny9o z&G8~J(xF2q>UqK^;4x_3H>C0?)@+%k@Q;DwSrvp`+XCKmPgs-?C}x0i2RC!ZajLP% zzWZmc*-0`Ir0)g3I8KR6J9EHGw^3ZEy<=JMGD*aadmyt#kphR3gJ`ONHJzSzsE4g| z-*5zsNmAW?0c1(@=op0=6Ey;V&{-;W_s?Eep;z8Hv=3{n8RIghHc3hd*H2ERaiW1N zo;B9NJ{XFsIfaDjRZzS8OZ#_0vZSGh_o<8uf(8}=V;8NB?EsB3WtTl+?@CE0C!`FNIz z224gV5faJgs)6go>(&QI#wJe1lWp1@Yq=ti(I@tB5xinW^KLVAzl^KsWFp;c;;nBSRiMWz=00F7?k6JQJ`Ci2oTcn*Esp5$@2@l< z1>ohHpwK38nTHK|@riE7=txtB2Mp)0Xav$cd`K(%HgUiESFSsP?XA&l3p)s8KAbf@ zdGW&m`oXIT6dMW0$e3!kVGriBA8HF{?2-;oT#wKBFkS0h*p;Py=PA77|m55kbp( z_itXS)&iOcw{fg7A&73O4JS88jT){+F>HnK-~e2tOCk?Ly9a`K*;R>RHUx+tka3E4 zayz`2N$a%_YXNZ-DyqEdl+Uoqmci@p-+E)hJp=puH!i(6&F2naltOv#CFl@!9SzRl zJ|TAo{sm1QaHCrS_&+?Pz^{z955Zhc!ImJd;3Z>gw;olgS7`E^Jo$D$(_cn&*z@D@_B2Q4zU1JJVNswdEHhi10_6`J* zPgOO?%El0?_^b|U8TAfd^>IgxVPcowVfRFy;hHF9REJ?6#Ck!fairb-yVo7zBAiV7 zD#w-!aWu`L1QlhPVXS8rEnp%LX0~a!6F}MoP-M_v@~#fIz9+b6032RCI|Q|K)j+}i zM4vGE%Vy+^wr$yH4)$^P@4b0OP)+OGu3{u02vaY0YXs~R=2ZFHp zz4a`%li>&)MQ?ET2x7z~QwfS{UT*0B9KLcTWnKH9oqgaSkZa%l`|m`>?mxKRsfaTN zVp5>Mtp(;2YwaqP9f2wf@78qj+-B1d)T+tFF&TzoLL^vE?U0mnj6Su?0@_-)H?{x_is&8b{q8?}?|b8O8w~&K@4Y!p|L&XrdGb?+zbD({>F2bt{N+FU zYd*Jw<}bVXjxXT={7WDHiqG!=y8S!8j2rN`f5vxw{;T-z%{P4N?|bt7=O5#)d~iPJ zH~rN=^P4{W_|>y7^i_Z5&-$t%xUA3lEw}USr@sZ4^f|xgcOLwjPppVv;Bx+||IhFF z0vGh~=v?;1uRJ<$zU3>A&L@7yuRJ&NcRAkPp)c!oyqz#VVrF`>)Pn?tya|r8(p-NZ5=~4`+$$*|$SZSTJ$4J+( zxd_xLfX4Ra6%&*l3$BGqrLn3VKK=C7%el=KI>z?XQ=6Hma}7N~Il~Nf%X>|2Jw)Ri zqe;%IfWSvuM_fp*w?6x22LHv3L9g#qx)SsQ7&T7cjkBT&UJN) z=3a!v-sui9^Tp>{DqzDm)bRJoIVV{NYmg5nxL_HWknc7jNvg)FI7V)=IiP^r85+>8ti!Y80KHJ}?`I2DYUi&F^el(AfHYU z>Ozwe0Oy$zT~K;ob>dxAz0QzS|78lOokG}QxR}gea zxE9Egi=Z0ihF!&6Flqy-i2~x(oRz>%mUZgf<^;uWbg4}&y`{Iftp64W2+GQY=1!{N zj|&jPY|e2Iq6~o^9#({7#q9*Se64#nq{VwDDBog9n+HkSh-+w0%(HX|_uc@u&Mjv& zBs?w<>ju!Vg4nNEr!OKj2sa9br3llVY|`=y$wROrsZ>k>Etl80HR}HQe)Z%<{Ql0@ zPyF?Z5AVAtA9?g1bWie)d-82)ExfExWF&TkMPI5Ai!*Wo7mE(+%u#Kje?c2SiEDM= zh&44HwsIqI3eoj!#ApPTCt_e~YcjP2x>$?RkJ`N#Xm`>>yUiYL+{^QPH+F|r5L($=_>}Ybqe1JE*!vsSIUCYqKJ^vv6tIu+*lwN?@ULA zqdCr9I=XwjI-_ajqf10YJ7L6QDfQkhNNyLB{`D**$Ywber+no0K&J@#JZyapvue~~ zOKm`7Zg(u>;k8nT4vokvJ`5yiQwH{W8sZXNiAT>F*hV1b*H7iynl%%`8$ED;0z`i6 ztJqDUx+$av0`(!Y2d}w%ss%LyiJ6C9T;W|MRRi6lYRK^&q|!zrdU0AuWg3lv%A}J8 zqABk~r=P9+u$%*hZNx!j!mfe)bGwlI))gK2Q;DAEnZN$f@5#3wdlVm7Q2J-K<8S`` z7NP`o90bXbhdY?;HnLf@-LW5pp$QfYG^Qui6L7b55d=afR`4#D?|h;wVRMZfDGH+E zD7%(eq<~Uj#lJASy8%oIsS2#=a^mhke(zlf7X44&iD1$H^lCJtGpT?Hhi8*{#cHkv zF6%l#j|#$IuD@>}ZmDgYaTTUBWX(dnG9hb2W|Q~BKeXJ3QUf=F;Gwdoz~>eg5j@6ki7Cypk%_>=NVnH$i`OB=$+-3W=H*A}yT zGdP`9mnmD!L4D6F-PgJ_3WVwKS{Ev}7+vYzyd%c*)@gyoXDl1q5Un&AuSq%kSh(S9rK-n5oYfBU-exbJ0Rgg2?q~X{+)%wFGQ6;lv`&+DL?hSj z{hn|7FZlgeKYZe^UO)Nx_0#*+sK*|=2kg_I$u<4fn}5FrAu0F7&P*+i%8;=kz!>ui zlqKOsh-^TiZ*IW2c( zkuvqY?*8*@EfT~qkox3#Asl8$+@0;jO2pAeQ7EjQ%yZ_>9+~!ik@*y!3`msqy8(CW5HK8s= z@E@+0SdkJ!igxg~Z?Y^t1K}o>-z+-$<{^ z#^nc2JPKf)&uO_Vk)Jr$fY9Q&DUY*zzx%JghP9|O1jiHD^cH4kF;O*yx}jb$-Ezft zQKX9`1iI3ic|w*_8;To|&;3kQqM)g#5f>7FG9=(c3wDJK>OVjtu;rHQQ|* zXtwR6?2>|{(mZIqPamgKGi}Jx^f;5K5Up7S;~`Wa6Hqt{gv5j`Mu;w`MQt1yM3oRQ z&^z`|`Nq0u+o>6ZUZhYqWYvs$YkBxHZ_ZioZ=h=Sy~XIU2k*g?mff7R>`%bP=w_BY z_T}83w9=nFdlFBd*8?Z5aUw`hZ`2%x24aNqvN;hz zSmO|n7+G@`h|>Tehn6vhwRGqRdp85>63*T+o6~f&mAp0Ymu%MMb%GP|fM9QUk>^q9 zI5%j8g(gk!h&;gg6%N0k66!o{M|D|SnipP^Hm|i3&>RQ&O9noO;6?5*kVVpj=zk;I z0ND_*$vOh8gXzpIda^0R?FRt@$jqfgxH_By83%dw&8E>t(8X?N zx7!KE2vvIrs%AfDMZEhr7F5|YHRL3eyk{%~SJa#++g<3ttcw6Skzdvh@_<_J$44J~ zAH&%UTMj0Lvmp0E%vlbFQkJ8vo9dNls*+mBHfoBzO_xgLdo>!m((>N=4rHCNxuOYR zSb@c7VZF>eK5dU~qmUh|EwT(K!;bKwxtj4pv`>}wzSOXqJF$_%%8i)9BC|8#iAkY4 zg^j`yKb_GuL2U|^n0qxEU$i>hr#d@`iIWFIrJsD-BCOxA59~cLUPF){5mARI0b^i{JQU2XbD%`0!`!LLPen zALtvkpH3zJ)|-F-{O>~U{+n-JS%0EmS&v@x`fuNR2i{b7|J~Pc&II8x7hs5~oDO+A z9osOUUVg3vYYievWtb=;?%I(yR<5hJnP-PO2a@r+Me^za3+Pb5kF6CW@U>w^a>!u8 z{xrSp8XBkDUd>~l>h;h(hY?7Z3qJ%dx8JvnE5B~nEBs- z^UnSg{my>ux8=|MF*A#8FWaDLJNmUL3?KNM&1hT`34-P9(zl;TaI(D(F_zg65$H33 zCn&nP&eXILo>7_D?f@*q05+V=-q+p=P%|Mya9N?e`>>|yt#3eZfu3{A=vmB$`hW8v zt0E{dXchBuz0{>6O_7|8q+}!`GZJJ1S#|p=NjJzV4TiqfBOGZWoKt30*`$7ym=A-8 zYCN;JwOdu9`exg~!olD#;K>Ox8oR;@X_A*EePUaIXGq`<9z51wgFsw0pv`^lew-3G zj94_bg zLxxQ>>dbOm#Of35|C8X?V4a_}n>K~0*ou0w4j4csX4nETr6c%LyKI#j8GVU{st;5j z;?sDY?|uuClUJY2zhC|RS1+DFd6ggR5B;7l_L0Z$0RuvNpY$^ZgzE?I+{|l`ulhh% z?4Ejx)xiqkgS>>EV7uix*^r7FI^hSlcmu3A0RkOL32(%)#A0m+-h{f)>A73$J+M{@ zpHmmiq4li*A1q6QQvG&6oqGgt1c0Cz)uK$IA&k3EKPq|!mMkBo=-{Rrumgv3p}N^8 zWT^vSoziP>xUeGb61G{fE8-|nVUR?%z0NU&1{?S#G&d&a!C&xSdPun`%1Q~?~fhL^X~fyM@R9r4Ei zQW6kS+G98(1I|+9STphfXzwniP>=+y@I_m&O+|tnNY}bAa03ViS-Ntvcb5<=x;NoI zLhQ*${_=iw-D3~jgON`2CerC0v{)UQDb*UNxrjGclE_x@%<=3zJbPP+rQbVyJA1aJ zC(i=Il=sB>-Z=ts_HM(~WL=30y;2Nx<0%3-8#ZN%LeB)c;724!C`4 z3JLCkxa>NEs1Kg9x*nxTls&j5TZ9IZ8&Z^p997Pi?PQFDmlS9lU?f^L#CZ|E-#g8# z^eAVnfqe3whmlu!GvWU1tB*hW=*7#|ubzDLa=+Ryf3Tmt`q78DU$35=Xa4eL|2B<_ZgRRqjcO(b^ z_{z)Fw@86{6B63VcLADR3WTD2^H>Cq7sp}sy={S-EM8@F>A1q@9O5pYoA&`}yGTSt1L5rWhNJBs#KEf3aXSGwN`#c*MVwhduRM1%q z`HoFStF@eW1iSw=Gbfs1A!!`97JEh(HF-Av}kWAlR@6=LJ5N}Kz0+6c4uFJskWIy%NG2pySrO0 zTo>E8j$6%;P`VF%V!ObAo>2J4B?CCtKU=a+83Y0DB*{hSb%E1fdQG)=GKySab+v9K$?7y@jpTRC3#?5T9 zj&hSss0#4cj&-G9oyLz-EX;kktpsha*v1wyiO&rK! zj8~u_all8)Dk`(G=83!i@#}EOuX%?0j{zEmDw(1gLS(VUhf2&_2U22#LTR# zWj7ZmFr^1+Ut^91ia^$tTH!|-t}@+qP60JN(N`W_(5S1198n0Ikosh3bHNjmT-ioa zW~&ZUG`iRp>%pqvuUu#4C#VhHJE}bL@IAO= z&vnl;+q7+r^ElFA-~juV5qh&nq4l&2Ozw#S@;qZFf*F@C9eqQ1XXQu4eI$6Vh&eI{ zX=r!fqOwl&%98_)Z=joZoZZF&(tGmSdauQPRcJ5;@A-}%dE6eHZ|!Ejy@N;NI@TI2 z&8Vo$S)&z6*9IBXX+xygP=`MUp5bEN3*f{Vm9`B(2mNvdIQp|!*VTQDp0Xj&+1qE; zX`lH{VctIq;&68^4Rb*D-30r95cQ=)K*sX0~71!(z|s=;s*AqZjEh)I#KKc}Jk zYc$b^(=e}Dxvj|0UK+fh$K#Ff zy;&esc(m3AWD7C-=_5CtAUT#c7E;!{^)0PhM$HbH;LuzB5CdZ0rZ>*jT8)u{nAg_L z5u{LSKzym*E8e3y9ECB8~5H{nDOqsLC zJUxk!`WZv|sXmO3HpI5+#qSQNrFUxs*>5TYwp?TUsdFM*xK`{2Nfe5@5R$x+vaS1; z6Vw}i@om2+ql$hI4uA1{ci3Dum|n zx%1RSmQfen%Oots6_Jt+R`rb(r8VMk0`++N;3IpP)}%cUl$vW1uK{hK>}+Q^C6db# z_f6UB*jSA{N9zTPc+Ra7HP+g+sAL70P_*20okTW`pSeMe-yM-}I0>zZgvzc63f0>O z|NHy(lM4!R`(}9TaeMI1KsRrOw<1JNlGP!ugu8yP(!5?#mM4&Ekh=@4>R=9-v8POJ zU6-%i5CGGh-8KMA(!5$^)~mv^Hc}pQ)oAHfH4R2Hhr6dKaUMiI0dkLB8kMdr`rLMo1NJ){sdV zO=I=4i{_%rNCeGvBnb8`Jen{ep$@M)mORtO9;*!L(Y%P+_j1HMA{NIGV6)m;xBZvD zSl?!GEDq)DjfZ!HK5>SRw&=9n($6vL(U|YA zDDzEn={E+4KdAi$@&+okhhtqG)%5VLw{Mc-@+g89MU(S6;#FJMaJpJ&=$ItO| zk7p0A8bJFhj}CJ9DHO~g{KQJ1I@PQ%Rv+HVr_A1vSeo0rEk!z%pI%6WJ9y^6{zkwS zHMKDUuNL%LHxkM^6;kbKZpL|;7Hb~P_OwL4(z{1&N^4NV!UES`L+OL@D(HG8Gq6^KVoCjnk zoK;Rk%R4EQveZ^TV~nUaj7Rw-SRGK%)Z54Z*W;zDS28dBSDrABp|cvswU&mp2_=m zZ^g`~dFx{ZWGPDzMCqK(*w)drtq_-an&D_gy(~`0j%h6=OC))YS`$2(vk}uN*>(mX zC#^MZQ+c6X^X41IWB8hE6riDtao*}Y_*4YCJ1%}FhZFKKu8^e36;c!}? zLb`XG!)?Hs?bF+3-_x+z%6JtL9YNf2ug-V>>(`;}6nLmu5Q{MsAv9rY&!gCK%eGa} zg*&omJ9ee4A~AI`(^_Uak5a8YkVzbY1Q_<-xW{T!T{Wy9j#Pmg(yt;gYeQ-y5wMK6 zdG}~)p5E)=4{tjPA@38F8cIOQ=Vp&RW)kR^U3#Enl?ZW|iy8HvPF+G{QAdh8YL!d2 zAub+?eTA@URCCHEu4)hj@PcH;-Q>XlonOrtAAaPopOnA8XI^{k@%#Br&lz27w7zJ? zF!W0zT&mVwH1=wVvbIjtz~^ZQBPSZ{%@Gz)S8}Jpuw%f2_Ku?Y+8u@10|(D>WZ#x; zW+eJ`<8im@%MtT^bZjV>|Teh;hCxtmHvtZ10L-+2nI%nQkI8 zMf+t2M5Tq4h9OPJW8%=+G*O;L*3*RltFbci@`*gx-I#5Gfz#>=PvVW06@a*H%W|IH z7ImBBo;3AWK1ptS{o-DR(_;_Zy*+Px-#$}Kee>_H{@PCtZlzSMPH2*7V>~juFB4-Z zPLcEt$%gspXUkNRY9w~jcn=zA%26H2E7g%})x+y7l!z$-a%tp-%|KtPqK9-E3e0k3 zj=TR2^%>Nkvn3*O{p9RER!4~pG4EbN^BghF72zgxYiq6fR<2`-oND||6hG<=9#A>W zu^V*=A;kdIKHNeV;_LeCQcx7{j$HGrC(L*M`-Mn`CjthwMSMBlcEnjMMeTGC-?P*= zxXa6oTD6)(W4Y>XlP9lPIyI%l#|-v0VnJswBGUEB<-sMXAg&D2Upjad4_cM)bB27<~Z45}pk!10(K;V@n9_o^hD6_7H1HU_c{x zxgQD)o=(QS zWbFa35bf|jqn*=W-$nLQv~jY^X`Z%~P_kUZxSfebufg);NOs?Qlm`M2S$T+c)O?kz z!^9Ujy50R>?|tvr-uBCltOjS_(qc z03+h);RVS5wT-9_`vLqVu5U|}>CRg|fFouQ%0@JDMyIo#VvYue zT01&gB70=c=*vsB3sMWD8-xcyxvy#^0-?+f>tI|`8AY`TR(=eV;iv?z1HX0y0Bf{_ zv~o_h`^KDl@!^9R1dlyz4;U}_GXl9c|NiQ)wl$^>g^4mH&lwBqLb1_R3LLu#>n0tL z5Jfet~f^f6c8AtAximRCotg3cZrX7`zd&%z_MbQ8ks?*8xh z-hq(B+dB0lU(Rj)rCxlvpKZWlFWvh6*9)qIRH7qLm{<&|{7I-X1c2e~DWz=`;tnv+ z3^l|$Pxou60OilPj)wwmBI(5jpmNA^(SnhcpO~BsS)`x|+SU7r)1&@p+G-g2% zn;$!H>ojQudjwj8y#q`oyVh9J`i+2Uo0B!WKQ2f_92UQ$>4&bS>Ae}4TGcqr#JOie|%FrdgbqcnB*I6%UjpB zJhoQ(8|n1dA)S5)R6^f~mcBO8(pxWY?O^mupfCWkB~ch(!b4k62QJ;Cvn)JG02EAh zC!Tgz0#kNQPz!PuADwEgrlgj`1iK?5JLpBMXiE^o$L z&J7-~UcrO5fm?}AyW;Q}dyf(UZyRozdjUG?wbgVA zucZQ3%K;*}=}g zbEneKiJ&6iqusU*oq1a&WN4?;R&>w;>G0TziFaR%muDjDXiCmRA-2n$XN*O~g4E8_ z2$ODL11$p)&epDwLTofs$ul<=4Qw^oPf3dks#>W3{$?*|Jh~ z?^|SzYN!Y{2vD@^s9;9~>O5$U_*yl&Rvl36k~g9E+O?}ezS~B$3LO3#&laaK#XHMaGNq>2PCt5+3dOxe9kxq zx9jpE*wusF0(#5PLj8NEGxu@!?P>UzJzu(~~`n0-4){YK|0?M3lA3cT-Nv z6ET`^P?*P{G0Tp1iLHmDd*3<<1hCs(*&|=hgW#)gU32Gwo%=zc_8U+tK$Z=TLUfE* zTSmK&JP2?EdZwfjlEE`qw`qgThl|PXq_N3I!|u_>MnQK$-@dlY&PWDdiKs&Johbva zcnvdabA4Jv`BQ(*bsCF^ebRS}4nw*@GPdSq@ZCG>+0obG#cB*%*TE={wbtqEYi~Nc z+LQ_}ovTR^fvUv5>-d}0RCGP>8^MG|rfI*TTA zTwPRyfw)H;KWH%bS|~(N3=p{2&mPzRJirvlr?v;0<4{BBN~TW|6skJ-IF@p_-; zXZFOO{NUZ$r2Kd!e>t8$e={q;_X}?%onTmtBHFL)^Z@b1;l#m~Pcu3Wp*Bvn&a3ae zw>KtTZK9VwVQsJ?@2=gT0k>o@f60NqT;8pMm$t1NX;9>CQZ%%bTr5+h{kVI)Ph(8q4~B z*?Y4dOOPZx4-m+qW+BC;o1`c}98mz@vgK}zyBUG`D+QRFnNJs0n<~3zdY~8W+waxB z6Irg=rE|KDq za@Lj4{)eCa^sEXXbS3v@w1B{PX=g2DxX>8j8hZ&Oeq>F_>QrfLT^7h97MG1Fa0Ec ztKXmRKL4VATRVLI>v!LLlS`id4!-sJz0e$?{Uas+_kZ#K^0)Ax{r#`s|4DrQ>p%YI zf1KZZ_a`5I_E+zh>>NsK0ttEdCSfMh&ARsNQA4(ebOyTbY<&FiQoTzDex(4ktF65h z{cseR$2J74#cR{Zh2t`45T0Cl>+%@G8`@!3pEI8JOVIWW+yeQCf|>0;QV!2yHKwiP z=DDu#X+(j ze59wF@o&dh_3hW6*Sq-k%jX;Nt=I6?Hsn9VhWzl8f4?a|{QR%IDdB?+!KI4yC`^7t zZCqE&+%=PXFTEgWje;d@Y7??d@18*idrH|ryt@(+KoDW74=-gpIHZA<>_r7ijD z8}fmwx66a!ye7yl7su%1WAnATA~p?*QY0GL9(iRPghjfcrDB`N8r@Jsr!5ykX0|4U z*E*>#9B1r9%4#TYmtdaca<7j&pPrHj4Gu&OIg8iY`wU-&<7How`It~#Ov_Ir@l`Q80S439KNYb6A{ovHq1beE0G99xfT7F~MDy!)vG|ykA+k9+8{`!SW z`;Axd6K=>~e}WS-21B(v8hU|p(NN^2`Z>}Dr}%NZJCYoVPQ8Z!rL7yeSp&|?W6Ou} zBPY!%Tj|nxjAS8Wrq#{C8{(nMZjMC_HIpPvET0POe1REewm`h}YW+bT&6bW-L4b)w#NLKBS zY{);V`1a2~|LWyi`>mJo)pq31zkdHGAAaypdTA3vhHMl)$~X$XQFhUog?>pGvb)Z6 z{KR?aI}GK*0Q7!J2V~9em6s2#6({$+EYPeP?Hz1jtl}NN9q+rt>XoEEt~(HOPci4i zhs8;WQOs>SI=t_O`~p>ZrlTggs{%qkg?9SrS@Y&z#|FHmuVM)z{6>bhe08u8z9P1-n@(;e>k}n*QZ@qx8wjuw)(+&AaPDtk)k!9Q;A|ClD zv5Bv)VL4|{@t7vOU{;Kfs~0V#OK~4=UCg|&anA9XhvB9g(FFBIf=iGNL;L89ekKIh zcTfOtO0(B9%Z%|zxt2=YP%)m-`{8O?+iXgaC@$59+AU5 z=d$p2$UCd64g3$h;UrhXdVl+p?*w-h0kEncdqe*1`)&7m|B=Gxt=I5X3!CqM@=tn3 z8X8V93dTyh`-ZDvs+#zngzRrXdpz{uE|gOwv+w4f?P(|BgUSmSJ~V3uKR);@HRlqv6# zo752Wb~@o0x$Dx+hx@vrck>#9fpJ)b4$Af(=&?+jdGy+yJQM`ckF|dO@HdA48i>=)ql{Ng%$=os$#Pok(b zV(;41?;UfGc0o?%L=>FWFp5en@xQ|X6-cqP;ig;1_Ru|*NgT;+%l(X; zv7Ut*qqS{*_kpH#x9Wq=fZVTpVBE~3c-vDcSaJz$IMfhE&}&gFwoYVe-?NNqBkXOo zA}(QRZ?|ReH$baQ!#4ag(R@wUFw6bXlIFu^{5+VRd05|g0bjMG`QdJS{P3^69hDMp ziqlNolt#PT$2bI_%a-fM5}-m#6&nMC>A^$<>HBntf@^@WRfw@H5(7vm?m1_zeb9}r zhq4~ACHLXZne(KUv0o^JpKQlRCIv%HGSLQ zt=I5XOPU|<$lv_@uTBR`y~PZ*c_B|wjv*7pa~A?ZhJm2tODFVP&7)Ebp8IIsz-}EL zvmhMQ<4Fu9DG- zBso~-g$p{iwMLuWEtbguA2}zGBsMPok@E&pq4&w3ban@~s5V|m!;NXh8PTwm!dWj0H1ZXkwc`!`uSbG}}W{yPz zy~dFqdS==g*IEic427;>Ouk2~>*Am|$%Gyw{xaQaVy@sFc^8U@w z|Js}KVh+2Rt7oFnWm~IeD4s4^ljp*$!9j1bn$YTM=YZ$uI#~w_kPU|XL2Io<&YFAf zi$PcJ0#qKbkc%|W)^!hFbg)vE%$8^N&OgM%u6<7!fhrz_g+GW+cH#X!rgIGSM{`vlte9u0f z8Cl+X1wYv-`QfL3^%7@627~Ti-!+G<11`os6Aq)ZJ?ACGIdYq?Sl!-h;oC;xxAv9Q zJXUXzJzFvdknn*ZU~Yayx{^p78%7Pw3pge0pso5_l=1ux8SQ8h&n{>&VRH z#yNCY;(BknQ|ug+D8RJd2~SEMpsT$WJX3?`p{p__!F)Umy0xxF&}@il1RTyGS**)* zPjpj$XZz=c_V`<`-zRJTe2V6{s`d5MEk-yk;?f**L%b&-JJ2c~nE6UA@WalkM8^&A zI*6$l9s)VNa)Mi%H%3k&TrPk~B`V_00ILto_;#(+qA5s8t7iol=UD?UW;9GUTTo`ecU>8 zOBBC$F1EI)*DI$^U1QhCK~I0tR6x_(ASF(w~OxiMVBS%opU(7AfVfPp<7 zg*a?^$lBn4sIdaEqsQq8OsXI2NPfR1UpOG&dI4XxBl)8Z`6*6Fj&q5DuB^v>(WDV5 zO;vb;(G)#lgAp|O_7F#COD^X?wuGNj2>;ITao`=vIHf?%9V9#3?ITbN%m=@b07T3S zU2KA=Z`My^H#H!U9<}%FZfushIUk8d2-1PW<0w2g7bz?zyI6CB$Wat~0U#FeBc4OR zKqxH7@D|02GY;Ge8Hi}HQ)c_pIC?n zit2`=$3RZCM3|`-JfcC?rh#Ja=(0eH)EQgvsks5?pLQ2WdyDy;mhpj509d+`*la>_ zcQ~+|IVv9=={h8KGURa`KQ&kO_1NfL58iqq%#t2-w}=1;CM86Wc-P>SHBL|thJAnq*${Eg1~7w;tw6sQ>?^@E?~1~FWhVsk2iOHVJts22 z=U9!>5KupA$-&NsIqi;XqrUN80w(htBkTyfBG!~YH&>8 zt3z0I1J5*SqTf9q#l^|tOeE*=SS$pT7tSI0uLG6E90JlkN|7$~_(W#7<=M?2Ymxsw zd@;X_Z@>KdtG{^pq7!$l0ybs4G12&wzQAf{~O1XP(OjBBDR>jo?Ha8sBa9IK3cc+6_9ctHs=(q)yx^69Zo>Uv% z^`WT8!O-U+h@x&mn87umpZjChhTnhx-B(|~f9b4z>-Brpiu>_Xf5MXzrCby}zSM_v zx7&6186)XZKWLFRXYXi(Tsk0}wZ@cg!LXSIINv#?x^(je+}ehZi9kq4l1n@Dol68h z)hJl$ARZ9gTb>184Viu;S^^P6yLZJIz{(66%Xih{D}{)ZN7d@mw?esPjo~`Me>{i| zlx9t3@Gj0|Ti3IuhskK}$MtzPG63b~-PhQ5I{Elmll%|={PVAvUOpq=dIewg>VEv( zpH_~xX*A44V+;oF%_p-VQHuAvYNk-^k)l^&v(yStwCtJ0_pr-A3pZrMij?E~%*`ro z%Yc@?j5tZw!*|jw#5{$%6|wCLTIy55t{s0|QUanl>~=NAsXE1R3CS*d-mSs+SZ9WE z3C1xrQCg4F1L2IgnNdnCT%3zYE>E~!miQ#qoVje6fyffOQnVC4guOp@b^pPK4f&D+ z=&cvTD{Iz&ug+(1==HFrUP1 z+5V{Q>-Rrw#}_W^w_d+jy{vz@8$ZQmji{)56&x1bWdaZUp*4Cde0rND7#h9u>bYC+ zns&jLdKT!coltvuB&?u)%~W{!a}qY$=}ou}pLX1t4wXX${p z|F#xz`2xzrYDFTpL;@7M&bSL;@IcCFk?CQe?FwJlT)qbZ2C5<$fg>VvO-`^v<#Zuz zd*h0CZ;-l&Za@33@f2e8x4!N7Uw`pu&j>Pay=p()f`9iz8u0kVc=uKR`d2^Ph=25> zzy7Q9WZs(S{{I8!e{#V5Tc>b;_CG#S>0sJ9XNMya4V_vA%5X4}dSb`PfX7$Itc486 zc~TIHNbTEqi3}ieR|T}4x@Z+Xn+4ua+jUIXeCc@4g~%OKGrDktBFZ87e)d1%Q_OKj zY(!PUmM%kuvr;e&*=s>pZHV)P7!Q!Y!$W~O0%Lje}nuX4z)7H5WC&vfW zCD;!X<7OI%Y<9Dh5=M+S@r|}1CPWkF=sUH^6TpXF;5z1h956?KPk-`D_SPTgDc0)& zzx^h@eg9HK7*vw9+&Q%`Q`0z&k&O%H6Fr_W&Z%Xpke#vGtVytu2dF4UO342qk5OiX zCL^dlozj!ChrSr=@Dq~%fAI1E_V4>Yd=LJ^=*Nsgrzl9%o^#5b!-#qrH6ixcP}Ym? z358TTI$CrC^*w%r`$FX89b!c1XzL&dsgPCIBd$$UiaZD}`9wrQCXgLV~-sdP}eJhcVq5F~M-gDL7Lt-e?(c4gl#lCYfP*80s{6b<3GiVB~5l(&* zoEfyQZ<2YSLx_mLu8ODG5x@V%x8J?Y{d?KC^Vo$%p{X!~-R z)D-tFwDavu$-0|-&@wzWZ6h0Ob2iVMJK>AtSq-NfBq>1%1%;@7A?ls;PRD><&LH2G z0EbUD)m~KNv;XC1|Ki{H$p!~piHwp>B3E#D=WaUH&|jC11B@Jg`rGNp;>bi7Se~jT0;0r*<`2~b<2qPV z(-V#C?U7-RI+Yd})^)2+S}NdF=FYw&r;eOQXO_D0U27cx`*1q# zS@al$4}JRh{I|}xk^QcJ{Y`xJ*i29N{u{5}v!Z!oum2zcSef2_3Gr-4#041^{VW zqKwQ5E3X*x+6MLc?0>~GPOXRgUWm271y<79Olz4hhciymMH}>0b|w)t6*B}#$y za#!)zY|df(=@9f}o7tkhmkSfr!E4YqURsY15h^UEXc`89r0%4YBf+pJzyt>K&U(7}vzvD!Wdtwttm+)S+)&xDJUE^Z~?^1dL~IiG`P{B`90 zJlrKJ{HRj#@(l7qb*>k+|D_JTh<9ImWynhT?0^5+gF)E=5;^D)Ly-j;vQB8~nMY}| zV?4Z(qi_QWFSFO;y~~-)dp%yZl-mLoC{`dje*e1S}X%1&)r1GaW+&pFda z-p~GzSNQd-X?&>mIjgCfMxXNtLaqgtaYGJOyRktTP5<1fwP&UQ-vV#sofsb#SNE~7 zK>3LpM$2%nHBbyFk*@V7C{n|=ArRb%_tP;iDsbd?u}yju4t)+Bm<62(IAFUp+Rkyq zSy!X>(qp08;0qFFZd+3dsmzDM)-mH|0TxrUr6v;5RS=@wS6vrbO|+(acRo#n`x{^M zpFO+x-g?QN{o0LR$d7*QKK%J7xb@&JR2ha&r-U88BFkEM)zmBAaVFfp2y+AVS$bcF zH4RbNqjy%4uOS2HUMiXuB8S$sS$87BdtID0jK-9v#sJ@xi0%0Gr$xbAf1GD+gKztb z@2cN@@nTFXX$B*%KE_aMt2A2+UBWfiyjHM?E~FJ&G|_yJJ?x%Y%XME&JTwe3Kb#9W zrGbdVi?#^)J|c-MT2x0q>;T4ekZ0-$tM(Nii)rnl8MEc2)jA9w^1k;{r4Z=NS)_7- z>60U~InSk;)k}Qj+z1h_TQH3pj>EY$yM%Z0;Uzk>LrVuF8R%#e>{NVnfy)CZ!Ds*H zD;#1`1Fx~+V{2fdjd=E)(4O@Ot$JW!co#S+Si3!XC))zIhf0k z&xqD&(kKKn+gg^8w8>mN{rIIOWW}!>8w{&k&kmE;lT+?isV-n}4?*Xp$c5j9 z9Onpjxru-LD$Zlc9ngA^Owg~?H+~>A3uXpwL8oBLish684vffk@X=DKJ!Q3+ANbA2 zv!u9xa^wB4-u=t>Uw`%P{jU(B`tJR&zWw~GKmGhZ&yIWJg?#o-qF>A(=Cb_F4}bpa z6U*`&FV9v-lCU$^BOo_t74y9;+1)s4cRcVFDr4-%dwK7gj1;#q6D$;<mP2;gIS19ptrzxFSus}Ss*}2K{(e)S2zNBS#V%O3@fUD6647R{Mm=S z_lRVD_p5IM-{!Mh?X8#a(>&2%LG*j*4CL^ZijFupPN!?ZbuEZ;K_&uNv+P=F4Z9)O zJ%EP{I1-NOX2e2*TCqFH0hb+FgqYC**#Snd<$Q)UC%T2|dM1G)@zl4|OlA(hY1W*p zR}?SgDud&)#yrUFm|V*!Y!`ZN98+x6#^VHmeyi1ysME3|5!40=ZjRM>)cO{*ygo37pq2i|yc;EliffrqC6Oq$#d zsZ3sE7aUuaIUS0ql=7m-7}_r2Bn%n^ywY=#tz0sfnKPBIxh|3^6|qT`r#_5qc}2Uc zVh%VUu$XJfBQH!~7ulcvU#~C>U_4dtCUn|2-ouWLJE2b|1d^DBk26pA1Z{FRs}k&g zJ{S!l-OBd(T5UhxHuu5;nYyGB2jPhY{8QdF?XaSX1Ed+Hm6Jd1guu#>fi4zp7!5-; z;fJKXGP$&hVZ`8hfrA<8LN)l-fkTXPw!s9eD$=0Db+wol6eob=^T3tbx8<|{ zSzxWR@5B|%)`Fy#dHiFj151Ml>W zuKD4$j%oKgbwIyh_tSUMwOYf&DpvtOw9=Os(ddOW@uNPsp4gkV4C4;oUQZkIyziKr zg4+6S+biNogHTTFl#$oZ0XkdRTFsH><+|otxRMb)RU49$L8VR&c@iJJ5Znuh=->{A zV+69`Aet2xaGh%;q|v{%%l#;f^!NMyx1Ha;@B(@3)q5cjj-Ld={RF-FS0G_Sk>0uoU{C?VSNH(6ea`Gx@yM$aEmVnVFrcw#C^*LjTpT|?fsA%|DE3e1ME+4Yb zoyZ^cInSN-~aXx@R|gft;M@uv)H`n<8*)By%AQx%Ysq1tXLrg@>mTsE5}{@l?=2Wro)k(>~)~f%Xxt z9a;j-+5ruapwO6C2suwpHIS8AFYnEtJ>Q!zxRKs?C0}i0zEv_BfvzEI!D8lf>CtIY z2S^yz1w*6=cxEPaQU7!ydPiwzPIe?rh=SUDO!Txhm+^xjXysC4*f!1;0vBIlb8XgL1tvxEaVlKJ}B)A!edLf$J+K_{x`tsKN2j6ea-4_{QhOFlngX%_S zUYFk1%#z23m(gf25!XUPsd_97K}K696EEY9P{Ok`S*UjF<&q!z4bD_ z+O~X?3?Lr2J1^D)%Iv%=GBu0Uzf<}$+c`ru!3UL)gY-6PPzE^l8e!Xp( z=*fWLwF7OMhdIdBM#6ZGX+81~7z2_?Vm%Nl+JFyMo62D6fw^GJkWC z|IQ?!w_eFty~y7p323)zEoj}Rjy*klz)5g-&(#y!0p0`MH--wSugoYXQ1}L!WE~Yk zcErNi4S;=~5bI*f4|5HBP1T)#>CSzw+RR*1XFX6J&)%43SzTj?k`-bl=5C zy3|8ys83xmhNsUXaH5REg9ABG0~w7i+ZA~$BDbo}M6GSevF#0R`!+~3;0UGRK^O)M z66u$>=HGv^HDAh=eB*U|)zatF=KQdH1JZeTTaIm-m@=`iIf>b9RqW`OHw7+Q^%q&SJ~O)R*RRi7qAv* zgALapCi@=4khYhBr|fT~w@-HJKYY4Vm*7-=R<^(KTE5yQ{r6rLlpukqpjk z6$3mq5Xg(9lWJ6$Xe1?A!f1~hOnc(T#j7d^k&8fM>>F2Y7cE&?Bzhq(9<|P5Y-$b{Fj5;*r z-Z0?c%x`Ss)?RXsNsQI~fQXEcADdU1xf65j((%kmqz|NJHkEc%(_RbNlG9K>S=Z>B_v+a> zO%@JBHeC%IH?r2s!5W6=71p95W6XhfDKglgjuLHNeoHJu2Z!815>fASH~x(u*{A>b zNBi{qFsPSK)VE&ESKFxn{>y<_pY}{$_-(#=r}GhbKX_Gp9u+s8L-?WgF%wcGrU6Ba zQg(XZS*T%r0v}s}J%k1`GMB;LZv(D`z<}M4terf@Kxni-xM#8btQCc zebp9z`F$NLX@uN|?o?br2@@ST04x}BYj1NuATQ;vWe;je-`Jz?!#|s(DSA&r>437H z@|kXa;_m0(vmlk52JP=cAfMZ#@+}DcRs~+MePPrico?AUydKMZPe8Lz6h|w%s1NAI zIR|QU=G=+6$=#cEMXbS!pIB(J!G!p)@=kq3N4<2azV%vuvUloZ1wQSW>a%v{#%M%> zj+W8223}ymr*0F0e``t07Cm%4Ve{sgcTo(t?cSL zYpx+~WwGp$gXKD(#$fVv5q94I8sW4k0(KY`{jB4GaL7a);fX!vLgQ{`1a&9`OzF0d z?1zhc7v#l@U~Pl{7-{B<+ld~&HWWWy|~y6jxrpdK=>QTxQg{~08U5YvTG zR3KV-*K~!99&x^t~;q(k-Nck1`K zXD^+oZ@rqI?4A1k8hqL_HPBzr_DQ?Oez0KyC$uqu4PYA~Lp|57o|A=VxlGHI`K9 zYbw{6!Kbm) zK#fIhj(LkA8tX2g4sSjFTj|L#-y5ENWan(#TDF=m7z7Ld38Kp#T~c>K$@45DPLsEq zOqo>^tYzj&hQ#PYT#ox1Q1}?6UPvFtX}Mti-r+@u>L}oaHsefjAfNI+fZOZjG9?gS zES4`&U0?y`I{cxP@Ua=ykKd_}@V=K$)wf>DPxelItiUJkr|yl6odNQ(dKBD>6DbqN z7kiE9Rjw&{V+~EyIC%~^qsrY#239+I9dbFsFS+SDQFqR|Xm4Jf=}D6o)V{ewyO|Fu z6yoz)vciBUq=ED58@i1O;1Y<5g!V?EKTh5q#U@B~Z^9&1W=sXae$j;dDMp|Ywk~-8 z4hceE$woRG54e1g@z%=`rCK$78qaHE=kHdZ{5H|>rCs{gEBVQ$sK5Ty_x`!F>8NTe zF99{vPE9{X-P3Zc(R~S!*%<5sz~N!`t4KWnYCx60Cm5HoJ~WKC#vZ#WOHvV8G|L9= zKI<`;U6bHs+CVy@Dnk1&p33mE-CS!9wu@YigG@K8(ex2L>Cd0-(UT7d1*boQ0AmPpd%sMz#&Q}H;p5zbNdot#GsTW20;lnmT4aU>I)uHE% z2r@A!MVQwWUIV^MSwsiPXi>G6g^mP2_~{;1I|C^mTbF^jy~j`;I!9xGc#*0p4q-H! z0NfCw!aYfMXMs#vK0s@u2e(#kZK|S98W%o#8C-oyOMRlR2_IcuSW6ut)Q9YMOQn8C zs@Geumhdc6cB= zCbME*kRL?G445%6Wr5Wh5bi2SFsAOiR7)13WyaHIr~xd}VILCX&K-f&7uj``b{jZK zlXZ54rn3nAGUo%tM|Nd4zMe2aVbTz}`gwCS^g`LA8WG za&-RVA8gCtneFw~tNCi1^DVQz^lBe;-*k_Sgo7TKDLw!q$MGAA%D36}M%mi}t~&H~ zEa`nYnBy;){7z&FlBq7AIdxxBk zHIvp9q|9bOu=%??r9TK&diUk~Kg(xP#&5isuX=ob`eY>}pDmeV&M^=AG}L=cOEARP zrk$}vd1HQ}fe;T)<+0HO7m~FkDUjewYu%+#SuCg|m7tK{vH(QY$%s|urcREHEJCEW zjNS26ZL*notmV02ed8Ep2~vrzEv(QmmCbhSF(+k?Gb6StJikcm0tzBFVgV)`N|UpFCvAC}RcdZDp*O zglWbqBCAGHFS6j4HN-|2+2cDOqYaR(r*R;1VwTR+6#j@;Q-N0&{q@VvH6B`BxZiNa z_S#6Grg4;dX*}(P8r3{`He^Il=F@|+J_|utQ2l@}ylZ>=)5|;`7-??TW9apGZ^aR}4gkftpp6c=)5$Rg!e+Y=xbxQ)JHRC3CfN@aZ*f|VA_C%6jJC;UN9x6edIF#`Lk{L(s}vTOZoq) zeTfurX^SXrnh$AKzS1QU$~12`-VyoL7E8(g4o z!TE;19forI8nRo*n6!Ho_@uO=pVdKQI=n?aHc(_WC>6JCqumVXUFXq*^3*PE#;emH zV}>etqHkG|1{plWC29sO&@lA7*?sX?Govn4@<;`Ch5~MjQf)&VUn9wpEYbTdDXj^XxM^PHLvLK#ntdmBRhDbHmLhzE!Lcu}UDacnt(3*gAch1Z_xqCg;Ds3onv~;#_ zWHq2+$rooIL2x&P5sZc8b8yNY^B{^VxPc8Gkvq>tugK=gx$5z+Oy@f!tk!Z2sF5qB zq!_a|ry!w_&ci!&&y!8}hkx;P{_5*@|Iv5--LoC{)+_e{GVjN<#_`va)_8`^#pbfc zU16xu(9Z?NWuU7I9hwyw-qltMdBC{{m?+oncdm>nbA}6`*3}+h>W&Fz3?XrBuSW#T zHQ~pNv;iivd6>>v=jrvk2peRw`nf7gR%05tz&6Jak!)^oq7R(3BDmBHK}O{?Xyee+ z@O@O~Y+!pw8Z|)Lx>7*Qv)l8|gSLcUqT^E?b87BhrQeQc|MziRmD?)SAhHPuY4ReeSi^L?& zO)e~5I~d_&+cy|`34>MfDxXYalex{KKF&QCz~vJnurLlSmitum^VT2dX}(g%7hk+P zpMO;^aEI4Le%j?RN9=^8Xo3HZm2#t^_q(21Fpt4p9Z@i)-xxrmVXqHE7yTbGht6Qr~0kyXZ7fpqy7B=Ig!#TNd#> zg6NlX(LC)l(b=KxeF|6w83;B$?4X1pI=c}QHcNog7SJn+y?q>*i)1du&c)VBf-R}8 z4te^OzVXL-O2_~3m45x*i{GiZMj>8f!j}?IGx*LVop=b(mc_0 z`YIMWWj1-iFcyKGH|#8x#3p9|MQJG^bo%Vk1?GX8A)Pg7fl?!vgpdh?{W!c&_Pzpf zBm&`f)`NIUP4{W6_gjCQC*SGctG=Iq)$hLf_Umu@+h2YDA|`y?;ddSZ;(_o3cpz{W z>5T`*P^R?JbHR5HHs9K^1RNcv_ylvTCT^o$y`6EdF#(@vq>Ba&Fr$P_`6piEw${ii=ivzR3jKfaPAc!Fez)T|An zFnjeGF^P8R5&~_Qk>DkFjqua9^Fj5}5boi}E+anzR$2553+F8);xf>QqqBMOR4J_c zl^|PBeIIZAah?Kp`~ADG&%f;a)w}rB*I&N0y%4y1w;s6((bQdrEY;dO0i3%Aib!Il zy6Gs7%j8fi-B`T3uj30ISxr-6as_!&xpOH*1q5D`t3IHsDydavG1Qfa?*Vz@5vdh;8SU3MT)wi=y;EA?vL9 z&}ny+b?lIh`Pd-HeFgR8E}WrYnF5GyB@rR_+&ei}5wtb<-!qI09ECOx*=PSbJ_WSC zA;;#dq={~auNWuUr|QJO&F9t2MuQ7^C6~1n^n+!a;O;;wBE!b0lgg0Mh?Csu+DRR& z$3q1Y7hx`P0=z=qkBmEXmYy=7-uUA@-Q-^)Zuax9fX#pZdA^wJEL+9#;s#xka_S6n z+k4PB=^PKdk2Fw|?lX=v!cg&V5BzHn=+%TeAHJxyH;P|1s!OiOtuH<9c_wd z(L&m;uApa8r1O!q@OOW56Wppf^JHA5i~4a5a9J>eMOrRmf}uD(3OtL`xpZUcv<9lm zjx>fA$A{z?8MchBE1ewI^Mr$M*#|!!5M2jUB_vvBUNV)PVKq)jh%2 zrCv9E5zuS1k)ZgP&)tVD7HNvm$({&Es4RyIs#ypf?&H6`k);YXHqfO5v)B!@^iHOs zpZym(K_pq zpCETt4aD2^o;n8cwn+HxH-Mr@HS#;l#}N&h_rmHijhyfH)<#P_y>v{Cb;=O95YMt5 z{z1Qg_x_ikfBEjaukiPX7kRe--+Bd~?f?0tPc?svKGj1%zSj;hBqc47u7e7=06$31 z*n0|Vbm?6py|kdsUWxRm3CfW;>0wlv|OG$I~& z=5EgmKs&cvri$}=ggL;zbSFuT;p|M8_mVlm{JMD~b1wuPZwnjAKfXL40Q%R6DYB3f zk_n!C@gZJoWvlwga`+B#qaXF|a7ek3VNcf)@wK4k-wWpm{pcS3@aLZ(xf@Xlx(`0}hR8UD zW1#~-5J=~~!11H2AS{BR277-kN=3>NhO=AueCXi>Sa8H~jIiuS7|`W2oPr$b5jh;; zK-}zi;NigM`e*;;qcU+DyUs}jL7!OADoB6`jBMJ;EUrEXdB$nO!OplOC{#EPQLP?` z*A>KztW3e7yb93>6pd_h!&+x=8Z~bbFaQ$EF#ftq>$Csr@hQd`pid?ulD7;M&PqWE zxz}1&V&sW=FOCJG^vXqM)Hv0kG8q8oI8Qc|r~Ady`(OOtPmVe) zjt~l@?=8yoiWaqrA?pD$&aIyRn&D+U#uKOyWu^JW{q_4z1 z0ofRs{AU~?y2!Jsgif3$-I-5Eh;JP|{&b*o;*0nyyWV{nzj_`B^VW;^LUl5JAwQ~4 z@aMmFQ^YX>HQaPJbQs2kY+$Q73dY+JU4rb;ktsborkfE5?ecKD7rA-b6Rs8n>ZQP~ zMFV3PfP#=LRgbgb4x7RWv|G=ZI7WcUd^$xe#<6K}_S&nc3GDUQ=fqt)kIQJd03pWp z>mXA*ufXA3E-p3{EeS-wZKzneIYUhk(#B(+)pk$sdv`f1x#e|mhXGtOGnWMDYX0R65aGVs;u$~d>?04WJs3zjXT z+g)&#Y{fZGJ9FGSslZx*-~Hf+z+S{y}>>9LJ3fA;=Z=n@+vvnh+<{MOqg|hcIwPU1MN%60_tn!%>T} z8AMdV^Z#b=&3Y|6k}N$yXjMto)j&&1Y61jkfP{Jpwz;{xxm!XlNIyd_7cjSh40JF^ zFd}QvyQBxr-K}|^=UKn4rAJ}yAS=mpZ?=ZI%oD-BZ$%cFJh8WLcXP9~z9o|m)YmRI z8`1AZ<~OfiKfX-d`KdiAo*6gdnUC<;D~~nKj+(eINn4|*%z2pj;A@4vcUjb^1Sf&D zuMyDK4PDZaI^GuaBE7*M(y=rG#-V6?=9A$th)HV-JnEbG|B63Cvi$X#niBF!+8tS2=ph4cP zN%hsoh4{-3FojNLzwL4S#Vc#~P5xoNefQ=2eEsO~yZ7UJGJa2P;`ij^TXsDMpma9T ziy#;o`%GF)dqnM-tI3`kymOAJdq+_{@_LOSFhof-w7t_#lLPuwj_nhAtm>70DO~_4 zU`iFkCp|WN;@UR`F6S7DHpo#0r-=3rNRv;avEb9|`)KK{X6yI9`8J`}diCbfK6md2 z_uFZj`~;EC97H}2sV4?8h+{+ji}|Y~3eW)mOa|q1ihG_i`^S|00H zA{fO`6vT8$$|J0;BFH^gV`OSkp>wgR_c@T!)G{UPCTW@`;mvxMQSI2B$pfGj~MYh3d(6%obmOOmW z>6OaaM0aisi>sm3-EzVzR}p&(N_0QXW}Ri=v}cL9gMu{*PgSd6PUN$qMB*yck!#dC z9K)R3N=#@pa6c}np_&_44lSb5@U6v0VLR5!iMzAvqsr^fKj&tJ{C$5aNPT7BeDmf{ zUVWKwzR7Q&>WcO=rp&$-OlJ(+AtU0pL3n6w_|6HKmsda&(ncY)tF6;Fk~8Ch=nZ^YX@raASqOko z=7F1PT#)@)6EXDJv?~S@YuNFL_=M6EtKklPYG`e30r{B+2I~nsOFKaExbeDt0vJhD zRx~IDlpf{!ID$)zbi-8L0FaD2aq1i)-aFbv{To#p4mr8X-g}8QJ~=UnhLGI|YA+yu zK1?JQfvStXxltBC61nz}y$6XQ5@*X4P$u;Dx?gYX{rh}$O5FRYJz-lIKZ-s7@Yf$* zS<;|JY9|#^(w);QLqOc#DDbllz?P2K)*X@uM$n*|16hW6TIQMtOOzgsX*dRuEQkL! zHe_`t6ibo2X2AT$S?Rc^uj*`d+g$pX$8Wc)mpebXCsi-)M)mR$Uc77qG&JRmy3A&! zbBg)`LL`?0AA*xr*#JV;d^V<5J6XeF*Q}B2H#NNDl{qFrEOzEAU+LN}d zc4N!>C|4WCrvkng*YV(^=gbL50R}GA@`SCT>7*P&klQM@l}1{d*kn*3{ACF8x`kWy zeLOr*E%woy+4UaLhqTzbdLplz`T)xIR^9h$jgIgA@SePS@y*riBRo{$*kt4tW!Okr zt1S?ZM-weDIpM=osA~oUd1yK28qxrAYbP+#m?9$}u#7~x zf_pJ9m);1;bQJu^QnC|q$+C531<&0Dq8`}_e#io{R+0XSGneAR+XH(SeNPznayya{ z%4c=-wQVIPbqCX%vF5qx5(Bak6)5mm)R?_>OgWj(quvr;h1>gAUp;Ov-TT2kF|?r{ z?Q$Rf`lDNLLR01@f_G*c*=AgO*rU6PBPv>MMX&V$yZadDw zjKQcFnKJFbkuk|?=jz9hnlP5`wj_Ct2}Sy?h$;!xjU2~!$mz6^(OSjfgBNM{U^H6z z?D1QidYBZ3B8x(W9;1(!9y^jDg|E=`tpAh-XYH>Jbml8h_$PU~^$<-Xnmc#+-Xa~450X|p z2Cpt~+HFhbMyaFkIxR%!0zDjo2is_LaOM(9cjqd-Vwlbt4&^O{9OQmp(Aw@Np;oOK+fEaraedPzKZ)eJxJnvEmj;q!aPu zsi5vUq;KKYEW&9jOE*75OkBb9np7R=CQY5y!tl3$UlBmE8Y3oJ#i!a@tW%&=bAfn??op# z+t6H&0aq_$95c(bN1cYjBsb0m7uI4l|3>Z@$0!rZd(2ixZU{TjOFTP7VcJAIkX6{q?*2<3}W-dq1-$ zRV{R*YWWD)8fHz5!)LW@2UyP@XBc6CNp4I-teFEsJ{nx{vIdQgsS6z5o{9dTi>=x zFwqX890%hrvz{OYtkK7WzH`-bF`b;d4Q3&P<<$)I`$H@s;=Wa=n#ai_b-UL7 z++WE*`NK#0f;&I5Cyvs2BUhi#GVXPmBaE~k%&0oXsS!P=MhePL>D_l%_-PMK1jT5u7t9JAemshy* z7XG~@H4py^OcDk&Z3Af9bg?Y62BDYlTn<5UESI2->CzVBUYB!*K zxN6I^?L$F>ff-Ja7u1fW^EH%9D#2)`?RL%?F(tRD5EBpH>YZB+5Y*sw9v$~e-T-@S z1htKG&H=)qvFwR33_XvPMVABxil?fvylSlx7c*<90|+?|FW9akNGAT+u=HiIEcmm) zB?XeUuPGO&DPqw8#2fy4r>5SwoTgsAWI%~&T{axXypL7#w3A~!a-QG&=iJtrUwr+| zQ^>oil(9t(Ip{)(*Tk;Y8YyFv08l#-q%3Fxk2N!4HDBxGsfHw=03&UYX8?b)`+|#d z2E+T9r|p4zQmirB+?0BH(Ni)p4BzY6#zGZ*>^73z#&RN4&^@9=^Pt@ zMAcC2@fJg9tA>Lo+ef#xare|K#c-}b2LYBlTr^b@(opK~od-NS38do|)URN0-^$KD zUeM+3v2^F>_T;goH^0Q0suf$+@J#)=C;P{ z;@x|}dO3+hmBz9I*OWGMMBr@*?U0|Q-W4U;T(zflq+FnYNp{QdP?<} zxd5e$glqyAET1SlVNTwwOkuPZVX3!g*k{3zP&&X4ekqNIP`e^ivK1x(6*IvGo zFEBxO_c77y1pB5r?7g||2=AsSrxxM6MmS6i{L=@#lO}uEg3EFDHP)e}3h2gM4G`iE z-b+>U`2MB-`R`w9|9oC=_1-MfPY{jzM1=`D2n*iMsX!&5(Hx=8=vH6V?=)yyZH?8b zqtZ+3iZ>0WaF40Zg%t*4G-7=lO%*wb5Ob!Hh*9q?R`mwKEa|~B@V;o#6Bh@-FQ2`( z(*>{2V0hCfW-df)o+H2{FHVwDcAtE+=k-&9q!5t|!Q1A5u4p@(uR3Cn!2c@`* zKzAPKl`dyQB~xrcgdG+vHKK9@Ad3f* zQ;m5nnH^+S_3N>~K8jBXsG#;b*t??3>qbQTM!!SN`>zUw!rV(Ym|$ z^Lr8{GHy^JA0eWPxua4j-RL|)-LsUeY~|r$5%}(SoLbb8<%^*=tK~3@xqI#|l#APO zfm&(~c)6N&;&#YP#oNYX=7cPCt!m(eoCf}&Pg%D()RG>(#U$rbl{0W78H(`goCsze z<`Z(ILnWBf+Bj<>A^3C-P!N{`*s+MaZR7@5jR}~owC?>P#blTOB-wMQCdQ^Tm*NG} z?YjHj?}Xa7tL@%T?T4%FpZx}QyI+3yOaJM&-+c9t_kX5+&ir}ff9&gTu#W7_KXQKc z`px^-Z~saE`m1m3{a^a-pZ=$Q`OEJX=wJTs-}ooKw0B?rW$&mGe!Y5s_q+e^GxTEa zJ)(d38~^C_0x#iJmwi|@_pF2C5#B@H@Tno|a%zF|t=g~&US~4x4McL;7!rFSpr}&8 z!*WVLEWC(_X-(cN(-vB+BYRiR*(k>3beDYi=YMhSva_`qYe-7Orome*jH<&FJh?>@ z!`U&B-BJ^(+{3t_&($cHAhpWuBPN3cdilaz4qUpY*9fgPll6mQTs-FX#nx@$($@Up zU--pkNpZs{QT7NMQQ7s(1+bj7)`hQLbIrC|bM&E|;oLlJuY;SUjGB{Sh%Y|^IeJ3# zy^n2mB8%Sezi+**>uNkoHsWkn_u^>PAO6K(JmVGO2jA>@{r3BX{>#7Z12}1I@ctO@ zsMX=t%yTe_7Ox72UJU+3e8Py8wB7a&a7;TD?+MBgA)EE!e?kvc^HF*BbVUlqW-{L( z(hk~v_Gm?m`f)et>u*olEo;j3PRIhPl8w>fQ0a37OXWG*b@X$9;%=M>sX$=yJbRCX zlc_6Buz0a0c3HdU8D{`Ouq`@GunPJ~6wi(Zh068Eq?VbzkO|QUjK9X z?IU>7ogdzBN4WhFWJ!No(bkW<6qu;B7*kGN2}CC+x`RLkAl(gWdT}{Z0P;xu(#a?vDWT2wfZU3OC)V$M zZ>4NMfKL3*cYot$#Q8Gfd`X~w&IIb7tvh%7PFuY<676vZ-xfGC95ifX)wF>@op|^* zSqqsFs=#FFHma27g)*cK!0B|yjIM#q88=FWIbXgasLRKAFQ;*+ie;Hf9jIDpt z1nPhN#gOr{G-TX6#ru;F7588y=OoV^*5q6gXXp{p;h;XXr9Q7wRICJXz7JHHZTK;cW`|B7 zEQVTiZy0@uIbXc-xm?{S<#TYO2drBi11{3^NOw@nq6HIvUcnt;AB}(;9=R zrMyAr>I=E9j6Zpg>_q5c4?-H#2hj{hf4hP3ptZq3(8(LQ6y0ewm~eCxdSIj_4SEY# zyRZ{D7AA9V_3&??R!c*OM!&#KL$$TB3iHDBz7Wnc4Gmjc#*;`HLAFV|!cMo;>vLu^ zSX?IPhWL;%HC+O{v}yD{b{p0U4_uDrKFG5*_~|8hrfnjarL4dQ>N&I7a#&5Uh+POiQa`5qu~)l9T~eS8}ZIvJ3@@+;tzk=%f>@% z%v{i(3{)d%5=@XAAh+VZDQfU`SZI*TL_qF7{PoX%`42w3sACbVI$CX`dSqTl5|>Zk zeYNrh$eh+OUkSc+*yMKU!1f+H3N75-=fEVdjjfxGav`|*2#CVwwN9V--n*#=ic+LA z^7Rd^+r8u7A-y+y$KQ{=<9nCXt6%ROkF_0levH2zbnHi9W_$QIe*&0=FTNT;1BzQD zwR?-^j98R0NOf>IF7kecT?@1;Xuk!6<%Z>H&Oy9DsBSiDfY5#dvycThZSZbwOaxXY z*qsNP4h)mk*FuZ!R$X`Jh|60s=XD)@^%%)^@5lC}IcMCMbDo1;q!5_5T>vJXf^LE! zATVDJ)=#kLgF#rVG4_C`@1WY^)dNk^!o_z8Z|l|RT%j1q)24l*HETYh%XXO- zSExLlv70S-FaU$D-65@X@EH}+sA|rkAIMl(mRYxI_r}(cL1Dz{q79Qc?NDG^wYCc* z-;*6%{lqjG0bH@u7BZ6DgZP-t!6Lo_|83CYP}%GlW;W_nH2`jz(2xmY6a}-xCzipF z62V@-d-Y+6^JuHT^K<*{1R;C`-Sn5{{_{8YcVI&v+Pe~NCA(=_Ay^YyS^?!eCk&9N zxEKp?+howm2W;Lb%OGP7FbB4r(HykviD13Hrzo?mhWK@aTer2#1ist?`It%{sf+IX zb8Z`TDEHof{o%WRZ(lss+J~S!JMX9s&>9A68*Aip-oVr(1jSv|bRJ=vG`3@22SE#8 zqETF1rDzI#Fl*KxHOYJ87CibOk}k-dAJ*W;keN`7c9@{%)Ap8UPh~QEO(#b?qt5|V zDB?H@c-N>Q3W`=uT!A-c&BM7yapQ~SIVO4-(Z*;H{AlJuReMZNI2ZSer+FaApa!{L zF_YEIwnjs)Qa(Bye9wki140zR!d?wsgpr046e^R}hwn{}@r6T8NR{E?3w>D{>P&~A z_in8^VnX~#>~l1I$3#8R`54Bb|Gv zJ$^#rlTUC3IxT^*X;SWjU9QhH&=j3w&V77HT194D6ZBjRY3-wTgc#}?)eBfd9KSGj zXmb*TcpbBx>2zknh(|;xa!Q+9awpEHwd&A%{8Euh^ZU;pZB-aL1@+a|%4W6C0L^*t zWOyqYwCxx)p~2op3Grwk8TF=<5ST`EHdb6Z=d4W!t?N^iBhUko?m zGgCSuI&ULFT11_L&;t}PVrK&0Nc{-Fj&|G#sWj9=LctXGaZVFXU5K_Dbi_--6c{mK z35?^n?Q~x{sr9pkkHXsJ-1gj?>qK`k7yxb=6n__PDX;R6zxn#x_wQc4ep`>=%J+VL zPju(xM-HG5fBk2_d?g`5VnrABhFWR$!+T}-spoRgx5+X)3-^o|5yG&U61tYs<{?vMQ$XIb|-IArOt-9{uZw(k%hW3LS!ImE_1HB_T4jbqJVQBCwyXX zXBwK=U;t*%xP&dMOp+gK>iT!Kkr$cd&rBxilqP{}$HFnSPyxy^soqE@sSL4GtF>4L z?^4t@X^x5+DYosxu7G?x1o<8$wfMjb#2sNXB<_24BSX|OCK0pRL=>+_tn)QLStCkSdJ$Vf~EUq9FLEUG)Q754Ne3W!EIP7C@9gsA$hM?PacpVr|^;Au+=`c!H zmipPlY}zgcF_OSbSS@Q?cwISUNqe72KSQ^>?8gGE_PKueRP|&jj~sr);|vws=-RH5 z+KyzZh9DOk)pE#c4V7h2C=+3ZWz1aW-&=t3s~1>W~}@4S;A!i9)y`Sud4TGnXP7 znp}p99f7MoC&^;ca9Mrv7zGZ<$wI2bq59J3p(*aywMp_|Vp2dy z578MwrLA^01{_O)^QO)H_Orip63=bjf5Cgsuc{vVx$phto(z3!H=%DIA*zREmu|!y za}Mtp&coEYOY=rG3`o}Lr@6;o$nRX{$Fu_uG6OIs=wo3QRMEB`o_exHwIT=#x%PsYyEP3-(f8T@u)CyI!{zGm;u zdP!2$*(5;wtv(hS_JO#kwi{hh#(k(RlXi)tXIxjsnLR)NZ(EkM6RQ%b*D5`!UmYTn z-dhAAJ)PRBcH6E(CN|G?*2?QbK|Z=k6VxPGTUE};;F`ir%%_()g|N>nKP`~+jR-%T zZFoNdRxlwdXa{tB{gAS;>Zo#L8))?G&_A8d{nRbA;uqhwn8V)NubJzQg5d7^2%nUd zj2l_WbBL+#tswk4(D|i_gffDpEu6d=4_>Z0(KqE<+owk<%A6(v*7uP!Y$)1w-9@(s zk?v*COi$M{qXn3KQ)=rd+l)x*^j?}R8m-N9R=4bD=x=IU-}{pIa%cV7Wi37Y+dl!l z0wHb}EfqpebtJrLZ&NqxXx`g7baYIMIWM5m3af@{U<~bh^r911>Zwrm%_WB?N*l*T zR2fWST{he+bRsPWM%yK}1%ZckJLbMOA>@(Z_wD=F*Ch1jjJo$@dorw)Zo*1G!tzME zmb=C5XYGn3=^#~`Zm1WmNk2PM#-gd=h?iZcOQJTEV!G7Q?W~2J`Ak6iQa7P2rkZR` zSC-c5GiTc_XiADZ7$J-O?A!7PqtiJrP1PQ~cN9D6tIs)XdN7aak=Tw1%Ai8Svz*4YI}mi z=tsI79=W1IMc_!_Th!$DY9w$jT8ucpZHqCQndo7Lz&d`}Pa~)p;q0Q*CpA9ZYi}co z1Dy<9cLsDUkx_*v(ZacYent+qCV zO&@?ndcrK#gr{pMU5{x7l3@@gr0(W6k8j7whp*)6(R6_eY(~XG_1#AiNm8b=ErR=Ov`poUM46n<;cYz z@)#;}U8zBbwFpe;Bm~z3_8^GM-D^t5!+(e!Lus>(gD6?&X1jM4qvKuMoNa8N!E09E zO#MnWu0CUi@{ql_pXgh%dKHh^IQA-C=;sG0K z=bv-yz4^-CfBEZ5>&Z*+SaT?HCECDcx6Nj(dm$n0xOU?{kB=0G*tXdL$%GyMb;E!5 zR9>@kMN$ZMysMds(v3Jb8w0Ivdn`4c1@km~l7gI)DaMbi)YtO*`rVh0)Hrv3a*vw+gpS(}n*JaD`lA~+ zu_%%s_eoA9o0THo?y{#<;mMg^XAJ6Cm8J`tm#(|*%4OP!1l@25b~|55F9*H#$>>(j z8Uq2JGp$>SDw;91!FJ2W^VGP#0)E`b-XjIreV^TvG90>*;XH?bYNMn7HA}`wBz2~+_+;OB&L>nF-up8)Nk1CRT|D0PH`j__Z>pyz?#QRK_5xpr)i*Bg=P6B5(51dH~ z$Ro+{!7>;?N5iF>;ACFvwX&a{un5edU6fm(kD%2U3^(oCx%!gP+SQ%*G8ilkV)c!y zQNQibejgljZ{Xx@x8=@1=jMI>{=3(aul!4U`!?S^bt#?Lk^xTMBJe_Vh6;}+Gz1RV zBDtj4hSnyN_Gw*PHEjPpvEmH;yuor{I3EbD^|b>gRGViTA6mr|z4o2g1aO@q4W^V_ zPc&#zUOu~&Ny1=$@Wg$&Y_OwOVv}UUvEG6%j}Lbr%4HpUE8IHpNltHKhFs)fClOic zbi^2?RYjd7becK>p|2#o=q1yKAtGJp85J)M*J`#=0geg<{K!(aV_k0C7cZ~WpTa7#b@pTGDBeEkpq*GCZ?`q%#8 zV+aoY>woZ!jDWvsa40p}(H5Le8Z^$L3G!`V(*({=t)|7< z#J62Ogp-|`z$cYqfRJtEAs$$wZN#pmWv42<(>yH~-8MV#-PXS?=)WU5zkfswxc75= zGM1ZeV!5B=#`;&mo*>k*`B)RK1sGqTFl=je%@sbE zt=%~^_MTH^^$sa;XWbmF`+!auxU#v@cTTD{jqTw-`UxnuJ=7SkUqva&*r^R|9jQXE zYDS?c)%Pl=#lAIbW$T%kzb1S!me-XYo9cjwWR2p|c}DDm{^wXo?^wC!Rz96_Y%gOs zR4cbmw|kT7Z&huOr~Ijs;X}jiCNcNU&+o~^T)s)neGYK>y**(M|M81P?q}I`F;}C& zPC9o$(-kH%4KSI~zI>eFCr8!*T=dL{scFYjR-0#8J1y943dPx}EF&1h->zXQF%Meo zYTg84pFM#Uqr<+A^fEsW|H)?`!7Tq%&2e~Qokh&pDU1YRs-VCH4`RWS>~O5?E>TNo<}@>;VQoF=Zl;9+_j^TputUpCPnMXKvc4M83y&7 zYgt}A2Zf#yI!)@B+xJst59K3u`D!x3642A(^ROYxlYpJp4UBIym3t z+b`Zf9#7r*2|igk@=f9Rb2vIbMR)fTUFKcoy{&c(Xq`zOytz$sAA2+J5wl8njwJ*d zx?oU7Oo0K~0(N|y>amxKEIC;Mm=<4SsMB+yL0jxI@fS zbA)5s;L*36;SQ~g38fD(5;q$nFXpk8GCR6#eV$$nHOxT7Ko(Q)XRC`-8~$jkpzo|> z_b$|5?hQZfz2VsbwUNx`(zNU5Wpg0!aTrFrJuJ)N(2Rbp?@)q!c6!?}GEXU_!B!<$ z=ealL22Dl%n%VQ>vO#TVXQtkG(OhfgmK*@IuneVJk-@!v5x3UhFW!88?9KZxUq6lr zyz_&5G9qx?L?V1A_aBNNmtP!{-$4z8gHW zxw}5Tb$rZnrN>j4yFR+#TBhK=Z}%_FhG%a!6eh$MFv4o|xno?Jo9J=1Nrtqev!eCV zCbD=4={kcL+Nmjx0Ffpel}@6yF5?$&*t!Pwr4~!2&o+z)u%WXb(2d*nIAv-4@Sk1& zy^cf(d=Y2Ngw6j{$pGN0HEv3YFq+mKBkc}M(OI#|kB-q1o;x7go79$Pk;6*2bBK%% z-h2kSb7RM9>p<_bW_owR?L()Z%7_2_vrBV$QV1W|pq?&J*N~36NT--tA8HBB+Xhy2 zokPu+pxYp5VxMlHIac$w<~VDQBh-t>!78g9M~1*n5hZ&rv4IT$2j1*OUjFc3e0KRw zW6UFlr%31=s&%8$y!EzE_0BnVqAA!~o1CKveNv7++Zd2GcHUq+bJf&YKFHSr)u{%I z5o?K`uF&JBZv`xIfC07BrPAf$zx?c%zxV8?ixO=+G8`6=g#q&#qYK8&p<{ZcPUJqe zjRmE-`E1$S_3VKUb4+oY8fS3C*g-Bf<6@Rivq`koA^*wf)ophIKJ!Dan(ckNbEM@F zgcy;Wq1xJ5)qC^wzIsjoCuD9I2PToSSaj6;VW(T_Rj;ra=#l{CKpMYjjxAIw5KJyP z;>|Srhr_3rUFI~)eOeehbsblbB+^e%r;1k_bKRcx0&y9K4V#}+#n8gIG*F2y^;2ieTK@Mx3Bch zKj-$90z>mbjr#bNmV)_k)Owz6e$D`+(8{NGQ%waebu^wdTEtw5qug7q36FkGFfrX) zQqx1u3)zIJW}85X>k`C=!inIQS|GyB*-1@ctq^`9lklba^Yeqh+*_&o$q8p4zgi$S zQ35#FPT>XQLfIKLdtozK$or+5(Mh4C<=Hsf-o9wJW_p=tVC+rs(sMd+IWg-yL_N}`A z-mR{u1Jho;e*5m5^hYRzdq2D%F1p|QuBqIAc-#M-@BYR|x9k+YPgh-w+$C%ic3h~H z5F7_Z4Z*#>2P&{7VFVUeh@TO0Sl6_U;_|H1j|Bi&oM!>e z-v{zp9-B(;%saZpo_-H&|8=+NcIn;w0X{j;m^br``67*dk;eW_rLp(Uv%h(}_x?Gz zh_8J2>bn!j-hchoQ{4#<*4&yrcUY6-J~(h)U8GH}1{c&!-baV+-p`R~Btvh%$7p+2pC)f4X( z)QLqo=MF@gplji3$c@%En}DkX&1m!zJ%{vAXX3R%9?`fUOfA+%AE7NV zi0ga0D)n_r$JmNhlG$i;TR??=c&~r{`_sSUCiwhP*{Rg$>gai(yl;nE%d!U8Xd8vJ z8KJ#t;ueq8USnv;hF8VbmN-dG$Cx(P>4{6vTtj{AneOR&bjYd&y%?(Kh)&p1ofde6 zx6{#k%hqnz$zS}@8S#~Ub9+SG`|oE%$^VvsmK0W-m zpFKZVgLoPKJgU&OsbjIWh&~ff7u%Wt&bq?Na!GW*{0FY;jSh-) zWO6sot#r~RojKV;25&=9sUVN97(le!rs18%z_%^oAMNdbl=fGi*x&E{2%p^F`DTBA z4zk9*_xDdZXO+>*rdcJ3KwV=6QxQapNV1%nxYIJIk#N%%24g+j0{1t^LawTkNRe(% z@CAI1A>HOKQ`8Tlz`nwB?5%Cic6QE9d!vj=d%{)4FJi`*)AD6p@OWH+b6se{tiNP= z=?Mo*l4u=qi!~~DTiSc;Zo!yKN%?B!G^VV^akQOzf(aGx2wbsRyrLMicZUvlsWA97& z^096oQKP83ZUj8+8lui_TX6n($DHX269_EJ&u%Kah|oSK^da^xygJZ~WPd^vNxK9w!k^qt&*zw#YWC z48N39)B#}kJv9V=ISo+H_tH9mLRnujFU^nnTwZz}Cp7L$hV1%!5aDx-2p0Hi2!aMJUuI#gk5-Wwc99L7guiR#Mtx^66%0 z*~9S$>)@?aavKw zZpU(pSf}*es<$d@K2AHQFUh?J0o+Or_*W}IMiNQ}83us{{w&}DZr-D6`i5R@tg=M6 z=@6eR2BC@O#DUnCyFC1lpItMhbWFAJc@`)4)psNtCq71J%^HVd)M=2?+eEsB_0ha6 z`W&7$olrAleq_89m&SI6=Ym|nO@u$x>fKglhohS2+~mo946TR%>7wTC-otjIu{ZLr zSe8>Xi|v_7Mmg(XzAcx!(i~na^Q1Oi1s8Ed$3WI{A{3g3u)dEClYvw@J1KrB()S!& ztJkIsl0mxwFnRc&uS3L^1dvd}kkXs&J~t0))w(#DZn0cLZV@f_{yDe8=6v_+$2Quh#Hxf0 z3k0m-uDSFCojm)j#dG22ys0O2XgGA+k-!`9=%;P2rn|2d;KbDKrR0t=RU-HHXiL*hUjE zGB&~|KYFq4yKi*}O=KZmc<%-FkD-LDkY4190R7DEsrHRASLz4y;~VjqT}@cq~C&{X{5y?yai zSJ9SovqG?>)U1VEsbj?O1SaDI^wDO5qCR~#8oh9PBv3(j>!-S;s?7#7Nk?^x`m9&P zJZlG%iyA~IyZezYhesmoPemrt;9EK2_e#-5J$5qnIs57e8%|;f5osslkkNOojs*tC6|I zS!V~G3rP)jCF`Mp`CZV;P^#+5?I1^$b8j;Q*1-e}!~8a3Qa()G)j68%Y@tp=o1VmU zJq_3R-_!-TH>cwT8}gjkkb48#UwH99DKGvb2=4r3azr1$QcJOB8+YO0kr>DhOkrSt zO_8|;ZJj?6jx1*rbygb?CsP9-l67u%6WC~B|(h!KkL0V zBFybkYv}ur_TCo27f0ex;7DA+A=uch&?v(#n1eW2k2lr@z5*g~W})3IGb)7zinxs? z+zH3@U96)hz`&+rBCC3dsbIik%g9Zw&7&tL15XHWHWCMV^xInL-aqH&rT)&B_U`LH zdixY?z-0t@>g4zzENUm07R@8lrh*YpGJLQM1`phD974vjkd(XfGNElp^jsI^7N`KU z8jm1?J%Fn(8LeGC6E93M!~`@Atd;(x4H3UfnzofV@A=Jz?0OnZ9J+c$+ z9hlQLyE-bfGhEb72()r2aiRO!XvTD>(c~!3$&T@emNahY6IfhfMwV?d_jcQxzxU6% zy(_k5%FlcfwLO8cB<|on_yqi0tKZ-wAH2;Zyp)_^xA+`iEcC*x>H}? zo%@{7WGH@lJpAw1#Y%e}fwL-Nf;PJe%m~$4y1FyVYLgB(OYk! z(Hc};bx>XfQ~=AYjug}=2N8%JKMeQhm3{EQ_uZ0PKKvi}6+-xUxCNeQ)5ZhyNdO(J z&wcj)&EB6bYjz}CVwf3?YPC@`QcV-oH0c>o7VaM5Lp@BIxqC!ZL8@CQ190!{mYz$Z z22vwQ&GS6ZdJft8vTk?PcTP#NzKQyP>hljsBr^Aj9XrB(`5G`1_lawIZCKm@hm}JP zsa6k+maWFrdr=yf-yIZJb>zU`hyn`F?d{##*QKW;lu=+G1M=^u|H5M+D1%ll+2`O^ z>52}&K|^RL+X)w@!F?X*&=Rwumoi3(9A&wkYqJ_}xfdvp%bW_35ynVc<(^a!F(wtb z=6qpCwo}QKQ~c9^@xft$_I5X_x0$;3jJtEyW#upgE63v5x*SRKsq?5(Ldc9rh?qn> zfC3z|ji`rKUhdSw!$mpPT6v=ZS2jq|OO6c&`lGSNxc=$ic>r`_J6CW#(!Hl2048#W z49mM>KunJ27v%cJ@QgPGF%MC8=-jl8cpaUWdd$p~m0%&l5O)l)kCtw>*Waq_?#7Y0^++_9Y}WPT0XG#O32`#>6w?0ajg%Ydo_fcrOFmmjI@@7mTeHb8NV5YlMILFFzu5IZ5XO+&ry8b7I$MugFV; zEY7q#g63g$t!h2F{iNjtzzXCg6;4^&wlOl7EsnFz_sj$selMsln+IlBdoV=!OLB*w z&Hmily!dgR3*T?P|N1i={~oF}JSb%Mp5nvQXD=CEth1Qe{#-p#^PQR(oU`F6Xb*@ zfEkp7T7CfP_C!M!b~<}sxDKYb%!CsSuH@tDBvNaD?9OosYqX%vDZC$ zWDN>$5UW1@SFo`d&d_G&Rwsx&#HB5U9UC2OFd1D69(+_w&{{Oz zHsTAfI1hOQ@m^Vb?ck|60&0uvxpFVhMZDc^7#JbJ*Q?jiGbU(bd3DS&E0bE5jiy?I z-_(n*ew^oF;$P(tzy9Z7{JRbNv^7I}Hcd>2X;Ct+-oc|fBw1GVJlZ!RC=1$CM$qp} z{Izutf$SJHW21?A5V?Tv19s!&YG3KoB6;0$e1Tr2WHOc}uRm2`yqY)ubEmQYG)3o+ zNn(L#LU4I0u!^Si?uik$sjBbk9K8oU$i8mPz{1#f>>B4%X>3@xncmv$am`Q^`Weg6 z{g8p`M0{FR>in-(VLO5&Tq$nKqp1lH*NtaHNBc3&C1ohB6$tv@#(*p?1y>lR)_AI64di-GM zWOi%VpSqH$eG$HnS%7kyjevK|lORAX7b2NZJ2aTy9qoZGrFR>+5MyGup(;C@z@uve zWVjtpH$9Jy*uEH3$DOw0!9c|B9-`{m=hMIYsJQZgtBF6m_C1dy4AY*`y4JOv3RuZ8 z?$35wn0gSdOYObS*}6a_24Z1=YP^(hq3l9bE{ME(z5A}Yu0`C2_TH&rDmrpwSrd#_OIgGCO0OPJ zmdqQw(2Jg0k6F~XS^^)@zIMUfA^0|wz*~xYA)Hx#uB;1^$Pt;@U4E#UA)TO4|E?7Hk-|ir{`w^s_ld zFHCoH2@aX+wi%RMAiC=IJ^9mr`_ZBGjT4HF*M~(M6Y)Lw%yMlRC{U@^9!=wb%-~b@ zawb*cExA;0HMB;hyQv4l0Z#_wF7mnWc3ZLL&avkls#}Z=Bo5ohbbb2wA4>f}K<9k% zk+aX~&f`7jqHfeh1Qz2FrmmT;*4E60G@yEDHjY&gXe~oPuG?GAUiDzyq``?wJyR7G z+OAdbqMAfj8lbtjeEJU_D25&g&$GSQ(M^E-Q;gh^4j?5!erkg1qblcSNWdf1&$(dj z9EG4tbDeu-2Jg&=SP5iN=Q(2_t7wrWn}B{BH1PHv$D z+_69&<@9Fz^xwf#3>C!6l&A}8A}@w_qRE+QLo{NMKKy&(`P^VG%e{eYrfHAS#u%5^ z5Z^TXnBiDVuTD-^HR`_0hl%4#d~kX zuDS%bb1`>eKewKTpD^Jz1KBDf8dL+UAK$V zVAZGp-sjl0I}G~$xRtRJ@$nN;H88oAVUON3@5Ay7$QLFj_~Er8mM$Fm1Y2Ppx6c}? z3-c7=F|nxXxyGCqgx}eQZu}v0&{%u>4Yg1I{Rg5`GzRPKN5sz=O05e*feZxt8dQC< z2`v0*#L4q9SKddI7K5;*)9yGD^UOYhU2@5!TTRGG!Nd1~=bf~D?GyL#fT44tIsWuN zc(i%jyVh;^%om84bF0pA(EtU@5wkNclq!$ui*3s5#X%COrME=anr&eFT?43eCZLwF z+j65%L+$EDtg>NaPj|zA2T&IGtxx~MuYUQPFRjz_;VDCo(pX16D}3i&1JjpNm4krm z=(@13yFI0qmSC9{%?BjZpz;M83|;~KR2|Ut$#{=>(2nuF@HY&a-Eb!K%~SdK40=|F zyc$h?u7tn&{%Z(CvVQZ%iTl+n_ipllJtYs=PtO8=4~61Km~(?Cdb53sEdrPcPA0EQ zH`62$g*8DjxXbK33~t3hUM@a%msKC$XC|$IUMLFwn>Uw&e}c~s#Q!O zYc&dgusxXXd{D>M8M`|U1@2_1l1wL`&2}Emvg}dtzkwG*F0#kC8DDbSK&i>O*A%$_ z!v?46LT$<*COK`|`AnF7@p#~QsQb->82-H3UcG2P*Ufg;SwPd=<~-KyIwlyNE2_gf zCKYIZ5-iFYHOvbU<0QD^N?W&fPbww zYOq&pi=QJ^^KbH-$DR5$A};pV`Q3N*;>s4h>UR8hZ3-%!rL63yLbccB? z&aR7;M_zL-VB&K-+MQcI>rRKQz;^g~5d6Ym4Q56T4gCE4re`8JeUq~#){K1LQv-_l zJt+4OfK7DjtU90mM_>K&U-{x@&7;F?`6{wb;P{!mHVwn%gsLkRex8`8ks)ybvOpm} zRw6hzXpOt_wD(=wPBwSb!UR*$yBT8H`9_Vxh-S_@#Q1rm#+v#}XMFV_^!XFOdHd`9 z?(a7L*Y(%;p6}i`Hotfg-~9yU(i^;*b-`K8lE0T&y6b@uG!F(QXo+F} z4!E5r{7kerAOXOC_eNYCvYz7}rM{Qfq`7H%`1XxX79u2@p!iXqAT3s~Vb01cEc(U- zYQQV#%O5BR>V|(Hp;k@ir zm>=$4de*uG_(7^@pOGCsD^SZfWL$UL%=5fOUOfPR9>#t1{U2VYZ{o>cym;>=mi>a( zA19XK7ykZ7$;)Ay|M8D-n;xCZeb}8sU4YMJ2Q<&AN^VG#>k6TV$ff!6@``cUOT2GF zF|%$QJ;zCv4b?#c_q&S+%{Vp_W2#+CPYAb7a7+pu;9dI6pm{a#;`x01=KF`?>38S8 zDI#CIaPQ`&(NkX9UxK0a#|`?Ezd<4Epc8g5ZEU}!27GlS>Qv8?SaZsP`1n#{qRIno z3-B`Z7#jHSioFyBStSS`?=B_VR=HX+au}sa^D3~5J6i5_e&7f5IX~sq?qAOeqdzRf zzpj7!!}czsRXCxV6j3NUqdyBc%m#w433kSfe0 zF?ukV?OcqoSAv(c)>xb6@>4>e{9?dz_eaQ4p#+@>@_;Q%wuS8}fY@@LQMOl85%==B z7GjTK(GYMr1Hee6je&hx>zs|ms;Q^u3QQ`-JSgpa>t$(hM&|MiUJc%H9k}4Vfp1>R z;d$OC-{(DF|L(89|Ml1TyWjohO}q8#)qD4f7*AKk_(|Js>4l$g`3{sP za8XF|p4kc}o(_UL3e-Wg*0vj?P?^!GA~|siQ=WU8R+J{sCAtxcA#y<>;^Bvu6vWo% zaO|nADm---fBK(%_2rMVu}tPdCXO8ZA`b=9zwiTmyme} z>=)f5QH_QzVmpdfyO(=z{Jg#pX@K{~3A4dFDw+4WaN~ZqBYrgj?rER?hQe{mwC(Ul3{J{|JAk# z&t?CMALr?n{_Ed-|MfpR(ccyNHJrE%y3%mD2!T(7S;X>f)IAvxCgd%6cl?D;@Y;)8U=-n=yira2^?aZ;py_?Rx@A_!{@*jNhJ0HC% z--_M=Ip_>?3`6zqb{I-hwOB2{3lhL9uH*@+$0C&d~4dBer=Y(cak}n zMb0)^GCjD)fC5j}kfJr^Sq%DWSN*3=^3@;Q`G0yQ^6EAGxcEOV{*R0Q>Qk3ZSTmzby<5rbz;^&H@(O#& zlL{UGz&BhyYlVoJD=2tlM2w{CNMLyO&wX)_&Hs;!|J!@tQHZ>H4d1=^>FMJC;8%SF zN`C}Oe_Z^34kN_>=~rL=qOyeZ3pGz}H5~%CoFdUkJ$D_0dwIh!71lHG<^_$MQ)v}A zCfkS1qemQTO|wU&@+xDr#|gnhg^(coE2gH(vmF2n!K z7#v6cvzF$?i}+_7UcUNj_&MKHA1&&~P4#EGsa_qK^fOOzTDD1LZ#NS}HfvAc5k@3= z_K9kkgqS$>QJA2WYRnde3sLksz#g}qI(9Kn*QVJ8m$ii3&n~G!Tbf+_o;m4qslpMV zhurCJ69M$c=usU#71&aWajM2ZZ24807T$a9vBxN#i+%T4Yx*O7!7ogH3gpFOO|tI{ zvQ-;2^4lhw)4(nTqjDT}v9n^X8syNdv7&yWIM1B@pE_Un*`wvftM}&4fADqx;LiX2 z?_c1~|H$qB$nE|p<9_O8+^a9yk30Woapz|oL4+_+MNSJSj<*$nV&M+LmU4EinN6&pJ$EEt09&D zufvPy3;)GS_c4e58Qcy(RXF<9$MMJQ@a1oZpMX=yr~lcH07(-sz#ou-<9-_A%$RM{{|Z_FJ>; z)V&1}$+JH2#jfj5d-WfF`?tUSY@h#ZsQ2P!`?HNpUwwFdoMk`CS@!CrijUxoA0as7 z)#B=(nb!Lq2nk=BBTNZF)$3FZIHUU3c^pD4VHx1q%weN(%W%QHT5a;UGn+;t;KJRV zvTCZB!F&o_9c!Z)MYt*wzDp-Dh8%^cvJ#_l-WHVO$LLGvl2c9vGww41ajuL@FfWnK zz{%)v4Y-{wLL*S-3-399g_8ryU@4@RO5qHrYg zP-Av>3lo*|NaYCb7)VdrtOK5FLDmbdXbwzwjdBFOPc`ETLa%hwp$ku;QOpw`;98b0 z=V^nyI=brloB#g&@b&M$`}T)72@S7aw?CWt4}8X5u6K~fJib?tu8lDFvfR=~rh83Z zw<0*<$~OcdmW|YjNAf`&+r2E!g?DWCwP1oJz91C{=S^_)>s=VSE<5dK!FDG3Ia1-( zkMlgI*nj=oeZKqs9(j9;)I}s$isyqkD2_{~5TTG1iQUV|C`XnoDE*cJ!ZD!(^2Inq z)7H2LRW9$lsn=!d;E+2&>%T)+uwkG{QL^X8Z<~c=y|D52s;7^u{x9>YUoyLo4Q-w& zMAy8~i{5cVVxJmG%(mCVeq)3z>oczo*eAQSY(-r<<%}r5;zV4~?#yP`NWk+x=4eUd zGC{=5M5HF)ne1xM#-A^Koae^veE;?Dft&o{+rN76#rEbn9*39jBrW(GZ>Uvm1nG!_ zEI~4$^e1mMu-qK*0GuY5C`*edWvR3!(^$JPK%F*e>W~(`z4q-E@dKaZJY<&bu`hT1 znHqe+oTLTq4R9%&aBW$4;~`Y8Uy<&bQKU`ee$3B9Mb-a$AJ#7^NQ;fC%F3{n0N1qAj|BxEYZ_gC_9D2UbyvWW0aEv&q z4bXABlc?^a&_+xjUb>K36E4HXVSQvX?y_-q7KUq%QY=}Ml;`EiyJ4Gt>v3KlyVDB# z{@m7ZPVM5u_l?-(#gFs!O8?P5_nY4yRCT{Q-~I5-dGERycf_Tdiv}@%fJo~*7QCln z!5}F252-}9DwMWUXA6mNMFQ!%b60F1- z_q-|X`1hsVt1sSq$GpRbKm$cVm-r|TLqMg1 zC503%qp^g`@~CT2AQK`k62s>?yN=|{WjU6sbKV0hlc>Y{ty|`6V}YOc$-ngnIV*pH zcmC=HeE0sBr~Ci!otyU)0M~!cSpQFzr2OiR`vU;@^5&t@8(w1Q*QN#W5>rF`n@@{fUV#6noWdMpGFdg=$XY9 zG;;5u3+MNaI_I)l5k;oBvXvMDYQ1yApm;B;Rn9#qS{~FL_!8?>z9U7Q^$L6CJ-o7z zO8nfxy!vsT-s!*kt8ahz-rHO;puLEM-LxW|z9w>=iAFH_^J#;!WdvF5WrMbSmvhxwUQ2Yvo##dibym5r|bJ)5*?;0&9L*d^w23#&CLLez~PhH3Qkj!y> z{i)B?w!sm@>7w>J(TSYd%~4GpW;A8x+3UjRO4q(e;Tp;C2=h}L^C{Jou{9x`yn789 z!!$!7wM@&=8A+?6&SF41M0ZN2%NBkA zTvJWV(?>sjsQi25wSV}fE4QREuZ8Ivcf*rKn;JRao38q~akt@1OHNcgy6kbtR*zEN zR#fdnuJ40zX1_=8J~uS_Oxt0RU~{fg2PPvFA#5_lC!f>fSv-KCIo0&VN6tQ{I}fPz zi@I?b(iZn4OkFcwt*x1Bcyt}G5{^|+>GUBe`1h8xSDmF7Y3qkbJyW$Y@2yoBI!_`i z4Ulghjw3MyKBj-iM;$=Wtd1M5i1R&9``$hPqm+Y^Zx^FW(0ykg>;>b9^ey zm&JPd;jxV72%289vI3I=>eFk?RR)>nx@VJ3-XjQ8h&lF*WtTQr?a9JAyr+HoUw-u< z3aw*2O7Wxc&hF^+jX(c!;0GP(k$c3@V3~RZeR)fGQ`1&UkFqguOhe{8$1;nIt0vr1 zh>S*tEc`4Rkz$&bu&TI$>*^T+dGX^s>nVYNe0KJH@2Z@6FKE#hgn5ZktPuIGvn(eq zbhJ9o<(Y9hJ%ij&+yxouLAM6>H5(kWZ{hks-gTL`iI3Py)BzmGpxDzDIS{0kGi^F5 z@pm)H9%YAJzjp%!2w%C5&cKRpWS$|HQ67O+j{T;0huyH@0%`6Ic3J7fD`*pH5;sV7 zZOjsn38T!nS(x$wNTX`=TT^N_Gn|<2z8PY*m zCZlLuJIvwJ+I3OS@Pb5wX3Xv20^IUhclx2~?Lt1Oc2T6V899>UCu-@YnPcC%$=MR- zwdDJr8px5~gK`gnRREnjtIjhw@OR&S|NS@hoAdP_k^}Ic-dF&LWqS)kUooCd(&uRl2vT-5ET4FLn6N9g+7=Ff(3$K8SXxqDK47|KD?>Zx- z$C&qC0c7N888CH~J7T(__PKB{B7p+h4hp`zaQUR{)qc|yfsXHxmwx#6PuFU%UcGmA zojgtbF~^W>H$K} zhxwklqEec46U&{*)r7l94RwOAR3*rnyF&ES|N5(+0BPZaL-EBq6drO*ZJf3D0zA;E z={cb1W}6&g<00mnham2UsToP=UNllR2?@Mfh~)0L#Q;20!shb2pc^I63ddUHx1X`>}4Vq%TT^muD8|~{Cl$V z&|!I3t$8tbJ`)agJNI#FuYo#Z9p2G~J@UvQ83@UMLMl`yTC(Xob0Ox}CaREIF=*c`2bFaAn5T

ckp4}T9lW4y4)BpCXU;b-f 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 + + + +

Get started using Preact and Vite!

+ +## Getting Started + +- `yarn dev` - Starts a dev server at http://localhost:5173/ + +- `yarn build` - Builds for production, emitting to `dist/` + +- `yarn preview` - Starts a server at http://localhost:4173/ to test production build locally diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..170c101 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,17 @@ + + + + + + + + + + Vite + Preact + + + +
+ + + diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..75419b2 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,31 @@ +{ + "private": true, + "type": "module", + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview" + }, + "dependencies": { + "@babel/core": "^8.0.1", + "@base-ui/react": "^1.6.0", + "@emotion/react": "^11.14.0", + "@emotion/styled": "^11.14.1", + "@fontsource/roboto": "^5.2.10", + "@mui/icons-material": "^9.1.1", + "@mui/material": "^9.1.2", + "axios": "^1.18.1", + "preact": "^10.26.9" + }, + "devDependencies": { + "@preact/preset-vite": "^2.10.2", + "eslint": "^10.5.0", + "eslint-config-preact": "^2.0.0", + "typescript": "^6.0.3", + "vite": "^7.0.4" + }, + "eslintConfig": { + "extends": "preact" + }, + "packageManager": "yarn@4.17.0" +} diff --git a/frontend/public/vite.svg b/frontend/public/vite.svg new file mode 100644 index 0000000..ffcb6bc --- /dev/null +++ b/frontend/public/vite.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/frontend/src/assets/preact.svg b/frontend/src/assets/preact.svg new file mode 100644 index 0000000..f34e939 --- /dev/null +++ b/frontend/src/assets/preact.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/frontend/src/components/detail.tsx b/frontend/src/components/detail.tsx new file mode 100644 index 0000000..4cdcbbf --- /dev/null +++ b/frontend/src/components/detail.tsx @@ -0,0 +1,137 @@ +import Box from "@mui/material/Box"; +import Modal from "@mui/material/Modal"; +import { forwardRef, useEffect, useState } from "react"; +import { SolicitorInfo } from "../models/solicitorSummary"; +import getSolicitor from "../functions/getSolicitor"; +import Card from "@mui/material/Card"; +import { Grid, Rating, Typography } from "@mui/material"; + +interface ClosedProps { + open : false; +} + +interface OpenProps { + open : true; + id : string; +} + +export type DetailInfo = OpenProps | ClosedProps; +type DetailProps = DetailInfo & { onClose : (error? : string) => void }; + + +export default function Detail(props : DetailProps) { + const [data, setData] = useState('loading'); + + const handleResult = (result : SolicitorInfo | undefined) => { + console.log(data, props, result); + if (data == 'loading' && props.open && props.id == result?.id) { + setData(result); + } else if (!result) { + handleClose('An error occurred loading the solicitor'); + } + } + + const handleClose = (error? : string) => { + props.onClose(error); + setData('loading'); + } + + useEffect(() => { + if (props.open && data == 'loading') { + getSolicitor(props.id) + .then(result => { console.log(result); handleResult(result); }); + } + }, [props.open]); + + useEffect(() => {}, [data]) + + return ( + handleClose()} + > + + + + ); +} + +const style = { + position: 'absolute', + top: '50%', + left: '50%', + transform: 'translate(-50%, -50%)', + width: 800, + maxWidth: '60%', + maxHeight: '80%', + bgcolor: 'background.default', + overflow: 'scroll', + p: 4, +}; + +const DetailDisplay = forwardRef((props : {data : SolicitorInfo | 'loading'}) => { + console.log(props.data); + useEffect(() => {console.log(props.data);}, [props.data]); + + if (props.data === 'loading') { + return Nope; + } else { + return ( + + {props.data.name} + {props.data.shortDescription} + {props.data.ratings && + (<> +
+ Ratings + + {props.data.ratings.map(rating => ( + + + {rating.provider} + + + + ))} + + ) + } + {props.data.locations && + (<> +
+ Offices + + {props.data.locations.map(office => ( + + + {office.address.split('\n').map(line => ({line}))} + {office.phone && <>
tel: {office.phone}} + {office.ratings && office.ratings.map(rating => + (<> + {rating.provider} + + ) + )} + + + ))} + + ) + } + + + ); + } +}); \ No newline at end of file diff --git a/frontend/src/components/header.tsx b/frontend/src/components/header.tsx new file mode 100644 index 0000000..41cd118 --- /dev/null +++ b/frontend/src/components/header.tsx @@ -0,0 +1,42 @@ +import DarkMode from "@mui/icons-material/DarkMode"; +import LightMode from "@mui/icons-material/LightMode"; +import { AppBar, IconButton, Toolbar, Tooltip, Typography } from "@mui/material"; +import { Theme } from "@mui/material/styles"; + +export interface ThemeWrapper { + theme : Theme, + value : 'dark' | 'light'; +} + +interface HeaderProps { + theme : ThemeWrapper; + toggleTheme : () => void; +} + +export default function Header(props : HeaderProps) { + return ( + + + + Conveyancing Search + + + + { + props.theme.value === 'dark' + ? + : + } + + + + + ); +} \ No newline at end of file diff --git a/frontend/src/components/numberField.tsx b/frontend/src/components/numberField.tsx new file mode 100644 index 0000000..75794f9 --- /dev/null +++ b/frontend/src/components/numberField.tsx @@ -0,0 +1,114 @@ +import * as React from 'react'; +import { NumberField as BaseNumberField } from '@base-ui/react/number-field'; +import IconButton from '@mui/material/IconButton'; +import FormControl from '@mui/material/FormControl'; +import FormHelperText from '@mui/material/FormHelperText'; +import OutlinedInput from '@mui/material/OutlinedInput'; +import InputAdornment from '@mui/material/InputAdornment'; +import InputLabel from '@mui/material/InputLabel'; +import KeyboardArrowUpIcon from '@mui/icons-material/KeyboardArrowUp'; +import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown'; + +/** + * This component is a placeholder for FormControl to correctly set the shrink label state on SSR. + */ +function SSRInitialFilled(_: BaseNumberField.Root.Props) { + return null; +} +SSRInitialFilled.muiName = 'Input'; + +export default function NumberField({ + id: idProp, + label, + error, + size = 'medium', + ...other +}: BaseNumberField.Root.Props & { + label?: React.ReactNode; + size?: 'small' | 'medium'; + error?: boolean; +}) { + let id = React.useId(); + if (idProp) { + id = idProp; + } + return ( + ( + + {props.children} + + )} + > + + {label} + ( + + } + > + + + + } + > + + + + } + sx={{ pr: 0 }} + /> + )} + /> + + Enter value between 10 and 40 + + + ); +} \ No newline at end of file diff --git a/frontend/src/components/result.tsx b/frontend/src/components/result.tsx new file mode 100644 index 0000000..3d1adf3 --- /dev/null +++ b/frontend/src/components/result.tsx @@ -0,0 +1,42 @@ +import ListItemText from "@mui/material/ListItemText"; +import SolicitorSummary from "../models/solicitorSummary"; +import ListItemButton from "@mui/material/ListItemButton"; +import Typography from "@mui/material/Typography"; +import Rating from "@mui/material/Rating"; +import Divider from "@mui/material/Divider"; + +type ResultProps = SolicitorSummary & { last : boolean, onClick: () => void }; + +export default function Result(props : ResultProps) { + return ( + <> + + + + {props.name} + + + + } + secondary={props.shortDescription} + /> + + {props.last || } + + ); +} \ No newline at end of file diff --git a/frontend/src/components/results.tsx b/frontend/src/components/results.tsx new file mode 100644 index 0000000..364e101 --- /dev/null +++ b/frontend/src/components/results.tsx @@ -0,0 +1,38 @@ +import { useEffect, useState } from "preact/hooks"; +import GetSolicitors from "../functions/getSolicitors"; +import Grid from "@mui/material/Grid"; +import Sidebar from "./sidebar"; +import FilterState from "../models/filterState"; +import { default as ResultsType, waitingResults } from "../models/results"; +import ResultsList from "./resultsList"; + +export default function Results() { + const [results, setResults] = useState(waitingResults); + const [filters, setFilters] = useState({cities: [], minRating: 3, resultsPerPage: 20, currentPage: 1, ratingsProvider: 'Solicitors.com', sortBy: 'rating-desc'}); + + useEffect(() => { + if (results.type == 'Waiting') { + GetSolicitors(filters) + .then(result => setResults({type: 'Success', data: result})); + } + }, [results]); + + useEffect(() => { + setResults({type: 'Waiting'}); + }, [filters]); + + return ( + + + + + + + + + ); +} + diff --git a/frontend/src/components/resultsList.tsx b/frontend/src/components/resultsList.tsx new file mode 100644 index 0000000..7b911bb --- /dev/null +++ b/frontend/src/components/resultsList.tsx @@ -0,0 +1,42 @@ +import List from "@mui/material/List"; +import Pagination from "@mui/material/Pagination"; +import FilterState from "../models/filterState"; +import Results from "../models/results"; +import Result from "./result"; +import Detail, { DetailInfo } from "./detail"; +import { useState } from "react"; + +interface ResultsListProps { + results : Results; + filters : FilterState; + setFilters : (state : FilterState) => void; +} + +export default function ResultsList(props : ResultsListProps) { + const [detail, setDetail] = useState({open: false}); + + switch (props.results.type) { + case 'Success': + let data = props.results.data.data; + return ( + <> + + {data.map((r, i) => ( setDetail({open : true, id : r.id})} last={i == data.length - 1} />))} + + setDetail({open: false})} /> + props.setFilters(Object.assign({}, {...props.filters}, {currentPage: page}))} + /> + + ); + case 'Waiting': + return
Waiting...
; + case 'Error': + return
Error...
; + case 'Warning': + return
Warning...
; + } +} \ No newline at end of file diff --git a/frontend/src/components/sidebar.tsx b/frontend/src/components/sidebar.tsx new file mode 100644 index 0000000..5d1264a --- /dev/null +++ b/frontend/src/components/sidebar.tsx @@ -0,0 +1,140 @@ +import { Autocomplete, Box, Divider, Grid, InputLabel, MenuItem, Paper, Rating, Select, SelectChangeEvent, TextField, Typography } from "@mui/material"; +import getCities from "../functions/getCities"; +import FilterState from "../models/filterState"; +import { useEffect, useState } from "react"; +import NumberField from "./numberField"; +import getRatingsProviders from "../functions/getRatingsProviders"; + +interface SidebarProps { + filters : FilterState; + onChange : (filters : FilterState) => void; +} + +function capitalizeFirstLetter(val : string) { + return String(val).charAt(0).toUpperCase() + String(val).slice(1); +} + +export default function Sidebar(props : SidebarProps) { + const [cities, setCities] = useState([]); + const [ratingsProviders, setRatingsProviders] = useState(['Solicitors.com']); + + useEffect(() => { + if (cities.length === 0) { + getCities().then((results) => setCities(results)); + } + }, [cities.length]); + + useEffect(() => { + if (cities.length === 0) { + getRatingsProviders().then((results) => setRatingsProviders(results)); + } + }, [cities.length]); + + return ( + + + Filter Conveyancers + + + Cities + props.onChange(Object.assign({}, {...props.filters}, {cities: value}))} + renderInput={(params) => ( + + )} + /> + + + + + + Min. Rating + props.onChange(Object.assign({}, {...props.filters}, {minRating: value}))} + /> + + + Rating Provider + + + + + + + Results per Page + props.onChange(Object.assign({}, {...props.filters}, {resultsPerPage: value, currentPage: 1}))} + min={10} + max={40} + /> + + + + Sort By + + + + ) +} + +const sortingOptions = [ + { + value: 'rating-desc', + name: 'Rating (descending)' + }, + { + value: 'rating-asc', + name: 'Rating (ascending)' + }, + { + value: 'alphabet-asc', + name: 'Alphabetical (ascending)' + }, + { + value: 'alphabet-desc', + name: 'Alphabetical (descending)' + } +] \ No newline at end of file diff --git a/frontend/src/functions/axios.ts b/frontend/src/functions/axios.ts new file mode 100644 index 0000000..a801971 --- /dev/null +++ b/frontend/src/functions/axios.ts @@ -0,0 +1,7 @@ +import axios from 'axios'; + +const api = axios.create({ + baseURL: import.meta.env.VITE_API_URL +}); + +export default api; \ No newline at end of file diff --git a/frontend/src/functions/getCities.ts b/frontend/src/functions/getCities.ts new file mode 100644 index 0000000..0d1a36e --- /dev/null +++ b/frontend/src/functions/getCities.ts @@ -0,0 +1,6 @@ +import api from "./axios"; + +export default async function GetCiries() { + const response = await api.get('/cities'); + return response.data as string[]; +} \ No newline at end of file diff --git a/frontend/src/functions/getRatingsProviders.ts b/frontend/src/functions/getRatingsProviders.ts new file mode 100644 index 0000000..9efc592 --- /dev/null +++ b/frontend/src/functions/getRatingsProviders.ts @@ -0,0 +1,6 @@ +import api from "./axios"; + +export default async function GetCiries() { + const response = await api.get('/ratingsProviders'); + return response.data as string[]; +} \ No newline at end of file diff --git a/frontend/src/functions/getSolicitor.ts b/frontend/src/functions/getSolicitor.ts new file mode 100644 index 0000000..382843a --- /dev/null +++ b/frontend/src/functions/getSolicitor.ts @@ -0,0 +1,7 @@ +import { SolicitorInfo } from "../models/solicitorSummary"; +import api from "./axios"; + +export default async function GetSolicitor(id : string) : Promise { + const response = await api.get(`/conveyancors/${id}`); + return response.data as SolicitorInfo; +} \ No newline at end of file diff --git a/frontend/src/functions/getSolicitors.ts b/frontend/src/functions/getSolicitors.ts new file mode 100644 index 0000000..c69a5a4 --- /dev/null +++ b/frontend/src/functions/getSolicitors.ts @@ -0,0 +1,22 @@ +import SolicitorSummary from "../models/solicitorSummary"; +import PaginationResponse from "../models/paginationResponse"; +import FilterState from "../models/filterState"; +import api from "./axios"; + +export default async function GetSolicitors(filters : FilterState) { + console.log(api.defaults.baseURL); + var minRating = filters.minRating; + if (minRating == null) { + minRating = 0; + } + + let queryString = `pageSize=${filters.resultsPerPage}&pageNumber=${filters.currentPage}&ratingsProvider=${filters.ratingsProvider}&minRating=${minRating}`; + if (filters.cities.length > 0) { + queryString += '&cities=' + filters.cities.join('&cities='); + } + if (filters.sortBy != null) { + queryString += `&orderingType=${filters.sortBy}`; + } + const response = await api.get(`/conveyancors?${queryString}`); + return response.data as PaginationResponse; +} \ No newline at end of file diff --git a/frontend/src/index.tsx b/frontend/src/index.tsx new file mode 100644 index 0000000..89568a2 --- /dev/null +++ b/frontend/src/index.tsx @@ -0,0 +1,129 @@ +import { render } from 'preact'; +import Button from '@mui/material/Button'; +import AppBar from '@mui/material/AppBar'; +import Toolbar from '@mui/material/Toolbar'; +import IconButton from '@mui/material/IconButton'; +import Typography from '@mui/material/Typography'; +import Container from '@mui/material/Container'; +import { useState } from 'preact/compat'; +import { createTheme, Theme, ThemeProvider } from '@mui/material/styles'; +import DarkMode from '@mui/icons-material/DarkMode'; +import LightMode from '@mui/icons-material/LightMode'; +import { CssBaseline, Tooltip } from '@mui/material'; +import Header, { ThemeWrapper } from './components/header'; +import Results from './components/results'; + +function prefersDarkMode() { + const darkModeMql = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)'); + return darkModeMql && darkModeMql.matches; +} + +const darkTheme = createTheme({ + palette: { + mode: 'dark', + primary: { + light: '#B79AD5', + main: '#A27EC9', + dark: '#8D61BD' + }, + secondary: { + light: '#70DBFF', + main: '#47D1FF', + dark: '#1FC7FF' + }, + error: { + light: '#E73936', + main: '#DD1C1A', + dark: '#B71815' + }, + warning: { + light: '#FA804C', + main: '#F9611F', + dark: '#EF4C06' + }, + info : { + light: '#FFEB99', + main: '#FFE066', + dark: '#FFDA47' + }, + success: { + light: '#6ADC98', + main: '#48D480', + dark: '#2FC66B' + }, + background: { + default: '#1D2535', + paper: '#242E42' + } + } +}); + +const lightTheme = createTheme({ + palette: { + mode: 'light', + primary: { + light: '#B79AD5', + main: '#A27EC9', + dark: '#8D61BD' + }, + secondary: { + light: '#70DBFF', + main: '#47D1FF', + dark: '#1FC7FF' + }, + error: { + light: '#E73936', + main: '#DD1C1A', + dark: '#B71815' + }, + warning: { + light: '#FA804C', + main: '#F9611F', + dark: '#EF4C06' + }, + info : { + light: '#FFEB99', + main: '#FFE066', + dark: '#FFDA47' + }, + success: { + light: '#6ADC98', + main: '#48D480', + dark: '#2FC66B' + }, + background: { + default: '#EFFFFF', + paper: '#e8f1f1' + } + } +}); + +export function App() { + const [value, setValue] = useState(0); + const [theme, setTheme] = useState({ + theme : prefersDarkMode() ? darkTheme : lightTheme, + value : prefersDarkMode() ? 'dark' : 'light' + }); + + const handleChange = (event: any, newValue: number) => { + setValue(newValue); + }; + + const toggleTheme = () => { + setTheme(theme.value == 'dark' + ? { theme : lightTheme, value : 'light' } + : { theme : darkTheme, value : 'dark' }); + } + + return ( + + +
+ + + + + ); +} + +render(, document.getElementById('app')); diff --git a/frontend/src/models/filterState.ts b/frontend/src/models/filterState.ts new file mode 100644 index 0000000..6d1bd34 --- /dev/null +++ b/frontend/src/models/filterState.ts @@ -0,0 +1,8 @@ +export default interface FilterState { + cities : string[]; + minRating : number; + resultsPerPage : number; + currentPage : number; + ratingsProvider : string; + sortBy : string; +}; \ No newline at end of file diff --git a/frontend/src/models/paginationResponse.ts b/frontend/src/models/paginationResponse.ts new file mode 100644 index 0000000..c7dc57e --- /dev/null +++ b/frontend/src/models/paginationResponse.ts @@ -0,0 +1,4 @@ +export default interface PaginationResponse { + data : T[]; + total : number; +} \ No newline at end of file diff --git a/frontend/src/models/results.ts b/frontend/src/models/results.ts new file mode 100644 index 0000000..20381b7 --- /dev/null +++ b/frontend/src/models/results.ts @@ -0,0 +1,25 @@ +import PaginationResponse from "./paginationResponse"; +import SolicitorSummary from "./solicitorSummary"; + +type Results = SuccessResults | ErrorResults | WaitingResults; + +interface SuccessResults { + type : 'Success', + data : PaginationResponse +}; + +interface ErrorResults { + type : 'Error' | 'Warning', + message : string +}; + +interface WaitingResults { + type : 'Waiting' +}; + +const waitingResults : WaitingResults = { + type : 'Waiting' +}; + +export default Results; +export {waitingResults}; \ No newline at end of file diff --git a/frontend/src/models/solicitorSummary.ts b/frontend/src/models/solicitorSummary.ts new file mode 100644 index 0000000..7dc69b7 --- /dev/null +++ b/frontend/src/models/solicitorSummary.ts @@ -0,0 +1,30 @@ +export default interface SolicitorSummary { + name : string, + shortDescription : string | null, + id : string, + rating : Rating +}; + +export interface Rating { + value : number, + maximum : number, + provider : string +} + +export interface Location { + address : string, + phone : string, + ratings : Rating[] +} + +export interface SolicitorInfo { + name : string, + shortDescription : string | null, + id : string, + phone? : string, + email? : string, + website? : string, + + ratings : Rating[], + locations : Location[] +} \ No newline at end of file diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json new file mode 100644 index 0000000..12bb30b --- /dev/null +++ b/frontend/tsconfig.json @@ -0,0 +1,20 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "ESNext", + "moduleResolution": "bundler", + "noEmit": true, + "allowJs": true, + "checkJs": true, + + /* Preact Config */ + "jsx": "react-jsx", + "jsxImportSource": "preact", + "skipLibCheck": true, + "paths": { + "react": ["./node_modules/preact/compat/"], + "react-dom": ["./node_modules/preact/compat/"] + } + }, + "include": ["node_modules/vite/client.d.ts", "**/*"] +} diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts new file mode 100644 index 0000000..0e309b2 --- /dev/null +++ b/frontend/vite.config.ts @@ -0,0 +1,7 @@ +import { defineConfig } from 'vite'; +import preact from '@preact/preset-vite'; + +// https://vitejs.dev/config/ +export default defineConfig({ + plugins: [preact()], +}); diff --git a/frontend/yarn.lock b/frontend/yarn.lock new file mode 100644 index 0000000..160358a --- /dev/null +++ b/frontend/yarn.lock @@ -0,0 +1,4693 @@ +# This file is generated by running "yarn install" inside your project. +# Manual changes might be lost - proceed with caution! + +__metadata: + version: 10 + cacheKey: 10c0 + +"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/code-frame@npm:7.29.7" + dependencies: + "@babel/helper-validator-identifier": "npm:^7.29.7" + js-tokens: "npm:^4.0.0" + picocolors: "npm:^1.1.1" + checksum: 10c0/169fc2080169a40c1760155eaaaf739bcb882df0bec76a83adbda5493645bc17270a3434b8848c494b1933e96fe1d147370001e3cda09a39f43ae30f08ef2069 + languageName: node + linkType: hard + +"@babel/code-frame@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/code-frame@npm:8.0.0" + dependencies: + "@babel/helper-validator-identifier": "npm:^8.0.0" + js-tokens: "npm:^10.0.0" + checksum: 10c0/2ea8614018bcd8c86358ab6aa930508115d2205e5e111f736d355b150453818bdf487850f6dec5ec92a10bf27ba4536f4b3b8ad9204514e43d8d68ff2e542443 + languageName: node + linkType: hard + +"@babel/compat-data@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/compat-data@npm:7.29.7" + checksum: 10c0/47913f05e08a45a1c9df38c02b4b49e391005085b489432647a1abe112e5d9c75e3be8ea5972b7f6da4ec5d1339922ceb9ea02b8a25d4ed1cb8636e5261f344e + languageName: node + linkType: hard + +"@babel/compat-data@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/compat-data@npm:8.0.0" + checksum: 10c0/8d934415a308cf6c893d815b1dbb79faf7678c1e489934e81025c61673bf98ef88770b42297492bbd4c014978688012aa635e855bf8553b96ec8287bddfbae89 + languageName: node + linkType: hard + +"@babel/core@npm:^7.13.16, @babel/core@npm:^7.22.1": + version: 7.29.7 + resolution: "@babel/core@npm:7.29.7" + dependencies: + "@babel/code-frame": "npm:^7.29.7" + "@babel/generator": "npm:^7.29.7" + "@babel/helper-compilation-targets": "npm:^7.29.7" + "@babel/helper-module-transforms": "npm:^7.29.7" + "@babel/helpers": "npm:^7.29.7" + "@babel/parser": "npm:^7.29.7" + "@babel/template": "npm:^7.29.7" + "@babel/traverse": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + "@jridgewell/remapping": "npm:^2.3.5" + convert-source-map: "npm:^2.0.0" + debug: "npm:^4.1.0" + gensync: "npm:^1.0.0-beta.2" + json5: "npm:^2.2.3" + semver: "npm:^6.3.1" + checksum: 10c0/112fb09c24de7a1de64d1de2c31fe65c4e6af4cb2fb6e6d99ea5373e6fc51e75b88581c0efae4c4c68f119a02a988c7106e95011a41530a2fb8ed793c7eaa07b + languageName: node + linkType: hard + +"@babel/core@npm:^8.0.1": + version: 8.0.1 + resolution: "@babel/core@npm:8.0.1" + dependencies: + "@babel/code-frame": "npm:^8.0.0" + "@babel/generator": "npm:^8.0.0" + "@babel/helper-compilation-targets": "npm:^8.0.0" + "@babel/helpers": "npm:^8.0.0" + "@babel/parser": "npm:^8.0.0" + "@babel/template": "npm:^8.0.0" + "@babel/traverse": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + "@types/gensync": "npm:^1.0.5" + convert-source-map: "npm:^2.0.0" + empathic: "npm:^2.0.1" + gensync: "npm:^1.0.0-beta.2" + import-meta-resolve: "npm:^4.2.0" + json5: "npm:^2.2.3" + obug: "npm:^2.1.1" + semver: "npm:^7.7.3" + checksum: 10c0/e7fd9266d22906132fb052383a624358f54268dade31d50264416afeab6e5648cd23c7e845a89a501d270b80601d6e89abc67de0a9f1f55133f4abd8ac745be7 + languageName: node + linkType: hard + +"@babel/eslint-parser@npm:^7.27.5": + version: 7.29.7 + resolution: "@babel/eslint-parser@npm:7.29.7" + dependencies: + "@nicolo-ribaudo/eslint-scope-5-internals": "npm:5.1.1-v1" + eslint-visitor-keys: "npm:^2.1.0" + semver: "npm:^6.3.1" + peerDependencies: + "@babel/core": ^7.11.0 + eslint: ^7.5.0 || ^8.0.0 || ^9.0.0 + checksum: 10c0/c24dcd941b0a149b197a9e9c3297a01d621775ac71cdf2e1134b1097c1691b46ce969355e1be3676d83b88f62c43ed33cf3a499da21ea11a5eb07339ce64ac20 + languageName: node + linkType: hard + +"@babel/generator@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/generator@npm:7.29.7" + dependencies: + "@babel/parser": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + "@jridgewell/gen-mapping": "npm:^0.3.12" + "@jridgewell/trace-mapping": "npm:^0.3.28" + jsesc: "npm:^3.0.2" + checksum: 10c0/9bf72b01b5bd0ea5b1288a0e37dbd360bff2f2b1ce73342c0d40fb3db2ec3dc004ada5ffa925c5e12939a416eed59e600d562b8ecd938ce0d27dfd0eb6c6c2b7 + languageName: node + linkType: hard + +"@babel/generator@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/generator@npm:8.0.0" + dependencies: + "@babel/parser": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + "@jridgewell/gen-mapping": "npm:^0.3.12" + "@jridgewell/trace-mapping": "npm:^0.3.28" + "@types/jsesc": "npm:^2.5.0" + jsesc: "npm:^3.0.2" + checksum: 10c0/2b2d171beaedcacca62164f0f39bc8962df5f9700a54c5515174276ea20b3a53933e9804e0b35c2be1059108a764447d99d0c5beb63ecbbf8c66035ca6c003c4 + languageName: node + linkType: hard + +"@babel/helper-annotate-as-pure@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-annotate-as-pure@npm:7.29.7" + dependencies: + "@babel/types": "npm:^7.29.7" + checksum: 10c0/c56536b52d17632d89d49db2063ed6102f0e3bbadf6a0ccb74e6599d6a77173b644c7fe8c3ef17c7a162709d55b75ee5145ef6db917d16ba7f375fbffcf2e942 + languageName: node + linkType: hard + +"@babel/helper-compilation-targets@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-compilation-targets@npm:7.29.7" + dependencies: + "@babel/compat-data": "npm:^7.29.7" + "@babel/helper-validator-option": "npm:^7.29.7" + browserslist: "npm:^4.24.0" + lru-cache: "npm:^5.1.1" + semver: "npm:^6.3.1" + checksum: 10c0/4c15fd4c69a0a7047799a28a88460c19cede0a0ee8af994ea169114986f4af48b92c7393a4a3fee0456c11a656eece3448a6ed06354453d6c27cccf17195453b + languageName: node + linkType: hard + +"@babel/helper-compilation-targets@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helper-compilation-targets@npm:8.0.0" + dependencies: + "@babel/compat-data": "npm:^8.0.0" + "@babel/helper-validator-option": "npm:^8.0.0" + browserslist: "npm:^4.24.0" + lru-cache: "npm:^11.0.0" + semver: "npm:^7.7.3" + checksum: 10c0/871876b4a9de1a2be68f2ec6c7576933dd9a8452bfb3c02ebcc16939791b8f2ab7467686e40060c6abfbb44bd76f898972e53034c3e7626a686a656f3a8d3bc9 + languageName: node + linkType: hard + +"@babel/helper-globals@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-globals@npm:7.29.7" + checksum: 10c0/f38417c40b1129a1b2b519ca961b9040c8827d1444fd74068702286b91b77089431dc76b6b9d5c1496e5da2a4f3ad329c6946e688ba3fa0d1d0b3d2b4f34f36a + languageName: node + linkType: hard + +"@babel/helper-globals@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helper-globals@npm:8.0.0" + checksum: 10c0/c53a9fcf451df5c8d3aa72f282d1f058e2874e2ccbbdbb5572a805595d75a9355461822d01a6cac3128f5d9ab9a3a99538c6be4ebd728068afb20a65a4d1d986 + languageName: node + linkType: hard + +"@babel/helper-module-imports@npm:^7.16.7, @babel/helper-module-imports@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-module-imports@npm:7.29.7" + dependencies: + "@babel/traverse": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + checksum: 10c0/6adf60d97356027413342a092f818d9678c4f5caff716a33e3284b5ae14e47a9e88059d421dde4ee4894691260039a12602c0e7becadc175602194b40dfa345d + languageName: node + linkType: hard + +"@babel/helper-module-transforms@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-module-transforms@npm:7.29.7" + dependencies: + "@babel/helper-module-imports": "npm:^7.29.7" + "@babel/helper-validator-identifier": "npm:^7.29.7" + "@babel/traverse": "npm:^7.29.7" + peerDependencies: + "@babel/core": ^7.0.0 + checksum: 10c0/ee5a2172c24a42be696836f4b0d947489c9729d8adf5821885cf77d1ad5333e3c447368e9a71f67df1099570490553dccf9f888ef0a92a48aa63cb086bd8c7e1 + languageName: node + linkType: hard + +"@babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-plugin-utils@npm:7.29.7" + checksum: 10c0/380477a06133274a2759f9355929cb60a95e8b8fee624a1ae1fa349e1d1645b89daca456f72833f6d1062bffa12ee4271c5bf0cc5a61c0166cdc24c7591e2408 + languageName: node + linkType: hard + +"@babel/helper-string-parser@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-string-parser@npm:7.29.7" + checksum: 10c0/194bc0f1716e396d5ffde56ad6119745fb9557662c98611590e5e454906783a4ccb21ce93056b8eb69a4909044834e45d96e50ac695bbe9e3221648fe033c06c + languageName: node + linkType: hard + +"@babel/helper-string-parser@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helper-string-parser@npm:8.0.0" + checksum: 10c0/b2272a9eaa63a1bc9ce2673d580e69620fd79786f3e3cf1891f406801f8211810f194f2739fef920f01a97ae06ae465b2dfd238ab8037a3182d0869939ca9a5d + languageName: node + linkType: hard + +"@babel/helper-validator-identifier@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-validator-identifier@npm:7.29.7" + checksum: 10c0/4795354e7ae0dcafa72de1cd04ec51252dc1498517170beaf019e03effc5b7bf13c6b21a3949a77e07b8125be7f106ed1131350d8ebd4566ae874094a726d62b + languageName: node + linkType: hard + +"@babel/helper-validator-identifier@npm:^8.0.0": + version: 8.0.2 + resolution: "@babel/helper-validator-identifier@npm:8.0.2" + checksum: 10c0/629eda2a0a99442a1628bbef5f9fd8e26c1aa21ddbf02760d1c482b737932b1bb21fb1f89aacf9c3cf0642b481b810e39f94b8ae9aa44fc4f5516ebec6798b7b + languageName: node + linkType: hard + +"@babel/helper-validator-option@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helper-validator-option@npm:7.29.7" + checksum: 10c0/d2a06c6d0ac40ba4a2f219fc2cab249c7a94bacdb2686273b7f9598571c908809b48468ff588915a346e6cc7296f60b581023d1d498b747fed06f779d335c2cc + languageName: node + linkType: hard + +"@babel/helper-validator-option@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helper-validator-option@npm:8.0.0" + checksum: 10c0/eb466b464479f75c15ba06f6c53862f10d90740350c9203b3d81c6f33d4193bf0a7b7b89de901f256fb639a1346475b48616734af89906d6b4fcf9a856d9f1f1 + languageName: node + linkType: hard + +"@babel/helpers@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/helpers@npm:7.29.7" + dependencies: + "@babel/template": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + checksum: 10c0/218e8d10953647c9f44775f5a022b227a182674853b5ea8631889deb7e1a3e4bc870388aaecf59bb8bd92a87f9a96220ed3f70a35bffec6bcf9169ecb67891ac + languageName: node + linkType: hard + +"@babel/helpers@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/helpers@npm:8.0.0" + dependencies: + "@babel/template": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + checksum: 10c0/5d649bf2cfc37b76b8c9dd7d2992fa0503a6081c2439cd4de16b56abb778f3bb391441d687594f3e08af5ef3f59c8b93a77ae81f9e5f831989ebfd3443851189 + languageName: node + linkType: hard + +"@babel/parser@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/parser@npm:7.29.7" + dependencies: + "@babel/types": "npm:^7.29.7" + bin: + parser: ./bin/babel-parser.js + checksum: 10c0/65133038f80b54a714d6027cb77cee3f9a6b5c4c6842ce674301e13947cbcbfa8055e63acaf1b84c085d34226a14425b2c2b97b829e0e226d2e8f1299942a51d + languageName: node + linkType: hard + +"@babel/parser@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/parser@npm:8.0.0" + dependencies: + "@babel/types": "npm:^8.0.0" + bin: + parser: ./bin/babel-parser.js + checksum: 10c0/f10665bf3289f4bdc43bc58c482d6baa9fc4e306460d1bc57b059486dc9f23ed4463e746f62d721396466e2a2e0b32d856648b8c30dedbf6b69787b430f21e75 + languageName: node + linkType: hard + +"@babel/plugin-syntax-class-properties@npm:^7.12.13": + version: 7.12.13 + resolution: "@babel/plugin-syntax-class-properties@npm:7.12.13" + dependencies: + "@babel/helper-plugin-utils": "npm:^7.12.13" + peerDependencies: + "@babel/core": ^7.0.0-0 + checksum: 10c0/95168fa186416195280b1264fb18afcdcdcea780b3515537b766cb90de6ce042d42dd6a204a39002f794ae5845b02afb0fd4861a3308a861204a55e68310a120 + languageName: node + linkType: hard + +"@babel/plugin-syntax-jsx@npm:^7.12.13, @babel/plugin-syntax-jsx@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/plugin-syntax-jsx@npm:7.29.7" + dependencies: + "@babel/helper-plugin-utils": "npm:^7.29.7" + peerDependencies: + "@babel/core": ^7.0.0-0 + checksum: 10c0/1736000de183538ba8eef34520105508860e48b0c763254ba9158af5e814ed8bbceeedbb4281fbda33de787ae5b3870e92f60c6ae7131e7d322e451d57387896 + languageName: node + linkType: hard + +"@babel/plugin-transform-react-jsx-development@npm:^7.27.1": + version: 7.29.7 + resolution: "@babel/plugin-transform-react-jsx-development@npm:7.29.7" + dependencies: + "@babel/plugin-transform-react-jsx": "npm:^7.29.7" + peerDependencies: + "@babel/core": ^7.0.0-0 + checksum: 10c0/a2d44d068d35f8e6bc0437ba0da86526d4473491a43108caf77cba467a3ab522cbd09bcd8184b7a49f3d2b52e0883ad797ed2f91c090b857a80a6f383e88f449 + languageName: node + linkType: hard + +"@babel/plugin-transform-react-jsx@npm:^7.27.1, @babel/plugin-transform-react-jsx@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/plugin-transform-react-jsx@npm:7.29.7" + dependencies: + "@babel/helper-annotate-as-pure": "npm:^7.29.7" + "@babel/helper-module-imports": "npm:^7.29.7" + "@babel/helper-plugin-utils": "npm:^7.29.7" + "@babel/plugin-syntax-jsx": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + peerDependencies: + "@babel/core": ^7.0.0-0 + checksum: 10c0/ae6487c3deafcffda8a2c1b1eb77e0b7121630fa1a9646cecd73dbbdd8271532a0f7f0e8c01f69b6d39a36d8d79eb67e2d51031369c9055f18f7d8e70d9b5446 + languageName: node + linkType: hard + +"@babel/runtime@npm:^7.12.5, @babel/runtime@npm:^7.18.3, @babel/runtime@npm:^7.29.2, @babel/runtime@npm:^7.5.5, @babel/runtime@npm:^7.8.7": + version: 7.29.7 + resolution: "@babel/runtime@npm:7.29.7" + checksum: 10c0/ca11572f7146b21e0bde6a9ed4bb6a89eafbee5f0944c7eb54d0d8a2dac962c33638a1d611e14faa71dfbb92b4b5f9236232208568a6b7d5c6f3f39ddb91771e + languageName: node + linkType: hard + +"@babel/template@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/template@npm:7.29.7" + dependencies: + "@babel/code-frame": "npm:^7.29.7" + "@babel/parser": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + checksum: 10c0/8bb7f900dcab0e9e1c5ffbc33ca10e0d26b7b2e2ca804becb73ee771b9c4ed6e2908a4ae4a14c08560febb45d2b6b9a173955e42ad404d05f8b04840a14d9c58 + languageName: node + linkType: hard + +"@babel/template@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/template@npm:8.0.0" + dependencies: + "@babel/code-frame": "npm:^8.0.0" + "@babel/parser": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + checksum: 10c0/8a5e5687299517cc6b0efff3a6342cf4c4256aeeffa14753cc8d08106aaf0ba1916707c0e1f385b511a7b42c6c87806fecaecd4fe06316207475e0d4d1148e2c + languageName: node + linkType: hard + +"@babel/traverse@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/traverse@npm:7.29.7" + dependencies: + "@babel/code-frame": "npm:^7.29.7" + "@babel/generator": "npm:^7.29.7" + "@babel/helper-globals": "npm:^7.29.7" + "@babel/parser": "npm:^7.29.7" + "@babel/template": "npm:^7.29.7" + "@babel/types": "npm:^7.29.7" + debug: "npm:^4.3.1" + checksum: 10c0/e256a1fbdb956555b76f3c285b1e453f6bedec8b3afb61751d99d933efd11c7d79caf5ddf2493570058a9f7deaa1b48324380d7c1aa1443fd9508becbf56331a + languageName: node + linkType: hard + +"@babel/traverse@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/traverse@npm:8.0.0" + dependencies: + "@babel/code-frame": "npm:^8.0.0" + "@babel/generator": "npm:^8.0.0" + "@babel/helper-globals": "npm:^8.0.0" + "@babel/parser": "npm:^8.0.0" + "@babel/template": "npm:^8.0.0" + "@babel/types": "npm:^8.0.0" + obug: "npm:^2.1.1" + checksum: 10c0/de5e5c144c72a2949d75ea8baf5dd2926a6410512397ac28692719df45e31e70e26415e10cacfe2c1c1dd73e7276c6a8fc832754c8b14202627d64e1aa1a9393 + languageName: node + linkType: hard + +"@babel/types@npm:^7.29.7": + version: 7.29.7 + resolution: "@babel/types@npm:7.29.7" + dependencies: + "@babel/helper-string-parser": "npm:^7.29.7" + "@babel/helper-validator-identifier": "npm:^7.29.7" + checksum: 10c0/b6623994c69717fa27294f5fa46d59140338e2d86c6c1c13085c84ef7d53086ee357fbf4fe9abe3dd3da75734dc77c4c0df2f90fb29e667558bb3b3fb705e88f + languageName: node + linkType: hard + +"@babel/types@npm:^8.0.0": + version: 8.0.0 + resolution: "@babel/types@npm:8.0.0" + dependencies: + "@babel/helper-string-parser": "npm:^8.0.0" + "@babel/helper-validator-identifier": "npm:^8.0.0" + checksum: 10c0/f4130b88818cf9fd0fb653dd35459f58794018416bc0cee0eccefd364c2d146ae90611ae3ae19d91c2f0bbd1e0e440840832baf9a3d5eb5fed077a52f0bcc001 + languageName: node + linkType: hard + +"@base-ui/react@npm:^1.6.0": + version: 1.6.0 + resolution: "@base-ui/react@npm:1.6.0" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@base-ui/utils": "npm:0.3.1" + "@floating-ui/react-dom": "npm:^2.1.8" + "@floating-ui/utils": "npm:^0.2.11" + use-sync-external-store: "npm:^1.6.0" + peerDependencies: + "@date-fns/tz": ^1.2.0 + "@types/react": ^17 || ^18 || ^19 + date-fns: ^4.0.0 + react: ^17 || ^18 || ^19 + react-dom: ^17 || ^18 || ^19 + peerDependenciesMeta: + "@date-fns/tz": + optional: true + "@types/react": + optional: true + date-fns: + optional: true + checksum: 10c0/5e5994dc782710eac900d68cc0691aea70a47fabc6ef8d2ea943103d9aa96c4b44f9fd76ba65d29fa2667a5fbd7ea7a1cc02fe111c4bf639d4e3e65a1c281118 + languageName: node + linkType: hard + +"@base-ui/utils@npm:0.3.1": + version: 0.3.1 + resolution: "@base-ui/utils@npm:0.3.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@floating-ui/utils": "npm:^0.2.11" + reselect: "npm:^5.2.0" + use-sync-external-store: "npm:^1.6.0" + peerDependencies: + "@types/react": ^17 || ^18 || ^19 + react: ^17 || ^18 || ^19 + react-dom: ^17 || ^18 || ^19 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/4de858c3e2c8a4486a549d51c5e887bba6921e5a7f8db54439ba558feaf1656c3592a873928aee8a1711ee9210be3a65ca43b26713e97f649695ed2fa8c3af2c + languageName: node + linkType: hard + +"@emotion/babel-plugin@npm:^11.13.5": + version: 11.13.5 + resolution: "@emotion/babel-plugin@npm:11.13.5" + dependencies: + "@babel/helper-module-imports": "npm:^7.16.7" + "@babel/runtime": "npm:^7.18.3" + "@emotion/hash": "npm:^0.9.2" + "@emotion/memoize": "npm:^0.9.0" + "@emotion/serialize": "npm:^1.3.3" + babel-plugin-macros: "npm:^3.1.0" + convert-source-map: "npm:^1.5.0" + escape-string-regexp: "npm:^4.0.0" + find-root: "npm:^1.1.0" + source-map: "npm:^0.5.7" + stylis: "npm:4.2.0" + checksum: 10c0/8ccbfec7defd0e513cb8a1568fa179eac1e20c35fda18aed767f6c59ea7314363ebf2de3e9d2df66c8ad78928dc3dceeded84e6fa8059087cae5c280090aeeeb + languageName: node + linkType: hard + +"@emotion/cache@npm:^11.14.0": + version: 11.14.0 + resolution: "@emotion/cache@npm:11.14.0" + dependencies: + "@emotion/memoize": "npm:^0.9.0" + "@emotion/sheet": "npm:^1.4.0" + "@emotion/utils": "npm:^1.4.2" + "@emotion/weak-memoize": "npm:^0.4.0" + stylis: "npm:4.2.0" + checksum: 10c0/3fa3e7a431ab6f8a47c67132a00ac8358f428c1b6c8421d4b20de9df7c18e95eec04a5a6ff5a68908f98d3280044f247b4965ac63df8302d2c94dba718769724 + languageName: node + linkType: hard + +"@emotion/hash@npm:^0.9.2": + version: 0.9.2 + resolution: "@emotion/hash@npm:0.9.2" + checksum: 10c0/0dc254561a3cc0a06a10bbce7f6a997883fd240c8c1928b93713f803a2e9153a257a488537012efe89dbe1246f2abfe2add62cdb3471a13d67137fcb808e81c2 + languageName: node + linkType: hard + +"@emotion/is-prop-valid@npm:^1.3.0": + version: 1.4.0 + resolution: "@emotion/is-prop-valid@npm:1.4.0" + dependencies: + "@emotion/memoize": "npm:^0.9.0" + checksum: 10c0/5f857814ec7d8c7e727727346dfb001af6b1fb31d621a3ce9c3edf944a484d8b0d619546c30899ae3ade2f317c76390ba4394449728e9bf628312defc2c41ac3 + languageName: node + linkType: hard + +"@emotion/memoize@npm:^0.9.0": + version: 0.9.0 + resolution: "@emotion/memoize@npm:0.9.0" + checksum: 10c0/13f474a9201c7f88b543e6ea42f55c04fb2fdc05e6c5a3108aced2f7e7aa7eda7794c56bba02985a46d8aaa914fcdde238727a98341a96e2aec750d372dadd15 + languageName: node + linkType: hard + +"@emotion/react@npm:^11.14.0": + version: 11.14.0 + resolution: "@emotion/react@npm:11.14.0" + dependencies: + "@babel/runtime": "npm:^7.18.3" + "@emotion/babel-plugin": "npm:^11.13.5" + "@emotion/cache": "npm:^11.14.0" + "@emotion/serialize": "npm:^1.3.3" + "@emotion/use-insertion-effect-with-fallbacks": "npm:^1.2.0" + "@emotion/utils": "npm:^1.4.2" + "@emotion/weak-memoize": "npm:^0.4.0" + hoist-non-react-statics: "npm:^3.3.1" + peerDependencies: + react: ">=16.8.0" + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/d0864f571a9f99ec643420ef31fde09e2006d3943a6aba079980e4d5f6e9f9fecbcc54b8f617fe003c00092ff9d5241179149ffff2810cb05cf72b4620cfc031 + languageName: node + linkType: hard + +"@emotion/serialize@npm:^1.3.3": + version: 1.3.3 + resolution: "@emotion/serialize@npm:1.3.3" + dependencies: + "@emotion/hash": "npm:^0.9.2" + "@emotion/memoize": "npm:^0.9.0" + "@emotion/unitless": "npm:^0.10.0" + "@emotion/utils": "npm:^1.4.2" + csstype: "npm:^3.0.2" + checksum: 10c0/b28cb7de59de382021de2b26c0c94ebbfb16967a1b969a56fdb6408465a8993df243bfbd66430badaa6800e1834724e84895f5a6a9d97d0d224de3d77852acb4 + languageName: node + linkType: hard + +"@emotion/sheet@npm:^1.4.0": + version: 1.4.0 + resolution: "@emotion/sheet@npm:1.4.0" + checksum: 10c0/3ca72d1650a07d2fbb7e382761b130b4a887dcd04e6574b2d51ce578791240150d7072a9bcb4161933abbcd1e38b243a6fb4464a7fe991d700c17aa66bb5acc7 + languageName: node + linkType: hard + +"@emotion/styled@npm:^11.14.1": + version: 11.14.1 + resolution: "@emotion/styled@npm:11.14.1" + dependencies: + "@babel/runtime": "npm:^7.18.3" + "@emotion/babel-plugin": "npm:^11.13.5" + "@emotion/is-prop-valid": "npm:^1.3.0" + "@emotion/serialize": "npm:^1.3.3" + "@emotion/use-insertion-effect-with-fallbacks": "npm:^1.2.0" + "@emotion/utils": "npm:^1.4.2" + peerDependencies: + "@emotion/react": ^11.0.0-rc.0 + react: ">=16.8.0" + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/2bbf8451df49c967e41fbcf8111a7f6dafe6757f0cc113f2f6e287206c45ac1d54dc8a95a483b7c0cee8614b8a8d08155bded6453d6721de1f8cc8d5b9216963 + languageName: node + linkType: hard + +"@emotion/unitless@npm:^0.10.0": + version: 0.10.0 + resolution: "@emotion/unitless@npm:0.10.0" + checksum: 10c0/150943192727b7650eb9a6851a98034ddb58a8b6958b37546080f794696141c3760966ac695ab9af97efe10178690987aee4791f9f0ad1ff76783cdca83c1d49 + languageName: node + linkType: hard + +"@emotion/use-insertion-effect-with-fallbacks@npm:^1.2.0": + version: 1.2.0 + resolution: "@emotion/use-insertion-effect-with-fallbacks@npm:1.2.0" + peerDependencies: + react: ">=16.8.0" + checksum: 10c0/074dbc92b96bdc09209871070076e3b0351b6b47efefa849a7d9c37ab142130767609ca1831da0055988974e3b895c1de7606e4c421fecaa27c3e56a2afd3b08 + languageName: node + linkType: hard + +"@emotion/utils@npm:^1.4.2": + version: 1.4.2 + resolution: "@emotion/utils@npm:1.4.2" + checksum: 10c0/7d0010bf60a2a8c1a033b6431469de4c80e47aeb8fd856a17c1d1f76bbc3a03161a34aeaa78803566e29681ca551e7bf9994b68e9c5f5c796159923e44f78d9a + languageName: node + linkType: hard + +"@emotion/weak-memoize@npm:^0.4.0": + version: 0.4.0 + resolution: "@emotion/weak-memoize@npm:0.4.0" + checksum: 10c0/64376af11f1266042d03b3305c30b7502e6084868e33327e944b539091a472f089db307af69240f7188f8bc6b319276fd7b141a36613f1160d73d12a60f6ca1a + languageName: node + linkType: hard + +"@esbuild/aix-ppc64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/aix-ppc64@npm:0.27.7" + conditions: os=aix & cpu=ppc64 + languageName: node + linkType: hard + +"@esbuild/android-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/android-arm64@npm:0.27.7" + conditions: os=android & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/android-arm@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/android-arm@npm:0.27.7" + conditions: os=android & cpu=arm + languageName: node + linkType: hard + +"@esbuild/android-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/android-x64@npm:0.27.7" + conditions: os=android & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/darwin-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/darwin-arm64@npm:0.27.7" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/darwin-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/darwin-x64@npm:0.27.7" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/freebsd-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/freebsd-arm64@npm:0.27.7" + conditions: os=freebsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/freebsd-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/freebsd-x64@npm:0.27.7" + conditions: os=freebsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/linux-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-arm64@npm:0.27.7" + conditions: os=linux & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/linux-arm@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-arm@npm:0.27.7" + conditions: os=linux & cpu=arm + languageName: node + linkType: hard + +"@esbuild/linux-ia32@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-ia32@npm:0.27.7" + conditions: os=linux & cpu=ia32 + languageName: node + linkType: hard + +"@esbuild/linux-loong64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-loong64@npm:0.27.7" + conditions: os=linux & cpu=loong64 + languageName: node + linkType: hard + +"@esbuild/linux-mips64el@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-mips64el@npm:0.27.7" + conditions: os=linux & cpu=mips64el + languageName: node + linkType: hard + +"@esbuild/linux-ppc64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-ppc64@npm:0.27.7" + conditions: os=linux & cpu=ppc64 + languageName: node + linkType: hard + +"@esbuild/linux-riscv64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-riscv64@npm:0.27.7" + conditions: os=linux & cpu=riscv64 + languageName: node + linkType: hard + +"@esbuild/linux-s390x@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-s390x@npm:0.27.7" + conditions: os=linux & cpu=s390x + languageName: node + linkType: hard + +"@esbuild/linux-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/linux-x64@npm:0.27.7" + conditions: os=linux & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/netbsd-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/netbsd-arm64@npm:0.27.7" + conditions: os=netbsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/netbsd-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/netbsd-x64@npm:0.27.7" + conditions: os=netbsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/openbsd-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/openbsd-arm64@npm:0.27.7" + conditions: os=openbsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/openbsd-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/openbsd-x64@npm:0.27.7" + conditions: os=openbsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/openharmony-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/openharmony-arm64@npm:0.27.7" + conditions: os=openharmony & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/sunos-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/sunos-x64@npm:0.27.7" + conditions: os=sunos & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/win32-arm64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/win32-arm64@npm:0.27.7" + conditions: os=win32 & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/win32-ia32@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/win32-ia32@npm:0.27.7" + conditions: os=win32 & cpu=ia32 + languageName: node + linkType: hard + +"@esbuild/win32-x64@npm:0.27.7": + version: 0.27.7 + resolution: "@esbuild/win32-x64@npm:0.27.7" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@eslint-community/eslint-utils@npm:^4.8.0": + version: 4.9.1 + resolution: "@eslint-community/eslint-utils@npm:4.9.1" + dependencies: + eslint-visitor-keys: "npm:^3.4.3" + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + checksum: 10c0/dc4ab5e3e364ef27e33666b11f4b86e1a6c1d7cbf16f0c6ff87b1619b3562335e9201a3d6ce806221887ff780ec9d828962a290bb910759fd40a674686503f02 + languageName: node + linkType: hard + +"@eslint-community/regexpp@npm:^4.12.2": + version: 4.12.2 + resolution: "@eslint-community/regexpp@npm:4.12.2" + checksum: 10c0/fddcbc66851b308478d04e302a4d771d6917a0b3740dc351513c0da9ca2eab8a1adf99f5e0aa7ab8b13fa0df005c81adeee7e63a92f3effd7d367a163b721c2d + languageName: node + linkType: hard + +"@eslint/config-array@npm:^0.23.5": + version: 0.23.5 + resolution: "@eslint/config-array@npm:0.23.5" + dependencies: + "@eslint/object-schema": "npm:^3.0.5" + debug: "npm:^4.3.1" + minimatch: "npm:^10.2.4" + checksum: 10c0/b24833c4c76e78ee075d306cd3f095db46b2db0f90cc13a6ee6e4275f9889731c05bf5403ab5fefb79c756e07ac9184ed0e04570341382f9eccbccc80e6d1a0c + languageName: node + linkType: hard + +"@eslint/config-helpers@npm:^0.6.0": + version: 0.6.0 + resolution: "@eslint/config-helpers@npm:0.6.0" + dependencies: + "@eslint/core": "npm:^1.2.1" + checksum: 10c0/f9af20e8b60b0ba27edb74b8eb40c0c5d51a9bf9baf9e053bb57833a87cb0a1c49b4dfaad88fc24d49c907ad1324c8a0b668684fa9c321351dac4bc9155ec10a + languageName: node + linkType: hard + +"@eslint/core@npm:^1.2.1": + version: 1.2.1 + resolution: "@eslint/core@npm:1.2.1" + dependencies: + "@types/json-schema": "npm:^7.0.15" + checksum: 10c0/10979b40588ecfef771fcb5013a542a35fb30692cc95a65f3481b0b36fbd89f5679efeb30d57f4eed35203d859aabace2a620177d6c536f71b299a1af2f3398f + languageName: node + linkType: hard + +"@eslint/js@npm:^9.29.0": + version: 9.39.4 + resolution: "@eslint/js@npm:9.39.4" + checksum: 10c0/5aa7dea2cbc5decf7f5e3b0c6f86a084ccee0f792d288ca8e839f8bc1b64e03e227068968e49b26096e6f71fd857ab6e42691d1b993826b9a3883f1bdd7a0e46 + languageName: node + linkType: hard + +"@eslint/object-schema@npm:^3.0.5": + version: 3.0.5 + resolution: "@eslint/object-schema@npm:3.0.5" + checksum: 10c0/1db337431f520b99e9edda64ef5fafd7ec6a029843eeb608753025125b6649d861d843cffafafd3c4e37926d7d5f9ec0c6a8e3665c13c3da2144e8132892e92e + languageName: node + linkType: hard + +"@eslint/plugin-kit@npm:^0.7.2": + version: 0.7.2 + resolution: "@eslint/plugin-kit@npm:0.7.2" + dependencies: + "@eslint/core": "npm:^1.2.1" + levn: "npm:^0.4.1" + checksum: 10c0/aafba08077bcd6d7dde6c2e21db18086046a88f914f29971a84cac9ad2d48952ded1b293e665e523805297eff756522dafa16f0062195e2c7143dcd1d47d11ed + languageName: node + linkType: hard + +"@floating-ui/core@npm:^1.7.5": + version: 1.7.5 + resolution: "@floating-ui/core@npm:1.7.5" + dependencies: + "@floating-ui/utils": "npm:^0.2.11" + checksum: 10c0/f9c52205e198b231d63a387b09c659aab08c46a1899e0b0bbe147b8b4f048b546f15ba17cb5d2a471da9534f1883d979425e13e5c4ceee67be63e4b0abd4db5d + languageName: node + linkType: hard + +"@floating-ui/dom@npm:^1.7.6": + version: 1.7.6 + resolution: "@floating-ui/dom@npm:1.7.6" + dependencies: + "@floating-ui/core": "npm:^1.7.5" + "@floating-ui/utils": "npm:^0.2.11" + checksum: 10c0/5c098e0d7b58c9bc769f276cca1766994c2c9c70c92d091a61bba8b3e9be53c011e0a79a8457fc2fb2f3d91697a26eb52e0a4962ef936dc963b45f58613c212f + languageName: node + linkType: hard + +"@floating-ui/react-dom@npm:^2.1.8": + version: 2.1.8 + resolution: "@floating-ui/react-dom@npm:2.1.8" + dependencies: + "@floating-ui/dom": "npm:^1.7.6" + peerDependencies: + react: ">=16.8.0" + react-dom: ">=16.8.0" + checksum: 10c0/26260ca4bb23b57c73b824062505abf977a008ce6e0463bdacca74f7e49853c4cd1d2bbf1a77c6caa17fa37dfffda2c6c4cd07a8737ebd7474aaff7818401d75 + languageName: node + linkType: hard + +"@floating-ui/utils@npm:^0.2.11": + version: 0.2.11 + resolution: "@floating-ui/utils@npm:0.2.11" + checksum: 10c0/f4bcea1559bdbb721ecc8e8ead423ac58d6a5b6e70b602cf0810ba6ad4ed1c77211b207faa88b278a9042f0c743133de08a203ed6741c1b6443423332884d5b3 + languageName: node + linkType: hard + +"@fontsource/roboto@npm:^5.2.10": + version: 5.2.10 + resolution: "@fontsource/roboto@npm:5.2.10" + checksum: 10c0/abadfcaefbe2196bbd36d9258b336063f721894a3624a9639da00792583c565bfd0748ef978f91a38c3c0de8d247615c9be92a763184c085c630fa43f04b1cd9 + languageName: node + linkType: hard + +"@humanfs/core@npm:^0.19.2": + version: 0.19.2 + resolution: "@humanfs/core@npm:0.19.2" + dependencies: + "@humanfs/types": "npm:^0.15.0" + checksum: 10c0/d0a1d52d7b30c27d49475a53072d1510b81c5803e44b342fb8faf3887f1aa27593a1e6dc76a45268e7892d3f4e198146659281f6b6d55eacf3fd5a38bac30c5c + languageName: node + linkType: hard + +"@humanfs/node@npm:^0.16.6": + version: 0.16.8 + resolution: "@humanfs/node@npm:0.16.8" + dependencies: + "@humanfs/core": "npm:^0.19.2" + "@humanfs/types": "npm:^0.15.0" + "@humanwhocodes/retry": "npm:^0.4.0" + checksum: 10c0/56140579db811af4e160b195d45d0f29acf644d192c93fe24c9e594ebf06f19dfc157494a07c84540b8a071c0e4b37209c2362765d31734f4d0be869c2422e25 + languageName: node + linkType: hard + +"@humanfs/types@npm:^0.15.0": + version: 0.15.0 + resolution: "@humanfs/types@npm:0.15.0" + checksum: 10c0/fc26b9a024b0e55f7eaf64036df94345bf5d36d6a41ef80ef38e78f1f7430ce26cf435af736adae58913baae18eac3f38c18739054a3d379102015978eae862e + languageName: node + linkType: hard + +"@humanwhocodes/module-importer@npm:^1.0.1": + version: 1.0.1 + resolution: "@humanwhocodes/module-importer@npm:1.0.1" + checksum: 10c0/909b69c3b86d482c26b3359db16e46a32e0fb30bd306a3c176b8313b9e7313dba0f37f519de6aa8b0a1921349e505f259d19475e123182416a506d7f87e7f529 + languageName: node + linkType: hard + +"@humanwhocodes/retry@npm:^0.4.0, @humanwhocodes/retry@npm:^0.4.2": + version: 0.4.3 + resolution: "@humanwhocodes/retry@npm:0.4.3" + checksum: 10c0/3775bb30087d4440b3f7406d5a057777d90e4b9f435af488a4923ef249e93615fb78565a85f173a186a076c7706a81d0d57d563a2624e4de2c5c9c66c486ce42 + languageName: node + linkType: hard + +"@isaacs/fs-minipass@npm:^4.0.0": + version: 4.0.1 + resolution: "@isaacs/fs-minipass@npm:4.0.1" + dependencies: + minipass: "npm:^7.0.4" + checksum: 10c0/c25b6dc1598790d5b55c0947a9b7d111cfa92594db5296c3b907e2f533c033666f692a3939eadac17b1c7c40d362d0b0635dc874cbfe3e70db7c2b07cc97a5d2 + languageName: node + linkType: hard + +"@jridgewell/gen-mapping@npm:^0.3.12, @jridgewell/gen-mapping@npm:^0.3.5": + version: 0.3.13 + resolution: "@jridgewell/gen-mapping@npm:0.3.13" + dependencies: + "@jridgewell/sourcemap-codec": "npm:^1.5.0" + "@jridgewell/trace-mapping": "npm:^0.3.24" + checksum: 10c0/9a7d65fb13bd9aec1fbab74cda08496839b7e2ceb31f5ab922b323e94d7c481ce0fc4fd7e12e2610915ed8af51178bdc61e168e92a8c8b8303b030b03489b13b + languageName: node + linkType: hard + +"@jridgewell/remapping@npm:^2.3.5": + version: 2.3.5 + resolution: "@jridgewell/remapping@npm:2.3.5" + dependencies: + "@jridgewell/gen-mapping": "npm:^0.3.5" + "@jridgewell/trace-mapping": "npm:^0.3.24" + checksum: 10c0/3de494219ffeb2c5c38711d0d7bb128097edf91893090a2dbc8ee0b55d092bb7347b1fd0f478486c5eab010e855c73927b1666f2107516d472d24a73017d1194 + languageName: node + linkType: hard + +"@jridgewell/resolve-uri@npm:^3.1.0": + version: 3.1.2 + resolution: "@jridgewell/resolve-uri@npm:3.1.2" + checksum: 10c0/d502e6fb516b35032331406d4e962c21fe77cdf1cbdb49c6142bcbd9e30507094b18972778a6e27cbad756209cfe34b1a27729e6fa08a2eb92b33943f680cf1e + languageName: node + linkType: hard + +"@jridgewell/sourcemap-codec@npm:^1.4.14, @jridgewell/sourcemap-codec@npm:^1.5.0, @jridgewell/sourcemap-codec@npm:^1.5.5": + version: 1.5.5 + resolution: "@jridgewell/sourcemap-codec@npm:1.5.5" + checksum: 10c0/f9e538f302b63c0ebc06eecb1dd9918dd4289ed36147a0ddce35d6ea4d7ebbda243cda7b2213b6a5e1d8087a298d5cf630fb2bd39329cdecb82017023f6081a0 + languageName: node + linkType: hard + +"@jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.28": + version: 0.3.31 + resolution: "@jridgewell/trace-mapping@npm:0.3.31" + dependencies: + "@jridgewell/resolve-uri": "npm:^3.1.0" + "@jridgewell/sourcemap-codec": "npm:^1.4.14" + checksum: 10c0/4b30ec8cd56c5fd9a661f088230af01e0c1a3888d11ffb6b47639700f71225be21d1f7e168048d6d4f9449207b978a235c07c8f15c07705685d16dc06280e9d9 + languageName: node + linkType: hard + +"@mdn/browser-compat-data@npm:^5.6.19": + version: 5.7.6 + resolution: "@mdn/browser-compat-data@npm:5.7.6" + checksum: 10c0/918df768e734115bee0a43fb2eceaf6438cb9b294c27e13d0ac8a19ab9f00f59e4f306fc38c498b62bdec2d726d4f3874826fa2afccd2a29d50d306f687bfdff + languageName: node + linkType: hard + +"@mdn/browser-compat-data@npm:^6.1.1": + version: 6.1.5 + resolution: "@mdn/browser-compat-data@npm:6.1.5" + checksum: 10c0/a2d8ef7cdb3268c72540909755d4d56ae5a8674ddd8216a3bd4a40e4d1497c01b0205a29a8fd6bf4599e091cbc8a90d9a3a52836a8439d66b0af00886f68e7b9 + languageName: node + linkType: hard + +"@mui/core-downloads-tracker@npm:^9.1.2": + version: 9.1.2 + resolution: "@mui/core-downloads-tracker@npm:9.1.2" + checksum: 10c0/787f9bf6bc178cf405252bbd7ab8fd24375cb203fe36beedc29165eea432bf120e1fdf61b22de0037b6e2db6702c9f348c8f45164a5c367a3f3dbacea6f1fe04 + languageName: node + linkType: hard + +"@mui/icons-material@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/icons-material@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + peerDependencies: + "@mui/material": ^9.1.1 + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/bb7719221fed6258be9959538986aa9525370a0db25ca4acf3d58adb85a119ebc98ca519054789efffb3813aeea9c83d120b3e0358f7b67e88f73997ef33c986 + languageName: node + linkType: hard + +"@mui/material@npm:^9.1.2": + version: 9.1.2 + resolution: "@mui/material@npm:9.1.2" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@mui/core-downloads-tracker": "npm:^9.1.2" + "@mui/system": "npm:^9.1.2" + "@mui/types": "npm:^9.1.1" + "@mui/utils": "npm:^9.1.1" + "@popperjs/core": "npm:^2.11.8" + "@types/react-transition-group": "npm:^4.4.12" + clsx: "npm:^2.1.1" + csstype: "npm:^3.2.3" + prop-types: "npm:^15.8.1" + react-is: "npm:^19.2.6" + react-transition-group: "npm:^4.4.5" + peerDependencies: + "@emotion/react": ^11.5.0 + "@emotion/styled": ^11.3.0 + "@mui/material-pigment-css": ^9.1.1 + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + react-dom: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@emotion/react": + optional: true + "@emotion/styled": + optional: true + "@mui/material-pigment-css": + optional: true + "@types/react": + optional: true + checksum: 10c0/b3279d4b8f2df6c6de88b51bb236b8f800dbc83d37eb168c4525bef01990a1e4016f65868a68e0244fd01113bba9b297e9fc10c41499b1b540c4c3778b61da5e + languageName: node + linkType: hard + +"@mui/private-theming@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/private-theming@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@mui/utils": "npm:^9.1.1" + prop-types: "npm:^15.8.1" + peerDependencies: + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/edf9cd75aee97a6b95e2ea98cbb4c8d3f72db48db909c445f3129a6a5fad00ca917ec1bfdd1d107481ecc20b9c9d9560298cb588102f069c0b0a5a9c7198eb49 + languageName: node + linkType: hard + +"@mui/styled-engine@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/styled-engine@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@emotion/cache": "npm:^11.14.0" + "@emotion/serialize": "npm:^1.3.3" + "@emotion/sheet": "npm:^1.4.0" + csstype: "npm:^3.2.3" + prop-types: "npm:^15.8.1" + peerDependencies: + "@emotion/react": ^11.4.1 + "@emotion/styled": ^11.3.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@emotion/react": + optional: true + "@emotion/styled": + optional: true + checksum: 10c0/250bb2a94ac3399a3a9c2ba81871419100fed51b823b87a935215c50781aace3022585697039898073964e661e749abd9e30a6a241ce7567ad5eec47ef082467 + languageName: node + linkType: hard + +"@mui/system@npm:^9.1.2": + version: 9.1.2 + resolution: "@mui/system@npm:9.1.2" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@mui/private-theming": "npm:^9.1.1" + "@mui/styled-engine": "npm:^9.1.1" + "@mui/types": "npm:^9.1.1" + "@mui/utils": "npm:^9.1.1" + clsx: "npm:^2.1.1" + csstype: "npm:^3.2.3" + prop-types: "npm:^15.8.1" + peerDependencies: + "@emotion/react": ^11.5.0 + "@emotion/styled": ^11.3.0 + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@emotion/react": + optional: true + "@emotion/styled": + optional: true + "@types/react": + optional: true + checksum: 10c0/9f274cf009e4235a9bbb9a6524aa2de6ba59a3fc01e91157004be1a4d5c6d4db5f16d91dfe95d3c3acb36fa355a8ac7d811b146a547f3b9292c2a1c981adb707 + languageName: node + linkType: hard + +"@mui/types@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/types@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + peerDependencies: + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/83cb89cafba0c55c909a8a89bd165550a71f92a67bbd191823b6ec304e5f59b43438052fecc4f69cc27e4e557c6bce3d5a073b9f5d5787d62d8cdc055e479905 + languageName: node + linkType: hard + +"@mui/utils@npm:^9.1.1": + version: 9.1.1 + resolution: "@mui/utils@npm:9.1.1" + dependencies: + "@babel/runtime": "npm:^7.29.2" + "@mui/types": "npm:^9.1.1" + "@types/prop-types": "npm:^15.7.15" + clsx: "npm:^2.1.1" + prop-types: "npm:^15.8.1" + react-is: "npm:^19.2.6" + peerDependencies: + "@types/react": ^17.0.0 || ^18.0.0 || ^19.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + "@types/react": + optional: true + checksum: 10c0/a39936fa287ba3f53c47ef3072b813b797a75b43ed95212e817e9d3828e2de8079ae834061fc7e76b096eb0ceddd39468f4f0423ac25b6ac39aa77d70945966b + languageName: node + linkType: hard + +"@nicolo-ribaudo/eslint-scope-5-internals@npm:5.1.1-v1": + version: 5.1.1-v1 + resolution: "@nicolo-ribaudo/eslint-scope-5-internals@npm:5.1.1-v1" + dependencies: + eslint-scope: "npm:5.1.1" + checksum: 10c0/75dda3e623b8ad7369ca22552d6beee337a814b2d0e8a32d23edd13fcb65c8082b32c5d86e436f3860dd7ade30d91d5db55d4ef9a08fb5a976c718ecc0d88a74 + languageName: node + linkType: hard + +"@popperjs/core@npm:^2.11.8": + version: 2.11.8 + resolution: "@popperjs/core@npm:2.11.8" + checksum: 10c0/4681e682abc006d25eb380d0cf3efc7557043f53b6aea7a5057d0d1e7df849a00e281cd8ea79c902a35a414d7919621fc2ba293ecec05f413598e0b23d5a1e63 + languageName: node + linkType: hard + +"@preact/preset-vite@npm:^2.10.2": + version: 2.10.5 + resolution: "@preact/preset-vite@npm:2.10.5" + dependencies: + "@babel/plugin-transform-react-jsx": "npm:^7.27.1" + "@babel/plugin-transform-react-jsx-development": "npm:^7.27.1" + "@prefresh/vite": "npm:^2.4.11" + "@rollup/pluginutils": "npm:^5.0.0" + babel-plugin-transform-hook-names: "npm:^1.0.2" + debug: "npm:^4.4.3" + magic-string: "npm:^0.30.21" + picocolors: "npm:^1.1.1" + vite-prerender-plugin: "npm:^0.5.8" + zimmerframe: "npm:^1.1.4" + peerDependencies: + "@babel/core": 7.x + vite: 2.x || 3.x || 4.x || 5.x || 6.x || 7.x || 8.x + checksum: 10c0/fb548ffa0f7a90699ddc909b318d70d1f6f255a26193628578ef81517258d63d50d412b9dc87a5a4d9b13c4a62d47e9688aeee575bc8cdeeeefe5145e62ea741 + languageName: node + linkType: hard + +"@prefresh/babel-plugin@npm:^0.5.2": + version: 0.5.3 + resolution: "@prefresh/babel-plugin@npm:0.5.3" + checksum: 10c0/59cb7bde2dac2265f28f18c8fc3799efd75ebb117c7df19c7fea597a03db4af973ee56a21e9fa2588f707a3ef8a90ddc19e95d1d151641a068d98a690b0bc6ea + languageName: node + linkType: hard + +"@prefresh/core@npm:^1.5.0": + version: 1.5.10 + resolution: "@prefresh/core@npm:1.5.10" + peerDependencies: + preact: ^10.0.0 || ^11.0.0-0 + checksum: 10c0/61320c197b8075f0a2895b2cde75d9600b471b4241eb4a5855547fdef20298f732480e27522bb6e9ca64d47d645dd45717d9c0571446523c5b0701063c486c60 + languageName: node + linkType: hard + +"@prefresh/utils@npm:^1.2.0": + version: 1.2.1 + resolution: "@prefresh/utils@npm:1.2.1" + checksum: 10c0/d36bcc8995128ee9028e2c48cb7812c7736a0c8e228ded586de4595f587b239ec9daac2c82221a476ffd341412dbb62082d09f7191d3ee7f5d0b8a99a45f01a8 + languageName: node + linkType: hard + +"@prefresh/vite@npm:^2.4.11": + version: 2.4.12 + resolution: "@prefresh/vite@npm:2.4.12" + dependencies: + "@babel/core": "npm:^7.22.1" + "@prefresh/babel-plugin": "npm:^0.5.2" + "@prefresh/core": "npm:^1.5.0" + "@prefresh/utils": "npm:^1.2.0" + "@rollup/pluginutils": "npm:^4.2.1" + peerDependencies: + preact: ^10.4.0 || ^11.0.0-0 + vite: ">=2.0.0" + checksum: 10c0/b3e9957a6821831c294457fd0b5063fa83828fc9837b01472a377c858d3335a3c88920e99ce77381de3a63f8394459423d812e973d9afd32950b4e0db66970df + languageName: node + linkType: hard + +"@rollup/pluginutils@npm:^4.2.1": + version: 4.2.1 + resolution: "@rollup/pluginutils@npm:4.2.1" + dependencies: + estree-walker: "npm:^2.0.1" + picomatch: "npm:^2.2.2" + checksum: 10c0/3ee56b2c8f1ed8dfd0a92631da1af3a2dfdd0321948f089b3752b4de1b54dc5076701eadd0e5fc18bd191b77af594ac1db6279e83951238ba16bf8a414c64c48 + languageName: node + linkType: hard + +"@rollup/pluginutils@npm:^5.0.0": + version: 5.4.0 + resolution: "@rollup/pluginutils@npm:5.4.0" + dependencies: + "@types/estree": "npm:^1.0.0" + estree-walker: "npm:^2.0.2" + picomatch: "npm:^4.0.2" + peerDependencies: + rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0 + peerDependenciesMeta: + rollup: + optional: true + checksum: 10c0/ccc2cbd3a05df642df60ab05ffb81b2e564bd945e2a118bb8a474ea75b941033c8f44273133d4865643cca1492d0c80b14de1281f74779a64285a80fc3a194d8 + languageName: node + linkType: hard + +"@rollup/rollup-android-arm-eabi@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-android-arm-eabi@npm:4.62.2" + conditions: os=android & cpu=arm + languageName: node + linkType: hard + +"@rollup/rollup-android-arm64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-android-arm64@npm:4.62.2" + conditions: os=android & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-darwin-arm64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-darwin-arm64@npm:4.62.2" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-darwin-x64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-darwin-x64@npm:4.62.2" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@rollup/rollup-freebsd-arm64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-freebsd-arm64@npm:4.62.2" + conditions: os=freebsd & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-freebsd-x64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-freebsd-x64@npm:4.62.2" + conditions: os=freebsd & cpu=x64 + languageName: node + linkType: hard + +"@rollup/rollup-linux-arm-gnueabihf@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-arm-gnueabihf@npm:4.62.2" + conditions: os=linux & cpu=arm & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-arm-musleabihf@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-arm-musleabihf@npm:4.62.2" + conditions: os=linux & cpu=arm & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-arm64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-arm64-gnu@npm:4.62.2" + conditions: os=linux & cpu=arm64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-arm64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-arm64-musl@npm:4.62.2" + conditions: os=linux & cpu=arm64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-loong64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-loong64-gnu@npm:4.62.2" + conditions: os=linux & cpu=loong64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-loong64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-loong64-musl@npm:4.62.2" + conditions: os=linux & cpu=loong64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-ppc64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-ppc64-gnu@npm:4.62.2" + conditions: os=linux & cpu=ppc64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-ppc64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-ppc64-musl@npm:4.62.2" + conditions: os=linux & cpu=ppc64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-riscv64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-riscv64-gnu@npm:4.62.2" + conditions: os=linux & cpu=riscv64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-riscv64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-riscv64-musl@npm:4.62.2" + conditions: os=linux & cpu=riscv64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-linux-s390x-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-s390x-gnu@npm:4.62.2" + conditions: os=linux & cpu=s390x & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-x64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-x64-gnu@npm:4.62.2" + conditions: os=linux & cpu=x64 & libc=glibc + languageName: node + linkType: hard + +"@rollup/rollup-linux-x64-musl@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-linux-x64-musl@npm:4.62.2" + conditions: os=linux & cpu=x64 & libc=musl + languageName: node + linkType: hard + +"@rollup/rollup-openbsd-x64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-openbsd-x64@npm:4.62.2" + conditions: os=openbsd & cpu=x64 + languageName: node + linkType: hard + +"@rollup/rollup-openharmony-arm64@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-openharmony-arm64@npm:4.62.2" + conditions: os=openharmony & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-win32-arm64-msvc@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-win32-arm64-msvc@npm:4.62.2" + conditions: os=win32 & cpu=arm64 + languageName: node + linkType: hard + +"@rollup/rollup-win32-ia32-msvc@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-win32-ia32-msvc@npm:4.62.2" + conditions: os=win32 & cpu=ia32 + languageName: node + linkType: hard + +"@rollup/rollup-win32-x64-gnu@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-win32-x64-gnu@npm:4.62.2" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@rollup/rollup-win32-x64-msvc@npm:4.62.2": + version: 4.62.2 + resolution: "@rollup/rollup-win32-x64-msvc@npm:4.62.2" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@types/esrecurse@npm:^4.3.1": + version: 4.3.1 + resolution: "@types/esrecurse@npm:4.3.1" + checksum: 10c0/90dad74d5da3ad27606d8e8e757322f33171cfeaa15ad558b615cf71bb2a516492d18f55f4816384685a3eb2412142e732bbae9a4a7cd2cf3deb7572aa4ebe03 + languageName: node + linkType: hard + +"@types/estree@npm:1.0.9, @types/estree@npm:^1.0.0, @types/estree@npm:^1.0.6, @types/estree@npm:^1.0.8": + version: 1.0.9 + resolution: "@types/estree@npm:1.0.9" + checksum: 10c0/3ad3286ca2988cd550dafb8f2ad599c8474868e954fa601a36655bdfefd8039f7c714b8c1c7f2ae219ffbd58bd4660e66fa7479a0120fc02d4777057d4865387 + languageName: node + linkType: hard + +"@types/gensync@npm:^1.0.5": + version: 1.0.5 + resolution: "@types/gensync@npm:1.0.5" + checksum: 10c0/7c37c8fc3b1a49efd8889f635a6204008f1c1cc86a09ac6a96e219cf3fc52cf1ff091c4dddc3160e93261d6e599fbba39f5fb698fbf936518d1c410289cdd640 + languageName: node + linkType: hard + +"@types/jsesc@npm:^2.5.0": + version: 2.5.1 + resolution: "@types/jsesc@npm:2.5.1" + checksum: 10c0/12ba7bf5968aeeb36408269f4b5a39718efc6411fa197cf0f5e967ba36ad7b7d555b78787fc480db43ce63ebe6ab0ffe5fd9f64b1ea3b0d073877f0747491b30 + languageName: node + linkType: hard + +"@types/json-schema@npm:^7.0.15": + version: 7.0.15 + resolution: "@types/json-schema@npm:7.0.15" + checksum: 10c0/a996a745e6c5d60292f36731dd41341339d4eeed8180bb09226e5c8d23759067692b1d88e5d91d72ee83dfc00d3aca8e7bd43ea120516c17922cbcb7c3e252db + languageName: node + linkType: hard + +"@types/parse-json@npm:^4.0.0": + version: 4.0.2 + resolution: "@types/parse-json@npm:4.0.2" + checksum: 10c0/b1b863ac34a2c2172fbe0807a1ec4d5cb684e48d422d15ec95980b81475fac4fdb3768a8b13eef39130203a7c04340fc167bae057c7ebcafd7dec9fe6c36aeb1 + languageName: node + linkType: hard + +"@types/prop-types@npm:^15.7.15": + version: 15.7.15 + resolution: "@types/prop-types@npm:15.7.15" + checksum: 10c0/b59aad1ad19bf1733cf524fd4e618196c6c7690f48ee70a327eb450a42aab8e8a063fbe59ca0a5701aebe2d92d582292c0fb845ea57474f6a15f6994b0e260b2 + languageName: node + linkType: hard + +"@types/react-transition-group@npm:^4.4.12": + version: 4.4.12 + resolution: "@types/react-transition-group@npm:4.4.12" + peerDependencies: + "@types/react": "*" + checksum: 10c0/0441b8b47c69312c89ec0760ba477ba1a0808a10ceef8dc1c64b1013ed78517332c30f18681b0ec0b53542731f1ed015169fed1d127cc91222638ed955478ec7 + languageName: node + linkType: hard + +"abbrev@npm:^5.0.0": + version: 5.0.0 + resolution: "abbrev@npm:5.0.0" + checksum: 10c0/8e88f5c798ea4562d28c5a3e9ad69e3879890bc5d695d8f2dffb8609be4c890aacc8f80ef4553fdd2c6a62d70c2ce8bc57b38074e383beb7487bdafa9ed42ea5 + languageName: node + linkType: hard + +"acorn-jsx@npm:^5.3.2": + version: 5.3.2 + resolution: "acorn-jsx@npm:5.3.2" + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + checksum: 10c0/4c54868fbef3b8d58927d5e33f0a4de35f59012fe7b12cf9dfbb345fb8f46607709e1c4431be869a23fb63c151033d84c4198fa9f79385cec34fcb1dd53974c1 + languageName: node + linkType: hard + +"acorn@npm:^8.16.0": + version: 8.17.0 + resolution: "acorn@npm:8.17.0" + bin: + acorn: bin/acorn + checksum: 10c0/5dcefea5f8f023b6cc24cbe71fb5a8112b601d36c4fa07d14e4e6ffc2ee47383332c46b36c766d9437725aa6660156eae50efa0c838719823b50d7c327c4ed42 + languageName: node + linkType: hard + +"agent-base@npm:6": + version: 6.0.2 + resolution: "agent-base@npm:6.0.2" + dependencies: + debug: "npm:4" + checksum: 10c0/dc4f757e40b5f3e3d674bc9beb4f1048f4ee83af189bae39be99f57bf1f48dde166a8b0a5342a84b5944ee8e6ed1e5a9d801858f4ad44764e84957122fe46261 + languageName: node + linkType: hard + +"ajv@npm:^6.14.0": + version: 6.15.0 + resolution: "ajv@npm:6.15.0" + dependencies: + fast-deep-equal: "npm:^3.1.1" + fast-json-stable-stringify: "npm:^2.0.0" + json-schema-traverse: "npm:^0.4.1" + uri-js: "npm:^4.2.2" + checksum: 10c0/67966499dd272ecde1c2e467084411132891523d057487587879d39ac04207f4351b7b2324c83198013967fbfa632c1612adc960114a30770fbe07a0773b32c2 + languageName: node + linkType: hard + +"array-buffer-byte-length@npm:^1.0.1, array-buffer-byte-length@npm:^1.0.2": + version: 1.0.2 + resolution: "array-buffer-byte-length@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.3" + is-array-buffer: "npm:^3.0.5" + checksum: 10c0/74e1d2d996941c7a1badda9cabb7caab8c449db9086407cad8a1b71d2604cc8abf105db8ca4e02c04579ec58b7be40279ddb09aea4784832984485499f48432d + languageName: node + linkType: hard + +"array-includes@npm:^3.1.6, array-includes@npm:^3.1.8": + version: 3.1.9 + resolution: "array-includes@npm:3.1.9" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.4" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.24.0" + es-object-atoms: "npm:^1.1.1" + get-intrinsic: "npm:^1.3.0" + is-string: "npm:^1.1.1" + math-intrinsics: "npm:^1.1.0" + checksum: 10c0/0235fa69078abeac05ac4250699c44996bc6f774a9cbe45db48674ce6bd142f09b327d31482ff75cf03344db4ea03eae23edb862d59378b484b47ed842574856 + languageName: node + linkType: hard + +"array.prototype.findlast@npm:^1.2.5": + version: 1.2.5 + resolution: "array.prototype.findlast@npm:1.2.5" + dependencies: + call-bind: "npm:^1.0.7" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.2" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.0.0" + es-shim-unscopables: "npm:^1.0.2" + checksum: 10c0/ddc952b829145ab45411b9d6adcb51a8c17c76bf89c9dd64b52d5dffa65d033da8c076ed2e17091779e83bc892b9848188d7b4b33453c5565e65a92863cb2775 + languageName: node + linkType: hard + +"array.prototype.flat@npm:^1.3.1": + version: 1.3.3 + resolution: "array.prototype.flat@npm:1.3.3" + dependencies: + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.5" + es-shim-unscopables: "npm:^1.0.2" + checksum: 10c0/d90e04dfbc43bb96b3d2248576753d1fb2298d2d972e29ca7ad5ec621f0d9e16ff8074dae647eac4f31f4fb7d3f561a7ac005fb01a71f51705a13b5af06a7d8a + languageName: node + linkType: hard + +"array.prototype.flatmap@npm:^1.3.3": + version: 1.3.3 + resolution: "array.prototype.flatmap@npm:1.3.3" + dependencies: + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.5" + es-shim-unscopables: "npm:^1.0.2" + checksum: 10c0/ba899ea22b9dc9bf276e773e98ac84638ed5e0236de06f13d63a90b18ca9e0ec7c97d622d899796e3773930b946cd2413d098656c0c5d8cc58c6f25c21e6bd54 + languageName: node + linkType: hard + +"array.prototype.tosorted@npm:^1.1.4": + version: 1.1.4 + resolution: "array.prototype.tosorted@npm:1.1.4" + dependencies: + call-bind: "npm:^1.0.7" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.3" + es-errors: "npm:^1.3.0" + es-shim-unscopables: "npm:^1.0.2" + checksum: 10c0/eb3c4c4fc0381b0bf6dba2ea4d48d367c2827a0d4236a5718d97caaccc6b78f11f4cadf090736e86301d295a6aa4967ed45568f92ced51be8cbbacd9ca410943 + languageName: node + linkType: hard + +"arraybuffer.prototype.slice@npm:^1.0.4": + version: 1.0.4 + resolution: "arraybuffer.prototype.slice@npm:1.0.4" + dependencies: + array-buffer-byte-length: "npm:^1.0.1" + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.5" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.6" + is-array-buffer: "npm:^3.0.4" + checksum: 10c0/2f2459caa06ae0f7f615003f9104b01f6435cc803e11bd2a655107d52a1781dc040532dc44d93026b694cc18793993246237423e13a5337e86b43ed604932c06 + languageName: node + linkType: hard + +"ast-metadata-inferer@npm:^0.8.1": + version: 0.8.1 + resolution: "ast-metadata-inferer@npm:0.8.1" + dependencies: + "@mdn/browser-compat-data": "npm:^5.6.19" + checksum: 10c0/4bfa6c268951f31123c2ea902d13d8fda5a226679a028eab7ccc063b5cc10964b07a30f075c3876fadaec315df9a894490ed24e6cb5c185afd373da42fff7a4f + languageName: node + linkType: hard + +"async-function@npm:^1.0.0": + version: 1.0.0 + resolution: "async-function@npm:1.0.0" + checksum: 10c0/669a32c2cb7e45091330c680e92eaeb791bc1d4132d827591e499cd1f776ff5a873e77e5f92d0ce795a8d60f10761dec9ddfe7225a5de680f5d357f67b1aac73 + languageName: node + linkType: hard + +"asynckit@npm:^0.4.0": + version: 0.4.0 + resolution: "asynckit@npm:0.4.0" + checksum: 10c0/d73e2ddf20c4eb9337e1b3df1a0f6159481050a5de457c55b14ea2e5cb6d90bb69e004c9af54737a5ee0917fcf2c9e25de67777bbe58261847846066ba75bc9d + languageName: node + linkType: hard + +"available-typed-arrays@npm:^1.0.7": + version: 1.0.7 + resolution: "available-typed-arrays@npm:1.0.7" + dependencies: + possible-typed-array-names: "npm:^1.0.0" + checksum: 10c0/d07226ef4f87daa01bd0fe80f8f310982e345f372926da2e5296aecc25c41cab440916bbaa4c5e1034b453af3392f67df5961124e4b586df1e99793a1374bdb2 + languageName: node + linkType: hard + +"axios@npm:^1.18.1": + version: 1.18.1 + resolution: "axios@npm:1.18.1" + dependencies: + follow-redirects: "npm:^1.16.0" + form-data: "npm:^4.0.5" + https-proxy-agent: "npm:^5.0.1" + proxy-from-env: "npm:^2.1.0" + checksum: 10c0/9d9378a3af0d0ad730a52ad9d15ec7201f3926ad6e7e8bbffc5ae21ca2835ad11d1d9598698f5dd9718917486039f55ea1d7dc23d8e44fa827a55cc3262c02fc + languageName: node + linkType: hard + +"babel-plugin-macros@npm:^3.1.0": + version: 3.1.0 + resolution: "babel-plugin-macros@npm:3.1.0" + dependencies: + "@babel/runtime": "npm:^7.12.5" + cosmiconfig: "npm:^7.0.0" + resolve: "npm:^1.19.0" + checksum: 10c0/c6dfb15de96f67871d95bd2e8c58b0c81edc08b9b087dc16755e7157f357dc1090a8dc60ebab955e92587a9101f02eba07e730adc253a1e4cf593ca3ebd3839c + languageName: node + linkType: hard + +"babel-plugin-transform-hook-names@npm:^1.0.2": + version: 1.0.2 + resolution: "babel-plugin-transform-hook-names@npm:1.0.2" + peerDependencies: + "@babel/core": ^7.12.10 + checksum: 10c0/517b85fe0611d742b3fffad5d0e119fcbd29bf69f95c6970b9ede4cb66453c7106a2d3bf048b35255b78a9d6a9565ad37e73b46c0be1fe557e941c792fad79f0 + languageName: node + linkType: hard + +"balanced-match@npm:^1.0.0": + version: 1.0.2 + resolution: "balanced-match@npm:1.0.2" + checksum: 10c0/9308baf0a7e4838a82bbfd11e01b1cb0f0cf2893bc1676c27c2a8c0e70cbae1c59120c3268517a8ae7fb6376b4639ef81ca22582611dbee4ed28df945134aaee + languageName: node + linkType: hard + +"balanced-match@npm:^4.0.2": + version: 4.0.4 + resolution: "balanced-match@npm:4.0.4" + checksum: 10c0/07e86102a3eb2ee2a6a1a89164f29d0dbaebd28f2ca3f5ca786f36b8b23d9e417eb3be45a4acf754f837be5ac0a2317de90d3fcb7f4f4dc95720a1f36b26a17b + languageName: node + linkType: hard + +"baseline-browser-mapping@npm:^2.10.12": + version: 2.10.38 + resolution: "baseline-browser-mapping@npm:2.10.38" + bin: + baseline-browser-mapping: dist/cli.cjs + checksum: 10c0/44bbea61ec54df6845f5f6f149c99057370081f1041d6e8dbc92835630ce37da9adc102528ebebd37f563342da2a5eea525d24698ced6674cdcfadb2ed613136 + languageName: node + linkType: hard + +"boolbase@npm:^1.0.0": + version: 1.0.0 + resolution: "boolbase@npm:1.0.0" + checksum: 10c0/e4b53deb4f2b85c52be0e21a273f2045c7b6a6ea002b0e139c744cb6f95e9ec044439a52883b0d74dedd1ff3da55ed140cfdddfed7fb0cccbed373de5dce1bcf + languageName: node + linkType: hard + +"brace-expansion@npm:^1.1.7": + version: 1.1.15 + resolution: "brace-expansion@npm:1.1.15" + dependencies: + balanced-match: "npm:^1.0.0" + concat-map: "npm:0.0.1" + checksum: 10c0/648e273f57cfa9ed67d8a77bdb15b408205465d33da9331808ee3c188d8b55674c9cdbf1f320b65bc562e485e1263360ae62ad355e128e0435891f6430e795d7 + languageName: node + linkType: hard + +"brace-expansion@npm:^5.0.5": + version: 5.0.6 + resolution: "brace-expansion@npm:5.0.6" + dependencies: + balanced-match: "npm:^4.0.2" + checksum: 10c0/8c919869b90f61d533b341d3340be5ee4413232ea89b8246cbc2f38eb014f1d8182785c98a006eaf6111d02dc9eeffefdc240d5ac158625b2ed084dccd4bbf9b + languageName: node + linkType: hard + +"browserslist@npm:^4.24.0, browserslist@npm:^4.25.2": + version: 4.28.2 + resolution: "browserslist@npm:4.28.2" + dependencies: + baseline-browser-mapping: "npm:^2.10.12" + caniuse-lite: "npm:^1.0.30001782" + electron-to-chromium: "npm:^1.5.328" + node-releases: "npm:^2.0.36" + update-browserslist-db: "npm:^1.2.3" + bin: + browserslist: cli.js + checksum: 10c0/c0228b6330f785b7fa59d2d360124ec6d9322f96ed9f3ee1f873e33ecc9503a6f0ffc3b71191a28c4ff6e930b753b30043da1c33844a9548f3018d491f09ce60 + languageName: node + linkType: hard + +"call-bind-apply-helpers@npm:^1.0.1, call-bind-apply-helpers@npm:^1.0.2": + version: 1.0.2 + resolution: "call-bind-apply-helpers@npm:1.0.2" + dependencies: + es-errors: "npm:^1.3.0" + function-bind: "npm:^1.1.2" + checksum: 10c0/47bd9901d57b857590431243fea704ff18078b16890a6b3e021e12d279bbf211d039155e27d7566b374d49ee1f8189344bac9833dec7a20cdec370506361c938 + languageName: node + linkType: hard + +"call-bind@npm:^1.0.7, call-bind@npm:^1.0.8, call-bind@npm:^1.0.9": + version: 1.0.9 + resolution: "call-bind@npm:1.0.9" + dependencies: + call-bind-apply-helpers: "npm:^1.0.2" + es-define-property: "npm:^1.0.1" + get-intrinsic: "npm:^1.3.0" + set-function-length: "npm:^1.2.2" + checksum: 10c0/a6621f6da1444481919ce3b4983dff725691e0754d3507ae483ce56e54985f2da7d6f1df512c56dbf28660745cf1ca52553f1fc9aef5557f3ce353ef14fab714 + languageName: node + linkType: hard + +"call-bound@npm:^1.0.2, call-bound@npm:^1.0.3, call-bound@npm:^1.0.4": + version: 1.0.4 + resolution: "call-bound@npm:1.0.4" + dependencies: + call-bind-apply-helpers: "npm:^1.0.2" + get-intrinsic: "npm:^1.3.0" + checksum: 10c0/f4796a6a0941e71c766aea672f63b72bc61234c4f4964dc6d7606e3664c307e7d77845328a8f3359ce39ddb377fed67318f9ee203dea1d47e46165dcf2917644 + languageName: node + linkType: hard + +"callsites@npm:^3.0.0": + version: 3.1.0 + resolution: "callsites@npm:3.1.0" + checksum: 10c0/fff92277400eb06c3079f9e74f3af120db9f8ea03bad0e84d9aede54bbe2d44a56cccb5f6cf12211f93f52306df87077ecec5b712794c5a9b5dac6d615a3f301 + languageName: node + linkType: hard + +"caniuse-lite@npm:^1.0.30001782": + version: 1.0.30001799 + resolution: "caniuse-lite@npm:1.0.30001799" + checksum: 10c0/f24f9834edc7b60188f368ce44714695c3901bc4acb7f2a977dd9b7b697e39ddc0f9947fad6224a955b789f36a73432cb888d620aa7280d728f582d3bd8927a7 + languageName: node + linkType: hard + +"chownr@npm:^3.0.0": + version: 3.0.0 + resolution: "chownr@npm:3.0.0" + checksum: 10c0/43925b87700f7e3893296c8e9c56cc58f926411cce3a6e5898136daaf08f08b9a8eb76d37d3267e707d0dcc17aed2e2ebdf5848c0c3ce95cf910a919935c1b10 + languageName: node + linkType: hard + +"clsx@npm:^2.1.1": + version: 2.1.1 + resolution: "clsx@npm:2.1.1" + checksum: 10c0/c4c8eb865f8c82baab07e71bfa8897c73454881c4f99d6bc81585aecd7c441746c1399d08363dc096c550cceaf97bd4ce1e8854e1771e9998d9f94c4fe075839 + languageName: node + linkType: hard + +"combined-stream@npm:^1.0.8": + version: 1.0.8 + resolution: "combined-stream@npm:1.0.8" + dependencies: + delayed-stream: "npm:~1.0.0" + checksum: 10c0/0dbb829577e1b1e839fa82b40c07ffaf7de8a09b935cadd355a73652ae70a88b4320db322f6634a4ad93424292fa80973ac6480986247f1734a1137debf271d5 + languageName: node + linkType: hard + +"concat-map@npm:0.0.1": + version: 0.0.1 + resolution: "concat-map@npm:0.0.1" + checksum: 10c0/c996b1cfdf95b6c90fee4dae37e332c8b6eb7d106430c17d538034c0ad9a1630cb194d2ab37293b1bdd4d779494beee7786d586a50bd9376fd6f7bcc2bd4c98f + languageName: node + linkType: hard + +"convert-source-map@npm:^1.5.0": + version: 1.9.0 + resolution: "convert-source-map@npm:1.9.0" + checksum: 10c0/281da55454bf8126cbc6625385928c43479f2060984180c42f3a86c8b8c12720a24eac260624a7d1e090004028d2dee78602330578ceec1a08e27cb8bb0a8a5b + languageName: node + linkType: hard + +"convert-source-map@npm:^2.0.0": + version: 2.0.0 + resolution: "convert-source-map@npm:2.0.0" + checksum: 10c0/8f2f7a27a1a011cc6cc88cc4da2d7d0cfa5ee0369508baae3d98c260bb3ac520691464e5bbe4ae7cdf09860c1d69ecc6f70c63c6e7c7f7e3f18ec08484dc7d9b + languageName: node + linkType: hard + +"cosmiconfig@npm:^7.0.0": + version: 7.1.0 + resolution: "cosmiconfig@npm:7.1.0" + dependencies: + "@types/parse-json": "npm:^4.0.0" + import-fresh: "npm:^3.2.1" + parse-json: "npm:^5.0.0" + path-type: "npm:^4.0.0" + yaml: "npm:^1.10.0" + checksum: 10c0/b923ff6af581638128e5f074a5450ba12c0300b71302398ea38dbeabd33bbcaa0245ca9adbedfcf284a07da50f99ede5658c80bb3e39e2ce770a99d28a21ef03 + languageName: node + linkType: hard + +"cross-spawn@npm:^7.0.6": + version: 7.0.6 + resolution: "cross-spawn@npm:7.0.6" + dependencies: + path-key: "npm:^3.1.0" + shebang-command: "npm:^2.0.0" + which: "npm:^2.0.1" + checksum: 10c0/053ea8b2135caff68a9e81470e845613e374e7309a47731e81639de3eaeb90c3d01af0e0b44d2ab9d50b43467223b88567dfeb3262db942dc063b9976718ffc1 + languageName: node + linkType: hard + +"css-select@npm:^5.1.0": + version: 5.2.2 + resolution: "css-select@npm:5.2.2" + dependencies: + boolbase: "npm:^1.0.0" + css-what: "npm:^6.1.0" + domhandler: "npm:^5.0.2" + domutils: "npm:^3.0.1" + nth-check: "npm:^2.0.1" + checksum: 10c0/d79fffa97106007f2802589f3ed17b8c903f1c961c0fc28aa8a051eee0cbad394d8446223862efd4c1b40445a6034f626bb639cf2035b0bfc468544177593c99 + languageName: node + linkType: hard + +"css-what@npm:^6.1.0": + version: 6.2.2 + resolution: "css-what@npm:6.2.2" + checksum: 10c0/91e24c26fb977b4ccef30d7007d2668c1c10ac0154cc3f42f7304410e9594fb772aea4f30c832d2993b132ca8d99338050866476210316345ec2e7d47b248a56 + languageName: node + linkType: hard + +"csstype@npm:^3.0.2, csstype@npm:^3.2.3": + version: 3.2.3 + resolution: "csstype@npm:3.2.3" + checksum: 10c0/cd29c51e70fa822f1cecd8641a1445bed7063697469d35633b516e60fe8c1bde04b08f6c5b6022136bb669b64c63d4173af54864510fbb4ee23281801841a3ce + languageName: node + linkType: hard + +"data-view-buffer@npm:^1.0.2": + version: 1.0.2 + resolution: "data-view-buffer@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.3" + es-errors: "npm:^1.3.0" + is-data-view: "npm:^1.0.2" + checksum: 10c0/7986d40fc7979e9e6241f85db8d17060dd9a71bd53c894fa29d126061715e322a4cd47a00b0b8c710394854183d4120462b980b8554012acc1c0fa49df7ad38c + languageName: node + linkType: hard + +"data-view-byte-length@npm:^1.0.2": + version: 1.0.2 + resolution: "data-view-byte-length@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.3" + es-errors: "npm:^1.3.0" + is-data-view: "npm:^1.0.2" + checksum: 10c0/f8a4534b5c69384d95ac18137d381f18a5cfae1f0fc1df0ef6feef51ef0d568606d970b69e02ea186c6c0f0eac77fe4e6ad96fec2569cc86c3afcc7475068c55 + languageName: node + linkType: hard + +"data-view-byte-offset@npm:^1.0.1": + version: 1.0.1 + resolution: "data-view-byte-offset@npm:1.0.1" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + is-data-view: "npm:^1.0.1" + checksum: 10c0/fa7aa40078025b7810dcffc16df02c480573b7b53ef1205aa6a61533011005c1890e5ba17018c692ce7c900212b547262d33279fde801ad9843edc0863bf78c4 + languageName: node + linkType: hard + +"debug@npm:4, debug@npm:^4.1.0, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.4.3": + version: 4.4.3 + resolution: "debug@npm:4.4.3" + dependencies: + ms: "npm:^2.1.3" + peerDependenciesMeta: + supports-color: + optional: true + checksum: 10c0/d79136ec6c83ecbefd0f6a5593da6a9c91ec4d7ddc4b54c883d6e71ec9accb5f67a1a5e96d00a328196b5b5c86d365e98d8a3a70856aaf16b4e7b1985e67f5a6 + languageName: node + linkType: hard + +"deep-is@npm:^0.1.3": + version: 0.1.4 + resolution: "deep-is@npm:0.1.4" + checksum: 10c0/7f0ee496e0dff14a573dc6127f14c95061b448b87b995fc96c017ce0a1e66af1675e73f1d6064407975bc4ea6ab679497a29fff7b5b9c4e99cb10797c1ad0b4c + languageName: node + linkType: hard + +"define-data-property@npm:^1.0.1, define-data-property@npm:^1.1.4": + version: 1.1.4 + resolution: "define-data-property@npm:1.1.4" + dependencies: + es-define-property: "npm:^1.0.0" + es-errors: "npm:^1.3.0" + gopd: "npm:^1.0.1" + checksum: 10c0/dea0606d1483eb9db8d930d4eac62ca0fa16738b0b3e07046cddfacf7d8c868bbe13fa0cb263eb91c7d0d527960dc3f2f2471a69ed7816210307f6744fe62e37 + languageName: node + linkType: hard + +"define-properties@npm:^1.1.3, define-properties@npm:^1.2.1": + version: 1.2.1 + resolution: "define-properties@npm:1.2.1" + dependencies: + define-data-property: "npm:^1.0.1" + has-property-descriptors: "npm:^1.0.0" + object-keys: "npm:^1.1.1" + checksum: 10c0/88a152319ffe1396ccc6ded510a3896e77efac7a1bfbaa174a7b00414a1747377e0bb525d303794a47cf30e805c2ec84e575758512c6e44a993076d29fd4e6c3 + languageName: node + linkType: hard + +"delayed-stream@npm:~1.0.0": + version: 1.0.0 + resolution: "delayed-stream@npm:1.0.0" + checksum: 10c0/d758899da03392e6712f042bec80aa293bbe9e9ff1b2634baae6a360113e708b91326594c8a486d475c69d6259afb7efacdc3537bfcda1c6c648e390ce601b19 + languageName: node + linkType: hard + +"doctrine@npm:^2.1.0": + version: 2.1.0 + resolution: "doctrine@npm:2.1.0" + dependencies: + esutils: "npm:^2.0.2" + checksum: 10c0/b6416aaff1f380bf56c3b552f31fdf7a69b45689368deca72d28636f41c16bb28ec3ebc40ace97db4c1afc0ceeb8120e8492fe0046841c94c2933b2e30a7d5ac + languageName: node + linkType: hard + +"dom-helpers@npm:^5.0.1": + version: 5.2.1 + resolution: "dom-helpers@npm:5.2.1" + dependencies: + "@babel/runtime": "npm:^7.8.7" + csstype: "npm:^3.0.2" + checksum: 10c0/f735074d66dd759b36b158fa26e9d00c9388ee0e8c9b16af941c38f014a37fc80782de83afefd621681b19ac0501034b4f1c4a3bff5caa1b8667f0212b5e124c + languageName: node + linkType: hard + +"dom-serializer@npm:^2.0.0": + version: 2.0.0 + resolution: "dom-serializer@npm:2.0.0" + dependencies: + domelementtype: "npm:^2.3.0" + domhandler: "npm:^5.0.2" + entities: "npm:^4.2.0" + checksum: 10c0/d5ae2b7110ca3746b3643d3ef60ef823f5f078667baf530cec096433f1627ec4b6fa8c072f09d079d7cda915fd2c7bc1b7b935681e9b09e591e1e15f4040b8e2 + languageName: node + linkType: hard + +"domelementtype@npm:^2.3.0": + version: 2.3.0 + resolution: "domelementtype@npm:2.3.0" + checksum: 10c0/686f5a9ef0fff078c1412c05db73a0dce096190036f33e400a07e2a4518e9f56b1e324f5c576a0a747ef0e75b5d985c040b0d51945ce780c0dd3c625a18cd8c9 + languageName: node + linkType: hard + +"domhandler@npm:^5.0.2, domhandler@npm:^5.0.3": + version: 5.0.3 + resolution: "domhandler@npm:5.0.3" + dependencies: + domelementtype: "npm:^2.3.0" + checksum: 10c0/bba1e5932b3e196ad6862286d76adc89a0dbf0c773e5ced1eb01f9af930c50093a084eff14b8de5ea60b895c56a04d5de8bbc4930c5543d029091916770b2d2a + languageName: node + linkType: hard + +"domutils@npm:^3.0.1": + version: 3.2.2 + resolution: "domutils@npm:3.2.2" + dependencies: + dom-serializer: "npm:^2.0.0" + domelementtype: "npm:^2.3.0" + domhandler: "npm:^5.0.3" + checksum: 10c0/47938f473b987ea71cd59e59626eb8666d3aa8feba5266e45527f3b636c7883cca7e582d901531961f742c519d7514636b7973353b648762b2e3bedbf235fada + languageName: node + linkType: hard + +"dunder-proto@npm:^1.0.0, dunder-proto@npm:^1.0.1": + version: 1.0.1 + resolution: "dunder-proto@npm:1.0.1" + dependencies: + call-bind-apply-helpers: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + gopd: "npm:^1.2.0" + checksum: 10c0/199f2a0c1c16593ca0a145dbf76a962f8033ce3129f01284d48c45ed4e14fea9bbacd7b3610b6cdc33486cef20385ac054948fefc6272fcce645c09468f93031 + languageName: node + linkType: hard + +"electron-to-chromium@npm:^1.5.328": + version: 1.5.376 + resolution: "electron-to-chromium@npm:1.5.376" + checksum: 10c0/c57e306ef12ad258e427218f90e14d155dfba68b23699674d7b66e528ce41ff69b46a78f38545ee7690d080d25d3ebb98338282e95d65510e8fa5fd4f7455a86 + languageName: node + linkType: hard + +"empathic@npm:^2.0.1": + version: 2.0.1 + resolution: "empathic@npm:2.0.1" + checksum: 10c0/577f2868bfcad4ffbf911b57c75016125eb8cc8a7d32cf2d3e9fbcb31bfe6e9e6b66d9457ac34ccb2cd38bff353b3af34287899e0360b8c561ff6d4a048aca62 + languageName: node + linkType: hard + +"entities@npm:^4.2.0": + version: 4.5.0 + resolution: "entities@npm:4.5.0" + checksum: 10c0/5b039739f7621f5d1ad996715e53d964035f75ad3b9a4d38c6b3804bb226e282ffeae2443624d8fdd9c47d8e926ae9ac009c54671243f0c3294c26af7cc85250 + languageName: node + linkType: hard + +"env-paths@npm:^2.2.0": + version: 2.2.1 + resolution: "env-paths@npm:2.2.1" + checksum: 10c0/285325677bf00e30845e330eec32894f5105529db97496ee3f598478e50f008c5352a41a30e5e72ec9de8a542b5a570b85699cd63bd2bc646dbcb9f311d83bc4 + languageName: node + linkType: hard + +"error-ex@npm:^1.3.1": + version: 1.3.4 + resolution: "error-ex@npm:1.3.4" + dependencies: + is-arrayish: "npm:^0.2.1" + checksum: 10c0/b9e34ff4778b8f3b31a8377e1c654456f4c41aeaa3d10a1138c3b7635d8b7b2e03eb2475d46d8ae055c1f180a1063e100bffabf64ea7e7388b37735df5328664 + languageName: node + linkType: hard + +"es-abstract-get@npm:^1.0.0": + version: 1.0.0 + resolution: "es-abstract-get@npm:1.0.0" + dependencies: + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.1.2" + is-callable: "npm:^1.2.7" + object-inspect: "npm:^1.13.4" + checksum: 10c0/f9b4838ae719752207383a6d95a74590f891122bf26b92f5e72eeedbe53771029e4561f1cf75ea19330b71bcf3d4f536fb0c8f7e2b601fe24d284f46e488c7e3 + languageName: node + linkType: hard + +"es-abstract@npm:^1.17.5, es-abstract@npm:^1.23.2, es-abstract@npm:^1.23.3, es-abstract@npm:^1.23.5, es-abstract@npm:^1.23.6, es-abstract@npm:^1.23.9, es-abstract@npm:^1.24.0, es-abstract@npm:^1.24.2": + version: 1.24.2 + resolution: "es-abstract@npm:1.24.2" + dependencies: + array-buffer-byte-length: "npm:^1.0.2" + arraybuffer.prototype.slice: "npm:^1.0.4" + available-typed-arrays: "npm:^1.0.7" + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.4" + data-view-buffer: "npm:^1.0.2" + data-view-byte-length: "npm:^1.0.2" + data-view-byte-offset: "npm:^1.0.1" + es-define-property: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.1.1" + es-set-tostringtag: "npm:^2.1.0" + es-to-primitive: "npm:^1.3.0" + function.prototype.name: "npm:^1.1.8" + get-intrinsic: "npm:^1.3.0" + get-proto: "npm:^1.0.1" + get-symbol-description: "npm:^1.1.0" + globalthis: "npm:^1.0.4" + gopd: "npm:^1.2.0" + has-property-descriptors: "npm:^1.0.2" + has-proto: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + hasown: "npm:^2.0.2" + internal-slot: "npm:^1.1.0" + is-array-buffer: "npm:^3.0.5" + is-callable: "npm:^1.2.7" + is-data-view: "npm:^1.0.2" + is-negative-zero: "npm:^2.0.3" + is-regex: "npm:^1.2.1" + is-set: "npm:^2.0.3" + is-shared-array-buffer: "npm:^1.0.4" + is-string: "npm:^1.1.1" + is-typed-array: "npm:^1.1.15" + is-weakref: "npm:^1.1.1" + math-intrinsics: "npm:^1.1.0" + object-inspect: "npm:^1.13.4" + object-keys: "npm:^1.1.1" + object.assign: "npm:^4.1.7" + own-keys: "npm:^1.0.1" + regexp.prototype.flags: "npm:^1.5.4" + safe-array-concat: "npm:^1.1.3" + safe-push-apply: "npm:^1.0.0" + safe-regex-test: "npm:^1.1.0" + set-proto: "npm:^1.0.0" + stop-iteration-iterator: "npm:^1.1.0" + string.prototype.trim: "npm:^1.2.10" + string.prototype.trimend: "npm:^1.0.9" + string.prototype.trimstart: "npm:^1.0.8" + typed-array-buffer: "npm:^1.0.3" + typed-array-byte-length: "npm:^1.0.3" + typed-array-byte-offset: "npm:^1.0.4" + typed-array-length: "npm:^1.0.7" + unbox-primitive: "npm:^1.1.0" + which-typed-array: "npm:^1.1.19" + checksum: 10c0/67a5bf21ef5c7d775e6f6131a836323900b4d87194cf544394ac68fe31c57fa53828b978af4a4f551ef307f83a2f910a16b6b982760ad3ddc3dc471f98d5fd1b + languageName: node + linkType: hard + +"es-define-property@npm:^1.0.0, es-define-property@npm:^1.0.1": + version: 1.0.1 + resolution: "es-define-property@npm:1.0.1" + checksum: 10c0/3f54eb49c16c18707949ff25a1456728c883e81259f045003499efba399c08bad00deebf65cccde8c0e07908c1a225c9d472b7107e558f2a48e28d530e34527c + languageName: node + linkType: hard + +"es-errors@npm:^1.3.0": + version: 1.3.0 + resolution: "es-errors@npm:1.3.0" + checksum: 10c0/0a61325670072f98d8ae3b914edab3559b6caa980f08054a3b872052640d91da01d38df55df797fcc916389d77fc92b8d5906cf028f4db46d7e3003abecbca85 + languageName: node + linkType: hard + +"es-iterator-helpers@npm:^1.2.1": + version: 1.3.3 + resolution: "es-iterator-helpers@npm:1.3.3" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.24.2" + es-errors: "npm:^1.3.0" + es-set-tostringtag: "npm:^2.1.0" + function-bind: "npm:^1.1.2" + get-intrinsic: "npm:^1.3.0" + globalthis: "npm:^1.0.4" + gopd: "npm:^1.2.0" + has-property-descriptors: "npm:^1.0.2" + has-proto: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + internal-slot: "npm:^1.1.0" + iterator.prototype: "npm:^1.1.5" + math-intrinsics: "npm:^1.1.0" + checksum: 10c0/14d45ce96c1eeec1dfb76607f4277163c847cc799a417c69346bfd2a9cce04b1d1426e34cb867dbc3266d2ca516084259ff1836cd2da6bc70b3e25e02f3532a9 + languageName: node + linkType: hard + +"es-object-atoms@npm:^1.0.0, es-object-atoms@npm:^1.1.1, es-object-atoms@npm:^1.1.2": + version: 1.1.2 + resolution: "es-object-atoms@npm:1.1.2" + dependencies: + es-errors: "npm:^1.3.0" + checksum: 10c0/1772861f094f739d6f41b579cfb9a18579daffeb434552a370a5fbef50a32d22227e27b63fdbb757b7ddd429d1b42fe52ccae7966d9302a2ec221b6f1b41bbc4 + languageName: node + linkType: hard + +"es-set-tostringtag@npm:^2.1.0": + version: 2.1.0 + resolution: "es-set-tostringtag@npm:2.1.0" + dependencies: + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.6" + has-tostringtag: "npm:^1.0.2" + hasown: "npm:^2.0.2" + checksum: 10c0/ef2ca9ce49afe3931cb32e35da4dcb6d86ab02592cfc2ce3e49ced199d9d0bb5085fc7e73e06312213765f5efa47cc1df553a6a5154584b21448e9fb8355b1af + languageName: node + linkType: hard + +"es-shim-unscopables@npm:^1.0.2": + version: 1.1.0 + resolution: "es-shim-unscopables@npm:1.1.0" + dependencies: + hasown: "npm:^2.0.2" + checksum: 10c0/1b9702c8a1823fc3ef39035a4e958802cf294dd21e917397c561d0b3e195f383b978359816b1732d02b255ccf63e1e4815da0065b95db8d7c992037be3bbbcdb + languageName: node + linkType: hard + +"es-to-primitive@npm:^1.3.0": + version: 1.3.1 + resolution: "es-to-primitive@npm:1.3.1" + dependencies: + es-abstract-get: "npm:^1.0.0" + es-errors: "npm:^1.3.0" + is-callable: "npm:^1.2.7" + is-date-object: "npm:^1.1.0" + is-symbol: "npm:^1.1.1" + checksum: 10c0/288ec25e5d08c2718bab9faa87924e11f42f2b0b59854fc241f1fbbedcadf2682ab3a9a9fb4676fa40c483ce563ea63cfd3e33777cbb53833e94d5f60a851cde + languageName: node + linkType: hard + +"esbuild@npm:^0.27.0": + version: 0.27.7 + resolution: "esbuild@npm:0.27.7" + dependencies: + "@esbuild/aix-ppc64": "npm:0.27.7" + "@esbuild/android-arm": "npm:0.27.7" + "@esbuild/android-arm64": "npm:0.27.7" + "@esbuild/android-x64": "npm:0.27.7" + "@esbuild/darwin-arm64": "npm:0.27.7" + "@esbuild/darwin-x64": "npm:0.27.7" + "@esbuild/freebsd-arm64": "npm:0.27.7" + "@esbuild/freebsd-x64": "npm:0.27.7" + "@esbuild/linux-arm": "npm:0.27.7" + "@esbuild/linux-arm64": "npm:0.27.7" + "@esbuild/linux-ia32": "npm:0.27.7" + "@esbuild/linux-loong64": "npm:0.27.7" + "@esbuild/linux-mips64el": "npm:0.27.7" + "@esbuild/linux-ppc64": "npm:0.27.7" + "@esbuild/linux-riscv64": "npm:0.27.7" + "@esbuild/linux-s390x": "npm:0.27.7" + "@esbuild/linux-x64": "npm:0.27.7" + "@esbuild/netbsd-arm64": "npm:0.27.7" + "@esbuild/netbsd-x64": "npm:0.27.7" + "@esbuild/openbsd-arm64": "npm:0.27.7" + "@esbuild/openbsd-x64": "npm:0.27.7" + "@esbuild/openharmony-arm64": "npm:0.27.7" + "@esbuild/sunos-x64": "npm:0.27.7" + "@esbuild/win32-arm64": "npm:0.27.7" + "@esbuild/win32-ia32": "npm:0.27.7" + "@esbuild/win32-x64": "npm:0.27.7" + dependenciesMeta: + "@esbuild/aix-ppc64": + optional: true + "@esbuild/android-arm": + optional: true + "@esbuild/android-arm64": + optional: true + "@esbuild/android-x64": + optional: true + "@esbuild/darwin-arm64": + optional: true + "@esbuild/darwin-x64": + optional: true + "@esbuild/freebsd-arm64": + optional: true + "@esbuild/freebsd-x64": + optional: true + "@esbuild/linux-arm": + optional: true + "@esbuild/linux-arm64": + optional: true + "@esbuild/linux-ia32": + optional: true + "@esbuild/linux-loong64": + optional: true + "@esbuild/linux-mips64el": + optional: true + "@esbuild/linux-ppc64": + optional: true + "@esbuild/linux-riscv64": + optional: true + "@esbuild/linux-s390x": + optional: true + "@esbuild/linux-x64": + optional: true + "@esbuild/netbsd-arm64": + optional: true + "@esbuild/netbsd-x64": + optional: true + "@esbuild/openbsd-arm64": + optional: true + "@esbuild/openbsd-x64": + optional: true + "@esbuild/openharmony-arm64": + optional: true + "@esbuild/sunos-x64": + optional: true + "@esbuild/win32-arm64": + optional: true + "@esbuild/win32-ia32": + optional: true + "@esbuild/win32-x64": + optional: true + bin: + esbuild: bin/esbuild + checksum: 10c0/ccd51f0555708bc9ff4ec9dc3ac92d3daacd45ecaac949ca8645984c5c323bf8cefe98c2df307418685e0b4ce37f9a3bdbfe8e3651fe632a0059a436195a17d4 + languageName: node + linkType: hard + +"escalade@npm:^3.2.0": + version: 3.2.0 + resolution: "escalade@npm:3.2.0" + checksum: 10c0/ced4dd3a78e15897ed3be74e635110bbf3b08877b0a41be50dcb325ee0e0b5f65fc2d50e9845194d7c4633f327e2e1c6cce00a71b617c5673df0374201d67f65 + languageName: node + linkType: hard + +"escape-string-regexp@npm:^4.0.0": + version: 4.0.0 + resolution: "escape-string-regexp@npm:4.0.0" + checksum: 10c0/9497d4dd307d845bd7f75180d8188bb17ea8c151c1edbf6b6717c100e104d629dc2dfb687686181b0f4b7d732c7dfdc4d5e7a8ff72de1b0ca283a75bbb3a9cd9 + languageName: node + linkType: hard + +"eslint-config-preact@npm:^2.0.0": + version: 2.0.0 + resolution: "eslint-config-preact@npm:2.0.0" + dependencies: + "@babel/core": "npm:^7.13.16" + "@babel/eslint-parser": "npm:^7.27.5" + "@babel/plugin-syntax-class-properties": "npm:^7.12.13" + "@babel/plugin-syntax-jsx": "npm:^7.12.13" + "@eslint/js": "npm:^9.29.0" + eslint-plugin-compat: "npm:^6.0.2" + eslint-plugin-react: "npm:^7.37.5" + eslint-plugin-react-hooks: "npm:^5.2.0" + globals: "npm:^16.2.0" + peerDependencies: + eslint: ^8.57.1 || ^9.0.0 + checksum: 10c0/aebc4b09eb48d8b8b152d76cec56df59840397c497ea7bb0017d4855c94bb5b87fb211cc386acbddacade50011aa745169fff255893c3e8f23fde9981cb00012 + languageName: node + linkType: hard + +"eslint-plugin-compat@npm:^6.0.2": + version: 6.2.1 + resolution: "eslint-plugin-compat@npm:6.2.1" + dependencies: + "@mdn/browser-compat-data": "npm:^6.1.1" + ast-metadata-inferer: "npm:^0.8.1" + browserslist: "npm:^4.25.2" + find-up: "npm:^5.0.0" + globals: "npm:^15.7.0" + lodash.memoize: "npm:^4.1.2" + semver: "npm:^7.6.2" + peerDependencies: + eslint: ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0 + checksum: 10c0/08dc5ea7c46eed9cd2e656bfc32318fb2d3e5ba661bbd1b88633b316e5ab3ab898f7987353645f5b525c6b9ffa81d47b8c7d4f77b24fed9991c206b156d9a1ae + languageName: node + linkType: hard + +"eslint-plugin-react-hooks@npm:^5.2.0": + version: 5.2.0 + resolution: "eslint-plugin-react-hooks@npm:5.2.0" + peerDependencies: + eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 + checksum: 10c0/1c8d50fa5984c6dea32470651807d2922cc3934cf3425e78f84a24c2dfd972e7f019bee84aefb27e0cf2c13fea0ac1d4473267727408feeb1c56333ca1489385 + languageName: node + linkType: hard + +"eslint-plugin-react@npm:^7.37.5": + version: 7.37.5 + resolution: "eslint-plugin-react@npm:7.37.5" + dependencies: + array-includes: "npm:^3.1.8" + array.prototype.findlast: "npm:^1.2.5" + array.prototype.flatmap: "npm:^1.3.3" + array.prototype.tosorted: "npm:^1.1.4" + doctrine: "npm:^2.1.0" + es-iterator-helpers: "npm:^1.2.1" + estraverse: "npm:^5.3.0" + hasown: "npm:^2.0.2" + jsx-ast-utils: "npm:^2.4.1 || ^3.0.0" + minimatch: "npm:^3.1.2" + object.entries: "npm:^1.1.9" + object.fromentries: "npm:^2.0.8" + object.values: "npm:^1.2.1" + prop-types: "npm:^15.8.1" + resolve: "npm:^2.0.0-next.5" + semver: "npm:^6.3.1" + string.prototype.matchall: "npm:^4.0.12" + string.prototype.repeat: "npm:^1.0.0" + peerDependencies: + eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7 + checksum: 10c0/c850bfd556291d4d9234f5ca38db1436924a1013627c8ab1853f77cac73ec19b020e861e6c7b783436a48b6ffcdfba4547598235a37ad4611b6739f65fd8ad57 + languageName: node + linkType: hard + +"eslint-scope@npm:5.1.1": + version: 5.1.1 + resolution: "eslint-scope@npm:5.1.1" + dependencies: + esrecurse: "npm:^4.3.0" + estraverse: "npm:^4.1.1" + checksum: 10c0/d30ef9dc1c1cbdece34db1539a4933fe3f9b14e1ffb27ecc85987902ee663ad7c9473bbd49a9a03195a373741e62e2f807c4938992e019b511993d163450e70a + languageName: node + linkType: hard + +"eslint-scope@npm:^9.1.2": + version: 9.1.2 + resolution: "eslint-scope@npm:9.1.2" + dependencies: + "@types/esrecurse": "npm:^4.3.1" + "@types/estree": "npm:^1.0.8" + esrecurse: "npm:^4.3.0" + estraverse: "npm:^5.2.0" + checksum: 10c0/9fb8bca5a73e5741efb6cec84467027b6cb6f4203ff9b43a938e272c5cd30800bde46a5c20dfd1609f840225f0b62b7673be391b20acadf8658ca9fa4729b3dd + languageName: node + linkType: hard + +"eslint-visitor-keys@npm:^2.1.0": + version: 2.1.0 + resolution: "eslint-visitor-keys@npm:2.1.0" + checksum: 10c0/9f0e3a2db751d84067d15977ac4b4472efd6b303e369e6ff241a99feac04da758f46d5add022c33d06b53596038dbae4b4aceb27c7e68b8dfc1055b35e495787 + languageName: node + linkType: hard + +"eslint-visitor-keys@npm:^3.4.3": + version: 3.4.3 + resolution: "eslint-visitor-keys@npm:3.4.3" + checksum: 10c0/92708e882c0a5ffd88c23c0b404ac1628cf20104a108c745f240a13c332a11aac54f49a22d5762efbffc18ecbc9a580d1b7ad034bf5f3cc3307e5cbff2ec9820 + languageName: node + linkType: hard + +"eslint-visitor-keys@npm:^5.0.1": + version: 5.0.1 + resolution: "eslint-visitor-keys@npm:5.0.1" + checksum: 10c0/16190bdf2cbae40a1109384c94450c526a79b0b9c3cb21e544256ed85ac48a4b84db66b74a6561d20fe6ab77447f150d711c2ad5ad74df4fcc133736bce99678 + languageName: node + linkType: hard + +"eslint@npm:^10.5.0": + version: 10.5.0 + resolution: "eslint@npm:10.5.0" + dependencies: + "@eslint-community/eslint-utils": "npm:^4.8.0" + "@eslint-community/regexpp": "npm:^4.12.2" + "@eslint/config-array": "npm:^0.23.5" + "@eslint/config-helpers": "npm:^0.6.0" + "@eslint/core": "npm:^1.2.1" + "@eslint/plugin-kit": "npm:^0.7.2" + "@humanfs/node": "npm:^0.16.6" + "@humanwhocodes/module-importer": "npm:^1.0.1" + "@humanwhocodes/retry": "npm:^0.4.2" + "@types/estree": "npm:^1.0.6" + ajv: "npm:^6.14.0" + cross-spawn: "npm:^7.0.6" + debug: "npm:^4.3.2" + escape-string-regexp: "npm:^4.0.0" + eslint-scope: "npm:^9.1.2" + eslint-visitor-keys: "npm:^5.0.1" + espree: "npm:^11.2.0" + esquery: "npm:^1.7.0" + esutils: "npm:^2.0.2" + fast-deep-equal: "npm:^3.1.3" + file-entry-cache: "npm:^8.0.0" + find-up: "npm:^5.0.0" + glob-parent: "npm:^6.0.2" + ignore: "npm:^5.2.0" + imurmurhash: "npm:^0.1.4" + is-glob: "npm:^4.0.0" + json-stable-stringify-without-jsonify: "npm:^1.0.1" + minimatch: "npm:^10.2.4" + natural-compare: "npm:^1.4.0" + optionator: "npm:^0.9.3" + peerDependencies: + jiti: "*" + peerDependenciesMeta: + jiti: + optional: true + bin: + eslint: bin/eslint.js + checksum: 10c0/e1f7a1d442027e5478945cb07b6a382adc3f149fbfd3dbc14951a7a9fa312546b27fb35b0556897ca1d04539ad16ee85bda75ad9f724873e1153d1fbca0d6145 + languageName: node + linkType: hard + +"espree@npm:^11.2.0": + version: 11.2.0 + resolution: "espree@npm:11.2.0" + dependencies: + acorn: "npm:^8.16.0" + acorn-jsx: "npm:^5.3.2" + eslint-visitor-keys: "npm:^5.0.1" + checksum: 10c0/cf87e18ffd9dc113eb8d16588e7757701bc10c9934a71cce8b89c2611d51672681a918307bd6b19ac3ccd0e7ba1cbccc2f815b36b52fa7e73097b251014c3d81 + languageName: node + linkType: hard + +"esquery@npm:^1.7.0": + version: 1.7.0 + resolution: "esquery@npm:1.7.0" + dependencies: + estraverse: "npm:^5.1.0" + checksum: 10c0/77d5173db450b66f3bc685d11af4c90cffeedb340f34a39af96d43509a335ce39c894fd79233df32d38f5e4e219fa0f7076f6ec90bae8320170ba082c0db4793 + languageName: node + linkType: hard + +"esrecurse@npm:^4.3.0": + version: 4.3.0 + resolution: "esrecurse@npm:4.3.0" + dependencies: + estraverse: "npm:^5.2.0" + checksum: 10c0/81a37116d1408ded88ada45b9fb16dbd26fba3aadc369ce50fcaf82a0bac12772ebd7b24cd7b91fc66786bf2c1ac7b5f196bc990a473efff972f5cb338877cf5 + languageName: node + linkType: hard + +"estraverse@npm:^4.1.1": + version: 4.3.0 + resolution: "estraverse@npm:4.3.0" + checksum: 10c0/9cb46463ef8a8a4905d3708a652d60122a0c20bb58dec7e0e12ab0e7235123d74214fc0141d743c381813e1b992767e2708194f6f6e0f9fd00c1b4e0887b8b6d + languageName: node + linkType: hard + +"estraverse@npm:^5.1.0, estraverse@npm:^5.2.0, estraverse@npm:^5.3.0": + version: 5.3.0 + resolution: "estraverse@npm:5.3.0" + checksum: 10c0/1ff9447b96263dec95d6d67431c5e0771eb9776427421260a3e2f0fdd5d6bd4f8e37a7338f5ad2880c9f143450c9b1e4fc2069060724570a49cf9cf0312bd107 + languageName: node + linkType: hard + +"estree-walker@npm:^2.0.1, estree-walker@npm:^2.0.2": + version: 2.0.2 + resolution: "estree-walker@npm:2.0.2" + checksum: 10c0/53a6c54e2019b8c914dc395890153ffdc2322781acf4bd7d1a32d7aedc1710807bdcd866ac133903d5629ec601fbb50abe8c2e5553c7f5a0afdd9b6af6c945af + languageName: node + linkType: hard + +"esutils@npm:^2.0.2": + version: 2.0.3 + resolution: "esutils@npm:2.0.3" + checksum: 10c0/9a2fe69a41bfdade834ba7c42de4723c97ec776e40656919c62cbd13607c45e127a003f05f724a1ea55e5029a4cf2de444b13009f2af71271e42d93a637137c7 + languageName: node + linkType: hard + +"exponential-backoff@npm:^3.1.1": + version: 3.1.3 + resolution: "exponential-backoff@npm:3.1.3" + checksum: 10c0/77e3ae682b7b1f4972f563c6dbcd2b0d54ac679e62d5d32f3e5085feba20483cf28bd505543f520e287a56d4d55a28d7874299941faf637e779a1aa5994d1267 + languageName: node + linkType: hard + +"fast-deep-equal@npm:^3.1.1, fast-deep-equal@npm:^3.1.3": + version: 3.1.3 + resolution: "fast-deep-equal@npm:3.1.3" + checksum: 10c0/40dedc862eb8992c54579c66d914635afbec43350afbbe991235fdcb4e3a8d5af1b23ae7e79bef7d4882d0ecee06c3197488026998fb19f72dc95acff1d1b1d0 + languageName: node + linkType: hard + +"fast-json-stable-stringify@npm:^2.0.0": + version: 2.1.0 + resolution: "fast-json-stable-stringify@npm:2.1.0" + checksum: 10c0/7f081eb0b8a64e0057b3bb03f974b3ef00135fbf36c1c710895cd9300f13c94ba809bb3a81cf4e1b03f6e5285610a61abbd7602d0652de423144dfee5a389c9b + languageName: node + linkType: hard + +"fast-levenshtein@npm:^2.0.6": + version: 2.0.6 + resolution: "fast-levenshtein@npm:2.0.6" + checksum: 10c0/111972b37338bcb88f7d9e2c5907862c280ebf4234433b95bc611e518d192ccb2d38119c4ac86e26b668d75f7f3894f4ff5c4982899afced7ca78633b08287c4 + languageName: node + linkType: hard + +"fdir@npm:^6.5.0": + version: 6.5.0 + resolution: "fdir@npm:6.5.0" + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + checksum: 10c0/e345083c4306b3aed6cb8ec551e26c36bab5c511e99ea4576a16750ddc8d3240e63826cc624f5ae17ad4dc82e68a253213b60d556c11bfad064b7607847ed07f + languageName: node + linkType: hard + +"file-entry-cache@npm:^8.0.0": + version: 8.0.0 + resolution: "file-entry-cache@npm:8.0.0" + dependencies: + flat-cache: "npm:^4.0.0" + checksum: 10c0/9e2b5938b1cd9b6d7e3612bdc533afd4ac17b2fc646569e9a8abbf2eb48e5eb8e316bc38815a3ef6a1b456f4107f0d0f055a614ca613e75db6bf9ff4d72c1638 + languageName: node + linkType: hard + +"find-root@npm:^1.1.0": + version: 1.1.0 + resolution: "find-root@npm:1.1.0" + checksum: 10c0/1abc7f3bf2f8d78ff26d9e00ce9d0f7b32e5ff6d1da2857bcdf4746134c422282b091c672cde0572cac3840713487e0a7a636af9aa1b74cb11894b447a521efa + languageName: node + linkType: hard + +"find-up@npm:^5.0.0": + version: 5.0.0 + resolution: "find-up@npm:5.0.0" + dependencies: + locate-path: "npm:^6.0.0" + path-exists: "npm:^4.0.0" + checksum: 10c0/062c5a83a9c02f53cdd6d175a37ecf8f87ea5bbff1fdfb828f04bfa021441bc7583e8ebc0872a4c1baab96221fb8a8a275a19809fb93fbc40bd69ec35634069a + languageName: node + linkType: hard + +"flat-cache@npm:^4.0.0": + version: 4.0.1 + resolution: "flat-cache@npm:4.0.1" + dependencies: + flatted: "npm:^3.2.9" + keyv: "npm:^4.5.4" + checksum: 10c0/2c59d93e9faa2523e4fda6b4ada749bed432cfa28c8e251f33b25795e426a1c6dbada777afb1f74fcfff33934fdbdea921ee738fcc33e71adc9d6eca984a1cfc + languageName: node + linkType: hard + +"flatted@npm:^3.2.9": + version: 3.4.2 + resolution: "flatted@npm:3.4.2" + checksum: 10c0/a65b67aae7172d6cdf63691be7de6c5cd5adbdfdfe2e9da1a09b617c9512ed794037741ee53d93114276bff3f93cd3b0d97d54f9b316e1e4885dde6e9ffdf7ed + languageName: node + linkType: hard + +"follow-redirects@npm:^1.16.0": + version: 1.16.0 + resolution: "follow-redirects@npm:1.16.0" + peerDependenciesMeta: + debug: + optional: true + checksum: 10c0/a1e2900163e6f1b4d1ed5c221b607f41decbab65534c63fe7e287e40a5d552a6496e7d9d7d976fa4ba77b4c51c11e5e9f683f10b43011ea11e442ff128d0e181 + languageName: node + linkType: hard + +"for-each@npm:^0.3.3, for-each@npm:^0.3.5": + version: 0.3.5 + resolution: "for-each@npm:0.3.5" + dependencies: + is-callable: "npm:^1.2.7" + checksum: 10c0/0e0b50f6a843a282637d43674d1fb278dda1dd85f4f99b640024cfb10b85058aac0cc781bf689d5fe50b4b7f638e91e548560723a4e76e04fe96ae35ef039cee + languageName: node + linkType: hard + +"form-data@npm:^4.0.5": + version: 4.0.6 + resolution: "form-data@npm:4.0.6" + dependencies: + asynckit: "npm:^0.4.0" + combined-stream: "npm:^1.0.8" + es-set-tostringtag: "npm:^2.1.0" + hasown: "npm:^2.0.4" + mime-types: "npm:^2.1.35" + checksum: 10c0/43947a77bf0ff45c6ceed789778982d47a3f3e720a74b71721174ebf3310a5f1a8be1d6b38a3ee3688e8a18a2c4273073ec0844cd37efda3eaf46d41c9c318ff + languageName: node + linkType: hard + +"fsevents@npm:~2.3.2, fsevents@npm:~2.3.3": + version: 2.3.3 + resolution: "fsevents@npm:2.3.3" + dependencies: + node-gyp: "npm:latest" + checksum: 10c0/a1f0c44595123ed717febbc478aa952e47adfc28e2092be66b8ab1635147254ca6cfe1df792a8997f22716d4cbafc73309899ff7bfac2ac3ad8cf2e4ecc3ec60 + conditions: os=darwin + languageName: node + linkType: hard + +"fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin, fsevents@patch:fsevents@npm%3A~2.3.3#optional!builtin": + version: 2.3.3 + resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin::version=2.3.3&hash=df0bf1" + dependencies: + node-gyp: "npm:latest" + conditions: os=darwin + languageName: node + linkType: hard + +"function-bind@npm:^1.1.2": + version: 1.1.2 + resolution: "function-bind@npm:1.1.2" + checksum: 10c0/d8680ee1e5fcd4c197e4ac33b2b4dce03c71f4d91717292785703db200f5c21f977c568d28061226f9b5900cbcd2c84463646134fd5337e7925e0942bc3f46d5 + languageName: node + linkType: hard + +"function.prototype.name@npm:^1.1.6, function.prototype.name@npm:^1.1.8": + version: 1.2.0 + resolution: "function.prototype.name@npm:1.2.0" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + es-define-property: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + functions-have-names: "npm:^1.2.3" + has-property-descriptors: "npm:^1.0.2" + hasown: "npm:^2.0.4" + is-callable: "npm:^1.2.7" + is-document.all: "npm:^1.0.0" + checksum: 10c0/b20e6370ef4f7d56d0bedf5719f6684a517a8dd3334209b4d9f51e8834859302a584187156bf024cda9f50ba2479e4d6764ac34af9532ea47d2f4d9fa6bcf90d + languageName: node + linkType: hard + +"functions-have-names@npm:^1.2.3": + version: 1.2.3 + resolution: "functions-have-names@npm:1.2.3" + checksum: 10c0/33e77fd29bddc2d9bb78ab3eb854c165909201f88c75faa8272e35899e2d35a8a642a15e7420ef945e1f64a9670d6aa3ec744106b2aa42be68ca5114025954ca + languageName: node + linkType: hard + +"generator-function@npm:^2.0.0": + version: 2.0.1 + resolution: "generator-function@npm:2.0.1" + checksum: 10c0/8a9f59df0f01cfefafdb3b451b80555e5cf6d76487095db91ac461a0e682e4ff7a9dbce15f4ecec191e53586d59eece01949e05a4b4492879600bbbe8e28d6b8 + languageName: node + linkType: hard + +"gensync@npm:^1.0.0-beta.2": + version: 1.0.0-beta.2 + resolution: "gensync@npm:1.0.0-beta.2" + checksum: 10c0/782aba6cba65b1bb5af3b095d96249d20edbe8df32dbf4696fd49be2583faf676173bf4809386588828e4dd76a3354fcbeb577bab1c833ccd9fc4577f26103f8 + languageName: node + linkType: hard + +"get-intrinsic@npm:^1.2.4, get-intrinsic@npm:^1.2.5, get-intrinsic@npm:^1.2.6, get-intrinsic@npm:^1.2.7, get-intrinsic@npm:^1.3.0": + version: 1.3.0 + resolution: "get-intrinsic@npm:1.3.0" + dependencies: + call-bind-apply-helpers: "npm:^1.0.2" + es-define-property: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.1.1" + function-bind: "npm:^1.1.2" + get-proto: "npm:^1.0.1" + gopd: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + hasown: "npm:^2.0.2" + math-intrinsics: "npm:^1.1.0" + checksum: 10c0/52c81808af9a8130f581e6a6a83e1ba4a9f703359e7a438d1369a5267a25412322f03dcbd7c549edaef0b6214a0630a28511d7df0130c93cfd380f4fa0b5b66a + languageName: node + linkType: hard + +"get-proto@npm:^1.0.0, get-proto@npm:^1.0.1": + version: 1.0.1 + resolution: "get-proto@npm:1.0.1" + dependencies: + dunder-proto: "npm:^1.0.1" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/9224acb44603c5526955e83510b9da41baf6ae73f7398875fba50edc5e944223a89c4a72b070fcd78beb5f7bdda58ecb6294adc28f7acfc0da05f76a2399643c + languageName: node + linkType: hard + +"get-symbol-description@npm:^1.1.0": + version: 1.1.0 + resolution: "get-symbol-description@npm:1.1.0" + dependencies: + call-bound: "npm:^1.0.3" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.6" + checksum: 10c0/d6a7d6afca375779a4b307738c9e80dbf7afc0bdbe5948768d54ab9653c865523d8920e670991a925936eb524b7cb6a6361d199a760b21d0ca7620194455aa4b + languageName: node + linkType: hard + +"glob-parent@npm:^6.0.2": + version: 6.0.2 + resolution: "glob-parent@npm:6.0.2" + dependencies: + is-glob: "npm:^4.0.3" + checksum: 10c0/317034d88654730230b3f43bb7ad4f7c90257a426e872ea0bf157473ac61c99bf5d205fad8f0185f989be8d2fa6d3c7dce1645d99d545b6ea9089c39f838e7f8 + languageName: node + linkType: hard + +"globals@npm:^15.7.0": + version: 15.15.0 + resolution: "globals@npm:15.15.0" + checksum: 10c0/f9ae80996392ca71316495a39bec88ac43ae3525a438b5626cd9d5ce9d5500d0a98a266409605f8cd7241c7acf57c354a48111ea02a767ba4f374b806d6861fe + languageName: node + linkType: hard + +"globals@npm:^16.2.0": + version: 16.5.0 + resolution: "globals@npm:16.5.0" + checksum: 10c0/615241dae7851c8012f5aa0223005b1ed6607713d6813de0741768bd4ddc39353117648f1a7086b4b0fa45eae733f1c0a0fe369aa4e543bb63f8de8990178ea9 + languageName: node + linkType: hard + +"globalthis@npm:^1.0.4": + version: 1.0.4 + resolution: "globalthis@npm:1.0.4" + dependencies: + define-properties: "npm:^1.2.1" + gopd: "npm:^1.0.1" + checksum: 10c0/9d156f313af79d80b1566b93e19285f481c591ad6d0d319b4be5e03750d004dde40a39a0f26f7e635f9007a3600802f53ecd85a759b86f109e80a5f705e01846 + languageName: node + linkType: hard + +"gopd@npm:^1.0.1, gopd@npm:^1.2.0": + version: 1.2.0 + resolution: "gopd@npm:1.2.0" + checksum: 10c0/50fff1e04ba2b7737c097358534eacadad1e68d24cccee3272e04e007bed008e68d2614f3987788428fd192a5ae3889d08fb2331417e4fc4a9ab366b2043cead + languageName: node + linkType: hard + +"graceful-fs@npm:^4.2.6": + version: 4.2.11 + resolution: "graceful-fs@npm:4.2.11" + checksum: 10c0/386d011a553e02bc594ac2ca0bd6d9e4c22d7fa8cfbfc448a6d148c59ea881b092db9dbe3547ae4b88e55f1b01f7c4a2ecc53b310c042793e63aa44cf6c257f2 + languageName: node + linkType: hard + +"has-bigints@npm:^1.0.2": + version: 1.1.0 + resolution: "has-bigints@npm:1.1.0" + checksum: 10c0/2de0cdc4a1ccf7a1e75ffede1876994525ac03cc6f5ae7392d3415dd475cd9eee5bceec63669ab61aa997ff6cceebb50ef75561c7002bed8988de2b9d1b40788 + languageName: node + linkType: hard + +"has-property-descriptors@npm:^1.0.0, has-property-descriptors@npm:^1.0.2": + version: 1.0.2 + resolution: "has-property-descriptors@npm:1.0.2" + dependencies: + es-define-property: "npm:^1.0.0" + checksum: 10c0/253c1f59e80bb476cf0dde8ff5284505d90c3bdb762983c3514d36414290475fe3fd6f574929d84de2a8eec00d35cf07cb6776205ff32efd7c50719125f00236 + languageName: node + linkType: hard + +"has-proto@npm:^1.2.0": + version: 1.2.0 + resolution: "has-proto@npm:1.2.0" + dependencies: + dunder-proto: "npm:^1.0.0" + checksum: 10c0/46538dddab297ec2f43923c3d35237df45d8c55a6fc1067031e04c13ed8a9a8f94954460632fd4da84c31a1721eefee16d901cbb1ae9602bab93bb6e08f93b95 + languageName: node + linkType: hard + +"has-symbols@npm:^1.0.3, has-symbols@npm:^1.1.0": + version: 1.1.0 + resolution: "has-symbols@npm:1.1.0" + checksum: 10c0/dde0a734b17ae51e84b10986e651c664379018d10b91b6b0e9b293eddb32f0f069688c841fb40f19e9611546130153e0a2a48fd7f512891fb000ddfa36f5a20e + languageName: node + linkType: hard + +"has-tostringtag@npm:^1.0.2": + version: 1.0.2 + resolution: "has-tostringtag@npm:1.0.2" + dependencies: + has-symbols: "npm:^1.0.3" + checksum: 10c0/a8b166462192bafe3d9b6e420a1d581d93dd867adb61be223a17a8d6dad147aa77a8be32c961bb2f27b3ef893cae8d36f564ab651f5e9b7938ae86f74027c48c + languageName: node + linkType: hard + +"hasown@npm:^2.0.2, hasown@npm:^2.0.3, hasown@npm:^2.0.4": + version: 2.0.4 + resolution: "hasown@npm:2.0.4" + dependencies: + function-bind: "npm:^1.1.2" + checksum: 10c0/2d8de939e270b70618f8cebb69746620db10617dbb495bc66ddad326955ea24d3ca4af133aff3eb7c1853e0218f867bc2b050ec26fe02e3aea58f880ffc5e506 + languageName: node + linkType: hard + +"he@npm:1.2.0": + version: 1.2.0 + resolution: "he@npm:1.2.0" + bin: + he: bin/he + checksum: 10c0/a27d478befe3c8192f006cdd0639a66798979dfa6e2125c6ac582a19a5ebfec62ad83e8382e6036170d873f46e4536a7e795bf8b95bf7c247f4cc0825ccc8c17 + languageName: node + linkType: hard + +"hoist-non-react-statics@npm:^3.3.1": + version: 3.3.2 + resolution: "hoist-non-react-statics@npm:3.3.2" + dependencies: + react-is: "npm:^16.7.0" + checksum: 10c0/fe0889169e845d738b59b64badf5e55fa3cf20454f9203d1eb088df322d49d4318df774828e789898dcb280e8a5521bb59b3203385662ca5e9218a6ca5820e74 + languageName: node + linkType: hard + +"https-proxy-agent@npm:^5.0.1": + version: 5.0.1 + resolution: "https-proxy-agent@npm:5.0.1" + dependencies: + agent-base: "npm:6" + debug: "npm:4" + checksum: 10c0/6dd639f03434003577c62b27cafdb864784ef19b2de430d8ae2a1d45e31c4fd60719e5637b44db1a88a046934307da7089e03d6089ec3ddacc1189d8de8897d1 + languageName: node + linkType: hard + +"ignore@npm:^5.2.0": + version: 5.3.2 + resolution: "ignore@npm:5.3.2" + checksum: 10c0/f9f652c957983634ded1e7f02da3b559a0d4cc210fca3792cb67f1b153623c9c42efdc1c4121af171e295444459fc4a9201101fb041b1104a3c000bccb188337 + languageName: node + linkType: hard + +"import-fresh@npm:^3.2.1": + version: 3.3.1 + resolution: "import-fresh@npm:3.3.1" + dependencies: + parent-module: "npm:^1.0.0" + resolve-from: "npm:^4.0.0" + checksum: 10c0/bf8cc494872fef783249709385ae883b447e3eb09db0ebd15dcead7d9afe7224dad7bd7591c6b73b0b19b3c0f9640eb8ee884f01cfaf2887ab995b0b36a0cbec + languageName: node + linkType: hard + +"import-meta-resolve@npm:^4.2.0": + version: 4.2.0 + resolution: "import-meta-resolve@npm:4.2.0" + checksum: 10c0/3ee8aeecb61d19b49d2703987f977e9d1c7d4ba47db615a570eaa02fe414f40dfa63f7b953e842cbe8470d26df6371332bfcf21b2fd92b0112f9fea80dde2c4c + languageName: node + linkType: hard + +"imurmurhash@npm:^0.1.4": + version: 0.1.4 + resolution: "imurmurhash@npm:0.1.4" + checksum: 10c0/8b51313850dd33605c6c9d3fd9638b714f4c4c40250cff658209f30d40da60f78992fb2df5dabee4acf589a6a82bbc79ad5486550754bd9ec4e3fc0d4a57d6a6 + languageName: node + linkType: hard + +"internal-slot@npm:^1.1.0": + version: 1.1.0 + resolution: "internal-slot@npm:1.1.0" + dependencies: + es-errors: "npm:^1.3.0" + hasown: "npm:^2.0.2" + side-channel: "npm:^1.1.0" + checksum: 10c0/03966f5e259b009a9bf1a78d60da920df198af4318ec004f57b8aef1dd3fe377fbc8cce63a96e8c810010302654de89f9e19de1cd8ad0061d15be28a695465c7 + languageName: node + linkType: hard + +"is-array-buffer@npm:^3.0.4, is-array-buffer@npm:^3.0.5": + version: 3.0.5 + resolution: "is-array-buffer@npm:3.0.5" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.3" + get-intrinsic: "npm:^1.2.6" + checksum: 10c0/c5c9f25606e86dbb12e756694afbbff64bc8b348d1bc989324c037e1068695131930199d6ad381952715dad3a9569333817f0b1a72ce5af7f883ce802e49c83d + languageName: node + linkType: hard + +"is-arrayish@npm:^0.2.1": + version: 0.2.1 + resolution: "is-arrayish@npm:0.2.1" + checksum: 10c0/e7fb686a739068bb70f860b39b67afc62acc62e36bb61c5f965768abce1873b379c563e61dd2adad96ebb7edf6651111b385e490cf508378959b0ed4cac4e729 + languageName: node + linkType: hard + +"is-async-function@npm:^2.0.0": + version: 2.1.1 + resolution: "is-async-function@npm:2.1.1" + dependencies: + async-function: "npm:^1.0.0" + call-bound: "npm:^1.0.3" + get-proto: "npm:^1.0.1" + has-tostringtag: "npm:^1.0.2" + safe-regex-test: "npm:^1.1.0" + checksum: 10c0/d70c236a5e82de6fc4d44368ffd0c2fee2b088b893511ce21e679da275a5ecc6015ff59a7d7e1bdd7ca39f71a8dbdd253cf8cce5c6b3c91cdd5b42b5ce677298 + languageName: node + linkType: hard + +"is-bigint@npm:^1.1.0": + version: 1.1.0 + resolution: "is-bigint@npm:1.1.0" + dependencies: + has-bigints: "npm:^1.0.2" + checksum: 10c0/f4f4b905ceb195be90a6ea7f34323bf1c18e3793f18922e3e9a73c684c29eeeeff5175605c3a3a74cc38185fe27758f07efba3dbae812e5c5afbc0d2316b40e4 + languageName: node + linkType: hard + +"is-boolean-object@npm:^1.2.1": + version: 1.2.2 + resolution: "is-boolean-object@npm:1.2.2" + dependencies: + call-bound: "npm:^1.0.3" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/36ff6baf6bd18b3130186990026f5a95c709345c39cd368468e6c1b6ab52201e9fd26d8e1f4c066357b4938b0f0401e1a5000e08257787c1a02f3a719457001e + languageName: node + linkType: hard + +"is-callable@npm:^1.2.7": + version: 1.2.7 + resolution: "is-callable@npm:1.2.7" + checksum: 10c0/ceebaeb9d92e8adee604076971dd6000d38d6afc40bb843ea8e45c5579b57671c3f3b50d7f04869618242c6cee08d1b67806a8cb8edaaaf7c0748b3720d6066f + languageName: node + linkType: hard + +"is-core-module@npm:^2.16.1, is-core-module@npm:^2.16.2": + version: 2.16.2 + resolution: "is-core-module@npm:2.16.2" + dependencies: + hasown: "npm:^2.0.3" + checksum: 10c0/14b4258390283709c15476d023ec173e27458d5d014ccdb8ed39d576e551c3fa45498b7c9fe178f1529c4cb2648ddd58852a6a62107a019f6e349529f277518a + languageName: node + linkType: hard + +"is-data-view@npm:^1.0.1, is-data-view@npm:^1.0.2": + version: 1.0.2 + resolution: "is-data-view@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.2" + get-intrinsic: "npm:^1.2.6" + is-typed-array: "npm:^1.1.13" + checksum: 10c0/ef3548a99d7e7f1370ce21006baca6d40c73e9f15c941f89f0049c79714c873d03b02dae1c64b3f861f55163ecc16da06506c5b8a1d4f16650b3d9351c380153 + languageName: node + linkType: hard + +"is-date-object@npm:^1.1.0": + version: 1.1.0 + resolution: "is-date-object@npm:1.1.0" + dependencies: + call-bound: "npm:^1.0.2" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/1a4d199c8e9e9cac5128d32e6626fa7805175af9df015620ac0d5d45854ccf348ba494679d872d37301032e35a54fc7978fba1687e8721b2139aea7870cafa2f + languageName: node + linkType: hard + +"is-document.all@npm:^1.0.0": + version: 1.0.0 + resolution: "is-document.all@npm:1.0.0" + dependencies: + call-bound: "npm:^1.0.4" + checksum: 10c0/955c20ed5bf01d49da8243b4c714947a6ff64b6d9ba0e12bdbfa654a3e7c47f72cc01c6cd2905e85512d02bc3a1290edd73857bca8842566ff9dcfb7c3f92dae + languageName: node + linkType: hard + +"is-extglob@npm:^2.1.1": + version: 2.1.1 + resolution: "is-extglob@npm:2.1.1" + checksum: 10c0/5487da35691fbc339700bbb2730430b07777a3c21b9ebaecb3072512dfd7b4ba78ac2381a87e8d78d20ea08affb3f1971b4af629173a6bf435ff8a4c47747912 + languageName: node + linkType: hard + +"is-finalizationregistry@npm:^1.1.0": + version: 1.1.1 + resolution: "is-finalizationregistry@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.3" + checksum: 10c0/818dff679b64f19e228a8205a1e2d09989a98e98def3a817f889208cfcbf918d321b251aadf2c05918194803ebd2eb01b14fc9d0b2bea53d984f4137bfca5e97 + languageName: node + linkType: hard + +"is-generator-function@npm:^1.0.10": + version: 1.1.2 + resolution: "is-generator-function@npm:1.1.2" + dependencies: + call-bound: "npm:^1.0.4" + generator-function: "npm:^2.0.0" + get-proto: "npm:^1.0.1" + has-tostringtag: "npm:^1.0.2" + safe-regex-test: "npm:^1.1.0" + checksum: 10c0/83da102e89c3e3b71d67b51d47c9f9bc862bceb58f87201727e27f7fa19d1d90b0ab223644ecaee6fc6e3d2d622bb25c966fbdaf87c59158b01ce7c0fe2fa372 + languageName: node + linkType: hard + +"is-glob@npm:^4.0.0, is-glob@npm:^4.0.3": + version: 4.0.3 + resolution: "is-glob@npm:4.0.3" + dependencies: + is-extglob: "npm:^2.1.1" + checksum: 10c0/17fb4014e22be3bbecea9b2e3a76e9e34ff645466be702f1693e8f1ee1adac84710d0be0bd9f967d6354036fd51ab7c2741d954d6e91dae6bb69714de92c197a + languageName: node + linkType: hard + +"is-map@npm:^2.0.3": + version: 2.0.3 + resolution: "is-map@npm:2.0.3" + checksum: 10c0/2c4d431b74e00fdda7162cd8e4b763d6f6f217edf97d4f8538b94b8702b150610e2c64961340015fe8df5b1fcee33ccd2e9b62619c4a8a3a155f8de6d6d355fc + languageName: node + linkType: hard + +"is-negative-zero@npm:^2.0.3": + version: 2.0.3 + resolution: "is-negative-zero@npm:2.0.3" + checksum: 10c0/bcdcf6b8b9714063ffcfa9929c575ac69bfdabb8f4574ff557dfc086df2836cf07e3906f5bbc4f2a5c12f8f3ba56af640c843cdfc74da8caed86c7c7d66fd08e + languageName: node + linkType: hard + +"is-number-object@npm:^1.1.1": + version: 1.1.1 + resolution: "is-number-object@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.3" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/97b451b41f25135ff021d85c436ff0100d84a039bb87ffd799cbcdbea81ef30c464ced38258cdd34f080be08fc3b076ca1f472086286d2aa43521d6ec6a79f53 + languageName: node + linkType: hard + +"is-regex@npm:^1.2.1": + version: 1.2.1 + resolution: "is-regex@npm:1.2.1" + dependencies: + call-bound: "npm:^1.0.2" + gopd: "npm:^1.2.0" + has-tostringtag: "npm:^1.0.2" + hasown: "npm:^2.0.2" + checksum: 10c0/1d3715d2b7889932349241680032e85d0b492cfcb045acb75ffc2c3085e8d561184f1f7e84b6f8321935b4aea39bc9c6ba74ed595b57ce4881a51dfdbc214e04 + languageName: node + linkType: hard + +"is-set@npm:^2.0.3": + version: 2.0.3 + resolution: "is-set@npm:2.0.3" + checksum: 10c0/f73732e13f099b2dc879c2a12341cfc22ccaca8dd504e6edae26484bd5707a35d503fba5b4daad530a9b088ced1ae6c9d8200fd92e09b428fe14ea79ce8080b7 + languageName: node + linkType: hard + +"is-shared-array-buffer@npm:^1.0.4": + version: 1.0.4 + resolution: "is-shared-array-buffer@npm:1.0.4" + dependencies: + call-bound: "npm:^1.0.3" + checksum: 10c0/65158c2feb41ff1edd6bbd6fd8403a69861cf273ff36077982b5d4d68e1d59278c71691216a4a64632bd76d4792d4d1d2553901b6666d84ade13bba5ea7bc7db + languageName: node + linkType: hard + +"is-string@npm:^1.1.1": + version: 1.1.1 + resolution: "is-string@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.3" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/2f518b4e47886bb81567faba6ffd0d8a8333cf84336e2e78bf160693972e32ad00fe84b0926491cc598dee576fdc55642c92e62d0cbe96bf36f643b6f956f94d + languageName: node + linkType: hard + +"is-symbol@npm:^1.1.1": + version: 1.1.1 + resolution: "is-symbol@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.2" + has-symbols: "npm:^1.1.0" + safe-regex-test: "npm:^1.1.0" + checksum: 10c0/f08f3e255c12442e833f75a9e2b84b2d4882fdfd920513cf2a4a2324f0a5b076c8fd913778e3ea5d258d5183e9d92c0cd20e04b03ab3df05316b049b2670af1e + languageName: node + linkType: hard + +"is-typed-array@npm:^1.1.13, is-typed-array@npm:^1.1.14, is-typed-array@npm:^1.1.15": + version: 1.1.15 + resolution: "is-typed-array@npm:1.1.15" + dependencies: + which-typed-array: "npm:^1.1.16" + checksum: 10c0/415511da3669e36e002820584e264997ffe277ff136643a3126cc949197e6ca3334d0f12d084e83b1994af2e9c8141275c741cf2b7da5a2ff62dd0cac26f76c4 + languageName: node + linkType: hard + +"is-weakmap@npm:^2.0.2": + version: 2.0.2 + resolution: "is-weakmap@npm:2.0.2" + checksum: 10c0/443c35bb86d5e6cc5929cd9c75a4024bb0fff9586ed50b092f94e700b89c43a33b186b76dbc6d54f3d3d09ece689ab38dcdc1af6a482cbe79c0f2da0a17f1299 + languageName: node + linkType: hard + +"is-weakref@npm:^1.0.2, is-weakref@npm:^1.1.1": + version: 1.1.1 + resolution: "is-weakref@npm:1.1.1" + dependencies: + call-bound: "npm:^1.0.3" + checksum: 10c0/8e0a9c07b0c780949a100e2cab2b5560a48ecd4c61726923c1a9b77b6ab0aa0046c9e7fb2206042296817045376dee2c8ab1dabe08c7c3dfbf195b01275a085b + languageName: node + linkType: hard + +"is-weakset@npm:^2.0.3": + version: 2.0.4 + resolution: "is-weakset@npm:2.0.4" + dependencies: + call-bound: "npm:^1.0.3" + get-intrinsic: "npm:^1.2.6" + checksum: 10c0/6491eba08acb8dc9532da23cb226b7d0192ede0b88f16199e592e4769db0a077119c1f5d2283d1e0d16d739115f70046e887e477eb0e66cd90e1bb29f28ba647 + languageName: node + linkType: hard + +"isarray@npm:^2.0.5": + version: 2.0.5 + resolution: "isarray@npm:2.0.5" + checksum: 10c0/4199f14a7a13da2177c66c31080008b7124331956f47bca57dd0b6ea9f11687aa25e565a2c7a2b519bc86988d10398e3049a1f5df13c9f6b7664154690ae79fd + languageName: node + linkType: hard + +"isexe@npm:^2.0.0": + version: 2.0.0 + resolution: "isexe@npm:2.0.0" + checksum: 10c0/228cfa503fadc2c31596ab06ed6aa82c9976eec2bfd83397e7eaf06d0ccf42cd1dfd6743bf9aeb01aebd4156d009994c5f76ea898d2832c1fe342da923ca457d + languageName: node + linkType: hard + +"isexe@npm:^4.0.0": + version: 4.0.0 + resolution: "isexe@npm:4.0.0" + checksum: 10c0/5884815115bceac452877659a9c7726382531592f43dc29e5d48b7c4100661aed54018cb90bd36cb2eaeba521092570769167acbb95c18d39afdccbcca06c5ce + languageName: node + linkType: hard + +"iterator.prototype@npm:^1.1.5": + version: 1.1.5 + resolution: "iterator.prototype@npm:1.1.5" + dependencies: + define-data-property: "npm:^1.1.4" + es-object-atoms: "npm:^1.0.0" + get-intrinsic: "npm:^1.2.6" + get-proto: "npm:^1.0.0" + has-symbols: "npm:^1.1.0" + set-function-name: "npm:^2.0.2" + checksum: 10c0/f7a262808e1b41049ab55f1e9c29af7ec1025a000d243b83edf34ce2416eedd56079b117fa59376bb4a724110690f13aa8427f2ee29a09eec63a7e72367626d0 + languageName: node + linkType: hard + +"js-tokens@npm:^10.0.0": + version: 10.0.0 + resolution: "js-tokens@npm:10.0.0" + checksum: 10c0/a93498747812ba3e0c8626f95f75ab29319f2a13613a0de9e610700405760931624433a0de59eb7c27ff8836e526768fb20783861b86ef89be96676f2c996b64 + languageName: node + linkType: hard + +"js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0": + version: 4.0.0 + resolution: "js-tokens@npm:4.0.0" + checksum: 10c0/e248708d377aa058eacf2037b07ded847790e6de892bbad3dac0abba2e759cb9f121b00099a65195616badcb6eca8d14d975cb3e89eb1cfda644756402c8aeed + languageName: node + linkType: hard + +"jsesc@npm:^3.0.2": + version: 3.1.0 + resolution: "jsesc@npm:3.1.0" + bin: + jsesc: bin/jsesc + checksum: 10c0/531779df5ec94f47e462da26b4cbf05eb88a83d9f08aac2ba04206508fc598527a153d08bd462bae82fc78b3eaa1a908e1a4a79f886e9238641c4cdefaf118b1 + languageName: node + linkType: hard + +"json-buffer@npm:3.0.1": + version: 3.0.1 + resolution: "json-buffer@npm:3.0.1" + checksum: 10c0/0d1c91569d9588e7eef2b49b59851f297f3ab93c7b35c7c221e288099322be6b562767d11e4821da500f3219542b9afd2e54c5dc573107c1126ed1080f8e96d7 + languageName: node + linkType: hard + +"json-parse-even-better-errors@npm:^2.3.0": + version: 2.3.1 + resolution: "json-parse-even-better-errors@npm:2.3.1" + checksum: 10c0/140932564c8f0b88455432e0f33c4cb4086b8868e37524e07e723f4eaedb9425bdc2bafd71bd1d9765bd15fd1e2d126972bc83990f55c467168c228c24d665f3 + languageName: node + linkType: hard + +"json-schema-traverse@npm:^0.4.1": + version: 0.4.1 + resolution: "json-schema-traverse@npm:0.4.1" + checksum: 10c0/108fa90d4cc6f08243aedc6da16c408daf81793bf903e9fd5ab21983cda433d5d2da49e40711da016289465ec2e62e0324dcdfbc06275a607fe3233fde4942ce + languageName: node + linkType: hard + +"json-stable-stringify-without-jsonify@npm:^1.0.1": + version: 1.0.1 + resolution: "json-stable-stringify-without-jsonify@npm:1.0.1" + checksum: 10c0/cb168b61fd4de83e58d09aaa6425ef71001bae30d260e2c57e7d09a5fd82223e2f22a042dedaab8db23b7d9ae46854b08bb1f91675a8be11c5cffebef5fb66a5 + languageName: node + linkType: hard + +"json5@npm:^2.2.3": + version: 2.2.3 + resolution: "json5@npm:2.2.3" + bin: + json5: lib/cli.js + checksum: 10c0/5a04eed94810fa55c5ea138b2f7a5c12b97c3750bc63d11e511dcecbfef758003861522a070c2272764ee0f4e3e323862f386945aeb5b85b87ee43f084ba586c + languageName: node + linkType: hard + +"jsx-ast-utils@npm:^2.4.1 || ^3.0.0": + version: 3.3.5 + resolution: "jsx-ast-utils@npm:3.3.5" + dependencies: + array-includes: "npm:^3.1.6" + array.prototype.flat: "npm:^1.3.1" + object.assign: "npm:^4.1.4" + object.values: "npm:^1.1.6" + checksum: 10c0/a32679e9cb55469cb6d8bbc863f7d631b2c98b7fc7bf172629261751a6e7bc8da6ae374ddb74d5fbd8b06cf0eb4572287b259813d92b36e384024ed35e4c13e1 + languageName: node + linkType: hard + +"keyv@npm:^4.5.4": + version: 4.5.4 + resolution: "keyv@npm:4.5.4" + dependencies: + json-buffer: "npm:3.0.1" + checksum: 10c0/aa52f3c5e18e16bb6324876bb8b59dd02acf782a4b789c7b2ae21107fab95fab3890ed448d4f8dba80ce05391eeac4bfabb4f02a20221342982f806fa2cf271e + languageName: node + linkType: hard + +"kolorist@npm:^1.6.0, kolorist@npm:^1.8.0": + version: 1.8.0 + resolution: "kolorist@npm:1.8.0" + checksum: 10c0/73075db44a692bf6c34a649f3b4b3aea4993b84f6b754cbf7a8577e7c7db44c0bad87752bd23b0ce533f49de2244ce2ce03b7b1b667a85ae170a94782cc50f9b + languageName: node + linkType: hard + +"levn@npm:^0.4.1": + version: 0.4.1 + resolution: "levn@npm:0.4.1" + dependencies: + prelude-ls: "npm:^1.2.1" + type-check: "npm:~0.4.0" + checksum: 10c0/effb03cad7c89dfa5bd4f6989364bfc79994c2042ec5966cb9b95990e2edee5cd8969ddf42616a0373ac49fac1403437deaf6e9050fbbaa3546093a59b9ac94e + languageName: node + linkType: hard + +"lines-and-columns@npm:^1.1.6": + version: 1.2.4 + resolution: "lines-and-columns@npm:1.2.4" + checksum: 10c0/3da6ee62d4cd9f03f5dc90b4df2540fb85b352081bee77fe4bbcd12c9000ead7f35e0a38b8d09a9bb99b13223446dd8689ff3c4959807620726d788701a83d2d + languageName: node + linkType: hard + +"locate-path@npm:^6.0.0": + version: 6.0.0 + resolution: "locate-path@npm:6.0.0" + dependencies: + p-locate: "npm:^5.0.0" + checksum: 10c0/d3972ab70dfe58ce620e64265f90162d247e87159b6126b01314dd67be43d50e96a50b517bce2d9452a79409c7614054c277b5232377de50416564a77ac7aad3 + languageName: node + linkType: hard + +"lodash.memoize@npm:^4.1.2": + version: 4.1.2 + resolution: "lodash.memoize@npm:4.1.2" + checksum: 10c0/c8713e51eccc650422716a14cece1809cfe34bc5ab5e242b7f8b4e2241c2483697b971a604252807689b9dd69bfe3a98852e19a5b89d506b000b4187a1285df8 + languageName: node + linkType: hard + +"loose-envify@npm:^1.4.0": + version: 1.4.0 + resolution: "loose-envify@npm:1.4.0" + dependencies: + js-tokens: "npm:^3.0.0 || ^4.0.0" + bin: + loose-envify: cli.js + checksum: 10c0/655d110220983c1a4b9c0c679a2e8016d4b67f6e9c7b5435ff5979ecdb20d0813f4dec0a08674fcbdd4846a3f07edbb50a36811fd37930b94aaa0d9daceb017e + languageName: node + linkType: hard + +"lru-cache@npm:^11.0.0": + version: 11.5.1 + resolution: "lru-cache@npm:11.5.1" + checksum: 10c0/7b341cea79a8efe9c6a6f20c8757a77eca5b25d7ff983ccf4e11e547b81f6787824baa1c84705251dff84ab4ffac85717ac354b9d02e465f86a9f8b166409979 + languageName: node + linkType: hard + +"lru-cache@npm:^5.1.1": + version: 5.1.1 + resolution: "lru-cache@npm:5.1.1" + dependencies: + yallist: "npm:^3.0.2" + checksum: 10c0/89b2ef2ef45f543011e38737b8a8622a2f8998cddf0e5437174ef8f1f70a8b9d14a918ab3e232cb3ba343b7abddffa667f0b59075b2b80e6b4d63c3de6127482 + languageName: node + linkType: hard + +"magic-string@npm:0.x >= 0.26.0, magic-string@npm:^0.30.21": + version: 0.30.21 + resolution: "magic-string@npm:0.30.21" + dependencies: + "@jridgewell/sourcemap-codec": "npm:^1.5.5" + checksum: 10c0/299378e38f9a270069fc62358522ddfb44e94244baa0d6a8980ab2a9b2490a1d03b236b447eee309e17eb3bddfa482c61259d47960eb018a904f0ded52780c4a + languageName: node + linkType: hard + +"math-intrinsics@npm:^1.1.0": + version: 1.1.0 + resolution: "math-intrinsics@npm:1.1.0" + checksum: 10c0/7579ff94e899e2f76ab64491d76cf606274c874d8f2af4a442c016bd85688927fcfca157ba6bf74b08e9439dc010b248ce05b96cc7c126a354c3bae7fcb48b7f + languageName: node + linkType: hard + +"mime-db@npm:1.52.0": + version: 1.52.0 + resolution: "mime-db@npm:1.52.0" + checksum: 10c0/0557a01deebf45ac5f5777fe7740b2a5c309c6d62d40ceab4e23da9f821899ce7a900b7ac8157d4548ddbb7beffe9abc621250e6d182b0397ec7f10c7b91a5aa + languageName: node + linkType: hard + +"mime-types@npm:^2.1.35": + version: 2.1.35 + resolution: "mime-types@npm:2.1.35" + dependencies: + mime-db: "npm:1.52.0" + checksum: 10c0/82fb07ec56d8ff1fc999a84f2f217aa46cb6ed1033fefaabd5785b9a974ed225c90dc72fff460259e66b95b73648596dbcc50d51ed69cdf464af2d237d3149b2 + languageName: node + linkType: hard + +"minimatch@npm:^10.2.4": + version: 10.2.5 + resolution: "minimatch@npm:10.2.5" + dependencies: + brace-expansion: "npm:^5.0.5" + checksum: 10c0/6bb058bd6324104b9ec2f763476a35386d05079c1f5fe4fbf1f324a25237cd4534d6813ecd71f48208f4e635c1221899bef94c3c89f7df55698fe373aaae20fd + languageName: node + linkType: hard + +"minimatch@npm:^3.1.2": + version: 3.1.5 + resolution: "minimatch@npm:3.1.5" + dependencies: + brace-expansion: "npm:^1.1.7" + checksum: 10c0/2ecbdc0d33f07bddb0315a8b5afbcb761307a8778b48f0b312418ccbced99f104a2d17d8aca7573433c70e8ccd1c56823a441897a45e384ea76ef401a26ace70 + languageName: node + linkType: hard + +"minipass@npm:^7.0.4, minipass@npm:^7.1.2": + version: 7.1.3 + resolution: "minipass@npm:7.1.3" + checksum: 10c0/539da88daca16533211ea5a9ee98dc62ff5742f531f54640dd34429e621955e91cc280a91a776026264b7f9f6735947629f920944e9c1558369e8bf22eb33fbb + languageName: node + linkType: hard + +"minizlib@npm:^3.1.0": + version: 3.1.0 + resolution: "minizlib@npm:3.1.0" + dependencies: + minipass: "npm:^7.1.2" + checksum: 10c0/5aad75ab0090b8266069c9aabe582c021ae53eb33c6c691054a13a45db3b4f91a7fb1bd79151e6b4e9e9a86727b522527c0a06ec7d45206b745d54cd3097bcec + languageName: node + linkType: hard + +"ms@npm:^2.1.3": + version: 2.1.3 + resolution: "ms@npm:2.1.3" + checksum: 10c0/d924b57e7312b3b63ad21fc5b3dc0af5e78d61a1fc7cfb5457edaf26326bf62be5307cc87ffb6862ef1c2b33b0233cdb5d4f01c4c958cc0d660948b65a287a48 + languageName: node + linkType: hard + +"nanoid@npm:^3.3.12": + version: 3.3.13 + resolution: "nanoid@npm:3.3.13" + bin: + nanoid: bin/nanoid.cjs + checksum: 10c0/e913cd6d081e3b646788aa36e686964f2746f15935759425c98344053676b9444efedff4d87915bfb38b1626057e66c788f59ee7746b48c2b7886a4b049ca2ac + languageName: node + linkType: hard + +"natural-compare@npm:^1.4.0": + version: 1.4.0 + resolution: "natural-compare@npm:1.4.0" + checksum: 10c0/f5f9a7974bfb28a91afafa254b197f0f22c684d4a1731763dda960d2c8e375b36c7d690e0d9dc8fba774c537af14a7e979129bca23d88d052fbeb9466955e447 + languageName: node + linkType: hard + +"node-exports-info@npm:^1.6.0": + version: 1.6.0 + resolution: "node-exports-info@npm:1.6.0" + dependencies: + array.prototype.flatmap: "npm:^1.3.3" + es-errors: "npm:^1.3.0" + object.entries: "npm:^1.1.9" + semver: "npm:^6.3.1" + checksum: 10c0/3613f21c60b047e66f168d3499a6be0060d89fb01ddceaa7032c2fb318aff12e4b9b111449c1a9aeb3b848bfdc1d4b6bc8fab327af692319597d21a1e7063692 + languageName: node + linkType: hard + +"node-gyp@npm:latest": + version: 13.0.0 + resolution: "node-gyp@npm:13.0.0" + dependencies: + env-paths: "npm:^2.2.0" + exponential-backoff: "npm:^3.1.1" + graceful-fs: "npm:^4.2.6" + nopt: "npm:^10.0.0" + proc-log: "npm:^7.0.0" + semver: "npm:^7.3.5" + tar: "npm:^7.5.4" + tinyglobby: "npm:^0.2.12" + undici: "npm:^6.25.0" + which: "npm:^7.0.0" + bin: + node-gyp: bin/node-gyp.js + checksum: 10c0/e7525c427db2d16aa368b8947187de83083d2a8dda23e3e096a71c22ae637ac5bb8ed7cf6c871f1b9118cd2729dbfee4ff3a4245e2b79226900227b15831b492 + languageName: node + linkType: hard + +"node-html-parser@npm:^6.1.12": + version: 6.1.13 + resolution: "node-html-parser@npm:6.1.13" + dependencies: + css-select: "npm:^5.1.0" + he: "npm:1.2.0" + checksum: 10c0/ca36290507da8ec0fa131a0fd67ba62e300365c3950b5a6058b0e32b71b520ff43a5661b19e98a5c9797dbe3428b08db788b602f1f8aa62f2db5bb66e1d80782 + languageName: node + linkType: hard + +"node-releases@npm:^2.0.36": + version: 2.0.48 + resolution: "node-releases@npm:2.0.48" + checksum: 10c0/17eac8493c0be99130793e87fd67feb6291aecb9f4e473dea3b00f59c002cc8b9c0bdc923227c9aa84968da6b2e4c58e75251981503eb367ec9c742715175a34 + languageName: node + linkType: hard + +"nopt@npm:^10.0.0": + version: 10.0.1 + resolution: "nopt@npm:10.0.1" + dependencies: + abbrev: "npm:^5.0.0" + bin: + nopt: bin/nopt.js + checksum: 10c0/980d89257f9587f3e1f77877ddbf905d6aa3b738ec33e49a4fa1a059a0dd82eb28063982b150654a7ae9de386f2ead60e56172db7d37cf56de545f7392a2a26a + languageName: node + linkType: hard + +"nth-check@npm:^2.0.1": + version: 2.1.1 + resolution: "nth-check@npm:2.1.1" + dependencies: + boolbase: "npm:^1.0.0" + checksum: 10c0/5fee7ff309727763689cfad844d979aedd2204a817fbaaf0e1603794a7c20db28548d7b024692f953557df6ce4a0ee4ae46cd8ebd9b36cfb300b9226b567c479 + languageName: node + linkType: hard + +"object-assign@npm:^4.1.1": + version: 4.1.1 + resolution: "object-assign@npm:4.1.1" + checksum: 10c0/1f4df9945120325d041ccf7b86f31e8bcc14e73d29171e37a7903050e96b81323784ec59f93f102ec635bcf6fa8034ba3ea0a8c7e69fa202b87ae3b6cec5a414 + languageName: node + linkType: hard + +"object-inspect@npm:^1.13.3, object-inspect@npm:^1.13.4": + version: 1.13.4 + resolution: "object-inspect@npm:1.13.4" + checksum: 10c0/d7f8711e803b96ea3191c745d6f8056ce1f2496e530e6a19a0e92d89b0fa3c76d910c31f0aa270432db6bd3b2f85500a376a83aaba849a8d518c8845b3211692 + languageName: node + linkType: hard + +"object-keys@npm:^1.1.1": + version: 1.1.1 + resolution: "object-keys@npm:1.1.1" + checksum: 10c0/b11f7ccdbc6d406d1f186cdadb9d54738e347b2692a14439ca5ac70c225fa6db46db809711b78589866d47b25fc3e8dee0b4c722ac751e11180f9380e3d8601d + languageName: node + linkType: hard + +"object.assign@npm:^4.1.4, object.assign@npm:^4.1.7": + version: 4.1.7 + resolution: "object.assign@npm:4.1.7" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.3" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.0.0" + has-symbols: "npm:^1.1.0" + object-keys: "npm:^1.1.1" + checksum: 10c0/3b2732bd860567ea2579d1567525168de925a8d852638612846bd8082b3a1602b7b89b67b09913cbb5b9bd6e95923b2ae73580baa9d99cb4e990564e8cbf5ddc + languageName: node + linkType: hard + +"object.entries@npm:^1.1.9": + version: 1.1.9 + resolution: "object.entries@npm:1.1.9" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.4" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.1.1" + checksum: 10c0/d4b8c1e586650407da03370845f029aa14076caca4e4d4afadbc69cfb5b78035fd3ee7be417141abdb0258fa142e59b11923b4c44d8b1255b28f5ffcc50da7db + languageName: node + linkType: hard + +"object.fromentries@npm:^2.0.8": + version: 2.0.8 + resolution: "object.fromentries@npm:2.0.8" + dependencies: + call-bind: "npm:^1.0.7" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.2" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/cd4327e6c3369cfa805deb4cbbe919bfb7d3aeebf0bcaba291bb568ea7169f8f8cdbcabe2f00b40db0c20cd20f08e11b5f3a5a36fb7dd3fe04850c50db3bf83b + languageName: node + linkType: hard + +"object.values@npm:^1.1.6, object.values@npm:^1.2.1": + version: 1.2.1 + resolution: "object.values@npm:1.2.1" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.3" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/3c47814fdc64842ae3d5a74bc9d06bdd8d21563c04d9939bf6716a9c00596a4ebc342552f8934013d1ec991c74e3671b26710a0c51815f0b603795605ab6b2c9 + languageName: node + linkType: hard + +"obug@npm:^2.1.1": + version: 2.1.3 + resolution: "obug@npm:2.1.3" + checksum: 10c0/cb8187fed0a5fc8445507c950e89f3c1bd43895658c398b5803f6b7804dfa0c562975ecce1e67f3d9247d521452a5bfade9e0e951cc0326b7444272f7c24d25f + languageName: node + linkType: hard + +"optionator@npm:^0.9.3": + version: 0.9.4 + resolution: "optionator@npm:0.9.4" + dependencies: + deep-is: "npm:^0.1.3" + fast-levenshtein: "npm:^2.0.6" + levn: "npm:^0.4.1" + prelude-ls: "npm:^1.2.1" + type-check: "npm:^0.4.0" + word-wrap: "npm:^1.2.5" + checksum: 10c0/4afb687a059ee65b61df74dfe87d8d6815cd6883cb8b3d5883a910df72d0f5d029821f37025e4bccf4048873dbdb09acc6d303d27b8f76b1a80dd5a7d5334675 + languageName: node + linkType: hard + +"own-keys@npm:^1.0.1": + version: 1.0.1 + resolution: "own-keys@npm:1.0.1" + dependencies: + get-intrinsic: "npm:^1.2.6" + object-keys: "npm:^1.1.1" + safe-push-apply: "npm:^1.0.0" + checksum: 10c0/6dfeb3455bff92ec3f16a982d4e3e65676345f6902d9f5ded1d8265a6318d0200ce461956d6d1c70053c7fe9f9fe65e552faac03f8140d37ef0fdd108e67013a + languageName: node + linkType: hard + +"p-limit@npm:^3.0.2": + version: 3.1.0 + resolution: "p-limit@npm:3.1.0" + dependencies: + yocto-queue: "npm:^0.1.0" + checksum: 10c0/9db675949dbdc9c3763c89e748d0ef8bdad0afbb24d49ceaf4c46c02c77d30db4e0652ed36d0a0a7a95154335fab810d95c86153105bb73b3a90448e2bb14e1a + languageName: node + linkType: hard + +"p-locate@npm:^5.0.0": + version: 5.0.0 + resolution: "p-locate@npm:5.0.0" + dependencies: + p-limit: "npm:^3.0.2" + checksum: 10c0/2290d627ab7903b8b70d11d384fee714b797f6040d9278932754a6860845c4d3190603a0772a663c8cb5a7b21d1b16acb3a6487ebcafa9773094edc3dfe6009a + languageName: node + linkType: hard + +"parent-module@npm:^1.0.0": + version: 1.0.1 + resolution: "parent-module@npm:1.0.1" + dependencies: + callsites: "npm:^3.0.0" + checksum: 10c0/c63d6e80000d4babd11978e0d3fee386ca7752a02b035fd2435960ffaa7219dc42146f07069fb65e6e8bf1caef89daf9af7535a39bddf354d78bf50d8294f556 + languageName: node + linkType: hard + +"parse-json@npm:^5.0.0": + version: 5.2.0 + resolution: "parse-json@npm:5.2.0" + dependencies: + "@babel/code-frame": "npm:^7.0.0" + error-ex: "npm:^1.3.1" + json-parse-even-better-errors: "npm:^2.3.0" + lines-and-columns: "npm:^1.1.6" + checksum: 10c0/77947f2253005be7a12d858aedbafa09c9ae39eb4863adf330f7b416ca4f4a08132e453e08de2db46459256fb66afaac5ee758b44fe6541b7cdaf9d252e59585 + languageName: node + linkType: hard + +"path-exists@npm:^4.0.0": + version: 4.0.0 + resolution: "path-exists@npm:4.0.0" + checksum: 10c0/8c0bd3f5238188197dc78dced15207a4716c51cc4e3624c44fc97acf69558f5ebb9a2afff486fe1b4ee148e0c133e96c5e11a9aa5c48a3006e3467da070e5e1b + languageName: node + linkType: hard + +"path-key@npm:^3.1.0": + version: 3.1.1 + resolution: "path-key@npm:3.1.1" + checksum: 10c0/748c43efd5a569c039d7a00a03b58eecd1d75f3999f5a28303d75f521288df4823bc057d8784eb72358b2895a05f29a070bc9f1f17d28226cc4e62494cc58c4c + languageName: node + linkType: hard + +"path-parse@npm:^1.0.7": + version: 1.0.7 + resolution: "path-parse@npm:1.0.7" + checksum: 10c0/11ce261f9d294cc7a58d6a574b7f1b935842355ec66fba3c3fd79e0f036462eaf07d0aa95bb74ff432f9afef97ce1926c720988c6a7451d8a584930ae7de86e1 + languageName: node + linkType: hard + +"path-type@npm:^4.0.0": + version: 4.0.0 + resolution: "path-type@npm:4.0.0" + checksum: 10c0/666f6973f332f27581371efaf303fd6c272cc43c2057b37aa99e3643158c7e4b2626549555d88626e99ea9e046f82f32e41bbde5f1508547e9a11b149b52387c + languageName: node + linkType: hard + +"picocolors@npm:^1.1.1": + version: 1.1.1 + resolution: "picocolors@npm:1.1.1" + checksum: 10c0/e2e3e8170ab9d7c7421969adaa7e1b31434f789afb9b3f115f6b96d91945041ac3ceb02e9ec6fe6510ff036bcc0bf91e69a1772edc0b707e12b19c0f2d6bcf58 + languageName: node + linkType: hard + +"picomatch@npm:^2.2.2": + version: 2.3.2 + resolution: "picomatch@npm:2.3.2" + checksum: 10c0/a554d1709e59be97d1acb9eaedbbc700a5c03dbd4579807baed95100b00420bc729335440ef15004ae2378984e2487a7c1cebd743cfdb72b6fa9ab69223c0d61 + languageName: node + linkType: hard + +"picomatch@npm:^4.0.2, picomatch@npm:^4.0.3, picomatch@npm:^4.0.4": + version: 4.0.4 + resolution: "picomatch@npm:4.0.4" + checksum: 10c0/e2c6023372cc7b5764719a5ffb9da0f8e781212fa7ca4bd0562db929df8e117460f00dff3cb7509dacfc06b86de924b247f504d0ce1806a37fac4633081466b0 + languageName: node + linkType: hard + +"possible-typed-array-names@npm:^1.0.0, possible-typed-array-names@npm:^1.1.0": + version: 1.1.0 + resolution: "possible-typed-array-names@npm:1.1.0" + checksum: 10c0/c810983414142071da1d644662ce4caebce890203eb2bc7bf119f37f3fe5796226e117e6cca146b521921fa6531072674174a3325066ac66fce089a53e1e5196 + languageName: node + linkType: hard + +"postcss@npm:^8.5.6": + version: 8.5.15 + resolution: "postcss@npm:8.5.15" + dependencies: + nanoid: "npm:^3.3.12" + picocolors: "npm:^1.1.1" + source-map-js: "npm:^1.2.1" + checksum: 10c0/7f2e63ae22fbe43aace1bf652bd99da4e90737c64194d49e51ddc9cd0f9e51ff2861a7d734379b494deffa03a880a5c65eec70bc29ee9ebaa7136dde3eee8f31 + languageName: node + linkType: hard + +"preact@npm:^10.26.9": + version: 10.29.2 + resolution: "preact@npm:10.29.2" + checksum: 10c0/2ee161274e475804524608d42bba8c79920636b322293248796a9e5bf4c3332336f8c0eca1b1566ed09cdee95e408eb20b5b7613d95820ea6b6eb8fc090ef60a + languageName: node + linkType: hard + +"prelude-ls@npm:^1.2.1": + version: 1.2.1 + resolution: "prelude-ls@npm:1.2.1" + checksum: 10c0/b00d617431e7886c520a6f498a2e14c75ec58f6d93ba48c3b639cf241b54232d90daa05d83a9e9b9fef6baa63cb7e1e4602c2372fea5bc169668401eb127d0cd + languageName: node + linkType: hard + +"proc-log@npm:^7.0.0": + version: 7.0.0 + resolution: "proc-log@npm:7.0.0" + checksum: 10c0/b89c2d862604f35fec795477b0c7e376feab3ba0d4f4d291c4e959567442697cf451ac557d0623c1cc38af45a78128b983410f397a10c5d3a67f76c33de4754b + languageName: node + linkType: hard + +"prop-types@npm:^15.6.2, prop-types@npm:^15.8.1": + version: 15.8.1 + resolution: "prop-types@npm:15.8.1" + dependencies: + loose-envify: "npm:^1.4.0" + object-assign: "npm:^4.1.1" + react-is: "npm:^16.13.1" + checksum: 10c0/59ece7ca2fb9838031d73a48d4becb9a7cc1ed10e610517c7d8f19a1e02fa47f7c27d557d8a5702bec3cfeccddc853579832b43f449e54635803f277b1c78077 + languageName: node + linkType: hard + +"proxy-from-env@npm:^2.1.0": + version: 2.1.0 + resolution: "proxy-from-env@npm:2.1.0" + checksum: 10c0/ed01729fd4d094eab619cd7e17ce3698b3413b31eb102c4904f9875e677cd207392795d5b4adee9cec359dfd31c44d5ad7595a3a3ad51c40250e141512281c58 + languageName: node + linkType: hard + +"punycode@npm:^2.1.0": + version: 2.3.1 + resolution: "punycode@npm:2.3.1" + checksum: 10c0/14f76a8206bc3464f794fb2e3d3cc665ae416c01893ad7a02b23766eb07159144ee612ad67af5e84fa4479ccfe67678c4feb126b0485651b302babf66f04f9e9 + languageName: node + linkType: hard + +"react-is@npm:^16.13.1, react-is@npm:^16.7.0": + version: 16.13.1 + resolution: "react-is@npm:16.13.1" + checksum: 10c0/33977da7a5f1a287936a0c85639fec6ca74f4f15ef1e59a6bc20338fc73dc69555381e211f7a3529b8150a1f71e4225525b41b60b52965bda53ce7d47377ada1 + languageName: node + linkType: hard + +"react-is@npm:^19.2.6": + version: 19.2.7 + resolution: "react-is@npm:19.2.7" + checksum: 10c0/419fe54d5bd7fdf5414a5bb7bd9a1e0e36f9fae28ffb4cb73290fbe342bde15d8584a90d1db62547f6aa03018dce517b178a041abb522136cd4b4b51b4e94c83 + languageName: node + linkType: hard + +"react-transition-group@npm:^4.4.5": + version: 4.4.5 + resolution: "react-transition-group@npm:4.4.5" + dependencies: + "@babel/runtime": "npm:^7.5.5" + dom-helpers: "npm:^5.0.1" + loose-envify: "npm:^1.4.0" + prop-types: "npm:^15.6.2" + peerDependencies: + react: ">=16.6.0" + react-dom: ">=16.6.0" + checksum: 10c0/2ba754ba748faefa15f87c96dfa700d5525054a0141de8c75763aae6734af0740e77e11261a1e8f4ffc08fd9ab78510122e05c21c2d79066c38bb6861a886c82 + languageName: node + linkType: hard + +"reflect.getprototypeof@npm:^1.0.10, reflect.getprototypeof@npm:^1.0.9": + version: 1.0.10 + resolution: "reflect.getprototypeof@npm:1.0.10" + dependencies: + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.9" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.0.0" + get-intrinsic: "npm:^1.2.7" + get-proto: "npm:^1.0.1" + which-builtin-type: "npm:^1.2.1" + checksum: 10c0/7facec28c8008876f8ab98e80b7b9cb4b1e9224353fd4756dda5f2a4ab0d30fa0a5074777c6df24e1e0af463a2697513b0a11e548d99cf52f21f7bc6ba48d3ac + languageName: node + linkType: hard + +"regexp.prototype.flags@npm:^1.5.3, regexp.prototype.flags@npm:^1.5.4": + version: 1.5.4 + resolution: "regexp.prototype.flags@npm:1.5.4" + dependencies: + call-bind: "npm:^1.0.8" + define-properties: "npm:^1.2.1" + es-errors: "npm:^1.3.0" + get-proto: "npm:^1.0.1" + gopd: "npm:^1.2.0" + set-function-name: "npm:^2.0.2" + checksum: 10c0/83b88e6115b4af1c537f8dabf5c3744032cb875d63bc05c288b1b8c0ef37cbe55353f95d8ca817e8843806e3e150b118bc624e4279b24b4776b4198232735a77 + languageName: node + linkType: hard + +"reselect@npm:^5.2.0": + version: 5.2.0 + resolution: "reselect@npm:5.2.0" + checksum: 10c0/d0a8497e404b25a769fe792eacae88b9b576c30870450cd243d76ec9427d91a59c4a2cc00d824d283448b444c4c698a8f961d771c8ae39c759313afb31950e2e + languageName: node + linkType: hard + +"resolve-from@npm:^4.0.0": + version: 4.0.0 + resolution: "resolve-from@npm:4.0.0" + checksum: 10c0/8408eec31a3112ef96e3746c37be7d64020cda07c03a920f5024e77290a218ea758b26ca9529fd7b1ad283947f34b2291c1c0f6aa0ed34acfdda9c6014c8d190 + languageName: node + linkType: hard + +"resolve@npm:^1.19.0": + version: 1.22.12 + resolution: "resolve@npm:1.22.12" + dependencies: + es-errors: "npm:^1.3.0" + is-core-module: "npm:^2.16.1" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10c0/b16dc9b537c02e8c3388f7d3dcff9741d3071625f9a97ac1c885f2b0ca51e78df22328fb6d6ef214dd9101fb7cfc19aa2836fe3410402a94f3f7b8639c7149bf + languageName: node + linkType: hard + +"resolve@npm:^2.0.0-next.5": + version: 2.0.0-next.7 + resolution: "resolve@npm:2.0.0-next.7" + dependencies: + es-errors: "npm:^1.3.0" + is-core-module: "npm:^2.16.2" + node-exports-info: "npm:^1.6.0" + object-keys: "npm:^1.1.1" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10c0/8c6fa17ccdb826a3a52387ed8c42bf705dbc19d5494da52a86661b124b5b88fad5d8edbbb4434a1b563ecf7768368b7da9fb9489e20f36e02f7551a4ea87d707 + languageName: node + linkType: hard + +"resolve@patch:resolve@npm%3A^1.19.0#optional!builtin": + version: 1.22.12 + resolution: "resolve@patch:resolve@npm%3A1.22.12#optional!builtin::version=1.22.12&hash=c3c19d" + dependencies: + es-errors: "npm:^1.3.0" + is-core-module: "npm:^2.16.1" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10c0/fc6519984ae1f894d877c0060ba8b1f5ba3bc0e85a02f74e141929c118c23d74d9735619a9cc2965397387e514884245c65d72a40731dcb6cfc84c7bcdc8321e + languageName: node + linkType: hard + +"resolve@patch:resolve@npm%3A^2.0.0-next.5#optional!builtin": + version: 2.0.0-next.7 + resolution: "resolve@patch:resolve@npm%3A2.0.0-next.7#optional!builtin::version=2.0.0-next.7&hash=c3c19d" + dependencies: + es-errors: "npm:^1.3.0" + is-core-module: "npm:^2.16.2" + node-exports-info: "npm:^1.6.0" + object-keys: "npm:^1.1.1" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10c0/6bb6f1d8a1789f7a5b4e35d950e76bc0ba632ff7d51fe86b6f34fb5f41e1ce0f7b884ec166828cfc0728ddffeaee49527711d752d12398297f90c51acd22195e + languageName: node + linkType: hard + +"rollup@npm:^4.43.0": + version: 4.62.2 + resolution: "rollup@npm:4.62.2" + dependencies: + "@rollup/rollup-android-arm-eabi": "npm:4.62.2" + "@rollup/rollup-android-arm64": "npm:4.62.2" + "@rollup/rollup-darwin-arm64": "npm:4.62.2" + "@rollup/rollup-darwin-x64": "npm:4.62.2" + "@rollup/rollup-freebsd-arm64": "npm:4.62.2" + "@rollup/rollup-freebsd-x64": "npm:4.62.2" + "@rollup/rollup-linux-arm-gnueabihf": "npm:4.62.2" + "@rollup/rollup-linux-arm-musleabihf": "npm:4.62.2" + "@rollup/rollup-linux-arm64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-arm64-musl": "npm:4.62.2" + "@rollup/rollup-linux-loong64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-loong64-musl": "npm:4.62.2" + "@rollup/rollup-linux-ppc64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-ppc64-musl": "npm:4.62.2" + "@rollup/rollup-linux-riscv64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-riscv64-musl": "npm:4.62.2" + "@rollup/rollup-linux-s390x-gnu": "npm:4.62.2" + "@rollup/rollup-linux-x64-gnu": "npm:4.62.2" + "@rollup/rollup-linux-x64-musl": "npm:4.62.2" + "@rollup/rollup-openbsd-x64": "npm:4.62.2" + "@rollup/rollup-openharmony-arm64": "npm:4.62.2" + "@rollup/rollup-win32-arm64-msvc": "npm:4.62.2" + "@rollup/rollup-win32-ia32-msvc": "npm:4.62.2" + "@rollup/rollup-win32-x64-gnu": "npm:4.62.2" + "@rollup/rollup-win32-x64-msvc": "npm:4.62.2" + "@types/estree": "npm:1.0.9" + fsevents: "npm:~2.3.2" + dependenciesMeta: + "@rollup/rollup-android-arm-eabi": + optional: true + "@rollup/rollup-android-arm64": + optional: true + "@rollup/rollup-darwin-arm64": + optional: true + "@rollup/rollup-darwin-x64": + optional: true + "@rollup/rollup-freebsd-arm64": + optional: true + "@rollup/rollup-freebsd-x64": + optional: true + "@rollup/rollup-linux-arm-gnueabihf": + optional: true + "@rollup/rollup-linux-arm-musleabihf": + optional: true + "@rollup/rollup-linux-arm64-gnu": + optional: true + "@rollup/rollup-linux-arm64-musl": + optional: true + "@rollup/rollup-linux-loong64-gnu": + optional: true + "@rollup/rollup-linux-loong64-musl": + optional: true + "@rollup/rollup-linux-ppc64-gnu": + optional: true + "@rollup/rollup-linux-ppc64-musl": + optional: true + "@rollup/rollup-linux-riscv64-gnu": + optional: true + "@rollup/rollup-linux-riscv64-musl": + optional: true + "@rollup/rollup-linux-s390x-gnu": + optional: true + "@rollup/rollup-linux-x64-gnu": + optional: true + "@rollup/rollup-linux-x64-musl": + optional: true + "@rollup/rollup-openbsd-x64": + optional: true + "@rollup/rollup-openharmony-arm64": + optional: true + "@rollup/rollup-win32-arm64-msvc": + optional: true + "@rollup/rollup-win32-ia32-msvc": + optional: true + "@rollup/rollup-win32-x64-gnu": + optional: true + "@rollup/rollup-win32-x64-msvc": + optional: true + fsevents: + optional: true + bin: + rollup: dist/bin/rollup + checksum: 10c0/83ff5f4a1fea3fa05db2ef56beceee8c33d4a72b818e19c562f1e85c41076fe5b12aadc44048bb73e60b83336df82154b017fa6bf0186f3141643e6f215fbdcb + languageName: node + linkType: hard + +"root-workspace-0b6124@workspace:.": + version: 0.0.0-use.local + resolution: "root-workspace-0b6124@workspace:." + dependencies: + "@babel/core": "npm:^8.0.1" + "@base-ui/react": "npm:^1.6.0" + "@emotion/react": "npm:^11.14.0" + "@emotion/styled": "npm:^11.14.1" + "@fontsource/roboto": "npm:^5.2.10" + "@mui/icons-material": "npm:^9.1.1" + "@mui/material": "npm:^9.1.2" + "@preact/preset-vite": "npm:^2.10.2" + axios: "npm:^1.18.1" + eslint: "npm:^10.5.0" + eslint-config-preact: "npm:^2.0.0" + preact: "npm:^10.26.9" + typescript: "npm:^6.0.3" + vite: "npm:^7.0.4" + languageName: unknown + linkType: soft + +"safe-array-concat@npm:^1.1.3": + version: 1.1.4 + resolution: "safe-array-concat@npm:1.1.4" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + get-intrinsic: "npm:^1.3.0" + has-symbols: "npm:^1.1.0" + isarray: "npm:^2.0.5" + checksum: 10c0/95fb4904ab1d9360a666fe5ba6d88f1c4a3a39682739e4512cff809fc6b5722a94bd95189211015bfb45859a7ffbc3340ea303ae22721c91c59e8946d310975a + languageName: node + linkType: hard + +"safe-push-apply@npm:^1.0.0": + version: 1.0.0 + resolution: "safe-push-apply@npm:1.0.0" + dependencies: + es-errors: "npm:^1.3.0" + isarray: "npm:^2.0.5" + checksum: 10c0/831f1c9aae7436429e7862c7e46f847dfe490afac20d0ee61bae06108dbf5c745a0de3568ada30ccdd3eeb0864ca8331b2eef703abd69bfea0745b21fd320750 + languageName: node + linkType: hard + +"safe-regex-test@npm:^1.1.0": + version: 1.1.0 + resolution: "safe-regex-test@npm:1.1.0" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + is-regex: "npm:^1.2.1" + checksum: 10c0/f2c25281bbe5d39cddbbce7f86fca5ea9b3ce3354ea6cd7c81c31b006a5a9fff4286acc5450a3b9122c56c33eba69c56b9131ad751457b2b4a585825e6a10665 + languageName: node + linkType: hard + +"semver@npm:^6.3.1": + version: 6.3.1 + resolution: "semver@npm:6.3.1" + bin: + semver: bin/semver.js + checksum: 10c0/e3d79b609071caa78bcb6ce2ad81c7966a46a7431d9d58b8800cfa9cb6a63699b3899a0e4bcce36167a284578212d9ae6942b6929ba4aa5015c079a67751d42d + languageName: node + linkType: hard + +"semver@npm:^7.3.5, semver@npm:^7.7.3": + version: 7.8.5 + resolution: "semver@npm:7.8.5" + bin: + semver: bin/semver.js + checksum: 10c0/b1f3127a5be8125a94f37188b361c212466c292c6910adce3ec106cff5dc211ccaedc4739c11bb70fda59d6fc1f040a9bca289f4e093451521a2372e5231fe0c + languageName: node + linkType: hard + +"semver@npm:^7.6.2": + version: 7.8.4 + resolution: "semver@npm:7.8.4" + bin: + semver: bin/semver.js + checksum: 10c0/81b7c296fd7927b80f67fa516b75fa1017caac8167795320de28e76ccbc6f7f01763c30ecd10d6a0d8fd089708ab0548a5aebb94b0870e99c2a2b4600a46389b + languageName: node + linkType: hard + +"set-function-length@npm:^1.2.2": + version: 1.2.2 + resolution: "set-function-length@npm:1.2.2" + dependencies: + define-data-property: "npm:^1.1.4" + es-errors: "npm:^1.3.0" + function-bind: "npm:^1.1.2" + get-intrinsic: "npm:^1.2.4" + gopd: "npm:^1.0.1" + has-property-descriptors: "npm:^1.0.2" + checksum: 10c0/82850e62f412a258b71e123d4ed3873fa9377c216809551192bb6769329340176f109c2eeae8c22a8d386c76739855f78e8716515c818bcaef384b51110f0f3c + languageName: node + linkType: hard + +"set-function-name@npm:^2.0.2": + version: 2.0.2 + resolution: "set-function-name@npm:2.0.2" + dependencies: + define-data-property: "npm:^1.1.4" + es-errors: "npm:^1.3.0" + functions-have-names: "npm:^1.2.3" + has-property-descriptors: "npm:^1.0.2" + checksum: 10c0/fce59f90696c450a8523e754abb305e2b8c73586452619c2bad5f7bf38c7b6b4651895c9db895679c5bef9554339cf3ef1c329b66ece3eda7255785fbe299316 + languageName: node + linkType: hard + +"set-proto@npm:^1.0.0": + version: 1.0.0 + resolution: "set-proto@npm:1.0.0" + dependencies: + dunder-proto: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/ca5c3ccbba479d07c30460e367e66337cec825560b11e8ba9c5ebe13a2a0d6021ae34eddf94ff3dfe17a3104dc1f191519cb6c48378b503e5c3f36393938776a + languageName: node + linkType: hard + +"shebang-command@npm:^2.0.0": + version: 2.0.0 + resolution: "shebang-command@npm:2.0.0" + dependencies: + shebang-regex: "npm:^3.0.0" + checksum: 10c0/a41692e7d89a553ef21d324a5cceb5f686d1f3c040759c50aab69688634688c5c327f26f3ecf7001ebfd78c01f3c7c0a11a7c8bfd0a8bc9f6240d4f40b224e4e + languageName: node + linkType: hard + +"shebang-regex@npm:^3.0.0": + version: 3.0.0 + resolution: "shebang-regex@npm:3.0.0" + checksum: 10c0/1dbed0726dd0e1152a92696c76c7f06084eb32a90f0528d11acd764043aacf76994b2fb30aa1291a21bd019d6699164d048286309a278855ee7bec06cf6fb690 + languageName: node + linkType: hard + +"side-channel-list@npm:^1.0.1": + version: 1.0.1 + resolution: "side-channel-list@npm:1.0.1" + dependencies: + es-errors: "npm:^1.3.0" + object-inspect: "npm:^1.13.4" + checksum: 10c0/d346c787fd2f9f1c2fdea14f00e8250118db0e7596d85a6cb9faa75f105d31a73a8f7a341c93d7df2a2429098c3d37a77bd3be9e88c37094b8c01807bc77c7a2 + languageName: node + linkType: hard + +"side-channel-map@npm:^1.0.1": + version: 1.0.1 + resolution: "side-channel-map@npm:1.0.1" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.5" + object-inspect: "npm:^1.13.3" + checksum: 10c0/010584e6444dd8a20b85bc926d934424bd809e1a3af941cace229f7fdcb751aada0fb7164f60c2e22292b7fa3c0ff0bce237081fd4cdbc80de1dc68e95430672 + languageName: node + linkType: hard + +"side-channel-weakmap@npm:^1.0.2": + version: 1.0.2 + resolution: "side-channel-weakmap@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.5" + object-inspect: "npm:^1.13.3" + side-channel-map: "npm:^1.0.1" + checksum: 10c0/71362709ac233e08807ccd980101c3e2d7efe849edc51455030327b059f6c4d292c237f94dc0685031dd11c07dd17a68afde235d6cf2102d949567f98ab58185 + languageName: node + linkType: hard + +"side-channel@npm:^1.1.0": + version: 1.1.1 + resolution: "side-channel@npm:1.1.1" + dependencies: + es-errors: "npm:^1.3.0" + object-inspect: "npm:^1.13.4" + side-channel-list: "npm:^1.0.1" + side-channel-map: "npm:^1.0.1" + side-channel-weakmap: "npm:^1.0.2" + checksum: 10c0/dc0ab81d67f61bda9247d053ce93f41c3fd8ad2bdcb9cf9d8d2f8540d488f26d87a5e99ebfc07eea49ec025867b2452b705442d974b1478f0395e69f6bfb3270 + languageName: node + linkType: hard + +"simple-code-frame@npm:^1.3.0": + version: 1.3.0 + resolution: "simple-code-frame@npm:1.3.0" + dependencies: + kolorist: "npm:^1.6.0" + checksum: 10c0/f74332d839689b30deddc079f52845c05e455160888c2076056dd070d0088b8e84a0f36b6d273d38a8698e738dc5f34bbe6ecdcc86146b9d4250c67374f975c5 + languageName: node + linkType: hard + +"source-map-js@npm:^1.2.1": + version: 1.2.1 + resolution: "source-map-js@npm:1.2.1" + checksum: 10c0/7bda1fc4c197e3c6ff17de1b8b2c20e60af81b63a52cb32ec5a5d67a20a7d42651e2cb34ebe93833c5a2a084377e17455854fee3e21e7925c64a51b6a52b0faf + languageName: node + linkType: hard + +"source-map@npm:^0.5.7": + version: 0.5.7 + resolution: "source-map@npm:0.5.7" + checksum: 10c0/904e767bb9c494929be013017380cbba013637da1b28e5943b566031e29df04fba57edf3f093e0914be094648b577372bd8ad247fa98cfba9c600794cd16b599 + languageName: node + linkType: hard + +"source-map@npm:^0.7.4": + version: 0.7.6 + resolution: "source-map@npm:0.7.6" + checksum: 10c0/59f6f05538539b274ba771d2e9e32f6c65451982510564438e048bc1352f019c6efcdc6dd07909b1968144941c14015c2c7d4369fb7c4d7d53ae769716dcc16c + languageName: node + linkType: hard + +"stack-trace@npm:^1.0.0-pre2": + version: 1.0.0 + resolution: "stack-trace@npm:1.0.0" + checksum: 10c0/630e0a95137eeed8051b5359e0978baf86ae6b12f9ad8d4056398afb39c3953e39d94e104c415f4116b930527946c03df572414f289d435bf5f778490593a9de + languageName: node + linkType: hard + +"stop-iteration-iterator@npm:^1.1.0": + version: 1.1.0 + resolution: "stop-iteration-iterator@npm:1.1.0" + dependencies: + es-errors: "npm:^1.3.0" + internal-slot: "npm:^1.1.0" + checksum: 10c0/de4e45706bb4c0354a4b1122a2b8cc45a639e86206807ce0baf390ee9218d3ef181923fa4d2b67443367c491aa255c5fbaa64bb74648e3c5b48299928af86c09 + languageName: node + linkType: hard + +"string.prototype.matchall@npm:^4.0.12": + version: 4.0.12 + resolution: "string.prototype.matchall@npm:4.0.12" + dependencies: + call-bind: "npm:^1.0.8" + call-bound: "npm:^1.0.3" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.23.6" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.0.0" + get-intrinsic: "npm:^1.2.6" + gopd: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + internal-slot: "npm:^1.1.0" + regexp.prototype.flags: "npm:^1.5.3" + set-function-name: "npm:^2.0.2" + side-channel: "npm:^1.1.0" + checksum: 10c0/1a53328ada73f4a77f1fdf1c79414700cf718d0a8ef6672af5603e709d26a24f2181208144aed7e858b1bcc1a0d08567a570abfb45567db4ae47637ed2c2f85c + languageName: node + linkType: hard + +"string.prototype.repeat@npm:^1.0.0": + version: 1.0.0 + resolution: "string.prototype.repeat@npm:1.0.0" + dependencies: + define-properties: "npm:^1.1.3" + es-abstract: "npm:^1.17.5" + checksum: 10c0/94c7978566cffa1327d470fd924366438af9b04b497c43a9805e476e2e908aa37a1fd34cc0911156c17556dab62159d12c7b92b3cc304c3e1281fe4c8e668f40 + languageName: node + linkType: hard + +"string.prototype.trim@npm:^1.2.10": + version: 1.2.11 + resolution: "string.prototype.trim@npm:1.2.11" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + define-data-property: "npm:^1.1.4" + define-properties: "npm:^1.2.1" + es-abstract: "npm:^1.24.2" + es-object-atoms: "npm:^1.1.2" + has-property-descriptors: "npm:^1.0.2" + safe-regex-test: "npm:^1.1.0" + checksum: 10c0/b153cf8ed06db82ff40e27829e88e5c13f45eff9799f1d5707626e25989b488b059d6f5d57011e07f77745e28451e16735f295bc59c8ae146a4fd73a442366b0 + languageName: node + linkType: hard + +"string.prototype.trimend@npm:^1.0.9": + version: 1.0.10 + resolution: "string.prototype.trimend@npm:1.0.10" + dependencies: + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.1.2" + checksum: 10c0/cc09233181769047a5330becfd5740fec5f0c8137886e7b553626788b00f75df9f34db1159bc52dbb7fc389b8ebb6e1dab44c8c9e31eb600039729a542013286 + languageName: node + linkType: hard + +"string.prototype.trimstart@npm:^1.0.8": + version: 1.0.8 + resolution: "string.prototype.trimstart@npm:1.0.8" + dependencies: + call-bind: "npm:^1.0.7" + define-properties: "npm:^1.2.1" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/d53af1899959e53c83b64a5fd120be93e067da740e7e75acb433849aa640782fb6c7d4cd5b84c954c84413745a3764df135a8afeb22908b86a835290788d8366 + languageName: node + linkType: hard + +"stylis@npm:4.2.0": + version: 4.2.0 + resolution: "stylis@npm:4.2.0" + checksum: 10c0/a7128ad5a8ed72652c6eba46bed4f416521bc9745a460ef5741edc725252cebf36ee45e33a8615a7057403c93df0866ab9ee955960792db210bb80abd5ac6543 + languageName: node + linkType: hard + +"supports-preserve-symlinks-flag@npm:^1.0.0": + version: 1.0.0 + resolution: "supports-preserve-symlinks-flag@npm:1.0.0" + checksum: 10c0/6c4032340701a9950865f7ae8ef38578d8d7053f5e10518076e6554a9381fa91bd9c6850193695c141f32b21f979c985db07265a758867bac95de05f7d8aeb39 + languageName: node + linkType: hard + +"tar@npm:^7.5.4": + version: 7.5.16 + resolution: "tar@npm:7.5.16" + dependencies: + "@isaacs/fs-minipass": "npm:^4.0.0" + chownr: "npm:^3.0.0" + minipass: "npm:^7.1.2" + minizlib: "npm:^3.1.0" + yallist: "npm:^5.0.0" + checksum: 10c0/4f37f3c4bd2ca2755fd736a5df1d573c1a868ec1b1e893346aeafa95ac510f9e2fd1469420bd866cc7904799e5bd4ac62b5d4f03fe27747d6e1e373b44505c5c + languageName: node + linkType: hard + +"tinyglobby@npm:^0.2.12, tinyglobby@npm:^0.2.15": + version: 0.2.17 + resolution: "tinyglobby@npm:0.2.17" + dependencies: + fdir: "npm:^6.5.0" + picomatch: "npm:^4.0.4" + checksum: 10c0/7f7bb0f197c88bc4b20c231e0deca4240ca3bf313a88f5a7fee93a872b84966a4d50220947c0455ad07a60b3b360961c5b7fd979222aeb716a9f99b412002e4c + languageName: node + linkType: hard + +"type-check@npm:^0.4.0, type-check@npm:~0.4.0": + version: 0.4.0 + resolution: "type-check@npm:0.4.0" + dependencies: + prelude-ls: "npm:^1.2.1" + checksum: 10c0/7b3fd0ed43891e2080bf0c5c504b418fbb3e5c7b9708d3d015037ba2e6323a28152ec163bcb65212741fa5d2022e3075ac3c76440dbd344c9035f818e8ecee58 + languageName: node + linkType: hard + +"typed-array-buffer@npm:^1.0.3": + version: 1.0.3 + resolution: "typed-array-buffer@npm:1.0.3" + dependencies: + call-bound: "npm:^1.0.3" + es-errors: "npm:^1.3.0" + is-typed-array: "npm:^1.1.14" + checksum: 10c0/1105071756eb248774bc71646bfe45b682efcad93b55532c6ffa4518969fb6241354e4aa62af679ae83899ec296d69ef88f1f3763657cdb3a4d29321f7b83079 + languageName: node + linkType: hard + +"typed-array-byte-length@npm:^1.0.3": + version: 1.0.3 + resolution: "typed-array-byte-length@npm:1.0.3" + dependencies: + call-bind: "npm:^1.0.8" + for-each: "npm:^0.3.3" + gopd: "npm:^1.2.0" + has-proto: "npm:^1.2.0" + is-typed-array: "npm:^1.1.14" + checksum: 10c0/6ae083c6f0354f1fce18b90b243343b9982affd8d839c57bbd2c174a5d5dc71be9eb7019ffd12628a96a4815e7afa85d718d6f1e758615151d5f35df841ffb3e + languageName: node + linkType: hard + +"typed-array-byte-offset@npm:^1.0.4": + version: 1.0.4 + resolution: "typed-array-byte-offset@npm:1.0.4" + dependencies: + available-typed-arrays: "npm:^1.0.7" + call-bind: "npm:^1.0.8" + for-each: "npm:^0.3.3" + gopd: "npm:^1.2.0" + has-proto: "npm:^1.2.0" + is-typed-array: "npm:^1.1.15" + reflect.getprototypeof: "npm:^1.0.9" + checksum: 10c0/3d805b050c0c33b51719ee52de17c1cd8e6a571abdf0fffb110e45e8dd87a657e8b56eee94b776b13006d3d347a0c18a730b903cf05293ab6d92e99ff8f77e53 + languageName: node + linkType: hard + +"typed-array-length@npm:^1.0.7": + version: 1.0.8 + resolution: "typed-array-length@npm:1.0.8" + dependencies: + call-bind: "npm:^1.0.9" + for-each: "npm:^0.3.5" + gopd: "npm:^1.2.0" + is-typed-array: "npm:^1.1.15" + possible-typed-array-names: "npm:^1.1.0" + reflect.getprototypeof: "npm:^1.0.10" + checksum: 10c0/5319f740fc426a3217182c2f7c87656acb0903e046de5a938e30167337d26abf1bb3ad4b32833a72521a4cc58223aec80627b38b357d0a3d5fd64881427e77ab + languageName: node + linkType: hard + +"typescript@npm:^6.0.3": + version: 6.0.3 + resolution: "typescript@npm:6.0.3" + bin: + tsc: bin/tsc + tsserver: bin/tsserver + checksum: 10c0/4a25ff5045b984370f48f196b3a0120779b1b343d40b9a68d114ea5e5fff099809b2bb777576991a63a5cd59cf7bffd96ff6fe10afcefbcb8bd6fb96ad4b6606 + languageName: node + linkType: hard + +"typescript@patch:typescript@npm%3A^6.0.3#optional!builtin": + version: 6.0.3 + resolution: "typescript@patch:typescript@npm%3A6.0.3#optional!builtin::version=6.0.3&hash=5786d5" + bin: + tsc: bin/tsc + tsserver: bin/tsserver + checksum: 10c0/2f25c74e65663c248fa1ade2b8459d9ce5372ff9dad07067310f132966ebec1d93f6c42f0baf77a6b6a7a91460463f708e6887013aaade22111037457c6b25df + languageName: node + linkType: hard + +"unbox-primitive@npm:^1.1.0": + version: 1.1.0 + resolution: "unbox-primitive@npm:1.1.0" + dependencies: + call-bound: "npm:^1.0.3" + has-bigints: "npm:^1.0.2" + has-symbols: "npm:^1.1.0" + which-boxed-primitive: "npm:^1.1.1" + checksum: 10c0/7dbd35ab02b0e05fe07136c72cb9355091242455473ec15057c11430129bab38b7b3624019b8778d02a881c13de44d63cd02d122ee782fb519e1de7775b5b982 + languageName: node + linkType: hard + +"undici@npm:^6.25.0": + version: 6.27.0 + resolution: "undici@npm:6.27.0" + checksum: 10c0/f88c3dae3957dbf9d93cb481440aced317bd3c4941b5914fea5efba516d51138988cdb5c76006f0bb1337e41d56c3443351055d492e73af2428521c37ba2a76f + languageName: node + linkType: hard + +"update-browserslist-db@npm:^1.2.3": + version: 1.2.3 + resolution: "update-browserslist-db@npm:1.2.3" + dependencies: + escalade: "npm:^3.2.0" + picocolors: "npm:^1.1.1" + peerDependencies: + browserslist: ">= 4.21.0" + bin: + update-browserslist-db: cli.js + checksum: 10c0/13a00355ea822388f68af57410ce3255941d5fb9b7c49342c4709a07c9f230bbef7f7499ae0ca7e0de532e79a82cc0c4edbd125f1a323a1845bf914efddf8bec + languageName: node + linkType: hard + +"uri-js@npm:^4.2.2": + version: 4.4.1 + resolution: "uri-js@npm:4.4.1" + dependencies: + punycode: "npm:^2.1.0" + checksum: 10c0/4ef57b45aa820d7ac6496e9208559986c665e49447cb072744c13b66925a362d96dd5a46c4530a6b8e203e5db5fe849369444440cb22ecfc26c679359e5dfa3c + languageName: node + linkType: hard + +"use-sync-external-store@npm:^1.6.0": + version: 1.6.0 + resolution: "use-sync-external-store@npm:1.6.0" + peerDependencies: + react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 + checksum: 10c0/35e1179f872a53227bdf8a827f7911da4c37c0f4091c29b76b1e32473d1670ebe7bcd880b808b7549ba9a5605c233350f800ffab963ee4a4ee346ee983b6019b + languageName: node + linkType: hard + +"vite-prerender-plugin@npm:^0.5.8": + version: 0.5.13 + resolution: "vite-prerender-plugin@npm:0.5.13" + dependencies: + kolorist: "npm:^1.8.0" + magic-string: "npm:0.x >= 0.26.0" + node-html-parser: "npm:^6.1.12" + simple-code-frame: "npm:^1.3.0" + source-map: "npm:^0.7.4" + stack-trace: "npm:^1.0.0-pre2" + peerDependencies: + vite: 5.x || 6.x || 7.x || 8.x + checksum: 10c0/474feed1faac452f62c501330f0109e9c2a9ddac84bd27acc4ecb8ff92f1f0670abc1949ed8eff45957108ce65b94cd24f3b1ceae45cf3ffa75e11e0591f4bc4 + languageName: node + linkType: hard + +"vite@npm:^7.0.4": + version: 7.3.5 + resolution: "vite@npm:7.3.5" + dependencies: + esbuild: "npm:^0.27.0" + fdir: "npm:^6.5.0" + fsevents: "npm:~2.3.3" + picomatch: "npm:^4.0.3" + postcss: "npm:^8.5.6" + rollup: "npm:^4.43.0" + tinyglobby: "npm:^0.2.15" + peerDependencies: + "@types/node": ^20.19.0 || >=22.12.0 + jiti: ">=1.21.0" + less: ^4.0.0 + lightningcss: ^1.21.0 + sass: ^1.70.0 + sass-embedded: ^1.70.0 + stylus: ">=0.54.8" + sugarss: ^5.0.0 + terser: ^5.16.0 + tsx: ^4.8.1 + yaml: ^2.4.2 + dependenciesMeta: + fsevents: + optional: true + peerDependenciesMeta: + "@types/node": + optional: true + jiti: + optional: true + less: + optional: true + lightningcss: + optional: true + sass: + optional: true + sass-embedded: + optional: true + stylus: + optional: true + sugarss: + optional: true + terser: + optional: true + tsx: + optional: true + yaml: + optional: true + bin: + vite: bin/vite.js + checksum: 10c0/4ad700649ed2ebd1e726d32f3f6e41eecbec4e29bcb5977805f3d43a5659280518aa431b0fc61adc1879df4fe1978d7cfc7dbbe54cdf014022385052967721e8 + languageName: node + linkType: hard + +"which-boxed-primitive@npm:^1.1.0, which-boxed-primitive@npm:^1.1.1": + version: 1.1.1 + resolution: "which-boxed-primitive@npm:1.1.1" + dependencies: + is-bigint: "npm:^1.1.0" + is-boolean-object: "npm:^1.2.1" + is-number-object: "npm:^1.1.1" + is-string: "npm:^1.1.1" + is-symbol: "npm:^1.1.1" + checksum: 10c0/aceea8ede3b08dede7dce168f3883323f7c62272b49801716e8332ff750e7ae59a511ae088840bc6874f16c1b7fd296c05c949b0e5b357bfe3c431b98c417abe + languageName: node + linkType: hard + +"which-builtin-type@npm:^1.2.1": + version: 1.2.1 + resolution: "which-builtin-type@npm:1.2.1" + dependencies: + call-bound: "npm:^1.0.2" + function.prototype.name: "npm:^1.1.6" + has-tostringtag: "npm:^1.0.2" + is-async-function: "npm:^2.0.0" + is-date-object: "npm:^1.1.0" + is-finalizationregistry: "npm:^1.1.0" + is-generator-function: "npm:^1.0.10" + is-regex: "npm:^1.2.1" + is-weakref: "npm:^1.0.2" + isarray: "npm:^2.0.5" + which-boxed-primitive: "npm:^1.1.0" + which-collection: "npm:^1.0.2" + which-typed-array: "npm:^1.1.16" + checksum: 10c0/8dcf323c45e5c27887800df42fbe0431d0b66b1163849bb7d46b5a730ad6a96ee8bfe827d078303f825537844ebf20c02459de41239a0a9805e2fcb3cae0d471 + languageName: node + linkType: hard + +"which-collection@npm:^1.0.2": + version: 1.0.2 + resolution: "which-collection@npm:1.0.2" + dependencies: + is-map: "npm:^2.0.3" + is-set: "npm:^2.0.3" + is-weakmap: "npm:^2.0.2" + is-weakset: "npm:^2.0.3" + checksum: 10c0/3345fde20964525a04cdf7c4a96821f85f0cc198f1b2ecb4576e08096746d129eb133571998fe121c77782ac8f21cbd67745a3d35ce100d26d4e684c142ea1f2 + languageName: node + linkType: hard + +"which-typed-array@npm:^1.1.16, which-typed-array@npm:^1.1.19": + version: 1.1.22 + resolution: "which-typed-array@npm:1.1.22" + dependencies: + available-typed-arrays: "npm:^1.0.7" + call-bind: "npm:^1.0.9" + call-bound: "npm:^1.0.4" + for-each: "npm:^0.3.5" + get-proto: "npm:^1.0.1" + gopd: "npm:^1.2.0" + has-tostringtag: "npm:^1.0.2" + checksum: 10c0/e59db184a4e78b461fac3b05fafc1e7badbbedafbf04a967ee1de73717f1f9723a79699e7b5de71d449541cb5da8353efc01a4f8a72a152479850e54fa196c40 + languageName: node + linkType: hard + +"which@npm:^2.0.1": + version: 2.0.2 + resolution: "which@npm:2.0.2" + dependencies: + isexe: "npm:^2.0.0" + bin: + node-which: ./bin/node-which + checksum: 10c0/66522872a768b60c2a65a57e8ad184e5372f5b6a9ca6d5f033d4b0dc98aff63995655a7503b9c0a2598936f532120e81dd8cc155e2e92ed662a2b9377cc4374f + languageName: node + linkType: hard + +"which@npm:^7.0.0": + version: 7.0.0 + resolution: "which@npm:7.0.0" + dependencies: + isexe: "npm:^4.0.0" + bin: + node-which: bin/which.js + checksum: 10c0/ca0b54f198f78bbc4b7c02e34bda8d335cb352e0adb4cbca1c37b1a957af3a879a82c4c27ca6525bc942f548d8b64f816ef6528360af9f3de55ffb9b979b620d + languageName: node + linkType: hard + +"word-wrap@npm:^1.2.5": + version: 1.2.5 + resolution: "word-wrap@npm:1.2.5" + checksum: 10c0/e0e4a1ca27599c92a6ca4c32260e8a92e8a44f4ef6ef93f803f8ed823f486e0889fc0b93be4db59c8d51b3064951d25e43d434e95dc8c960cc3a63d65d00ba20 + languageName: node + linkType: hard + +"yallist@npm:^3.0.2": + version: 3.1.1 + resolution: "yallist@npm:3.1.1" + checksum: 10c0/c66a5c46bc89af1625476f7f0f2ec3653c1a1791d2f9407cfb4c2ba812a1e1c9941416d71ba9719876530e3340a99925f697142989371b72d93b9ee628afd8c1 + languageName: node + linkType: hard + +"yallist@npm:^5.0.0": + version: 5.0.0 + resolution: "yallist@npm:5.0.0" + checksum: 10c0/a499c81ce6d4a1d260d4ea0f6d49ab4da09681e32c3f0472dee16667ed69d01dae63a3b81745a24bd78476ec4fcf856114cb4896ace738e01da34b2c42235416 + languageName: node + linkType: hard + +"yaml@npm:^1.10.0": + version: 1.10.3 + resolution: "yaml@npm:1.10.3" + checksum: 10c0/c309ff85a0a569a981d71ab9cf0fef68672a16b9cdf40639d1c3b30034f6cd16ee428602bd6d64ecf006f8c8bee499023cac236538f79898aa99fb5db529a2ed + languageName: node + linkType: hard + +"yocto-queue@npm:^0.1.0": + version: 0.1.0 + resolution: "yocto-queue@npm:0.1.0" + checksum: 10c0/dceb44c28578b31641e13695d200d34ec4ab3966a5729814d5445b194933c096b7ced71494ce53a0e8820685d1d010df8b2422e5bf2cdea7e469d97ffbea306f + languageName: node + linkType: hard + +"zimmerframe@npm:^1.1.4": + version: 1.1.4 + resolution: "zimmerframe@npm:1.1.4" + checksum: 10c0/9470cbf22cefae975ab413c7158a119d082b354ddcf0da48a842f2f42246fa15943cd9b92c047de39db38015e3b866e32f383bc217e8e4f4192945c7d425536b + languageName: node + linkType: hard