From 4a06628213fc5b20abe4cf64d5f80135eaa724ef Mon Sep 17 00:00:00 2001 From: sangjanai Date: Mon, 3 Jun 2024 16:49:04 +0700 Subject: [PATCH 1/2] feat: add onnx server --- .clang-format | 83 + .gitignore | 558 +- .gitmodules | 3 + CMakeLists.txt | 73 + base/cortex-common/enginei.h | 44 + build_cortex_onnx.bat | 5 + examples/server/CMakeLists.txt | 52 + examples/server/dylib.h | 316 ++ examples/server/httplib.h | 9465 ++++++++++++++++++++++++++++++++ examples/server/server.cc | 273 + onnxruntime-genai | 1 + src/CMakeLists.txt | 45 + src/chat_completion_request.h | 34 + src/onnx_engine.cc | 350 ++ src/onnx_engine.h | 50 + third-party/CMakeLists.txt | 50 + third-party/DirectML.dll | Bin 0 -> 17801648 bytes third-party/onnxruntime.cmake | 35 + 18 files changed, 11426 insertions(+), 11 deletions(-) create mode 100644 .clang-format create mode 100644 .gitmodules create mode 100644 CMakeLists.txt create mode 100644 base/cortex-common/enginei.h create mode 100644 build_cortex_onnx.bat create mode 100644 examples/server/CMakeLists.txt create mode 100644 examples/server/dylib.h create mode 100644 examples/server/httplib.h create mode 100644 examples/server/server.cc create mode 160000 onnxruntime-genai create mode 100644 src/CMakeLists.txt create mode 100644 src/chat_completion_request.h create mode 100644 src/onnx_engine.cc create mode 100644 src/onnx_engine.h create mode 100644 third-party/CMakeLists.txt create mode 100644 third-party/DirectML.dll create mode 100644 third-party/onnxruntime.cmake diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..dc69733 --- /dev/null +++ b/.clang-format @@ -0,0 +1,83 @@ +# Google C/C++ Code Style settings +# https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# Author: Kehan Xue, kehan.xue (at) gmail.com + +Language: Cpp +BasedOnStyle: Google +AccessModifierOffset: -1 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: None +AlignOperands: Align +AllowAllArgumentsOnNextLine: true +AllowAllConstructorInitializersOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: Empty +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: Inline +AllowShortIfStatementsOnASingleLine: Never # To avoid conflict, set this "Never" and each "if statement" should include brace when coding +AllowShortLambdasOnASingleLine: Inline +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterReturnType: None +AlwaysBreakTemplateDeclarations: Yes +BinPackArguments: true +BreakBeforeBraces: Custom +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterStruct: false + AfterControlStatement: Never + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: false + BeforeLambdaBody: false + IndentBraces: false + SplitEmptyFunction: false + SplitEmptyRecord: false + SplitEmptyNamespace: false +BreakBeforeBinaryOperators: None +BreakBeforeTernaryOperators: true +BreakConstructorInitializers: BeforeColon +BreakInheritanceList: BeforeColon +ColumnLimit: 80 +CompactNamespaces: false +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false # Make sure the * or & align on the left +EmptyLineBeforeAccessModifier: LogicalBlock +FixNamespaceComments: true +IncludeBlocks: Preserve +IndentCaseLabels: true +IndentPPDirectives: None +IndentWidth: 2 +KeepEmptyLinesAtTheStartOfBlocks: true +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PointerAlignment: Left +ReflowComments: false +# SeparateDefinitionBlocks: Always # Only support since clang-format 14 +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: true +SpaceBeforeSquareBrackets: false +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 2 +SpacesInAngles: false +SpacesInCStyleCastParentheses: false +SpacesInContainerLiterals: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: c++11 +TabWidth: 4 +UseTab: Never \ No newline at end of file diff --git a/.gitignore b/.gitignore index 259148f..c5fefa0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,20 +1,74 @@ + +# Created by https://www.toptal.com/developers/gitignore/api/intellij+all,visualstudio,visualstudiocode,cmake,c,c++ +# Edit at https://www.toptal.com/developers/gitignore?templates=intellij+all,visualstudio,visualstudiocode,cmake,c,c++ + +### C ### # Prerequisites *.d -# Compiled Object files -*.slo -*.lo +# Object files *.o +*.ko *.obj +*.elf + +# Linker output +*.ilk +*.map +*.exp # Precompiled Headers *.gch *.pch -# Compiled Dynamic libraries +# Libraries +*.lib +*.a +*.la +*.lo + +# Shared objects (inc. Windows DLLs) +# *.dll *.so +*.so.* *.dylib -*.dll + +# Executables +*.exe +*.out +*.app +*.i*86 +*.x86_64 +*.hex + +# Debug files +*.dSYM/ +*.su +*.idb +*.pdb + +# Kernel Module Compile Results +*.mod +*.cmd +.tmp_versions/ +modules.order +Module.symvers +Mkfile.old +dkms.conf + +### C++ ### +# Prerequisites + +# Compiled Object files +*.slo + +# Precompiled Headers + +# Linker files + +# Debugger Files + +# Compiled Dynamic libraries # Fortran module files *.mod @@ -22,11 +76,493 @@ # Compiled Static libraries *.lai -*.la -*.a -*.lib # Executables -*.exe -*.out -*.app + +### CMake ### +CMakeLists.txt.user +CMakeCache.txt +CMakeFiles +CMakeScripts +Testing +!nitro-node/Makefile +cmake_install.cmake +install_manifest.txt +compile_commands.json +CTestTestfile.cmake +_deps +CMakeUserPresets.json + +### CMake Patch ### +# External projects +*-prefix/ + +### Intellij+all ### +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/usage.statistics.xml +.idea/**/dictionaries +.idea/**/shelf + +# Generated files +.idea/**/contentModel.xml + +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml + +# Gradle +.idea/**/gradle.xml +.idea/**/libraries + +# Gradle and Maven with auto-import +# When using Gradle or Maven with auto-import, you should exclude module files, +# since they will be recreated, and may cause churn. Uncomment if using +# auto-import. +# .idea/artifacts +# .idea/compiler.xml +# .idea/jarRepositories.xml +# .idea/modules.xml +# .idea/*.iml +# .idea/modules +# *.iml +# *.ipr + +# CMake +cmake-build-*/ + +# Mongo Explorer plugin +.idea/**/mongoSettings.xml + +# File-based project format +*.iws + +# IntelliJ +out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +# Editor-based Rest Client +.idea/httpRequests + +# Android studio 3.1+ serialized cache file +.idea/caches/build_file_checksums.ser + +### Intellij+all Patch ### +# Ignores the whole .idea folder and all .iml files +# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360 + +.idea/ + +# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023 + +*.iml +modules.xml +.idea/misc.xml +*.ipr + +# Sonarlint plugin +.idea/sonarlint + +### VisualStudioCode ### +.vscode/* +!.vscode/tasks.json +!.vscode/launch.json +*.code-workspace + +### VisualStudioCode Patch ### +# Ignore all local history of files +.history +.ionide + +### VisualStudio ### +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# 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 Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.meta +*.iobj +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.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, .xml, .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 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/ + +# 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 + +### VisualStudio Patch ### +# Additional files built by Visual Studio +*.tlog + +# End of https://www.toptal.com/developers/gitignore/api/intellij+all,visualstudio,visualstudiocode,cmake,c,c++ +build +build_deps +onnxruntime-genai/build +.DS_Store + +uploads/** \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..08670d9 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "onnxruntime-genai"] + path = onnxruntime-genai + url = https://github.com/microsoft/onnxruntime-genai.git diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..d15c6ff --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,73 @@ +cmake_minimum_required(VERSION 3.5) +project(cortex.onnx) +SET(TARGET engine) + +if(UNIX AND NOT APPLE) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") + add_compile_options(-fPIC) +endif() + +set(THIRD_PARTY_PATH ${CMAKE_CURRENT_SOURCE_DIR}/build_deps/_install) + +if(UNIX AND NOT APPLE) + add_compile_options(-fPIC) +endif() + +include(CheckIncludeFileCXX) +# CPP version +check_include_file_cxx(any HAS_ANY) +check_include_file_cxx(string_view HAS_STRING_VIEW) +check_include_file_cxx(coroutine HAS_COROUTINE) +if(HAS_ANY + AND HAS_STRING_VIEW + AND HAS_COROUTINE) + set(CMAKE_CXX_STANDARD 20) +elseif(HAS_ANY AND HAS_STRING_VIEW) + set(CMAKE_CXX_STANDARD 17) +else() + set(CMAKE_CXX_STANDARD 14) +endif() + +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +SET(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) + +set(ORT_GENAI_LIB_DIR ${CMAKE_SOURCE_DIR}/onnxruntime-genai/build/Release) +MESSAGE("ORT_GENAI_LIB_DIR=" ${ORT_GENAI_LIB_DIR}) +MESSAGE("CMAKE_SOURCE_DIR=" ${CMAKE_SOURCE_DIR}) + +if(WIN32) + set(ONNXRUNTIME_GENAI_LIB "onnxruntime-genai.dll") + set(ONNXRUNTIME_GENAI_DEPENDENCY "*.dll") +elseif(APPLE) + set(ONNXRUNTIME_GENAI_LIB "libonnxruntime-genai.dylib") + set(ONNXRUNTIME_GENAI_DEPENDENCY "*.dylib") +else() + set(ONNXRUNTIME_GENAI_LIB "libonnxruntime-genai.so") + set(ONNXRUNTIME_GENAI_DEPENDENCY "*.so") +endif() + +add_library(${TARGET} SHARED + src/onnx_engine.cc +) +# cmake -S .\onnxruntime-genai\ -B .\onnxruntime-genai\build -DUSE_DML=ON -DUSE_CUDA=OFF +# cmake --build .\onnxruntime-genai\build --config Release -j4 +find_library(JSONCPP + NAMES jsoncpp + HINTS "${THIRD_PARTY_PATH}/lib" +) + +find_library(TRANTOR + NAMES trantor + HINTS "${THIRD_PARTY_PATH}/lib" +) +target_link_directories(${TARGET} PRIVATE ${ORT_GENAI_LIB_DIR}) +target_link_libraries(${TARGET} PRIVATE ${ONNXRUNTIME_GENAI_LIB} ${JSONCPP} ${TRANTOR} + ${CMAKE_THREAD_LIBS_INIT}) +target_include_directories(${TARGET} PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/base + ${CMAKE_SOURCE_DIR}/onnxruntime-genai/src + ${CMAKE_SOURCE_DIR}/onnxruntime-genai/ort/include + ${THIRD_PARTY_PATH}/include +) \ No newline at end of file diff --git a/base/cortex-common/enginei.h b/base/cortex-common/enginei.h new file mode 100644 index 0000000..17b2829 --- /dev/null +++ b/base/cortex-common/enginei.h @@ -0,0 +1,44 @@ +#pragma once + +#include +#include + +#include "json/value.h" + +// Interface for inference engine. +// Note: only append new function to keep the compatibility. +class EngineI { + public: + virtual ~EngineI() {} + + virtual void HandleChatCompletion( + std::shared_ptr json_body, + std::function&& callback) = 0; + virtual void HandleEmbedding( + std::shared_ptr json_body, + std::function&& callback) = 0; + virtual void LoadModel( + std::shared_ptr json_body, + std::function&& callback) = 0; + virtual void UnloadModel( + std::shared_ptr json_body, + std::function&& callback) = 0; + virtual void GetModelStatus( + std::shared_ptr json_body, + std::function&& callback) = 0; + + // For backward compatible checking, add to list when we add more APIs + virtual bool IsSupported(const std::string& f) { + if (f == "HandleChatCompletion" || f == "HandleEmbedding" || + f == "LoadModel" || f == "UnloadModel" || f == "GetModelStatus" || + f == "GetModels") { + return true; + } + return false; + } + + // API to get running models. + virtual void GetModels( + std::shared_ptr json_body, + std::function&& callback) = 0; +}; \ No newline at end of file diff --git a/build_cortex_onnx.bat b/build_cortex_onnx.bat new file mode 100644 index 0000000..a10464c --- /dev/null +++ b/build_cortex_onnx.bat @@ -0,0 +1,5 @@ +cmake -S ./third-party -B ./build_deps/third-party +cmake --build ./build_deps/third-party --config Release -j4 + +cmake -S .\onnxruntime-genai\ -B .\onnxruntime-genai\build -DUSE_DML=ON -DUSE_CUDA=OFF -DENABLE_PYTHON=OFF -DORT_HOME=./build_deps/ort +cmake --build .\onnxruntime-genai\build --config Release -j4 diff --git a/examples/server/CMakeLists.txt b/examples/server/CMakeLists.txt new file mode 100644 index 0000000..dc2213b --- /dev/null +++ b/examples/server/CMakeLists.txt @@ -0,0 +1,52 @@ +cmake_minimum_required(VERSION 3.5) +project(server) + +find_package(Threads REQUIRED) + +if(UNIX AND NOT APPLE) + set(LINKER_FLAGS -ldl) +endif() + +include(CheckIncludeFileCXX) +# CPP version +check_include_file_cxx(any HAS_ANY) +check_include_file_cxx(string_view HAS_STRING_VIEW) +check_include_file_cxx(coroutine HAS_COROUTINE) +if(HAS_ANY + AND HAS_STRING_VIEW + AND HAS_COROUTINE) + set(CMAKE_CXX_STANDARD 20) +elseif(HAS_ANY AND HAS_STRING_VIEW) + set(CMAKE_CXX_STANDARD 17) +else() + set(CMAKE_CXX_STANDARD 14) +endif() + +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +add_executable(${PROJECT_NAME} + server.cc + dylib.h + httplib.h +) + +set(THIRD_PARTY_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../build_deps/_install) +set(CORTEX_COMMON_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../base/) + +find_library(JSONCPP + NAMES jsoncpp + HINTS "${THIRD_PARTY_PATH}/lib" +) + +find_library(TRANTOR + NAMES trantor + HINTS "${THIRD_PARTY_PATH}/lib" +) + +target_link_libraries(${PROJECT_NAME} PRIVATE ${JSONCPP} ${TRANTOR} ${LINKER_FLAGS} + ${CMAKE_THREAD_LIBS_INIT}) + +target_include_directories(${PROJECT_NAME} PRIVATE + ${CORTEX_COMMON_PATH} + ${THIRD_PARTY_PATH}/include) \ No newline at end of file diff --git a/examples/server/dylib.h b/examples/server/dylib.h new file mode 100644 index 0000000..806e2ee --- /dev/null +++ b/examples/server/dylib.h @@ -0,0 +1,316 @@ +/** + * @file dylib.hpp + * @version 2.2.1 + * @brief C++ cross-platform wrapper around dynamic loading of shared libraries + * @link https://github.com/martin-olivier/dylib + * + * @author Martin Olivier + * @copyright (c) 2023 Martin Olivier + * + * This library is released under MIT license + */ + +#pragma once + +#include +#include +#include + +#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) +#define DYLIB_CPP17 +#include +#endif + +#if (defined(_WIN32) || defined(_WIN64)) +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#define DYLIB_UNDEFINE_LEAN_AND_MEAN +#endif +#ifndef NOMINMAX +#define NOMINMAX +#define DYLIB_UNDEFINE_NOMINMAX +#endif +#include +#ifdef DYLIB_UNDEFINE_LEAN_AND_MEAN +#undef WIN32_LEAN_AND_MEAN +#undef DYLIB_UNDEFINE_LEAN_AND_MEAN +#endif +#ifdef DYLIB_UNDEFINE_NOMINMAX +#undef NOMINMAX +#undef DYLIB_UNDEFINE_NOMINMAX +#endif +#else +#include +#endif + +#if (defined(_WIN32) || defined(_WIN64)) +#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) win_def +#define DYLIB_WIN_OTHER(win_def, other_def) win_def +#elif defined(__APPLE__) +#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) mac_def +#define DYLIB_WIN_OTHER(win_def, other_def) other_def +#else +#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) other_def +#define DYLIB_WIN_OTHER(win_def, other_def) other_def +#endif + +/** + * The `dylib` class represents a single dynamic library instance, + * allowing the access of symbols like functions or global variables + */ +class dylib { +public: + struct filename_components { + static constexpr const char *prefix = DYLIB_WIN_OTHER("", "lib"); + static constexpr const char *suffix = DYLIB_WIN_MAC_OTHER(".dll", ".dylib", ".so"); + }; + using native_handle_type = DYLIB_WIN_OTHER(HINSTANCE, void *); + using native_symbol_type = DYLIB_WIN_OTHER(FARPROC, void *); + + static_assert(std::is_pointer::value, "Expecting HINSTANCE to be a pointer"); + static_assert(std::is_pointer::value, "Expecting FARPROC to be a pointer"); + + static constexpr bool add_filename_decorations = true; + static constexpr bool no_filename_decorations = false; + + /** + * This exception is raised when a library fails to load or a symbol fails to resolve + */ + class exception : public std::runtime_error { + using std::runtime_error::runtime_error; + }; + + /** + * This exception is raised when a library fails to load + */ + class load_error : public exception { + using exception::exception; + }; + + /** + * This exception is raised when a symbol fails to resolve + */ + class symbol_error : public exception { + using exception::exception; + }; + + dylib(const dylib&) = delete; + dylib& operator=(const dylib&) = delete; + + dylib(dylib &&other) noexcept : m_handle(other.m_handle) { + other.m_handle = nullptr; + } + + dylib& operator=(dylib &&other) noexcept { + if (this != &other) + std::swap(m_handle, other.m_handle); + return *this; + } + + /** + * Loads a dynamic library + * + * @throws `dylib::load_error` if the library could not be opened (including + * the case of the library file not being found) + * @throws `std::invalid_argument` if the arguments are null + * + * @param dir_path the directory path where the dynamic library is located + * @param name the name of the dynamic library to load + * @param decorations adds OS-specific decorations to the library name + */ + ///@{ + dylib(const char *dir_path, const char *lib_name, bool decorations = add_filename_decorations) { + if (!dir_path) + throw std::invalid_argument("The directory path is null"); + if (!lib_name) + throw std::invalid_argument("The library name is null"); + + std::string final_name = lib_name; + std::string final_path = dir_path; + + if (decorations) + final_name = filename_components::prefix + final_name + filename_components::suffix; + + if (!final_path.empty() && final_path.find_last_of('/') != final_path.size() - 1) + final_path += '/'; + + m_handle = open((final_path + final_name).c_str()); + + if (!m_handle) + throw load_error("Could not load library \"" + final_path + final_name + "\"\n" + get_error_description()); + } + + dylib(const std::string &dir_path, const std::string &lib_name, bool decorations = add_filename_decorations) + : dylib(dir_path.c_str(), lib_name.c_str(), decorations) {} + + dylib(const std::string &dir_path, const char *lib_name, bool decorations = add_filename_decorations) + : dylib(dir_path.c_str(), lib_name, decorations) {} + + dylib(const char *dir_path, const std::string &lib_name, bool decorations = add_filename_decorations) + : dylib(dir_path, lib_name.c_str(), decorations) {} + + explicit dylib(const std::string &lib_name, bool decorations = add_filename_decorations) + : dylib("", lib_name.c_str(), decorations) {} + + explicit dylib(const char *lib_name, bool decorations = add_filename_decorations) + : dylib("", lib_name, decorations) {} + +#ifdef DYLIB_CPP17 + explicit dylib(const std::filesystem::path &lib_path) + : dylib("", lib_path.string().c_str(), no_filename_decorations) {} + + dylib(const std::filesystem::path &dir_path, const std::string &lib_name, bool decorations = add_filename_decorations) + : dylib(dir_path.string().c_str(), lib_name.c_str(), decorations) {} + + dylib(const std::filesystem::path &dir_path, const char *lib_name, bool decorations = add_filename_decorations) + : dylib(dir_path.string().c_str(), lib_name, decorations) {} +#endif + ///@} + + ~dylib() { + if (m_handle) + close(m_handle); + } + + /** + * Get a symbol from the currently loaded dynamic library + * + * @throws `dylib::symbol_error` if the symbol could not be found + * @throws `std::invalid_argument` if the argument or library handle is null + * + * @param symbol_name the symbol name to lookup + * + * @return a pointer to the requested symbol + */ + native_symbol_type get_symbol(const char *symbol_name) const { + if (!symbol_name) + throw std::invalid_argument("The symbol name to lookup is null"); + if (!m_handle) + throw std::logic_error("The dynamic library handle is null. This object may have been moved from."); + + auto symbol = locate_symbol(m_handle, symbol_name); + + if (symbol == nullptr) + throw symbol_error("Could not get symbol \"" + std::string(symbol_name) + "\"\n" + get_error_description()); + return symbol; + } + + native_symbol_type get_symbol(const std::string &symbol_name) const { + return get_symbol(symbol_name.c_str()); + } + + /** + * Get a function from the currently loaded dynamic library + * + * @throws `dylib::symbol_error` if the function could not be found + * @throws `std::invalid_argument` if the argument is null + * + * @tparam T the function type, e.g., `double(int, int)` + * @param symbol_name the function name to lookup + * + * @return a pointer to the requested function + */ + template + T *get_function(const char *symbol_name) const { +#if (defined(__GNUC__) && __GNUC__ >= 8) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + return reinterpret_cast(get_symbol(symbol_name)); +#if (defined(__GNUC__) && __GNUC__ >= 8) +#pragma GCC diagnostic pop +#endif + } + + template + T *get_function(const std::string &symbol_name) const { + return get_function(symbol_name.c_str()); + } + + /** + * Get a variable from the currently loaded dynamic library + * + * @throws `dylib::symbol_error` if the variable could not be found + * @throws `std::invalid_argument` if the argument is null + * + * @tparam T the variable type + * @param symbol_name the variable name to lookup + * + * @return a reference to the requested variable + */ + template + T &get_variable(const char *symbol_name) const { + return *reinterpret_cast(get_symbol(symbol_name)); + } + + template + T &get_variable(const std::string &symbol_name) const { + return get_variable(symbol_name.c_str()); + } + + /** + * Check if a symbol exists in the currently loaded dynamic library. + * This method will return false if no dynamic library is currently loaded + * or if the symbol name is nullptr + * + * @param symbol_name the symbol name to look for + * + * @return true if the symbol exists in the dynamic library, false otherwise + */ + bool has_symbol(const char *symbol_name) const noexcept { + if (!m_handle || !symbol_name) + return false; + return locate_symbol(m_handle, symbol_name) != nullptr; + } + + bool has_symbol(const std::string &symbol) const noexcept { + return has_symbol(symbol.c_str()); + } + + /** + * @return the dynamic library handle + */ + native_handle_type native_handle() noexcept { + return m_handle; + } + +protected: + native_handle_type m_handle{nullptr}; + + static native_handle_type open(const char *path) noexcept { +#if (defined(_WIN32) || defined(_WIN64)) + return LoadLibraryA(path); +#else + return dlopen(path, RTLD_NOW | RTLD_LOCAL); +#endif + } + + static native_symbol_type locate_symbol(native_handle_type lib, const char *name) noexcept { + return DYLIB_WIN_OTHER(GetProcAddress, dlsym)(lib, name); + } + + static void close(native_handle_type lib) noexcept { + DYLIB_WIN_OTHER(FreeLibrary, dlclose)(lib); + } + + static std::string get_error_description() noexcept { +#if (defined(_WIN32) || defined(_WIN64)) + constexpr const size_t BUF_SIZE = 512; + const auto error_code = GetLastError(); + if (!error_code) + return "No error reported by GetLastError"; + char description[BUF_SIZE]; + const auto lang = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US); + const DWORD length = + FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, error_code, lang, description, BUF_SIZE, nullptr); + return (length == 0) ? "Unknown error (FormatMessage failed)" : description; +#else + const auto description = dlerror(); + return (description == nullptr) ? "No error reported by dlerror" : description; +#endif + } +}; + +#undef DYLIB_WIN_MAC_OTHER +#undef DYLIB_WIN_OTHER +#undef DYLIB_CPP17 \ No newline at end of file diff --git a/examples/server/httplib.h b/examples/server/httplib.h new file mode 100644 index 0000000..e86b70e --- /dev/null +++ b/examples/server/httplib.h @@ -0,0 +1,9465 @@ +// +// httplib.h +// +// Copyright (c) 2024 Yuji Hirose. All rights reserved. +// MIT License +// + +#ifndef CPPHTTPLIB_HTTPLIB_H +#define CPPHTTPLIB_HTTPLIB_H + +#define CPPHTTPLIB_VERSION "0.15.3" + +/* + * Configuration + */ + +#ifndef CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND +#define CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND 5 +#endif + +#ifndef CPPHTTPLIB_KEEPALIVE_MAX_COUNT +#define CPPHTTPLIB_KEEPALIVE_MAX_COUNT 5 +#endif + +#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND +#define CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND 300 +#endif + +#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND +#define CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND 0 +#endif + +#ifndef CPPHTTPLIB_READ_TIMEOUT_SECOND +#define CPPHTTPLIB_READ_TIMEOUT_SECOND 5 +#endif + +#ifndef CPPHTTPLIB_READ_TIMEOUT_USECOND +#define CPPHTTPLIB_READ_TIMEOUT_USECOND 0 +#endif + +#ifndef CPPHTTPLIB_WRITE_TIMEOUT_SECOND +#define CPPHTTPLIB_WRITE_TIMEOUT_SECOND 5 +#endif + +#ifndef CPPHTTPLIB_WRITE_TIMEOUT_USECOND +#define CPPHTTPLIB_WRITE_TIMEOUT_USECOND 0 +#endif + +#ifndef CPPHTTPLIB_IDLE_INTERVAL_SECOND +#define CPPHTTPLIB_IDLE_INTERVAL_SECOND 0 +#endif + +#ifndef CPPHTTPLIB_IDLE_INTERVAL_USECOND +#ifdef _WIN32 +#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 10000 +#else +#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 0 +#endif +#endif + +#ifndef CPPHTTPLIB_REQUEST_URI_MAX_LENGTH +#define CPPHTTPLIB_REQUEST_URI_MAX_LENGTH 8192 +#endif + +#ifndef CPPHTTPLIB_HEADER_MAX_LENGTH +#define CPPHTTPLIB_HEADER_MAX_LENGTH 8192 +#endif + +#ifndef CPPHTTPLIB_REDIRECT_MAX_COUNT +#define CPPHTTPLIB_REDIRECT_MAX_COUNT 20 +#endif + +#ifndef CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT +#define CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT 1024 +#endif + +#ifndef CPPHTTPLIB_PAYLOAD_MAX_LENGTH +#define CPPHTTPLIB_PAYLOAD_MAX_LENGTH ((std::numeric_limits::max)()) +#endif + +#ifndef CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH +#define CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH 8192 +#endif + +#ifndef CPPHTTPLIB_RANGE_MAX_COUNT +#define CPPHTTPLIB_RANGE_MAX_COUNT 1024 +#endif + +#ifndef CPPHTTPLIB_TCP_NODELAY +#define CPPHTTPLIB_TCP_NODELAY false +#endif + +#ifndef CPPHTTPLIB_RECV_BUFSIZ +#define CPPHTTPLIB_RECV_BUFSIZ size_t(4096u) +#endif + +#ifndef CPPHTTPLIB_COMPRESSION_BUFSIZ +#define CPPHTTPLIB_COMPRESSION_BUFSIZ size_t(16384u) +#endif + +#ifndef CPPHTTPLIB_THREAD_POOL_COUNT +#define CPPHTTPLIB_THREAD_POOL_COUNT \ + ((std::max)(8u, std::thread::hardware_concurrency() > 0 \ + ? std::thread::hardware_concurrency() - 1 \ + : 0)) +#endif + +#ifndef CPPHTTPLIB_RECV_FLAGS +#define CPPHTTPLIB_RECV_FLAGS 0 +#endif + +#ifndef CPPHTTPLIB_SEND_FLAGS +#define CPPHTTPLIB_SEND_FLAGS 0 +#endif + +#ifndef CPPHTTPLIB_LISTEN_BACKLOG +#define CPPHTTPLIB_LISTEN_BACKLOG 5 +#endif + +/* + * Headers + */ + +#ifdef _WIN32 +#ifndef _CRT_SECURE_NO_WARNINGS +#define _CRT_SECURE_NO_WARNINGS +#endif //_CRT_SECURE_NO_WARNINGS + +#ifndef _CRT_NONSTDC_NO_DEPRECATE +#define _CRT_NONSTDC_NO_DEPRECATE +#endif //_CRT_NONSTDC_NO_DEPRECATE + +#if defined(_MSC_VER) +#if _MSC_VER < 1900 +#error Sorry, Visual Studio versions prior to 2015 are not supported +#endif + +#pragma comment(lib, "ws2_32.lib") + +#ifdef _WIN64 +using ssize_t = __int64; +#else +using ssize_t = long; +#endif +#endif // _MSC_VER + +#ifndef S_ISREG +#define S_ISREG(m) (((m)&S_IFREG) == S_IFREG) +#endif // S_ISREG + +#ifndef S_ISDIR +#define S_ISDIR(m) (((m)&S_IFDIR) == S_IFDIR) +#endif // S_ISDIR + +#ifndef NOMINMAX +#define NOMINMAX +#endif // NOMINMAX + +#include +#include +#include + +#ifndef WSA_FLAG_NO_HANDLE_INHERIT +#define WSA_FLAG_NO_HANDLE_INHERIT 0x80 +#endif + +using socket_t = SOCKET; +#ifdef CPPHTTPLIB_USE_POLL +#define poll(fds, nfds, timeout) WSAPoll(fds, nfds, timeout) +#endif + +#else // not _WIN32 + +#include +#if !defined(_AIX) && !defined(__MVS__) +#include +#endif +#ifdef __MVS__ +#include +#ifndef NI_MAXHOST +#define NI_MAXHOST 1025 +#endif +#endif +#include +#include +#include +#ifdef __linux__ +#include +#endif +#include +#ifdef CPPHTTPLIB_USE_POLL +#include +#endif +#include +#include +#include +#include +#include +#include +#include + +using socket_t = int; +#ifndef INVALID_SOCKET +#define INVALID_SOCKET (-1) +#endif +#endif //_WIN32 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +#ifdef _WIN32 +#include + +// these are defined in wincrypt.h and it breaks compilation if BoringSSL is +// used +#undef X509_NAME +#undef X509_CERT_PAIR +#undef X509_EXTENSIONS +#undef PKCS7_SIGNER_INFO + +#ifdef _MSC_VER +#pragma comment(lib, "crypt32.lib") +#endif +#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__) +#include +#if TARGET_OS_OSX +#include +#include +#endif // TARGET_OS_OSX +#endif // _WIN32 + +#include +#include +#include +#include + +#if defined(_WIN32) && defined(OPENSSL_USE_APPLINK) +#include +#endif + +#include +#include + +#if OPENSSL_VERSION_NUMBER < 0x30000000L +#error Sorry, OpenSSL versions prior to 3.0.0 are not supported +#endif + +#endif + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +#include +#endif + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +#include +#include +#endif + +/* + * Declaration + */ +namespace httplib { + +namespace detail { + +/* + * Backport std::make_unique from C++14. + * + * NOTE: This code came up with the following stackoverflow post: + * https://stackoverflow.com/questions/10149840/c-arrays-and-make-unique + * + */ + +template +typename std::enable_if::value, std::unique_ptr>::type +make_unique(Args &&...args) { + return std::unique_ptr(new T(std::forward(args)...)); +} + +template +typename std::enable_if::value, std::unique_ptr>::type +make_unique(std::size_t n) { + typedef typename std::remove_extent::type RT; + return std::unique_ptr(new RT[n]); +} + +struct ci { + bool operator()(const std::string &s1, const std::string &s2) const { + return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), + s2.end(), + [](unsigned char c1, unsigned char c2) { + return ::tolower(c1) < ::tolower(c2); + }); + } +}; + +// This is based on +// "http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4189". + +struct scope_exit { + explicit scope_exit(std::function &&f) + : exit_function(std::move(f)), execute_on_destruction{true} {} + + scope_exit(scope_exit &&rhs) noexcept + : exit_function(std::move(rhs.exit_function)), + execute_on_destruction{rhs.execute_on_destruction} { + rhs.release(); + } + + ~scope_exit() { + if (execute_on_destruction) { this->exit_function(); } + } + + void release() { this->execute_on_destruction = false; } + +private: + scope_exit(const scope_exit &) = delete; + void operator=(const scope_exit &) = delete; + scope_exit &operator=(scope_exit &&) = delete; + + std::function exit_function; + bool execute_on_destruction; +}; + +} // namespace detail + +enum StatusCode { + // Information responses + Continue_100 = 100, + SwitchingProtocol_101 = 101, + Processing_102 = 102, + EarlyHints_103 = 103, + + // Successful responses + OK_200 = 200, + Created_201 = 201, + Accepted_202 = 202, + NonAuthoritativeInformation_203 = 203, + NoContent_204 = 204, + ResetContent_205 = 205, + PartialContent_206 = 206, + MultiStatus_207 = 207, + AlreadyReported_208 = 208, + IMUsed_226 = 226, + + // Redirection messages + MultipleChoices_300 = 300, + MovedPermanently_301 = 301, + Found_302 = 302, + SeeOther_303 = 303, + NotModified_304 = 304, + UseProxy_305 = 305, + unused_306 = 306, + TemporaryRedirect_307 = 307, + PermanentRedirect_308 = 308, + + // Client error responses + BadRequest_400 = 400, + Unauthorized_401 = 401, + PaymentRequired_402 = 402, + Forbidden_403 = 403, + NotFound_404 = 404, + MethodNotAllowed_405 = 405, + NotAcceptable_406 = 406, + ProxyAuthenticationRequired_407 = 407, + RequestTimeout_408 = 408, + Conflict_409 = 409, + Gone_410 = 410, + LengthRequired_411 = 411, + PreconditionFailed_412 = 412, + PayloadTooLarge_413 = 413, + UriTooLong_414 = 414, + UnsupportedMediaType_415 = 415, + RangeNotSatisfiable_416 = 416, + ExpectationFailed_417 = 417, + ImATeapot_418 = 418, + MisdirectedRequest_421 = 421, + UnprocessableContent_422 = 422, + Locked_423 = 423, + FailedDependency_424 = 424, + TooEarly_425 = 425, + UpgradeRequired_426 = 426, + PreconditionRequired_428 = 428, + TooManyRequests_429 = 429, + RequestHeaderFieldsTooLarge_431 = 431, + UnavailableForLegalReasons_451 = 451, + + // Server error responses + InternalServerError_500 = 500, + NotImplemented_501 = 501, + BadGateway_502 = 502, + ServiceUnavailable_503 = 503, + GatewayTimeout_504 = 504, + HttpVersionNotSupported_505 = 505, + VariantAlsoNegotiates_506 = 506, + InsufficientStorage_507 = 507, + LoopDetected_508 = 508, + NotExtended_510 = 510, + NetworkAuthenticationRequired_511 = 511, +}; + +using Headers = std::multimap; + +using Params = std::multimap; +using Match = std::smatch; + +using Progress = std::function; + +struct Response; +using ResponseHandler = std::function; + +struct MultipartFormData { + std::string name; + std::string content; + std::string filename; + std::string content_type; +}; +using MultipartFormDataItems = std::vector; +using MultipartFormDataMap = std::multimap; + +class DataSink { +public: + DataSink() : os(&sb_), sb_(*this) {} + + DataSink(const DataSink &) = delete; + DataSink &operator=(const DataSink &) = delete; + DataSink(DataSink &&) = delete; + DataSink &operator=(DataSink &&) = delete; + + std::function write; + std::function is_writable; + std::function done; + std::function done_with_trailer; + std::ostream os; + +private: + class data_sink_streambuf final : public std::streambuf { + public: + explicit data_sink_streambuf(DataSink &sink) : sink_(sink) {} + + protected: + std::streamsize xsputn(const char *s, std::streamsize n) override { + sink_.write(s, static_cast(n)); + return n; + } + + private: + DataSink &sink_; + }; + + data_sink_streambuf sb_; +}; + +using ContentProvider = + std::function; + +using ContentProviderWithoutLength = + std::function; + +using ContentProviderResourceReleaser = std::function; + +struct MultipartFormDataProvider { + std::string name; + ContentProviderWithoutLength provider; + std::string filename; + std::string content_type; +}; +using MultipartFormDataProviderItems = std::vector; + +using ContentReceiverWithProgress = + std::function; + +using ContentReceiver = + std::function; + +using MultipartContentHeader = + std::function; + +class ContentReader { +public: + using Reader = std::function; + using MultipartReader = std::function; + + ContentReader(Reader reader, MultipartReader multipart_reader) + : reader_(std::move(reader)), + multipart_reader_(std::move(multipart_reader)) {} + + bool operator()(MultipartContentHeader header, + ContentReceiver receiver) const { + return multipart_reader_(std::move(header), std::move(receiver)); + } + + bool operator()(ContentReceiver receiver) const { + return reader_(std::move(receiver)); + } + + Reader reader_; + MultipartReader multipart_reader_; +}; + +using Range = std::pair; +using Ranges = std::vector; + +struct Request { + std::string method; + std::string path; + Headers headers; + std::string body; + + std::string remote_addr; + int remote_port = -1; + std::string local_addr; + int local_port = -1; + + // for server + std::string version; + std::string target; + Params params; + MultipartFormDataMap files; + Ranges ranges; + Match matches; + std::unordered_map path_params; + + // for client + ResponseHandler response_handler; + ContentReceiverWithProgress content_receiver; + Progress progress; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + const SSL *ssl = nullptr; +#endif + + bool has_header(const std::string &key) const; + std::string get_header_value(const std::string &key, size_t id = 0) const; + uint64_t get_header_value_u64(const std::string &key, size_t id = 0) const; + size_t get_header_value_count(const std::string &key) const; + void set_header(const std::string &key, const std::string &val); + + bool has_param(const std::string &key) const; + std::string get_param_value(const std::string &key, size_t id = 0) const; + size_t get_param_value_count(const std::string &key) const; + + bool is_multipart_form_data() const; + + bool has_file(const std::string &key) const; + MultipartFormData get_file_value(const std::string &key) const; + std::vector get_file_values(const std::string &key) const; + + // private members... + size_t redirect_count_ = CPPHTTPLIB_REDIRECT_MAX_COUNT; + size_t content_length_ = 0; + ContentProvider content_provider_; + bool is_chunked_content_provider_ = false; + size_t authorization_count_ = 0; +}; + +struct Response { + std::string version; + int status = -1; + std::string reason; + Headers headers; + std::string body; + std::string location; // Redirect location + + bool has_header(const std::string &key) const; + std::string get_header_value(const std::string &key, size_t id = 0) const; + uint64_t get_header_value_u64(const std::string &key, size_t id = 0) const; + size_t get_header_value_count(const std::string &key) const; + void set_header(const std::string &key, const std::string &val); + + void set_redirect(const std::string &url, int status = StatusCode::Found_302); + void set_content(const char *s, size_t n, const std::string &content_type); + void set_content(const std::string &s, const std::string &content_type); + void set_content(std::string &&s, const std::string &content_type); + + void set_content_provider( + size_t length, const std::string &content_type, ContentProvider provider, + ContentProviderResourceReleaser resource_releaser = nullptr); + + void set_content_provider( + const std::string &content_type, ContentProviderWithoutLength provider, + ContentProviderResourceReleaser resource_releaser = nullptr); + + void set_chunked_content_provider( + const std::string &content_type, ContentProviderWithoutLength provider, + ContentProviderResourceReleaser resource_releaser = nullptr); + + Response() = default; + Response(const Response &) = default; + Response &operator=(const Response &) = default; + Response(Response &&) = default; + Response &operator=(Response &&) = default; + ~Response() { + if (content_provider_resource_releaser_) { + content_provider_resource_releaser_(content_provider_success_); + } + } + + // private members... + size_t content_length_ = 0; + ContentProvider content_provider_; + ContentProviderResourceReleaser content_provider_resource_releaser_; + bool is_chunked_content_provider_ = false; + bool content_provider_success_ = false; +}; + +class Stream { +public: + virtual ~Stream() = default; + + virtual bool is_readable() const = 0; + virtual bool is_writable() const = 0; + + virtual ssize_t read(char *ptr, size_t size) = 0; + virtual ssize_t write(const char *ptr, size_t size) = 0; + virtual void get_remote_ip_and_port(std::string &ip, int &port) const = 0; + virtual void get_local_ip_and_port(std::string &ip, int &port) const = 0; + virtual socket_t socket() const = 0; + + template + ssize_t write_format(const char *fmt, const Args &...args); + ssize_t write(const char *ptr); + ssize_t write(const std::string &s); +}; + +class TaskQueue { +public: + TaskQueue() = default; + virtual ~TaskQueue() = default; + + virtual bool enqueue(std::function fn) = 0; + virtual void shutdown() = 0; + + virtual void on_idle() {} +}; + +class ThreadPool final : public TaskQueue { +public: + explicit ThreadPool(size_t n, size_t mqr = 0) + : shutdown_(false), max_queued_requests_(mqr) { + while (n) { + threads_.emplace_back(worker(*this)); + n--; + } + } + + ThreadPool(const ThreadPool &) = delete; + ~ThreadPool() override = default; + + bool enqueue(std::function fn) override { + { + std::unique_lock lock(mutex_); + if (max_queued_requests_ > 0 && jobs_.size() >= max_queued_requests_) { + return false; + } + jobs_.push_back(std::move(fn)); + } + + cond_.notify_one(); + return true; + } + + void shutdown() override { + // Stop all worker threads... + { + std::unique_lock lock(mutex_); + shutdown_ = true; + } + + cond_.notify_all(); + + // Join... + for (auto &t : threads_) { + t.join(); + } + } + +private: + struct worker { + explicit worker(ThreadPool &pool) : pool_(pool) {} + + void operator()() { + for (;;) { + std::function fn; + { + std::unique_lock lock(pool_.mutex_); + + pool_.cond_.wait( + lock, [&] { return !pool_.jobs_.empty() || pool_.shutdown_; }); + + if (pool_.shutdown_ && pool_.jobs_.empty()) { break; } + + fn = std::move(pool_.jobs_.front()); + pool_.jobs_.pop_front(); + } + + assert(true == static_cast(fn)); + fn(); + } + } + + ThreadPool &pool_; + }; + friend struct worker; + + std::vector threads_; + std::list> jobs_; + + bool shutdown_; + size_t max_queued_requests_ = 0; + + std::condition_variable cond_; + std::mutex mutex_; +}; + +using Logger = std::function; + +using SocketOptions = std::function; + +void default_socket_options(socket_t sock); + +const char *status_message(int status); + +std::string get_bearer_token_auth(const Request &req); + +namespace detail { + +class MatcherBase { +public: + virtual ~MatcherBase() = default; + + // Match request path and populate its matches and + virtual bool match(Request &request) const = 0; +}; + +/** + * Captures parameters in request path and stores them in Request::path_params + * + * Capture name is a substring of a pattern from : to /. + * The rest of the pattern is matched agains the request path directly + * Parameters are captured starting from the next character after + * the end of the last matched static pattern fragment until the next /. + * + * Example pattern: + * "/path/fragments/:capture/more/fragments/:second_capture" + * Static fragments: + * "/path/fragments/", "more/fragments/" + * + * Given the following request path: + * "/path/fragments/:1/more/fragments/:2" + * the resulting capture will be + * {{"capture", "1"}, {"second_capture", "2"}} + */ +class PathParamsMatcher final : public MatcherBase { +public: + PathParamsMatcher(const std::string &pattern); + + bool match(Request &request) const override; + +private: + static constexpr char marker = ':'; + // Treat segment separators as the end of path parameter capture + // Does not need to handle query parameters as they are parsed before path + // matching + static constexpr char separator = '/'; + + // Contains static path fragments to match against, excluding the '/' after + // path params + // Fragments are separated by path params + std::vector static_fragments_; + // Stores the names of the path parameters to be used as keys in the + // Request::path_params map + std::vector param_names_; +}; + +/** + * Performs std::regex_match on request path + * and stores the result in Request::matches + * + * Note that regex match is performed directly on the whole request. + * This means that wildcard patterns may match multiple path segments with /: + * "/begin/(.*)/end" will match both "/begin/middle/end" and "/begin/1/2/end". + */ +class RegexMatcher final : public MatcherBase { +public: + RegexMatcher(const std::string &pattern) : regex_(pattern) {} + + bool match(Request &request) const override; + +private: + std::regex regex_; +}; + +ssize_t write_headers(Stream &strm, const Headers &headers); + +} // namespace detail + +class Server { +public: + using Handler = std::function; + + using ExceptionHandler = + std::function; + + enum class HandlerResponse { + Handled, + Unhandled, + }; + using HandlerWithResponse = + std::function; + + using HandlerWithContentReader = std::function; + + using Expect100ContinueHandler = + std::function; + + Server(); + + virtual ~Server(); + + virtual bool is_valid() const; + + Server &Get(const std::string &pattern, Handler handler); + Server &Post(const std::string &pattern, Handler handler); + Server &Post(const std::string &pattern, HandlerWithContentReader handler); + Server &Put(const std::string &pattern, Handler handler); + Server &Put(const std::string &pattern, HandlerWithContentReader handler); + Server &Patch(const std::string &pattern, Handler handler); + Server &Patch(const std::string &pattern, HandlerWithContentReader handler); + Server &Delete(const std::string &pattern, Handler handler); + Server &Delete(const std::string &pattern, HandlerWithContentReader handler); + Server &Options(const std::string &pattern, Handler handler); + + bool set_base_dir(const std::string &dir, + const std::string &mount_point = std::string()); + bool set_mount_point(const std::string &mount_point, const std::string &dir, + Headers headers = Headers()); + bool remove_mount_point(const std::string &mount_point); + Server &set_file_extension_and_mimetype_mapping(const std::string &ext, + const std::string &mime); + Server &set_default_file_mimetype(const std::string &mime); + Server &set_file_request_handler(Handler handler); + + Server &set_error_handler(HandlerWithResponse handler); + Server &set_error_handler(Handler handler); + Server &set_exception_handler(ExceptionHandler handler); + Server &set_pre_routing_handler(HandlerWithResponse handler); + Server &set_post_routing_handler(Handler handler); + + Server &set_expect_100_continue_handler(Expect100ContinueHandler handler); + Server &set_logger(Logger logger); + + Server &set_address_family(int family); + Server &set_tcp_nodelay(bool on); + Server &set_socket_options(SocketOptions socket_options); + + Server &set_default_headers(Headers headers); + Server & + set_header_writer(std::function const &writer); + + Server &set_keep_alive_max_count(size_t count); + Server &set_keep_alive_timeout(time_t sec); + + Server &set_read_timeout(time_t sec, time_t usec = 0); + template + Server &set_read_timeout(const std::chrono::duration &duration); + + Server &set_write_timeout(time_t sec, time_t usec = 0); + template + Server &set_write_timeout(const std::chrono::duration &duration); + + Server &set_idle_interval(time_t sec, time_t usec = 0); + template + Server &set_idle_interval(const std::chrono::duration &duration); + + Server &set_payload_max_length(size_t length); + + bool bind_to_port(const std::string &host, int port, int socket_flags = 0); + int bind_to_any_port(const std::string &host, int socket_flags = 0); + bool listen_after_bind(); + + bool listen(const std::string &host, int port, int socket_flags = 0); + + bool is_running() const; + void wait_until_ready() const; + void stop(); + + std::function new_task_queue; + +protected: + bool process_request(Stream &strm, bool close_connection, + bool &connection_closed, + const std::function &setup_request); + + std::atomic svr_sock_{INVALID_SOCKET}; + size_t keep_alive_max_count_ = CPPHTTPLIB_KEEPALIVE_MAX_COUNT; + time_t keep_alive_timeout_sec_ = CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND; + time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND; + time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND; + time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND; + time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND; + time_t idle_interval_sec_ = CPPHTTPLIB_IDLE_INTERVAL_SECOND; + time_t idle_interval_usec_ = CPPHTTPLIB_IDLE_INTERVAL_USECOND; + size_t payload_max_length_ = CPPHTTPLIB_PAYLOAD_MAX_LENGTH; + +private: + using Handlers = + std::vector, Handler>>; + using HandlersForContentReader = + std::vector, + HandlerWithContentReader>>; + + static std::unique_ptr + make_matcher(const std::string &pattern); + + socket_t create_server_socket(const std::string &host, int port, + int socket_flags, + SocketOptions socket_options) const; + int bind_internal(const std::string &host, int port, int socket_flags); + bool listen_internal(); + + bool routing(Request &req, Response &res, Stream &strm); + bool handle_file_request(const Request &req, Response &res, + bool head = false); + bool dispatch_request(Request &req, Response &res, + const Handlers &handlers) const; + bool dispatch_request_for_content_reader( + Request &req, Response &res, ContentReader content_reader, + const HandlersForContentReader &handlers) const; + + bool parse_request_line(const char *s, Request &req) const; + void apply_ranges(const Request &req, Response &res, + std::string &content_type, std::string &boundary) const; + bool write_response(Stream &strm, bool close_connection, Request &req, + Response &res); + bool write_response_with_content(Stream &strm, bool close_connection, + const Request &req, Response &res); + bool write_response_core(Stream &strm, bool close_connection, + const Request &req, Response &res, + bool need_apply_ranges); + bool write_content_with_provider(Stream &strm, const Request &req, + Response &res, const std::string &boundary, + const std::string &content_type); + bool read_content(Stream &strm, Request &req, Response &res); + bool + read_content_with_content_receiver(Stream &strm, Request &req, Response &res, + ContentReceiver receiver, + MultipartContentHeader multipart_header, + ContentReceiver multipart_receiver); + bool read_content_core(Stream &strm, Request &req, Response &res, + ContentReceiver receiver, + MultipartContentHeader multipart_header, + ContentReceiver multipart_receiver) const; + + virtual bool process_and_close_socket(socket_t sock); + + std::atomic is_running_{false}; + std::atomic done_{false}; + + struct MountPointEntry { + std::string mount_point; + std::string base_dir; + Headers headers; + }; + std::vector base_dirs_; + std::map file_extension_and_mimetype_map_; + std::string default_file_mimetype_ = "application/octet-stream"; + Handler file_request_handler_; + + Handlers get_handlers_; + Handlers post_handlers_; + HandlersForContentReader post_handlers_for_content_reader_; + Handlers put_handlers_; + HandlersForContentReader put_handlers_for_content_reader_; + Handlers patch_handlers_; + HandlersForContentReader patch_handlers_for_content_reader_; + Handlers delete_handlers_; + HandlersForContentReader delete_handlers_for_content_reader_; + Handlers options_handlers_; + + HandlerWithResponse error_handler_; + ExceptionHandler exception_handler_; + HandlerWithResponse pre_routing_handler_; + Handler post_routing_handler_; + Expect100ContinueHandler expect_100_continue_handler_; + + Logger logger_; + + int address_family_ = AF_UNSPEC; + bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY; + SocketOptions socket_options_ = default_socket_options; + + Headers default_headers_; + std::function header_writer_ = + detail::write_headers; +}; + +enum class Error { + Success = 0, + Unknown, + Connection, + BindIPAddress, + Read, + Write, + ExceedRedirectCount, + Canceled, + SSLConnection, + SSLLoadingCerts, + SSLServerVerification, + UnsupportedMultipartBoundaryChars, + Compression, + ConnectionTimeout, + ProxyConnection, + + // For internal use only + SSLPeerCouldBeClosed_, +}; + +std::string to_string(Error error); + +std::ostream &operator<<(std::ostream &os, const Error &obj); + +class Result { +public: + Result() = default; + Result(std::unique_ptr &&res, Error err, + Headers &&request_headers = Headers{}) + : res_(std::move(res)), err_(err), + request_headers_(std::move(request_headers)) {} + // Response + operator bool() const { return res_ != nullptr; } + bool operator==(std::nullptr_t) const { return res_ == nullptr; } + bool operator!=(std::nullptr_t) const { return res_ != nullptr; } + const Response &value() const { return *res_; } + Response &value() { return *res_; } + const Response &operator*() const { return *res_; } + Response &operator*() { return *res_; } + const Response *operator->() const { return res_.get(); } + Response *operator->() { return res_.get(); } + + // Error + Error error() const { return err_; } + + // Request Headers + bool has_request_header(const std::string &key) const; + std::string get_request_header_value(const std::string &key, + size_t id = 0) const; + uint64_t get_request_header_value_u64(const std::string &key, + size_t id = 0) const; + size_t get_request_header_value_count(const std::string &key) const; + +private: + std::unique_ptr res_; + Error err_ = Error::Unknown; + Headers request_headers_; +}; + +class ClientImpl { +public: + explicit ClientImpl(const std::string &host); + + explicit ClientImpl(const std::string &host, int port); + + explicit ClientImpl(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path); + + virtual ~ClientImpl(); + + virtual bool is_valid() const; + + Result Get(const std::string &path); + Result Get(const std::string &path, const Headers &headers); + Result Get(const std::string &path, Progress progress); + Result Get(const std::string &path, const Headers &headers, + Progress progress); + Result Get(const std::string &path, ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver); + Result Get(const std::string &path, ContentReceiver content_receiver, + Progress progress); + Result Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver, Progress progress); + Result Get(const std::string &path, ResponseHandler response_handler, + ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver); + Result Get(const std::string &path, ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress); + Result Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, ContentReceiver content_receiver, + Progress progress); + + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, Progress progress = nullptr); + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, ContentReceiver content_receiver, + Progress progress = nullptr); + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress = nullptr); + + Result Head(const std::string &path); + Result Head(const std::string &path, const Headers &headers); + + Result Post(const std::string &path); + Result Post(const std::string &path, const Headers &headers); + Result Post(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, const char *body, + size_t content_length, const std::string &content_type); + Result Post(const std::string &path, const std::string &body, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Post(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type); + Result Post(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Params ¶ms); + Result Post(const std::string &path, const Headers &headers, + const Params ¶ms); + Result Post(const std::string &path, const MultipartFormDataItems &items); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, const std::string &boundary); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + Result Put(const std::string &path); + Result Put(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, const char *body, + size_t content_length, const std::string &content_type); + Result Put(const std::string &path, const std::string &body, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Put(const std::string &path, size_t content_length, + ContentProvider content_provider, const std::string &content_type); + Result Put(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Params ¶ms); + Result Put(const std::string &path, const Headers &headers, + const Params ¶ms); + Result Put(const std::string &path, const MultipartFormDataItems &items); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, const std::string &boundary); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + Result Patch(const std::string &path); + Result Patch(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type); + Result Patch(const std::string &path, const std::string &body, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Patch(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type); + Result Patch(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + + Result Delete(const std::string &path); + Result Delete(const std::string &path, const Headers &headers); + Result Delete(const std::string &path, const char *body, + size_t content_length, const std::string &content_type); + Result Delete(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type); + Result Delete(const std::string &path, const std::string &body, + const std::string &content_type); + Result Delete(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + + Result Options(const std::string &path); + Result Options(const std::string &path, const Headers &headers); + + bool send(Request &req, Response &res, Error &error); + Result send(const Request &req); + + void stop(); + + std::string host() const; + int port() const; + + size_t is_socket_open() const; + socket_t socket() const; + + void set_hostname_addr_map(std::map addr_map); + + void set_default_headers(Headers headers); + + void + set_header_writer(std::function const &writer); + + void set_address_family(int family); + void set_tcp_nodelay(bool on); + void set_socket_options(SocketOptions socket_options); + + void set_connection_timeout(time_t sec, time_t usec = 0); + template + void + set_connection_timeout(const std::chrono::duration &duration); + + void set_read_timeout(time_t sec, time_t usec = 0); + template + void set_read_timeout(const std::chrono::duration &duration); + + void set_write_timeout(time_t sec, time_t usec = 0); + template + void set_write_timeout(const std::chrono::duration &duration); + + void set_basic_auth(const std::string &username, const std::string &password); + void set_bearer_token_auth(const std::string &token); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_digest_auth(const std::string &username, + const std::string &password); +#endif + + void set_keep_alive(bool on); + void set_follow_location(bool on); + + void set_url_encode(bool on); + + void set_compress(bool on); + + void set_decompress(bool on); + + void set_interface(const std::string &intf); + + void set_proxy(const std::string &host, int port); + void set_proxy_basic_auth(const std::string &username, + const std::string &password); + void set_proxy_bearer_token_auth(const std::string &token); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_proxy_digest_auth(const std::string &username, + const std::string &password); +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_ca_cert_path(const std::string &ca_cert_file_path, + const std::string &ca_cert_dir_path = std::string()); + void set_ca_cert_store(X509_STORE *ca_cert_store); + X509_STORE *create_ca_cert_store(const char *ca_cert, std::size_t size) const; +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void enable_server_certificate_verification(bool enabled); +#endif + + void set_logger(Logger logger); + +protected: + struct Socket { + socket_t sock = INVALID_SOCKET; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSL *ssl = nullptr; +#endif + + bool is_open() const { return sock != INVALID_SOCKET; } + }; + + virtual bool create_and_connect_socket(Socket &socket, Error &error); + + // All of: + // shutdown_ssl + // shutdown_socket + // close_socket + // should ONLY be called when socket_mutex_ is locked. + // Also, shutdown_ssl and close_socket should also NOT be called concurrently + // with a DIFFERENT thread sending requests using that socket. + virtual void shutdown_ssl(Socket &socket, bool shutdown_gracefully); + void shutdown_socket(Socket &socket) const; + void close_socket(Socket &socket); + + bool process_request(Stream &strm, Request &req, Response &res, + bool close_connection, Error &error); + + bool write_content_with_provider(Stream &strm, const Request &req, + Error &error) const; + + void copy_settings(const ClientImpl &rhs); + + // Socket endpoint information + const std::string host_; + const int port_; + const std::string host_and_port_; + + // Current open socket + Socket socket_; + mutable std::mutex socket_mutex_; + std::recursive_mutex request_mutex_; + + // These are all protected under socket_mutex + size_t socket_requests_in_flight_ = 0; + std::thread::id socket_requests_are_from_thread_ = std::thread::id(); + bool socket_should_be_closed_when_request_is_done_ = false; + + // Hostname-IP map + std::map addr_map_; + + // Default headers + Headers default_headers_; + + // Header writer + std::function header_writer_ = + detail::write_headers; + + // Settings + std::string client_cert_path_; + std::string client_key_path_; + + time_t connection_timeout_sec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND; + time_t connection_timeout_usec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND; + time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND; + time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND; + time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND; + time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND; + + std::string basic_auth_username_; + std::string basic_auth_password_; + std::string bearer_token_auth_token_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + std::string digest_auth_username_; + std::string digest_auth_password_; +#endif + + bool keep_alive_ = false; + bool follow_location_ = false; + + bool url_encode_ = true; + + int address_family_ = AF_UNSPEC; + bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY; + SocketOptions socket_options_ = nullptr; + + bool compress_ = false; + bool decompress_ = true; + + std::string interface_; + + std::string proxy_host_; + int proxy_port_ = -1; + + std::string proxy_basic_auth_username_; + std::string proxy_basic_auth_password_; + std::string proxy_bearer_token_auth_token_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + std::string proxy_digest_auth_username_; + std::string proxy_digest_auth_password_; +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + std::string ca_cert_file_path_; + std::string ca_cert_dir_path_; + + X509_STORE *ca_cert_store_ = nullptr; +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + bool server_certificate_verification_ = true; +#endif + + Logger logger_; + +private: + bool send_(Request &req, Response &res, Error &error); + Result send_(Request &&req); + + socket_t create_client_socket(Error &error) const; + bool read_response_line(Stream &strm, const Request &req, + Response &res) const; + bool write_request(Stream &strm, Request &req, bool close_connection, + Error &error); + bool redirect(Request &req, Response &res, Error &error); + bool handle_request(Stream &strm, Request &req, Response &res, + bool close_connection, Error &error); + std::unique_ptr send_with_content_provider( + Request &req, const char *body, size_t content_length, + ContentProvider content_provider, + ContentProviderWithoutLength content_provider_without_length, + const std::string &content_type, Error &error); + Result send_with_content_provider( + const std::string &method, const std::string &path, + const Headers &headers, const char *body, size_t content_length, + ContentProvider content_provider, + ContentProviderWithoutLength content_provider_without_length, + const std::string &content_type); + ContentProviderWithoutLength get_multipart_content_provider( + const std::string &boundary, const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) const; + + std::string adjust_host_string(const std::string &host) const; + + virtual bool process_socket(const Socket &socket, + std::function callback); + virtual bool is_ssl() const; +}; + +class Client { +public: + // Universal interface + explicit Client(const std::string &scheme_host_port); + + explicit Client(const std::string &scheme_host_port, + const std::string &client_cert_path, + const std::string &client_key_path); + + // HTTP only interface + explicit Client(const std::string &host, int port); + + explicit Client(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path); + + Client(Client &&) = default; + + ~Client(); + + bool is_valid() const; + + Result Get(const std::string &path); + Result Get(const std::string &path, const Headers &headers); + Result Get(const std::string &path, Progress progress); + Result Get(const std::string &path, const Headers &headers, + Progress progress); + Result Get(const std::string &path, ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver); + Result Get(const std::string &path, ContentReceiver content_receiver, + Progress progress); + Result Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver, Progress progress); + Result Get(const std::string &path, ResponseHandler response_handler, + ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver); + Result Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, ContentReceiver content_receiver, + Progress progress); + Result Get(const std::string &path, ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress); + + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, Progress progress = nullptr); + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, ContentReceiver content_receiver, + Progress progress = nullptr); + Result Get(const std::string &path, const Params ¶ms, + const Headers &headers, ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress = nullptr); + + Result Head(const std::string &path); + Result Head(const std::string &path, const Headers &headers); + + Result Post(const std::string &path); + Result Post(const std::string &path, const Headers &headers); + Result Post(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, const char *body, + size_t content_length, const std::string &content_type); + Result Post(const std::string &path, const std::string &body, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Post(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type); + Result Post(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Post(const std::string &path, const Params ¶ms); + Result Post(const std::string &path, const Headers &headers, + const Params ¶ms); + Result Post(const std::string &path, const MultipartFormDataItems &items); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, const std::string &boundary); + Result Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + Result Put(const std::string &path); + Result Put(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, const char *body, + size_t content_length, const std::string &content_type); + Result Put(const std::string &path, const std::string &body, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Put(const std::string &path, size_t content_length, + ContentProvider content_provider, const std::string &content_type); + Result Put(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Put(const std::string &path, const Params ¶ms); + Result Put(const std::string &path, const Headers &headers, + const Params ¶ms); + Result Put(const std::string &path, const MultipartFormDataItems &items); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, const std::string &boundary); + Result Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items); + + Result Patch(const std::string &path); + Result Patch(const std::string &path, const char *body, size_t content_length, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type); + Result Patch(const std::string &path, const std::string &body, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + Result Patch(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type); + Result Patch(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + size_t content_length, ContentProvider content_provider, + const std::string &content_type); + Result Patch(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type); + + Result Delete(const std::string &path); + Result Delete(const std::string &path, const Headers &headers); + Result Delete(const std::string &path, const char *body, + size_t content_length, const std::string &content_type); + Result Delete(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type); + Result Delete(const std::string &path, const std::string &body, + const std::string &content_type); + Result Delete(const std::string &path, const Headers &headers, + const std::string &body, const std::string &content_type); + + Result Options(const std::string &path); + Result Options(const std::string &path, const Headers &headers); + + bool send(Request &req, Response &res, Error &error); + Result send(const Request &req); + + void stop(); + + std::string host() const; + int port() const; + + size_t is_socket_open() const; + socket_t socket() const; + + void set_hostname_addr_map(std::map addr_map); + + void set_default_headers(Headers headers); + + void + set_header_writer(std::function const &writer); + + void set_address_family(int family); + void set_tcp_nodelay(bool on); + void set_socket_options(SocketOptions socket_options); + + void set_connection_timeout(time_t sec, time_t usec = 0); + template + void + set_connection_timeout(const std::chrono::duration &duration); + + void set_read_timeout(time_t sec, time_t usec = 0); + template + void set_read_timeout(const std::chrono::duration &duration); + + void set_write_timeout(time_t sec, time_t usec = 0); + template + void set_write_timeout(const std::chrono::duration &duration); + + void set_basic_auth(const std::string &username, const std::string &password); + void set_bearer_token_auth(const std::string &token); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_digest_auth(const std::string &username, + const std::string &password); +#endif + + void set_keep_alive(bool on); + void set_follow_location(bool on); + + void set_url_encode(bool on); + + void set_compress(bool on); + + void set_decompress(bool on); + + void set_interface(const std::string &intf); + + void set_proxy(const std::string &host, int port); + void set_proxy_basic_auth(const std::string &username, + const std::string &password); + void set_proxy_bearer_token_auth(const std::string &token); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_proxy_digest_auth(const std::string &username, + const std::string &password); +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void enable_server_certificate_verification(bool enabled); +#endif + + void set_logger(Logger logger); + + // SSL +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_ca_cert_path(const std::string &ca_cert_file_path, + const std::string &ca_cert_dir_path = std::string()); + + void set_ca_cert_store(X509_STORE *ca_cert_store); + void load_ca_cert_store(const char *ca_cert, std::size_t size); + + long get_openssl_verify_result() const; + + SSL_CTX *ssl_context() const; +#endif + +private: + std::unique_ptr cli_; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + bool is_ssl_ = false; +#endif +}; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +class SSLServer : public Server { +public: + SSLServer(const char *cert_path, const char *private_key_path, + const char *client_ca_cert_file_path = nullptr, + const char *client_ca_cert_dir_path = nullptr, + const char *private_key_password = nullptr); + + SSLServer(X509 *cert, EVP_PKEY *private_key, + X509_STORE *client_ca_cert_store = nullptr); + + SSLServer( + const std::function &setup_ssl_ctx_callback); + + ~SSLServer() override; + + bool is_valid() const override; + + SSL_CTX *ssl_context() const; + +private: + bool process_and_close_socket(socket_t sock) override; + + SSL_CTX *ctx_; + std::mutex ctx_mutex_; +}; + +class SSLClient final : public ClientImpl { +public: + explicit SSLClient(const std::string &host); + + explicit SSLClient(const std::string &host, int port); + + explicit SSLClient(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path, + const std::string &private_key_password = std::string()); + + explicit SSLClient(const std::string &host, int port, X509 *client_cert, + EVP_PKEY *client_key, + const std::string &private_key_password = std::string()); + + ~SSLClient() override; + + bool is_valid() const override; + + void set_ca_cert_store(X509_STORE *ca_cert_store); + void load_ca_cert_store(const char *ca_cert, std::size_t size); + + long get_openssl_verify_result() const; + + SSL_CTX *ssl_context() const; + +private: + bool create_and_connect_socket(Socket &socket, Error &error) override; + void shutdown_ssl(Socket &socket, bool shutdown_gracefully) override; + void shutdown_ssl_impl(Socket &socket, bool shutdown_gracefully); + + bool process_socket(const Socket &socket, + std::function callback) override; + bool is_ssl() const override; + + bool connect_with_proxy(Socket &sock, Response &res, bool &success, + Error &error); + bool initialize_ssl(Socket &socket, Error &error); + + bool load_certs(); + + bool verify_host(X509 *server_cert) const; + bool verify_host_with_subject_alt_name(X509 *server_cert) const; + bool verify_host_with_common_name(X509 *server_cert) const; + bool check_host_name(const char *pattern, size_t pattern_len) const; + + SSL_CTX *ctx_; + std::mutex ctx_mutex_; + std::once_flag initialize_cert_; + + std::vector host_components_; + + long verify_result_ = 0; + + friend class ClientImpl; +}; +#endif + +/* + * Implementation of template methods. + */ + +namespace detail { + +template +inline void duration_to_sec_and_usec(const T &duration, U callback) { + auto sec = std::chrono::duration_cast(duration).count(); + auto usec = std::chrono::duration_cast( + duration - std::chrono::seconds(sec)) + .count(); + callback(static_cast(sec), static_cast(usec)); +} + +inline uint64_t get_header_value_u64(const Headers &headers, + const std::string &key, size_t id, + uint64_t def) { + auto rng = headers.equal_range(key); + auto it = rng.first; + std::advance(it, static_cast(id)); + if (it != rng.second) { + return std::strtoull(it->second.data(), nullptr, 10); + } + return def; +} + +} // namespace detail + +inline uint64_t Request::get_header_value_u64(const std::string &key, + size_t id) const { + return detail::get_header_value_u64(headers, key, id, 0); +} + +inline uint64_t Response::get_header_value_u64(const std::string &key, + size_t id) const { + return detail::get_header_value_u64(headers, key, id, 0); +} + +template +inline ssize_t Stream::write_format(const char *fmt, const Args &...args) { + const auto bufsiz = 2048; + std::array buf{}; + + auto sn = snprintf(buf.data(), buf.size() - 1, fmt, args...); + if (sn <= 0) { return sn; } + + auto n = static_cast(sn); + + if (n >= buf.size() - 1) { + std::vector glowable_buf(buf.size()); + + while (n >= glowable_buf.size() - 1) { + glowable_buf.resize(glowable_buf.size() * 2); + n = static_cast( + snprintf(&glowable_buf[0], glowable_buf.size() - 1, fmt, args...)); + } + return write(&glowable_buf[0], n); + } else { + return write(buf.data(), n); + } +} + +inline void default_socket_options(socket_t sock) { + int yes = 1; +#ifdef _WIN32 + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + reinterpret_cast(&yes), sizeof(yes)); + setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, + reinterpret_cast(&yes), sizeof(yes)); +#else +#ifdef SO_REUSEPORT + setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, + reinterpret_cast(&yes), sizeof(yes)); +#else + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + reinterpret_cast(&yes), sizeof(yes)); +#endif +#endif +} + +inline const char *status_message(int status) { + switch (status) { + case StatusCode::Continue_100: return "Continue"; + case StatusCode::SwitchingProtocol_101: return "Switching Protocol"; + case StatusCode::Processing_102: return "Processing"; + case StatusCode::EarlyHints_103: return "Early Hints"; + case StatusCode::OK_200: return "OK"; + case StatusCode::Created_201: return "Created"; + case StatusCode::Accepted_202: return "Accepted"; + case StatusCode::NonAuthoritativeInformation_203: + return "Non-Authoritative Information"; + case StatusCode::NoContent_204: return "No Content"; + case StatusCode::ResetContent_205: return "Reset Content"; + case StatusCode::PartialContent_206: return "Partial Content"; + case StatusCode::MultiStatus_207: return "Multi-Status"; + case StatusCode::AlreadyReported_208: return "Already Reported"; + case StatusCode::IMUsed_226: return "IM Used"; + case StatusCode::MultipleChoices_300: return "Multiple Choices"; + case StatusCode::MovedPermanently_301: return "Moved Permanently"; + case StatusCode::Found_302: return "Found"; + case StatusCode::SeeOther_303: return "See Other"; + case StatusCode::NotModified_304: return "Not Modified"; + case StatusCode::UseProxy_305: return "Use Proxy"; + case StatusCode::unused_306: return "unused"; + case StatusCode::TemporaryRedirect_307: return "Temporary Redirect"; + case StatusCode::PermanentRedirect_308: return "Permanent Redirect"; + case StatusCode::BadRequest_400: return "Bad Request"; + case StatusCode::Unauthorized_401: return "Unauthorized"; + case StatusCode::PaymentRequired_402: return "Payment Required"; + case StatusCode::Forbidden_403: return "Forbidden"; + case StatusCode::NotFound_404: return "Not Found"; + case StatusCode::MethodNotAllowed_405: return "Method Not Allowed"; + case StatusCode::NotAcceptable_406: return "Not Acceptable"; + case StatusCode::ProxyAuthenticationRequired_407: + return "Proxy Authentication Required"; + case StatusCode::RequestTimeout_408: return "Request Timeout"; + case StatusCode::Conflict_409: return "Conflict"; + case StatusCode::Gone_410: return "Gone"; + case StatusCode::LengthRequired_411: return "Length Required"; + case StatusCode::PreconditionFailed_412: return "Precondition Failed"; + case StatusCode::PayloadTooLarge_413: return "Payload Too Large"; + case StatusCode::UriTooLong_414: return "URI Too Long"; + case StatusCode::UnsupportedMediaType_415: return "Unsupported Media Type"; + case StatusCode::RangeNotSatisfiable_416: return "Range Not Satisfiable"; + case StatusCode::ExpectationFailed_417: return "Expectation Failed"; + case StatusCode::ImATeapot_418: return "I'm a teapot"; + case StatusCode::MisdirectedRequest_421: return "Misdirected Request"; + case StatusCode::UnprocessableContent_422: return "Unprocessable Content"; + case StatusCode::Locked_423: return "Locked"; + case StatusCode::FailedDependency_424: return "Failed Dependency"; + case StatusCode::TooEarly_425: return "Too Early"; + case StatusCode::UpgradeRequired_426: return "Upgrade Required"; + case StatusCode::PreconditionRequired_428: return "Precondition Required"; + case StatusCode::TooManyRequests_429: return "Too Many Requests"; + case StatusCode::RequestHeaderFieldsTooLarge_431: + return "Request Header Fields Too Large"; + case StatusCode::UnavailableForLegalReasons_451: + return "Unavailable For Legal Reasons"; + case StatusCode::NotImplemented_501: return "Not Implemented"; + case StatusCode::BadGateway_502: return "Bad Gateway"; + case StatusCode::ServiceUnavailable_503: return "Service Unavailable"; + case StatusCode::GatewayTimeout_504: return "Gateway Timeout"; + case StatusCode::HttpVersionNotSupported_505: + return "HTTP Version Not Supported"; + case StatusCode::VariantAlsoNegotiates_506: return "Variant Also Negotiates"; + case StatusCode::InsufficientStorage_507: return "Insufficient Storage"; + case StatusCode::LoopDetected_508: return "Loop Detected"; + case StatusCode::NotExtended_510: return "Not Extended"; + case StatusCode::NetworkAuthenticationRequired_511: + return "Network Authentication Required"; + + default: + case StatusCode::InternalServerError_500: return "Internal Server Error"; + } +} + +inline std::string get_bearer_token_auth(const Request &req) { + if (req.has_header("Authorization")) { + static std::string BearerHeaderPrefix = "Bearer "; + return req.get_header_value("Authorization") + .substr(BearerHeaderPrefix.length()); + } + return ""; +} + +template +inline Server & +Server::set_read_timeout(const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); }); + return *this; +} + +template +inline Server & +Server::set_write_timeout(const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); }); + return *this; +} + +template +inline Server & +Server::set_idle_interval(const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_idle_interval(sec, usec); }); + return *this; +} + +inline std::string to_string(const Error error) { + switch (error) { + case Error::Success: return "Success (no error)"; + case Error::Connection: return "Could not establish connection"; + case Error::BindIPAddress: return "Failed to bind IP address"; + case Error::Read: return "Failed to read connection"; + case Error::Write: return "Failed to write connection"; + case Error::ExceedRedirectCount: return "Maximum redirect count exceeded"; + case Error::Canceled: return "Connection handling canceled"; + case Error::SSLConnection: return "SSL connection failed"; + case Error::SSLLoadingCerts: return "SSL certificate loading failed"; + case Error::SSLServerVerification: return "SSL server verification failed"; + case Error::UnsupportedMultipartBoundaryChars: + return "Unsupported HTTP multipart boundary characters"; + case Error::Compression: return "Compression failed"; + case Error::ConnectionTimeout: return "Connection timed out"; + case Error::ProxyConnection: return "Proxy connection failed"; + case Error::Unknown: return "Unknown"; + default: break; + } + + return "Invalid"; +} + +inline std::ostream &operator<<(std::ostream &os, const Error &obj) { + os << to_string(obj); + os << " (" << static_cast::type>(obj) << ')'; + return os; +} + +inline uint64_t Result::get_request_header_value_u64(const std::string &key, + size_t id) const { + return detail::get_header_value_u64(request_headers_, key, id, 0); +} + +template +inline void ClientImpl::set_connection_timeout( + const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec(duration, [&](time_t sec, time_t usec) { + set_connection_timeout(sec, usec); + }); +} + +template +inline void ClientImpl::set_read_timeout( + const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); }); +} + +template +inline void ClientImpl::set_write_timeout( + const std::chrono::duration &duration) { + detail::duration_to_sec_and_usec( + duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); }); +} + +template +inline void Client::set_connection_timeout( + const std::chrono::duration &duration) { + cli_->set_connection_timeout(duration); +} + +template +inline void +Client::set_read_timeout(const std::chrono::duration &duration) { + cli_->set_read_timeout(duration); +} + +template +inline void +Client::set_write_timeout(const std::chrono::duration &duration) { + cli_->set_write_timeout(duration); +} + +/* + * Forward declarations and types that will be part of the .h file if split into + * .h + .cc. + */ + +std::string hosted_at(const std::string &hostname); + +void hosted_at(const std::string &hostname, std::vector &addrs); + +std::string append_query_params(const std::string &path, const Params ¶ms); + +std::pair make_range_header(const Ranges &ranges); + +std::pair +make_basic_authentication_header(const std::string &username, + const std::string &password, + bool is_proxy = false); + +namespace detail { + +std::string encode_query_param(const std::string &value); + +std::string decode_url(const std::string &s, bool convert_plus_to_space); + +void read_file(const std::string &path, std::string &out); + +std::string trim_copy(const std::string &s); + +void split(const char *b, const char *e, char d, + std::function fn); + +void split(const char *b, const char *e, char d, size_t m, + std::function fn); + +bool process_client_socket(socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, + std::function callback); + +socket_t create_client_socket( + const std::string &host, const std::string &ip, int port, + int address_family, bool tcp_nodelay, SocketOptions socket_options, + time_t connection_timeout_sec, time_t connection_timeout_usec, + time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, const std::string &intf, Error &error); + +const char *get_header_value(const Headers &headers, const std::string &key, + size_t id = 0, const char *def = nullptr); + +std::string params_to_query_str(const Params ¶ms); + +void parse_query_text(const std::string &s, Params ¶ms); + +bool parse_multipart_boundary(const std::string &content_type, + std::string &boundary); + +bool parse_range_header(const std::string &s, Ranges &ranges); + +int close_socket(socket_t sock); + +ssize_t send_socket(socket_t sock, const void *ptr, size_t size, int flags); + +ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags); + +enum class EncodingType { None = 0, Gzip, Brotli }; + +EncodingType encoding_type(const Request &req, const Response &res); + +class BufferStream final : public Stream { +public: + BufferStream() = default; + ~BufferStream() override = default; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + void get_local_ip_and_port(std::string &ip, int &port) const override; + socket_t socket() const override; + + const std::string &get_buffer() const; + +private: + std::string buffer; + size_t position = 0; +}; + +class compressor { +public: + virtual ~compressor() = default; + + typedef std::function Callback; + virtual bool compress(const char *data, size_t data_length, bool last, + Callback callback) = 0; +}; + +class decompressor { +public: + virtual ~decompressor() = default; + + virtual bool is_valid() const = 0; + + typedef std::function Callback; + virtual bool decompress(const char *data, size_t data_length, + Callback callback) = 0; +}; + +class nocompressor final : public compressor { +public: + ~nocompressor() override = default; + + bool compress(const char *data, size_t data_length, bool /*last*/, + Callback callback) override; +}; + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +class gzip_compressor final : public compressor { +public: + gzip_compressor(); + ~gzip_compressor() override; + + bool compress(const char *data, size_t data_length, bool last, + Callback callback) override; + +private: + bool is_valid_ = false; + z_stream strm_; +}; + +class gzip_decompressor final : public decompressor { +public: + gzip_decompressor(); + ~gzip_decompressor() override; + + bool is_valid() const override; + + bool decompress(const char *data, size_t data_length, + Callback callback) override; + +private: + bool is_valid_ = false; + z_stream strm_; +}; +#endif + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +class brotli_compressor final : public compressor { +public: + brotli_compressor(); + ~brotli_compressor(); + + bool compress(const char *data, size_t data_length, bool last, + Callback callback) override; + +private: + BrotliEncoderState *state_ = nullptr; +}; + +class brotli_decompressor final : public decompressor { +public: + brotli_decompressor(); + ~brotli_decompressor(); + + bool is_valid() const override; + + bool decompress(const char *data, size_t data_length, + Callback callback) override; + +private: + BrotliDecoderResult decoder_r; + BrotliDecoderState *decoder_s = nullptr; +}; +#endif + +// NOTE: until the read size reaches `fixed_buffer_size`, use `fixed_buffer` +// to store data. The call can set memory on stack for performance. +class stream_line_reader { +public: + stream_line_reader(Stream &strm, char *fixed_buffer, + size_t fixed_buffer_size); + const char *ptr() const; + size_t size() const; + bool end_with_crlf() const; + bool getline(); + +private: + void append(char c); + + Stream &strm_; + char *fixed_buffer_; + const size_t fixed_buffer_size_; + size_t fixed_buffer_used_size_ = 0; + std::string glowable_buffer_; +}; + +class mmap { +public: + mmap(const char *path); + ~mmap(); + + bool open(const char *path); + void close(); + + bool is_open() const; + size_t size() const; + const char *data() const; + +private: +#if defined(_WIN32) + HANDLE hFile_; + HANDLE hMapping_; +#else + int fd_; +#endif + size_t size_; + void *addr_; +}; + +} // namespace detail + +// ---------------------------------------------------------------------------- + +/* + * Implementation that will be part of the .cc file if split into .h + .cc. + */ + +namespace detail { + +inline bool is_hex(char c, int &v) { + if (0x20 <= c && isdigit(c)) { + v = c - '0'; + return true; + } else if ('A' <= c && c <= 'F') { + v = c - 'A' + 10; + return true; + } else if ('a' <= c && c <= 'f') { + v = c - 'a' + 10; + return true; + } + return false; +} + +inline bool from_hex_to_i(const std::string &s, size_t i, size_t cnt, + int &val) { + if (i >= s.size()) { return false; } + + val = 0; + for (; cnt; i++, cnt--) { + if (!s[i]) { return false; } + auto v = 0; + if (is_hex(s[i], v)) { + val = val * 16 + v; + } else { + return false; + } + } + return true; +} + +inline std::string from_i_to_hex(size_t n) { + static const auto charset = "0123456789abcdef"; + std::string ret; + do { + ret = charset[n & 15] + ret; + n >>= 4; + } while (n > 0); + return ret; +} + +inline size_t to_utf8(int code, char *buff) { + if (code < 0x0080) { + buff[0] = static_cast(code & 0x7F); + return 1; + } else if (code < 0x0800) { + buff[0] = static_cast(0xC0 | ((code >> 6) & 0x1F)); + buff[1] = static_cast(0x80 | (code & 0x3F)); + return 2; + } else if (code < 0xD800) { + buff[0] = static_cast(0xE0 | ((code >> 12) & 0xF)); + buff[1] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[2] = static_cast(0x80 | (code & 0x3F)); + return 3; + } else if (code < 0xE000) { // D800 - DFFF is invalid... + return 0; + } else if (code < 0x10000) { + buff[0] = static_cast(0xE0 | ((code >> 12) & 0xF)); + buff[1] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[2] = static_cast(0x80 | (code & 0x3F)); + return 3; + } else if (code < 0x110000) { + buff[0] = static_cast(0xF0 | ((code >> 18) & 0x7)); + buff[1] = static_cast(0x80 | ((code >> 12) & 0x3F)); + buff[2] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[3] = static_cast(0x80 | (code & 0x3F)); + return 4; + } + + // NOTREACHED + return 0; +} + +// NOTE: This code came up with the following stackoverflow post: +// https://stackoverflow.com/questions/180947/base64-decode-snippet-in-c +inline std::string base64_encode(const std::string &in) { + static const auto lookup = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + std::string out; + out.reserve(in.size()); + + auto val = 0; + auto valb = -6; + + for (auto c : in) { + val = (val << 8) + static_cast(c); + valb += 8; + while (valb >= 0) { + out.push_back(lookup[(val >> valb) & 0x3F]); + valb -= 6; + } + } + + if (valb > -6) { out.push_back(lookup[((val << 8) >> (valb + 8)) & 0x3F]); } + + while (out.size() % 4) { + out.push_back('='); + } + + return out; +} + +inline bool is_file(const std::string &path) { +#ifdef _WIN32 + return _access_s(path.c_str(), 0) == 0; +#else + struct stat st; + return stat(path.c_str(), &st) >= 0 && S_ISREG(st.st_mode); +#endif +} + +inline bool is_dir(const std::string &path) { + struct stat st; + return stat(path.c_str(), &st) >= 0 && S_ISDIR(st.st_mode); +} + +inline bool is_valid_path(const std::string &path) { + size_t level = 0; + size_t i = 0; + + // Skip slash + while (i < path.size() && path[i] == '/') { + i++; + } + + while (i < path.size()) { + // Read component + auto beg = i; + while (i < path.size() && path[i] != '/') { + if (path[i] == '\0') { + return false; + } else if (path[i] == '\\') { + return false; + } + i++; + } + + auto len = i - beg; + assert(len > 0); + + if (!path.compare(beg, len, ".")) { + ; + } else if (!path.compare(beg, len, "..")) { + if (level == 0) { return false; } + level--; + } else { + level++; + } + + // Skip slash + while (i < path.size() && path[i] == '/') { + i++; + } + } + + return true; +} + +inline std::string encode_query_param(const std::string &value) { + std::ostringstream escaped; + escaped.fill('0'); + escaped << std::hex; + + for (auto c : value) { + if (std::isalnum(static_cast(c)) || c == '-' || c == '_' || + c == '.' || c == '!' || c == '~' || c == '*' || c == '\'' || c == '(' || + c == ')') { + escaped << c; + } else { + escaped << std::uppercase; + escaped << '%' << std::setw(2) + << static_cast(static_cast(c)); + escaped << std::nouppercase; + } + } + + return escaped.str(); +} + +inline std::string encode_url(const std::string &s) { + std::string result; + result.reserve(s.size()); + + for (size_t i = 0; s[i]; i++) { + switch (s[i]) { + case ' ': result += "%20"; break; + case '+': result += "%2B"; break; + case '\r': result += "%0D"; break; + case '\n': result += "%0A"; break; + case '\'': result += "%27"; break; + case ',': result += "%2C"; break; + // case ':': result += "%3A"; break; // ok? probably... + case ';': result += "%3B"; break; + default: + auto c = static_cast(s[i]); + if (c >= 0x80) { + result += '%'; + char hex[4]; + auto len = snprintf(hex, sizeof(hex) - 1, "%02X", c); + assert(len == 2); + result.append(hex, static_cast(len)); + } else { + result += s[i]; + } + break; + } + } + + return result; +} + +inline std::string decode_url(const std::string &s, + bool convert_plus_to_space) { + std::string result; + + for (size_t i = 0; i < s.size(); i++) { + if (s[i] == '%' && i + 1 < s.size()) { + if (s[i + 1] == 'u') { + auto val = 0; + if (from_hex_to_i(s, i + 2, 4, val)) { + // 4 digits Unicode codes + char buff[4]; + size_t len = to_utf8(val, buff); + if (len > 0) { result.append(buff, len); } + i += 5; // 'u0000' + } else { + result += s[i]; + } + } else { + auto val = 0; + if (from_hex_to_i(s, i + 1, 2, val)) { + // 2 digits hex codes + result += static_cast(val); + i += 2; // '00' + } else { + result += s[i]; + } + } + } else if (convert_plus_to_space && s[i] == '+') { + result += ' '; + } else { + result += s[i]; + } + } + + return result; +} + +inline void read_file(const std::string &path, std::string &out) { + std::ifstream fs(path, std::ios_base::binary); + fs.seekg(0, std::ios_base::end); + auto size = fs.tellg(); + fs.seekg(0); + out.resize(static_cast(size)); + fs.read(&out[0], static_cast(size)); +} + +inline std::string file_extension(const std::string &path) { + std::smatch m; + static auto re = std::regex("\\.([a-zA-Z0-9]+)$"); + if (std::regex_search(path, m, re)) { return m[1].str(); } + return std::string(); +} + +inline bool is_space_or_tab(char c) { return c == ' ' || c == '\t'; } + +inline std::pair trim(const char *b, const char *e, size_t left, + size_t right) { + while (b + left < e && is_space_or_tab(b[left])) { + left++; + } + while (right > 0 && is_space_or_tab(b[right - 1])) { + right--; + } + return std::make_pair(left, right); +} + +inline std::string trim_copy(const std::string &s) { + auto r = trim(s.data(), s.data() + s.size(), 0, s.size()); + return s.substr(r.first, r.second - r.first); +} + +inline std::string trim_double_quotes_copy(const std::string &s) { + if (s.length() >= 2 && s.front() == '"' && s.back() == '"') { + return s.substr(1, s.size() - 2); + } + return s; +} + +inline void split(const char *b, const char *e, char d, + std::function fn) { + return split(b, e, d, (std::numeric_limits::max)(), std::move(fn)); +} + +inline void split(const char *b, const char *e, char d, size_t m, + std::function fn) { + size_t i = 0; + size_t beg = 0; + size_t count = 1; + + while (e ? (b + i < e) : (b[i] != '\0')) { + if (b[i] == d && count < m) { + auto r = trim(b, e, beg, i); + if (r.first < r.second) { fn(&b[r.first], &b[r.second]); } + beg = i + 1; + count++; + } + i++; + } + + if (i) { + auto r = trim(b, e, beg, i); + if (r.first < r.second) { fn(&b[r.first], &b[r.second]); } + } +} + +inline stream_line_reader::stream_line_reader(Stream &strm, char *fixed_buffer, + size_t fixed_buffer_size) + : strm_(strm), fixed_buffer_(fixed_buffer), + fixed_buffer_size_(fixed_buffer_size) {} + +inline const char *stream_line_reader::ptr() const { + if (glowable_buffer_.empty()) { + return fixed_buffer_; + } else { + return glowable_buffer_.data(); + } +} + +inline size_t stream_line_reader::size() const { + if (glowable_buffer_.empty()) { + return fixed_buffer_used_size_; + } else { + return glowable_buffer_.size(); + } +} + +inline bool stream_line_reader::end_with_crlf() const { + auto end = ptr() + size(); + return size() >= 2 && end[-2] == '\r' && end[-1] == '\n'; +} + +inline bool stream_line_reader::getline() { + fixed_buffer_used_size_ = 0; + glowable_buffer_.clear(); + + for (size_t i = 0;; i++) { + char byte; + auto n = strm_.read(&byte, 1); + + if (n < 0) { + return false; + } else if (n == 0) { + if (i == 0) { + return false; + } else { + break; + } + } + + append(byte); + + if (byte == '\n') { break; } + } + + return true; +} + +inline void stream_line_reader::append(char c) { + if (fixed_buffer_used_size_ < fixed_buffer_size_ - 1) { + fixed_buffer_[fixed_buffer_used_size_++] = c; + fixed_buffer_[fixed_buffer_used_size_] = '\0'; + } else { + if (glowable_buffer_.empty()) { + assert(fixed_buffer_[fixed_buffer_used_size_] == '\0'); + glowable_buffer_.assign(fixed_buffer_, fixed_buffer_used_size_); + } + glowable_buffer_ += c; + } +} + +inline mmap::mmap(const char *path) +#if defined(_WIN32) + : hFile_(NULL), hMapping_(NULL) +#else + : fd_(-1) +#endif + , + size_(0), addr_(nullptr) { + open(path); +} + +inline mmap::~mmap() { close(); } + +inline bool mmap::open(const char *path) { + close(); + +#if defined(_WIN32) + std::wstring wpath; + for (size_t i = 0; i < strlen(path); i++) { + wpath += path[i]; + } + + hFile_ = ::CreateFile2(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ, + OPEN_EXISTING, NULL); + + if (hFile_ == INVALID_HANDLE_VALUE) { return false; } + + LARGE_INTEGER size{}; + if (!::GetFileSizeEx(hFile_, &size)) { return false; } + size_ = static_cast(size.QuadPart); + + hMapping_ = + ::CreateFileMappingFromApp(hFile_, NULL, PAGE_READONLY, size_, NULL); + + if (hMapping_ == NULL) { + close(); + return false; + } + + addr_ = ::MapViewOfFileFromApp(hMapping_, FILE_MAP_READ, 0, 0); +#else + fd_ = ::open(path, O_RDONLY); + if (fd_ == -1) { return false; } + + struct stat sb; + if (fstat(fd_, &sb) == -1) { + close(); + return false; + } + size_ = static_cast(sb.st_size); + + addr_ = ::mmap(NULL, size_, PROT_READ, MAP_PRIVATE, fd_, 0); +#endif + + if (addr_ == nullptr) { + close(); + return false; + } + + return true; +} + +inline bool mmap::is_open() const { return addr_ != nullptr; } + +inline size_t mmap::size() const { return size_; } + +inline const char *mmap::data() const { + return static_cast(addr_); +} + +inline void mmap::close() { +#if defined(_WIN32) + if (addr_) { + ::UnmapViewOfFile(addr_); + addr_ = nullptr; + } + + if (hMapping_) { + ::CloseHandle(hMapping_); + hMapping_ = NULL; + } + + if (hFile_ != INVALID_HANDLE_VALUE) { + ::CloseHandle(hFile_); + hFile_ = INVALID_HANDLE_VALUE; + } +#else + if (addr_ != nullptr) { + munmap(addr_, size_); + addr_ = nullptr; + } + + if (fd_ != -1) { + ::close(fd_); + fd_ = -1; + } +#endif + size_ = 0; +} +inline int close_socket(socket_t sock) { +#ifdef _WIN32 + return closesocket(sock); +#else + return close(sock); +#endif +} + +template inline ssize_t handle_EINTR(T fn) { + ssize_t res = 0; + while (true) { + res = fn(); + if (res < 0 && errno == EINTR) { continue; } + break; + } + return res; +} + +inline ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags) { + return handle_EINTR([&]() { + return recv(sock, +#ifdef _WIN32 + static_cast(ptr), static_cast(size), +#else + ptr, size, +#endif + flags); + }); +} + +inline ssize_t send_socket(socket_t sock, const void *ptr, size_t size, + int flags) { + return handle_EINTR([&]() { + return send(sock, +#ifdef _WIN32 + static_cast(ptr), static_cast(size), +#else + ptr, size, +#endif + flags); + }); +} + +inline ssize_t select_read(socket_t sock, time_t sec, time_t usec) { +#ifdef CPPHTTPLIB_USE_POLL + struct pollfd pfd_read; + pfd_read.fd = sock; + pfd_read.events = POLLIN; + + auto timeout = static_cast(sec * 1000 + usec / 1000); + + return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); }); +#else +#ifndef _WIN32 + if (sock >= FD_SETSIZE) { return -1; } +#endif + + fd_set fds; + FD_ZERO(&fds); + FD_SET(sock, &fds); + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + return handle_EINTR([&]() { + return select(static_cast(sock + 1), &fds, nullptr, nullptr, &tv); + }); +#endif +} + +inline ssize_t select_write(socket_t sock, time_t sec, time_t usec) { +#ifdef CPPHTTPLIB_USE_POLL + struct pollfd pfd_read; + pfd_read.fd = sock; + pfd_read.events = POLLOUT; + + auto timeout = static_cast(sec * 1000 + usec / 1000); + + return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); }); +#else +#ifndef _WIN32 + if (sock >= FD_SETSIZE) { return -1; } +#endif + + fd_set fds; + FD_ZERO(&fds); + FD_SET(sock, &fds); + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + return handle_EINTR([&]() { + return select(static_cast(sock + 1), nullptr, &fds, nullptr, &tv); + }); +#endif +} + +inline Error wait_until_socket_is_ready(socket_t sock, time_t sec, + time_t usec) { +#ifdef CPPHTTPLIB_USE_POLL + struct pollfd pfd_read; + pfd_read.fd = sock; + pfd_read.events = POLLIN | POLLOUT; + + auto timeout = static_cast(sec * 1000 + usec / 1000); + + auto poll_res = handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); }); + + if (poll_res == 0) { return Error::ConnectionTimeout; } + + if (poll_res > 0 && pfd_read.revents & (POLLIN | POLLOUT)) { + auto error = 0; + socklen_t len = sizeof(error); + auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR, + reinterpret_cast(&error), &len); + auto successful = res >= 0 && !error; + return successful ? Error::Success : Error::Connection; + } + + return Error::Connection; +#else +#ifndef _WIN32 + if (sock >= FD_SETSIZE) { return Error::Connection; } +#endif + + fd_set fdsr; + FD_ZERO(&fdsr); + FD_SET(sock, &fdsr); + + auto fdsw = fdsr; + auto fdse = fdsr; + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + auto ret = handle_EINTR([&]() { + return select(static_cast(sock + 1), &fdsr, &fdsw, &fdse, &tv); + }); + + if (ret == 0) { return Error::ConnectionTimeout; } + + if (ret > 0 && (FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) { + auto error = 0; + socklen_t len = sizeof(error); + auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR, + reinterpret_cast(&error), &len); + auto successful = res >= 0 && !error; + return successful ? Error::Success : Error::Connection; + } + return Error::Connection; +#endif +} + +inline bool is_socket_alive(socket_t sock) { + const auto val = detail::select_read(sock, 0, 0); + if (val == 0) { + return true; + } else if (val < 0 && errno == EBADF) { + return false; + } + char buf[1]; + return detail::read_socket(sock, &buf[0], sizeof(buf), MSG_PEEK) > 0; +} + +class SocketStream final : public Stream { +public: + SocketStream(socket_t sock, time_t read_timeout_sec, time_t read_timeout_usec, + time_t write_timeout_sec, time_t write_timeout_usec); + ~SocketStream() override; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + void get_local_ip_and_port(std::string &ip, int &port) const override; + socket_t socket() const override; + +private: + socket_t sock_; + time_t read_timeout_sec_; + time_t read_timeout_usec_; + time_t write_timeout_sec_; + time_t write_timeout_usec_; + + std::vector read_buff_; + size_t read_buff_off_ = 0; + size_t read_buff_content_size_ = 0; + + static const size_t read_buff_size_ = 1024l * 4; +}; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +class SSLSocketStream final : public Stream { +public: + SSLSocketStream(socket_t sock, SSL *ssl, time_t read_timeout_sec, + time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec); + ~SSLSocketStream() override; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + void get_local_ip_and_port(std::string &ip, int &port) const override; + socket_t socket() const override; + +private: + socket_t sock_; + SSL *ssl_; + time_t read_timeout_sec_; + time_t read_timeout_usec_; + time_t write_timeout_sec_; + time_t write_timeout_usec_; +}; +#endif + +inline bool keep_alive(socket_t sock, time_t keep_alive_timeout_sec) { + using namespace std::chrono; + auto start = steady_clock::now(); + while (true) { + auto val = select_read(sock, 0, 10000); + if (val < 0) { + return false; + } else if (val == 0) { + auto current = steady_clock::now(); + auto duration = duration_cast(current - start); + auto timeout = keep_alive_timeout_sec * 1000; + if (duration.count() > timeout) { return false; } + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } else { + return true; + } + } +} + +template +inline bool +process_server_socket_core(const std::atomic &svr_sock, socket_t sock, + size_t keep_alive_max_count, + time_t keep_alive_timeout_sec, T callback) { + assert(keep_alive_max_count > 0); + auto ret = false; + auto count = keep_alive_max_count; + while (svr_sock != INVALID_SOCKET && count > 0 && + keep_alive(sock, keep_alive_timeout_sec)) { + auto close_connection = count == 1; + auto connection_closed = false; + ret = callback(close_connection, connection_closed); + if (!ret || connection_closed) { break; } + count--; + } + return ret; +} + +template +inline bool +process_server_socket(const std::atomic &svr_sock, socket_t sock, + size_t keep_alive_max_count, + time_t keep_alive_timeout_sec, time_t read_timeout_sec, + time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, T callback) { + return process_server_socket_core( + svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec, + [&](bool close_connection, bool &connection_closed) { + SocketStream strm(sock, read_timeout_sec, read_timeout_usec, + write_timeout_sec, write_timeout_usec); + return callback(strm, close_connection, connection_closed); + }); +} + +inline bool process_client_socket(socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec, + time_t write_timeout_sec, + time_t write_timeout_usec, + std::function callback) { + SocketStream strm(sock, read_timeout_sec, read_timeout_usec, + write_timeout_sec, write_timeout_usec); + return callback(strm); +} + +inline int shutdown_socket(socket_t sock) { +#ifdef _WIN32 + return shutdown(sock, SD_BOTH); +#else + return shutdown(sock, SHUT_RDWR); +#endif +} + +template +socket_t create_socket(const std::string &host, const std::string &ip, int port, + int address_family, int socket_flags, bool tcp_nodelay, + SocketOptions socket_options, + BindOrConnect bind_or_connect) { + // Get address info + const char *node = nullptr; + struct addrinfo hints; + struct addrinfo *result; + + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_socktype = SOCK_STREAM; + hints.ai_protocol = 0; + + if (!ip.empty()) { + node = ip.c_str(); + // Ask getaddrinfo to convert IP in c-string to address + hints.ai_family = AF_UNSPEC; + hints.ai_flags = AI_NUMERICHOST; + } else { + if (!host.empty()) { node = host.c_str(); } + hints.ai_family = address_family; + hints.ai_flags = socket_flags; + } + +#ifndef _WIN32 + if (hints.ai_family == AF_UNIX) { + const auto addrlen = host.length(); + if (addrlen > sizeof(sockaddr_un::sun_path)) { return INVALID_SOCKET; } + + auto sock = socket(hints.ai_family, hints.ai_socktype, hints.ai_protocol); + if (sock != INVALID_SOCKET) { + sockaddr_un addr{}; + addr.sun_family = AF_UNIX; + std::copy(host.begin(), host.end(), addr.sun_path); + + hints.ai_addr = reinterpret_cast(&addr); + hints.ai_addrlen = static_cast( + sizeof(addr) - sizeof(addr.sun_path) + addrlen); + + fcntl(sock, F_SETFD, FD_CLOEXEC); + if (socket_options) { socket_options(sock); } + + if (!bind_or_connect(sock, hints)) { + close_socket(sock); + sock = INVALID_SOCKET; + } + } + return sock; + } +#endif + + auto service = std::to_string(port); + + if (getaddrinfo(node, service.c_str(), &hints, &result)) { +#if defined __linux__ && !defined __ANDROID__ + res_init(); +#endif + return INVALID_SOCKET; + } + + for (auto rp = result; rp; rp = rp->ai_next) { + // Create a socket +#ifdef _WIN32 + auto sock = + WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol, nullptr, 0, + WSA_FLAG_NO_HANDLE_INHERIT | WSA_FLAG_OVERLAPPED); + /** + * Since the WSA_FLAG_NO_HANDLE_INHERIT is only supported on Windows 7 SP1 + * and above the socket creation fails on older Windows Systems. + * + * Let's try to create a socket the old way in this case. + * + * Reference: + * https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketa + * + * WSA_FLAG_NO_HANDLE_INHERIT: + * This flag is supported on Windows 7 with SP1, Windows Server 2008 R2 with + * SP1, and later + * + */ + if (sock == INVALID_SOCKET) { + sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + } +#else + auto sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); +#endif + if (sock == INVALID_SOCKET) { continue; } + +#ifndef _WIN32 + if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1) { + close_socket(sock); + continue; + } +#endif + + if (tcp_nodelay) { + auto yes = 1; +#ifdef _WIN32 + setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, + reinterpret_cast(&yes), sizeof(yes)); +#else + setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, + reinterpret_cast(&yes), sizeof(yes)); +#endif + } + + if (socket_options) { socket_options(sock); } + + if (rp->ai_family == AF_INET6) { + auto no = 0; +#ifdef _WIN32 + setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, + reinterpret_cast(&no), sizeof(no)); +#else + setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, + reinterpret_cast(&no), sizeof(no)); +#endif + } + + // bind or connect + if (bind_or_connect(sock, *rp)) { + freeaddrinfo(result); + return sock; + } + + close_socket(sock); + } + + freeaddrinfo(result); + return INVALID_SOCKET; +} + +inline void set_nonblocking(socket_t sock, bool nonblocking) { +#ifdef _WIN32 + auto flags = nonblocking ? 1UL : 0UL; + ioctlsocket(sock, FIONBIO, &flags); +#else + auto flags = fcntl(sock, F_GETFL, 0); + fcntl(sock, F_SETFL, + nonblocking ? (flags | O_NONBLOCK) : (flags & (~O_NONBLOCK))); +#endif +} + +inline bool is_connection_error() { +#ifdef _WIN32 + return WSAGetLastError() != WSAEWOULDBLOCK; +#else + return errno != EINPROGRESS; +#endif +} + +inline bool bind_ip_address(socket_t sock, const std::string &host) { + struct addrinfo hints; + struct addrinfo *result; + + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_protocol = 0; + + if (getaddrinfo(host.c_str(), "0", &hints, &result)) { return false; } + + auto ret = false; + for (auto rp = result; rp; rp = rp->ai_next) { + const auto &ai = *rp; + if (!::bind(sock, ai.ai_addr, static_cast(ai.ai_addrlen))) { + ret = true; + break; + } + } + + freeaddrinfo(result); + return ret; +} + +#if !defined _WIN32 && !defined ANDROID && !defined _AIX && !defined __MVS__ +#define USE_IF2IP +#endif + +#ifdef USE_IF2IP +inline std::string if2ip(int address_family, const std::string &ifn) { + struct ifaddrs *ifap; + getifaddrs(&ifap); + std::string addr_candidate; + for (auto ifa = ifap; ifa; ifa = ifa->ifa_next) { + if (ifa->ifa_addr && ifn == ifa->ifa_name && + (AF_UNSPEC == address_family || + ifa->ifa_addr->sa_family == address_family)) { + if (ifa->ifa_addr->sa_family == AF_INET) { + auto sa = reinterpret_cast(ifa->ifa_addr); + char buf[INET_ADDRSTRLEN]; + if (inet_ntop(AF_INET, &sa->sin_addr, buf, INET_ADDRSTRLEN)) { + freeifaddrs(ifap); + return std::string(buf, INET_ADDRSTRLEN); + } + } else if (ifa->ifa_addr->sa_family == AF_INET6) { + auto sa = reinterpret_cast(ifa->ifa_addr); + if (!IN6_IS_ADDR_LINKLOCAL(&sa->sin6_addr)) { + char buf[INET6_ADDRSTRLEN] = {}; + if (inet_ntop(AF_INET6, &sa->sin6_addr, buf, INET6_ADDRSTRLEN)) { + // equivalent to mac's IN6_IS_ADDR_UNIQUE_LOCAL + auto s6_addr_head = sa->sin6_addr.s6_addr[0]; + if (s6_addr_head == 0xfc || s6_addr_head == 0xfd) { + addr_candidate = std::string(buf, INET6_ADDRSTRLEN); + } else { + freeifaddrs(ifap); + return std::string(buf, INET6_ADDRSTRLEN); + } + } + } + } + } + } + freeifaddrs(ifap); + return addr_candidate; +} +#endif + +inline socket_t create_client_socket( + const std::string &host, const std::string &ip, int port, + int address_family, bool tcp_nodelay, SocketOptions socket_options, + time_t connection_timeout_sec, time_t connection_timeout_usec, + time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, const std::string &intf, Error &error) { + auto sock = create_socket( + host, ip, port, address_family, 0, tcp_nodelay, std::move(socket_options), + [&](socket_t sock2, struct addrinfo &ai) -> bool { + if (!intf.empty()) { +#ifdef USE_IF2IP + auto ip_from_if = if2ip(address_family, intf); + if (ip_from_if.empty()) { ip_from_if = intf; } + if (!bind_ip_address(sock2, ip_from_if)) { + error = Error::BindIPAddress; + return false; + } +#endif + } + + set_nonblocking(sock2, true); + + auto ret = + ::connect(sock2, ai.ai_addr, static_cast(ai.ai_addrlen)); + + if (ret < 0) { + if (is_connection_error()) { + error = Error::Connection; + return false; + } + error = wait_until_socket_is_ready(sock2, connection_timeout_sec, + connection_timeout_usec); + if (error != Error::Success) { return false; } + } + + set_nonblocking(sock2, false); + + { +#ifdef _WIN32 + auto timeout = static_cast(read_timeout_sec * 1000 + + read_timeout_usec / 1000); + setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO, + reinterpret_cast(&timeout), sizeof(timeout)); +#else + timeval tv; + tv.tv_sec = static_cast(read_timeout_sec); + tv.tv_usec = static_cast(read_timeout_usec); + setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO, + reinterpret_cast(&tv), sizeof(tv)); +#endif + } + { + +#ifdef _WIN32 + auto timeout = static_cast(write_timeout_sec * 1000 + + write_timeout_usec / 1000); + setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO, + reinterpret_cast(&timeout), sizeof(timeout)); +#else + timeval tv; + tv.tv_sec = static_cast(write_timeout_sec); + tv.tv_usec = static_cast(write_timeout_usec); + setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO, + reinterpret_cast(&tv), sizeof(tv)); +#endif + } + + error = Error::Success; + return true; + }); + + if (sock != INVALID_SOCKET) { + error = Error::Success; + } else { + if (error == Error::Success) { error = Error::Connection; } + } + + return sock; +} + +inline bool get_ip_and_port(const struct sockaddr_storage &addr, + socklen_t addr_len, std::string &ip, int &port) { + if (addr.ss_family == AF_INET) { + port = ntohs(reinterpret_cast(&addr)->sin_port); + } else if (addr.ss_family == AF_INET6) { + port = + ntohs(reinterpret_cast(&addr)->sin6_port); + } else { + return false; + } + + std::array ipstr{}; + if (getnameinfo(reinterpret_cast(&addr), addr_len, + ipstr.data(), static_cast(ipstr.size()), nullptr, + 0, NI_NUMERICHOST)) { + return false; + } + + ip = ipstr.data(); + return true; +} + +inline void get_local_ip_and_port(socket_t sock, std::string &ip, int &port) { + struct sockaddr_storage addr; + socklen_t addr_len = sizeof(addr); + if (!getsockname(sock, reinterpret_cast(&addr), + &addr_len)) { + get_ip_and_port(addr, addr_len, ip, port); + } +} + +inline void get_remote_ip_and_port(socket_t sock, std::string &ip, int &port) { + struct sockaddr_storage addr; + socklen_t addr_len = sizeof(addr); + + if (!getpeername(sock, reinterpret_cast(&addr), + &addr_len)) { +#ifndef _WIN32 + if (addr.ss_family == AF_UNIX) { +#if defined(__linux__) + struct ucred ucred; + socklen_t len = sizeof(ucred); + if (getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == 0) { + port = ucred.pid; + } +#elif defined(SOL_LOCAL) && defined(SO_PEERPID) // __APPLE__ + pid_t pid; + socklen_t len = sizeof(pid); + if (getsockopt(sock, SOL_LOCAL, SO_PEERPID, &pid, &len) == 0) { + port = pid; + } +#endif + return; + } +#endif + get_ip_and_port(addr, addr_len, ip, port); + } +} + +inline constexpr unsigned int str2tag_core(const char *s, size_t l, + unsigned int h) { + return (l == 0) + ? h + : str2tag_core( + s + 1, l - 1, + // Unsets the 6 high bits of h, therefore no overflow happens + (((std::numeric_limits::max)() >> 6) & + h * 33) ^ + static_cast(*s)); +} + +inline unsigned int str2tag(const std::string &s) { + return str2tag_core(s.data(), s.size(), 0); +} + +namespace udl { + +inline constexpr unsigned int operator"" _t(const char *s, size_t l) { + return str2tag_core(s, l, 0); +} + +} // namespace udl + +inline std::string +find_content_type(const std::string &path, + const std::map &user_data, + const std::string &default_content_type) { + auto ext = file_extension(path); + + auto it = user_data.find(ext); + if (it != user_data.end()) { return it->second; } + + using udl::operator""_t; + + switch (str2tag(ext)) { + default: return default_content_type; + + case "css"_t: return "text/css"; + case "csv"_t: return "text/csv"; + case "htm"_t: + case "html"_t: return "text/html"; + case "js"_t: + case "mjs"_t: return "text/javascript"; + case "txt"_t: return "text/plain"; + case "vtt"_t: return "text/vtt"; + + case "apng"_t: return "image/apng"; + case "avif"_t: return "image/avif"; + case "bmp"_t: return "image/bmp"; + case "gif"_t: return "image/gif"; + case "png"_t: return "image/png"; + case "svg"_t: return "image/svg+xml"; + case "webp"_t: return "image/webp"; + case "ico"_t: return "image/x-icon"; + case "tif"_t: return "image/tiff"; + case "tiff"_t: return "image/tiff"; + case "jpg"_t: + case "jpeg"_t: return "image/jpeg"; + + case "mp4"_t: return "video/mp4"; + case "mpeg"_t: return "video/mpeg"; + case "webm"_t: return "video/webm"; + + case "mp3"_t: return "audio/mp3"; + case "mpga"_t: return "audio/mpeg"; + case "weba"_t: return "audio/webm"; + case "wav"_t: return "audio/wave"; + + case "otf"_t: return "font/otf"; + case "ttf"_t: return "font/ttf"; + case "woff"_t: return "font/woff"; + case "woff2"_t: return "font/woff2"; + + case "7z"_t: return "application/x-7z-compressed"; + case "atom"_t: return "application/atom+xml"; + case "pdf"_t: return "application/pdf"; + case "json"_t: return "application/json"; + case "rss"_t: return "application/rss+xml"; + case "tar"_t: return "application/x-tar"; + case "xht"_t: + case "xhtml"_t: return "application/xhtml+xml"; + case "xslt"_t: return "application/xslt+xml"; + case "xml"_t: return "application/xml"; + case "gz"_t: return "application/gzip"; + case "zip"_t: return "application/zip"; + case "wasm"_t: return "application/wasm"; + } +} + +inline bool can_compress_content_type(const std::string &content_type) { + using udl::operator""_t; + + auto tag = str2tag(content_type); + + switch (tag) { + case "image/svg+xml"_t: + case "application/javascript"_t: + case "application/json"_t: + case "application/xml"_t: + case "application/protobuf"_t: + case "application/xhtml+xml"_t: return true; + + default: + return !content_type.rfind("text/", 0) && tag != "text/event-stream"_t; + } +} + +inline EncodingType encoding_type(const Request &req, const Response &res) { + auto ret = + detail::can_compress_content_type(res.get_header_value("Content-Type")); + if (!ret) { return EncodingType::None; } + + const auto &s = req.get_header_value("Accept-Encoding"); + (void)(s); + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + // TODO: 'Accept-Encoding' has br, not br;q=0 + ret = s.find("br") != std::string::npos; + if (ret) { return EncodingType::Brotli; } +#endif + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + // TODO: 'Accept-Encoding' has gzip, not gzip;q=0 + ret = s.find("gzip") != std::string::npos; + if (ret) { return EncodingType::Gzip; } +#endif + + return EncodingType::None; +} + +inline bool nocompressor::compress(const char *data, size_t data_length, + bool /*last*/, Callback callback) { + if (!data_length) { return true; } + return callback(data, data_length); +} + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +inline gzip_compressor::gzip_compressor() { + std::memset(&strm_, 0, sizeof(strm_)); + strm_.zalloc = Z_NULL; + strm_.zfree = Z_NULL; + strm_.opaque = Z_NULL; + + is_valid_ = deflateInit2(&strm_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8, + Z_DEFAULT_STRATEGY) == Z_OK; +} + +inline gzip_compressor::~gzip_compressor() { deflateEnd(&strm_); } + +inline bool gzip_compressor::compress(const char *data, size_t data_length, + bool last, Callback callback) { + assert(is_valid_); + + do { + constexpr size_t max_avail_in = + (std::numeric_limits::max)(); + + strm_.avail_in = static_cast( + (std::min)(data_length, max_avail_in)); + strm_.next_in = const_cast(reinterpret_cast(data)); + + data_length -= strm_.avail_in; + data += strm_.avail_in; + + auto flush = (last && data_length == 0) ? Z_FINISH : Z_NO_FLUSH; + auto ret = Z_OK; + + std::array buff{}; + do { + strm_.avail_out = static_cast(buff.size()); + strm_.next_out = reinterpret_cast(buff.data()); + + ret = deflate(&strm_, flush); + if (ret == Z_STREAM_ERROR) { return false; } + + if (!callback(buff.data(), buff.size() - strm_.avail_out)) { + return false; + } + } while (strm_.avail_out == 0); + + assert((flush == Z_FINISH && ret == Z_STREAM_END) || + (flush == Z_NO_FLUSH && ret == Z_OK)); + assert(strm_.avail_in == 0); + } while (data_length > 0); + + return true; +} + +inline gzip_decompressor::gzip_decompressor() { + std::memset(&strm_, 0, sizeof(strm_)); + strm_.zalloc = Z_NULL; + strm_.zfree = Z_NULL; + strm_.opaque = Z_NULL; + + // 15 is the value of wbits, which should be at the maximum possible value + // to ensure that any gzip stream can be decoded. The offset of 32 specifies + // that the stream type should be automatically detected either gzip or + // deflate. + is_valid_ = inflateInit2(&strm_, 32 + 15) == Z_OK; +} + +inline gzip_decompressor::~gzip_decompressor() { inflateEnd(&strm_); } + +inline bool gzip_decompressor::is_valid() const { return is_valid_; } + +inline bool gzip_decompressor::decompress(const char *data, size_t data_length, + Callback callback) { + assert(is_valid_); + + auto ret = Z_OK; + + do { + constexpr size_t max_avail_in = + (std::numeric_limits::max)(); + + strm_.avail_in = static_cast( + (std::min)(data_length, max_avail_in)); + strm_.next_in = const_cast(reinterpret_cast(data)); + + data_length -= strm_.avail_in; + data += strm_.avail_in; + + std::array buff{}; + while (strm_.avail_in > 0 && ret == Z_OK) { + strm_.avail_out = static_cast(buff.size()); + strm_.next_out = reinterpret_cast(buff.data()); + + ret = inflate(&strm_, Z_NO_FLUSH); + + assert(ret != Z_STREAM_ERROR); + switch (ret) { + case Z_NEED_DICT: + case Z_DATA_ERROR: + case Z_MEM_ERROR: inflateEnd(&strm_); return false; + } + + if (!callback(buff.data(), buff.size() - strm_.avail_out)) { + return false; + } + } + + if (ret != Z_OK && ret != Z_STREAM_END) { return false; } + + } while (data_length > 0); + + return true; +} +#endif + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +inline brotli_compressor::brotli_compressor() { + state_ = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr); +} + +inline brotli_compressor::~brotli_compressor() { + BrotliEncoderDestroyInstance(state_); +} + +inline bool brotli_compressor::compress(const char *data, size_t data_length, + bool last, Callback callback) { + std::array buff{}; + + auto operation = last ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS; + auto available_in = data_length; + auto next_in = reinterpret_cast(data); + + for (;;) { + if (last) { + if (BrotliEncoderIsFinished(state_)) { break; } + } else { + if (!available_in) { break; } + } + + auto available_out = buff.size(); + auto next_out = buff.data(); + + if (!BrotliEncoderCompressStream(state_, operation, &available_in, &next_in, + &available_out, &next_out, nullptr)) { + return false; + } + + auto output_bytes = buff.size() - available_out; + if (output_bytes) { + callback(reinterpret_cast(buff.data()), output_bytes); + } + } + + return true; +} + +inline brotli_decompressor::brotli_decompressor() { + decoder_s = BrotliDecoderCreateInstance(0, 0, 0); + decoder_r = decoder_s ? BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT + : BROTLI_DECODER_RESULT_ERROR; +} + +inline brotli_decompressor::~brotli_decompressor() { + if (decoder_s) { BrotliDecoderDestroyInstance(decoder_s); } +} + +inline bool brotli_decompressor::is_valid() const { return decoder_s; } + +inline bool brotli_decompressor::decompress(const char *data, + size_t data_length, + Callback callback) { + if (decoder_r == BROTLI_DECODER_RESULT_SUCCESS || + decoder_r == BROTLI_DECODER_RESULT_ERROR) { + return 0; + } + + auto next_in = reinterpret_cast(data); + size_t avail_in = data_length; + size_t total_out; + + decoder_r = BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT; + + std::array buff{}; + while (decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) { + char *next_out = buff.data(); + size_t avail_out = buff.size(); + + decoder_r = BrotliDecoderDecompressStream( + decoder_s, &avail_in, &next_in, &avail_out, + reinterpret_cast(&next_out), &total_out); + + if (decoder_r == BROTLI_DECODER_RESULT_ERROR) { return false; } + + if (!callback(buff.data(), buff.size() - avail_out)) { return false; } + } + + return decoder_r == BROTLI_DECODER_RESULT_SUCCESS || + decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT; +} +#endif + +inline bool has_header(const Headers &headers, const std::string &key) { + return headers.find(key) != headers.end(); +} + +inline const char *get_header_value(const Headers &headers, + const std::string &key, size_t id, + const char *def) { + auto rng = headers.equal_range(key); + auto it = rng.first; + std::advance(it, static_cast(id)); + if (it != rng.second) { return it->second.c_str(); } + return def; +} + +inline bool compare_case_ignore(const std::string &a, const std::string &b) { + if (a.size() != b.size()) { return false; } + for (size_t i = 0; i < b.size(); i++) { + if (::tolower(a[i]) != ::tolower(b[i])) { return false; } + } + return true; +} + +template +inline bool parse_header(const char *beg, const char *end, T fn) { + // Skip trailing spaces and tabs. + while (beg < end && is_space_or_tab(end[-1])) { + end--; + } + + auto p = beg; + while (p < end && *p != ':') { + p++; + } + + if (p == end) { return false; } + + auto key_end = p; + + if (*p++ != ':') { return false; } + + while (p < end && is_space_or_tab(*p)) { + p++; + } + + if (p < end) { + auto key_len = key_end - beg; + if (!key_len) { return false; } + + auto key = std::string(beg, key_end); + auto val = compare_case_ignore(key, "Location") + ? std::string(p, end) + : decode_url(std::string(p, end), false); + fn(std::move(key), std::move(val)); + return true; + } + + return false; +} + +inline bool read_headers(Stream &strm, Headers &headers) { + const auto bufsiz = 2048; + char buf[bufsiz]; + stream_line_reader line_reader(strm, buf, bufsiz); + + for (;;) { + if (!line_reader.getline()) { return false; } + + // Check if the line ends with CRLF. + auto line_terminator_len = 2; + if (line_reader.end_with_crlf()) { + // Blank line indicates end of headers. + if (line_reader.size() == 2) { break; } +#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR + } else { + // Blank line indicates end of headers. + if (line_reader.size() == 1) { break; } + line_terminator_len = 1; + } +#else + } else { + continue; // Skip invalid line. + } +#endif + + if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; } + + // Exclude line terminator + auto end = line_reader.ptr() + line_reader.size() - line_terminator_len; + + parse_header(line_reader.ptr(), end, + [&](std::string &&key, std::string &&val) { + headers.emplace(std::move(key), std::move(val)); + }); + } + + return true; +} + +inline bool read_content_with_length(Stream &strm, uint64_t len, + Progress progress, + ContentReceiverWithProgress out) { + char buf[CPPHTTPLIB_RECV_BUFSIZ]; + + uint64_t r = 0; + while (r < len) { + auto read_len = static_cast(len - r); + auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ)); + if (n <= 0) { return false; } + + if (!out(buf, static_cast(n), r, len)) { return false; } + r += static_cast(n); + + if (progress) { + if (!progress(r, len)) { return false; } + } + } + + return true; +} + +inline void skip_content_with_length(Stream &strm, uint64_t len) { + char buf[CPPHTTPLIB_RECV_BUFSIZ]; + uint64_t r = 0; + while (r < len) { + auto read_len = static_cast(len - r); + auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ)); + if (n <= 0) { return; } + r += static_cast(n); + } +} + +inline bool read_content_without_length(Stream &strm, + ContentReceiverWithProgress out) { + char buf[CPPHTTPLIB_RECV_BUFSIZ]; + uint64_t r = 0; + for (;;) { + auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ); + if (n <= 0) { return true; } + + if (!out(buf, static_cast(n), r, 0)) { return false; } + r += static_cast(n); + } + + return true; +} + +template +inline bool read_content_chunked(Stream &strm, T &x, + ContentReceiverWithProgress out) { + const auto bufsiz = 16; + char buf[bufsiz]; + + stream_line_reader line_reader(strm, buf, bufsiz); + + if (!line_reader.getline()) { return false; } + + unsigned long chunk_len; + while (true) { + char *end_ptr; + + chunk_len = std::strtoul(line_reader.ptr(), &end_ptr, 16); + + if (end_ptr == line_reader.ptr()) { return false; } + if (chunk_len == ULONG_MAX) { return false; } + + if (chunk_len == 0) { break; } + + if (!read_content_with_length(strm, chunk_len, nullptr, out)) { + return false; + } + + if (!line_reader.getline()) { return false; } + + if (strcmp(line_reader.ptr(), "\r\n") != 0) { return false; } + + if (!line_reader.getline()) { return false; } + } + + assert(chunk_len == 0); + + // Trailer + if (!line_reader.getline()) { return false; } + + while (strcmp(line_reader.ptr(), "\r\n") != 0) { + if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; } + + // Exclude line terminator + constexpr auto line_terminator_len = 2; + auto end = line_reader.ptr() + line_reader.size() - line_terminator_len; + + parse_header(line_reader.ptr(), end, + [&](std::string &&key, std::string &&val) { + x.headers.emplace(std::move(key), std::move(val)); + }); + + if (!line_reader.getline()) { return false; } + } + + return true; +} + +inline bool is_chunked_transfer_encoding(const Headers &headers) { + return compare_case_ignore( + get_header_value(headers, "Transfer-Encoding", 0, ""), "chunked"); +} + +template +bool prepare_content_receiver(T &x, int &status, + ContentReceiverWithProgress receiver, + bool decompress, U callback) { + if (decompress) { + std::string encoding = x.get_header_value("Content-Encoding"); + std::unique_ptr decompressor; + + if (encoding == "gzip" || encoding == "deflate") { +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + decompressor = detail::make_unique(); +#else + status = StatusCode::UnsupportedMediaType_415; + return false; +#endif + } else if (encoding.find("br") != std::string::npos) { +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + decompressor = detail::make_unique(); +#else + status = StatusCode::UnsupportedMediaType_415; + return false; +#endif + } + + if (decompressor) { + if (decompressor->is_valid()) { + ContentReceiverWithProgress out = [&](const char *buf, size_t n, + uint64_t off, uint64_t len) { + return decompressor->decompress(buf, n, + [&](const char *buf2, size_t n2) { + return receiver(buf2, n2, off, len); + }); + }; + return callback(std::move(out)); + } else { + status = StatusCode::InternalServerError_500; + return false; + } + } + } + + ContentReceiverWithProgress out = [&](const char *buf, size_t n, uint64_t off, + uint64_t len) { + return receiver(buf, n, off, len); + }; + return callback(std::move(out)); +} + +template +bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status, + Progress progress, ContentReceiverWithProgress receiver, + bool decompress) { + return prepare_content_receiver( + x, status, std::move(receiver), decompress, + [&](const ContentReceiverWithProgress &out) { + auto ret = true; + auto exceed_payload_max_length = false; + + if (is_chunked_transfer_encoding(x.headers)) { + ret = read_content_chunked(strm, x, out); + } else if (!has_header(x.headers, "Content-Length")) { + ret = read_content_without_length(strm, out); + } else { + auto len = get_header_value_u64(x.headers, "Content-Length", 0, 0); + if (len > payload_max_length) { + exceed_payload_max_length = true; + skip_content_with_length(strm, len); + ret = false; + } else if (len > 0) { + ret = read_content_with_length(strm, len, std::move(progress), out); + } + } + + if (!ret) { + status = exceed_payload_max_length ? StatusCode::PayloadTooLarge_413 + : StatusCode::BadRequest_400; + } + return ret; + }); +} // namespace detail + +inline ssize_t write_headers(Stream &strm, const Headers &headers) { + ssize_t write_len = 0; + for (const auto &x : headers) { + auto len = + strm.write_format("%s: %s\r\n", x.first.c_str(), x.second.c_str()); + if (len < 0) { return len; } + write_len += len; + } + auto len = strm.write("\r\n"); + if (len < 0) { return len; } + write_len += len; + return write_len; +} + +inline bool write_data(Stream &strm, const char *d, size_t l) { + size_t offset = 0; + while (offset < l) { + auto length = strm.write(d + offset, l - offset); + if (length < 0) { return false; } + offset += static_cast(length); + } + return true; +} + +template +inline bool write_content(Stream &strm, const ContentProvider &content_provider, + size_t offset, size_t length, T is_shutting_down, + Error &error) { + size_t end_offset = offset + length; + auto ok = true; + DataSink data_sink; + + data_sink.write = [&](const char *d, size_t l) -> bool { + if (ok) { + if (strm.is_writable() && write_data(strm, d, l)) { + offset += l; + } else { + ok = false; + } + } + return ok; + }; + + data_sink.is_writable = [&]() -> bool { return strm.is_writable(); }; + + while (offset < end_offset && !is_shutting_down()) { + if (!strm.is_writable()) { + error = Error::Write; + return false; + } else if (!content_provider(offset, end_offset - offset, data_sink)) { + error = Error::Canceled; + return false; + } else if (!ok) { + error = Error::Write; + return false; + } + } + + error = Error::Success; + return true; +} + +template +inline bool write_content(Stream &strm, const ContentProvider &content_provider, + size_t offset, size_t length, + const T &is_shutting_down) { + auto error = Error::Success; + return write_content(strm, content_provider, offset, length, is_shutting_down, + error); +} + +template +inline bool +write_content_without_length(Stream &strm, + const ContentProvider &content_provider, + const T &is_shutting_down) { + size_t offset = 0; + auto data_available = true; + auto ok = true; + DataSink data_sink; + + data_sink.write = [&](const char *d, size_t l) -> bool { + if (ok) { + offset += l; + if (!strm.is_writable() || !write_data(strm, d, l)) { ok = false; } + } + return ok; + }; + + data_sink.is_writable = [&]() -> bool { return strm.is_writable(); }; + + data_sink.done = [&](void) { data_available = false; }; + + while (data_available && !is_shutting_down()) { + if (!strm.is_writable()) { + return false; + } else if (!content_provider(offset, 0, data_sink)) { + return false; + } else if (!ok) { + return false; + } + } + return true; +} + +template +inline bool +write_content_chunked(Stream &strm, const ContentProvider &content_provider, + const T &is_shutting_down, U &compressor, Error &error) { + size_t offset = 0; + auto data_available = true; + auto ok = true; + DataSink data_sink; + + data_sink.write = [&](const char *d, size_t l) -> bool { + if (ok) { + data_available = l > 0; + offset += l; + + std::string payload; + if (compressor.compress(d, l, false, + [&](const char *data, size_t data_len) { + payload.append(data, data_len); + return true; + })) { + if (!payload.empty()) { + // Emit chunked response header and footer for each chunk + auto chunk = + from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n"; + if (!strm.is_writable() || + !write_data(strm, chunk.data(), chunk.size())) { + ok = false; + } + } + } else { + ok = false; + } + } + return ok; + }; + + data_sink.is_writable = [&]() -> bool { return strm.is_writable(); }; + + auto done_with_trailer = [&](const Headers *trailer) { + if (!ok) { return; } + + data_available = false; + + std::string payload; + if (!compressor.compress(nullptr, 0, true, + [&](const char *data, size_t data_len) { + payload.append(data, data_len); + return true; + })) { + ok = false; + return; + } + + if (!payload.empty()) { + // Emit chunked response header and footer for each chunk + auto chunk = from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n"; + if (!strm.is_writable() || + !write_data(strm, chunk.data(), chunk.size())) { + ok = false; + return; + } + } + + static const std::string done_marker("0\r\n"); + if (!write_data(strm, done_marker.data(), done_marker.size())) { + ok = false; + } + + // Trailer + if (trailer) { + for (const auto &kv : *trailer) { + std::string field_line = kv.first + ": " + kv.second + "\r\n"; + if (!write_data(strm, field_line.data(), field_line.size())) { + ok = false; + } + } + } + + static const std::string crlf("\r\n"); + if (!write_data(strm, crlf.data(), crlf.size())) { ok = false; } + }; + + data_sink.done = [&](void) { done_with_trailer(nullptr); }; + + data_sink.done_with_trailer = [&](const Headers &trailer) { + done_with_trailer(&trailer); + }; + + while (data_available && !is_shutting_down()) { + if (!strm.is_writable()) { + error = Error::Write; + return false; + } else if (!content_provider(offset, 0, data_sink)) { + error = Error::Canceled; + return false; + } else if (!ok) { + error = Error::Write; + return false; + } + } + + error = Error::Success; + return true; +} + +template +inline bool write_content_chunked(Stream &strm, + const ContentProvider &content_provider, + const T &is_shutting_down, U &compressor) { + auto error = Error::Success; + return write_content_chunked(strm, content_provider, is_shutting_down, + compressor, error); +} + +template +inline bool redirect(T &cli, Request &req, Response &res, + const std::string &path, const std::string &location, + Error &error) { + Request new_req = req; + new_req.path = path; + new_req.redirect_count_ -= 1; + + if (res.status == StatusCode::SeeOther_303 && + (req.method != "GET" && req.method != "HEAD")) { + new_req.method = "GET"; + new_req.body.clear(); + new_req.headers.clear(); + } + + Response new_res; + + auto ret = cli.send(new_req, new_res, error); + if (ret) { + req = new_req; + res = new_res; + + if (res.location.empty()) { res.location = location; } + } + return ret; +} + +inline std::string params_to_query_str(const Params ¶ms) { + std::string query; + + for (auto it = params.begin(); it != params.end(); ++it) { + if (it != params.begin()) { query += "&"; } + query += it->first; + query += "="; + query += encode_query_param(it->second); + } + return query; +} + +inline void parse_query_text(const std::string &s, Params ¶ms) { + std::set cache; + split(s.data(), s.data() + s.size(), '&', [&](const char *b, const char *e) { + std::string kv(b, e); + if (cache.find(kv) != cache.end()) { return; } + cache.insert(kv); + + std::string key; + std::string val; + split(b, e, '=', [&](const char *b2, const char *e2) { + if (key.empty()) { + key.assign(b2, e2); + } else { + val.assign(b2, e2); + } + }); + + if (!key.empty()) { + params.emplace(decode_url(key, true), decode_url(val, true)); + } + }); +} + +inline bool parse_multipart_boundary(const std::string &content_type, + std::string &boundary) { + auto boundary_keyword = "boundary="; + auto pos = content_type.find(boundary_keyword); + if (pos == std::string::npos) { return false; } + auto end = content_type.find(';', pos); + auto beg = pos + strlen(boundary_keyword); + boundary = trim_double_quotes_copy(content_type.substr(beg, end - beg)); + return !boundary.empty(); +} + +inline void parse_disposition_params(const std::string &s, Params ¶ms) { + std::set cache; + split(s.data(), s.data() + s.size(), ';', [&](const char *b, const char *e) { + std::string kv(b, e); + if (cache.find(kv) != cache.end()) { return; } + cache.insert(kv); + + std::string key; + std::string val; + split(b, e, '=', [&](const char *b2, const char *e2) { + if (key.empty()) { + key.assign(b2, e2); + } else { + val.assign(b2, e2); + } + }); + + if (!key.empty()) { + params.emplace(trim_double_quotes_copy((key)), + trim_double_quotes_copy((val))); + } + }); +} + +#ifdef CPPHTTPLIB_NO_EXCEPTIONS +inline bool parse_range_header(const std::string &s, Ranges &ranges) { +#else +inline bool parse_range_header(const std::string &s, Ranges &ranges) try { +#endif + static auto re_first_range = std::regex(R"(bytes=(\d*-\d*(?:,\s*\d*-\d*)*))"); + std::smatch m; + if (std::regex_match(s, m, re_first_range)) { + auto pos = static_cast(m.position(1)); + auto len = static_cast(m.length(1)); + auto all_valid_ranges = true; + split(&s[pos], &s[pos + len], ',', [&](const char *b, const char *e) { + if (!all_valid_ranges) { return; } + static auto re_another_range = std::regex(R"(\s*(\d*)-(\d*))"); + std::cmatch cm; + if (std::regex_match(b, e, cm, re_another_range)) { + ssize_t first = -1; + if (!cm.str(1).empty()) { + first = static_cast(std::stoll(cm.str(1))); + } + + ssize_t last = -1; + if (!cm.str(2).empty()) { + last = static_cast(std::stoll(cm.str(2))); + } + + if (first != -1 && last != -1 && first > last) { + all_valid_ranges = false; + return; + } + ranges.emplace_back(std::make_pair(first, last)); + } + }); + return all_valid_ranges; + } + return false; +#ifdef CPPHTTPLIB_NO_EXCEPTIONS +} +#else +} catch (...) { return false; } +#endif + +class MultipartFormDataParser { +public: + MultipartFormDataParser() = default; + + void set_boundary(std::string &&boundary) { + boundary_ = boundary; + dash_boundary_crlf_ = dash_ + boundary_ + crlf_; + crlf_dash_boundary_ = crlf_ + dash_ + boundary_; + } + + bool is_valid() const { return is_valid_; } + + bool parse(const char *buf, size_t n, const ContentReceiver &content_callback, + const MultipartContentHeader &header_callback) { + + buf_append(buf, n); + + while (buf_size() > 0) { + switch (state_) { + case 0: { // Initial boundary + buf_erase(buf_find(dash_boundary_crlf_)); + if (dash_boundary_crlf_.size() > buf_size()) { return true; } + if (!buf_start_with(dash_boundary_crlf_)) { return false; } + buf_erase(dash_boundary_crlf_.size()); + state_ = 1; + break; + } + case 1: { // New entry + clear_file_info(); + state_ = 2; + break; + } + case 2: { // Headers + auto pos = buf_find(crlf_); + if (pos > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; } + while (pos < buf_size()) { + // Empty line + if (pos == 0) { + if (!header_callback(file_)) { + is_valid_ = false; + return false; + } + buf_erase(crlf_.size()); + state_ = 3; + break; + } + + const auto header = buf_head(pos); + + if (!parse_header(header.data(), header.data() + header.size(), + [&](std::string &&, std::string &&) {})) { + is_valid_ = false; + return false; + } + + static const std::string header_content_type = "Content-Type:"; + + if (start_with_case_ignore(header, header_content_type)) { + file_.content_type = + trim_copy(header.substr(header_content_type.size())); + } else { + static const std::regex re_content_disposition( + R"~(^Content-Disposition:\s*form-data;\s*(.*)$)~", + std::regex_constants::icase); + + std::smatch m; + if (std::regex_match(header, m, re_content_disposition)) { + Params params; + parse_disposition_params(m[1], params); + + auto it = params.find("name"); + if (it != params.end()) { + file_.name = it->second; + } else { + is_valid_ = false; + return false; + } + + it = params.find("filename"); + if (it != params.end()) { file_.filename = it->second; } + + it = params.find("filename*"); + if (it != params.end()) { + // Only allow UTF-8 enconnding... + static const std::regex re_rfc5987_encoding( + R"~(^UTF-8''(.+?)$)~", std::regex_constants::icase); + + std::smatch m2; + if (std::regex_match(it->second, m2, re_rfc5987_encoding)) { + file_.filename = decode_url(m2[1], false); // override... + } else { + is_valid_ = false; + return false; + } + } + } + } + buf_erase(pos + crlf_.size()); + pos = buf_find(crlf_); + } + if (state_ != 3) { return true; } + break; + } + case 3: { // Body + if (crlf_dash_boundary_.size() > buf_size()) { return true; } + auto pos = buf_find(crlf_dash_boundary_); + if (pos < buf_size()) { + if (!content_callback(buf_data(), pos)) { + is_valid_ = false; + return false; + } + buf_erase(pos + crlf_dash_boundary_.size()); + state_ = 4; + } else { + auto len = buf_size() - crlf_dash_boundary_.size(); + if (len > 0) { + if (!content_callback(buf_data(), len)) { + is_valid_ = false; + return false; + } + buf_erase(len); + } + return true; + } + break; + } + case 4: { // Boundary + if (crlf_.size() > buf_size()) { return true; } + if (buf_start_with(crlf_)) { + buf_erase(crlf_.size()); + state_ = 1; + } else { + if (dash_.size() > buf_size()) { return true; } + if (buf_start_with(dash_)) { + buf_erase(dash_.size()); + is_valid_ = true; + buf_erase(buf_size()); // Remove epilogue + } else { + return true; + } + } + break; + } + } + } + + return true; + } + +private: + void clear_file_info() { + file_.name.clear(); + file_.filename.clear(); + file_.content_type.clear(); + } + + bool start_with_case_ignore(const std::string &a, + const std::string &b) const { + if (a.size() < b.size()) { return false; } + for (size_t i = 0; i < b.size(); i++) { + if (::tolower(a[i]) != ::tolower(b[i])) { return false; } + } + return true; + } + + const std::string dash_ = "--"; + const std::string crlf_ = "\r\n"; + std::string boundary_; + std::string dash_boundary_crlf_; + std::string crlf_dash_boundary_; + + size_t state_ = 0; + bool is_valid_ = false; + MultipartFormData file_; + + // Buffer + bool start_with(const std::string &a, size_t spos, size_t epos, + const std::string &b) const { + if (epos - spos < b.size()) { return false; } + for (size_t i = 0; i < b.size(); i++) { + if (a[i + spos] != b[i]) { return false; } + } + return true; + } + + size_t buf_size() const { return buf_epos_ - buf_spos_; } + + const char *buf_data() const { return &buf_[buf_spos_]; } + + std::string buf_head(size_t l) const { return buf_.substr(buf_spos_, l); } + + bool buf_start_with(const std::string &s) const { + return start_with(buf_, buf_spos_, buf_epos_, s); + } + + size_t buf_find(const std::string &s) const { + auto c = s.front(); + + size_t off = buf_spos_; + while (off < buf_epos_) { + auto pos = off; + while (true) { + if (pos == buf_epos_) { return buf_size(); } + if (buf_[pos] == c) { break; } + pos++; + } + + auto remaining_size = buf_epos_ - pos; + if (s.size() > remaining_size) { return buf_size(); } + + if (start_with(buf_, pos, buf_epos_, s)) { return pos - buf_spos_; } + + off = pos + 1; + } + + return buf_size(); + } + + void buf_append(const char *data, size_t n) { + auto remaining_size = buf_size(); + if (remaining_size > 0 && buf_spos_ > 0) { + for (size_t i = 0; i < remaining_size; i++) { + buf_[i] = buf_[buf_spos_ + i]; + } + } + buf_spos_ = 0; + buf_epos_ = remaining_size; + + if (remaining_size + n > buf_.size()) { buf_.resize(remaining_size + n); } + + for (size_t i = 0; i < n; i++) { + buf_[buf_epos_ + i] = data[i]; + } + buf_epos_ += n; + } + + void buf_erase(size_t size) { buf_spos_ += size; } + + std::string buf_; + size_t buf_spos_ = 0; + size_t buf_epos_ = 0; +}; + +inline std::string to_lower(const char *beg, const char *end) { + std::string out; + auto it = beg; + while (it != end) { + out += static_cast(::tolower(*it)); + it++; + } + return out; +} + +inline std::string random_string(size_t length) { + static const char data[] = + "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + + // std::random_device might actually be deterministic on some + // platforms, but due to lack of support in the c++ standard library, + // doing better requires either some ugly hacks or breaking portability. + static std::random_device seed_gen; + + // Request 128 bits of entropy for initialization + static std::seed_seq seed_sequence{seed_gen(), seed_gen(), seed_gen(), + seed_gen()}; + + static std::mt19937 engine(seed_sequence); + + std::string result; + for (size_t i = 0; i < length; i++) { + result += data[engine() % (sizeof(data) - 1)]; + } + return result; +} + +inline std::string make_multipart_data_boundary() { + return "--cpp-httplib-multipart-data-" + detail::random_string(16); +} + +inline bool is_multipart_boundary_chars_valid(const std::string &boundary) { + auto valid = true; + for (size_t i = 0; i < boundary.size(); i++) { + auto c = boundary[i]; + if (!std::isalnum(c) && c != '-' && c != '_') { + valid = false; + break; + } + } + return valid; +} + +template +inline std::string +serialize_multipart_formdata_item_begin(const T &item, + const std::string &boundary) { + std::string body = "--" + boundary + "\r\n"; + body += "Content-Disposition: form-data; name=\"" + item.name + "\""; + if (!item.filename.empty()) { + body += "; filename=\"" + item.filename + "\""; + } + body += "\r\n"; + if (!item.content_type.empty()) { + body += "Content-Type: " + item.content_type + "\r\n"; + } + body += "\r\n"; + + return body; +} + +inline std::string serialize_multipart_formdata_item_end() { return "\r\n"; } + +inline std::string +serialize_multipart_formdata_finish(const std::string &boundary) { + return "--" + boundary + "--\r\n"; +} + +inline std::string +serialize_multipart_formdata_get_content_type(const std::string &boundary) { + return "multipart/form-data; boundary=" + boundary; +} + +inline std::string +serialize_multipart_formdata(const MultipartFormDataItems &items, + const std::string &boundary, bool finish = true) { + std::string body; + + for (const auto &item : items) { + body += serialize_multipart_formdata_item_begin(item, boundary); + body += item.content + serialize_multipart_formdata_item_end(); + } + + if (finish) { body += serialize_multipart_formdata_finish(boundary); } + + return body; +} + +inline bool range_error(Request &req, Response &res) { + if (!req.ranges.empty() && 200 <= res.status && res.status < 300) { + ssize_t contant_len = static_cast( + res.content_length_ ? res.content_length_ : res.body.size()); + + ssize_t prev_first_pos = -1; + ssize_t prev_last_pos = -1; + size_t overwrapping_count = 0; + + // NOTE: The following Range check is based on '14.2. Range' in RFC 9110 + // 'HTTP Semantics' to avoid potential denial-of-service attacks. + // https://www.rfc-editor.org/rfc/rfc9110#section-14.2 + + // Too many ranges + if (req.ranges.size() > CPPHTTPLIB_RANGE_MAX_COUNT) { return true; } + + for (auto &r : req.ranges) { + auto &first_pos = r.first; + auto &last_pos = r.second; + + if (first_pos == -1 && last_pos == -1) { + first_pos = 0; + last_pos = contant_len; + } + + if (first_pos == -1) { + first_pos = contant_len - last_pos; + last_pos = contant_len - 1; + } + + if (last_pos == -1) { last_pos = contant_len - 1; } + + // Range must be within content length + if (!(0 <= first_pos && first_pos <= last_pos && + last_pos <= contant_len - 1)) { + return true; + } + + // Ranges must be in ascending order + if (first_pos <= prev_first_pos) { return true; } + + // Request must not have more than two overlapping ranges + if (first_pos <= prev_last_pos) { + overwrapping_count++; + if (overwrapping_count > 2) { return true; } + } + + prev_first_pos = (std::max)(prev_first_pos, first_pos); + prev_last_pos = (std::max)(prev_last_pos, last_pos); + } + } + + return false; +} + +inline std::pair +get_range_offset_and_length(Range r, size_t content_length) { + (void)(content_length); // patch to get rid of "unused parameter" on release build + assert(r.first != -1 && r.second != -1); + assert(0 <= r.first && r.first < static_cast(content_length)); + assert(r.first <= r.second && + r.second < static_cast(content_length)); + + return std::make_pair(r.first, static_cast(r.second - r.first) + 1); +} + +inline std::string make_content_range_header_field( + const std::pair &offset_and_length, size_t content_length) { + auto st = offset_and_length.first; + auto ed = st + offset_and_length.second - 1; + + std::string field = "bytes "; + field += std::to_string(st); + field += "-"; + field += std::to_string(ed); + field += "/"; + field += std::to_string(content_length); + return field; +} + +template +bool process_multipart_ranges_data(const Request &req, + const std::string &boundary, + const std::string &content_type, + size_t content_length, SToken stoken, + CToken ctoken, Content content) { + for (size_t i = 0; i < req.ranges.size(); i++) { + ctoken("--"); + stoken(boundary); + ctoken("\r\n"); + if (!content_type.empty()) { + ctoken("Content-Type: "); + stoken(content_type); + ctoken("\r\n"); + } + + auto offset_and_length = + get_range_offset_and_length(req.ranges[i], content_length); + + ctoken("Content-Range: "); + stoken(make_content_range_header_field(offset_and_length, content_length)); + ctoken("\r\n"); + ctoken("\r\n"); + + if (!content(offset_and_length.first, offset_and_length.second)) { + return false; + } + ctoken("\r\n"); + } + + ctoken("--"); + stoken(boundary); + ctoken("--"); + + return true; +} + +inline void make_multipart_ranges_data(const Request &req, Response &res, + const std::string &boundary, + const std::string &content_type, + size_t content_length, + std::string &data) { + process_multipart_ranges_data( + req, boundary, content_type, content_length, + [&](const std::string &token) { data += token; }, + [&](const std::string &token) { data += token; }, + [&](size_t offset, size_t length) { + assert(offset + length <= content_length); + data += res.body.substr(offset, length); + return true; + }); +} + +inline size_t get_multipart_ranges_data_length(const Request &req, + const std::string &boundary, + const std::string &content_type, + size_t content_length) { + size_t data_length = 0; + + process_multipart_ranges_data( + req, boundary, content_type, content_length, + [&](const std::string &token) { data_length += token.size(); }, + [&](const std::string &token) { data_length += token.size(); }, + [&](size_t /*offset*/, size_t length) { + data_length += length; + return true; + }); + + return data_length; +} + +template +inline bool +write_multipart_ranges_data(Stream &strm, const Request &req, Response &res, + const std::string &boundary, + const std::string &content_type, + size_t content_length, const T &is_shutting_down) { + return process_multipart_ranges_data( + req, boundary, content_type, content_length, + [&](const std::string &token) { strm.write(token); }, + [&](const std::string &token) { strm.write(token); }, + [&](size_t offset, size_t length) { + return write_content(strm, res.content_provider_, offset, length, + is_shutting_down); + }); +} + +inline bool expect_content(const Request &req) { + if (req.method == "POST" || req.method == "PUT" || req.method == "PATCH" || + req.method == "PRI" || req.method == "DELETE") { + return true; + } + // TODO: check if Content-Length is set + return false; +} + +inline bool has_crlf(const std::string &s) { + auto p = s.c_str(); + while (*p) { + if (*p == '\r' || *p == '\n') { return true; } + p++; + } + return false; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline std::string message_digest(const std::string &s, const EVP_MD *algo) { + auto context = std::unique_ptr( + EVP_MD_CTX_new(), EVP_MD_CTX_free); + + unsigned int hash_length = 0; + unsigned char hash[EVP_MAX_MD_SIZE]; + + EVP_DigestInit_ex(context.get(), algo, nullptr); + EVP_DigestUpdate(context.get(), s.c_str(), s.size()); + EVP_DigestFinal_ex(context.get(), hash, &hash_length); + + std::stringstream ss; + for (auto i = 0u; i < hash_length; ++i) { + ss << std::hex << std::setw(2) << std::setfill('0') + << static_cast(hash[i]); + } + + return ss.str(); +} + +inline std::string MD5(const std::string &s) { + return message_digest(s, EVP_md5()); +} + +inline std::string SHA_256(const std::string &s) { + return message_digest(s, EVP_sha256()); +} + +inline std::string SHA_512(const std::string &s) { + return message_digest(s, EVP_sha512()); +} +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +#ifdef _WIN32 +// NOTE: This code came up with the following stackoverflow post: +// https://stackoverflow.com/questions/9507184/can-openssl-on-windows-use-the-system-certificate-store +inline bool load_system_certs_on_windows(X509_STORE *store) { + auto hStore = CertOpenSystemStoreW((HCRYPTPROV_LEGACY)NULL, L"ROOT"); + if (!hStore) { return false; } + + auto result = false; + PCCERT_CONTEXT pContext = NULL; + while ((pContext = CertEnumCertificatesInStore(hStore, pContext)) != + nullptr) { + auto encoded_cert = + static_cast(pContext->pbCertEncoded); + + auto x509 = d2i_X509(NULL, &encoded_cert, pContext->cbCertEncoded); + if (x509) { + X509_STORE_add_cert(store, x509); + X509_free(x509); + result = true; + } + } + + CertFreeCertificateContext(pContext); + CertCloseStore(hStore, 0); + + return result; +} +#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__) +#if TARGET_OS_OSX +template +using CFObjectPtr = + std::unique_ptr::type, void (*)(CFTypeRef)>; + +inline void cf_object_ptr_deleter(CFTypeRef obj) { + if (obj) { CFRelease(obj); } +} + +inline bool retrieve_certs_from_keychain(CFObjectPtr &certs) { + CFStringRef keys[] = {kSecClass, kSecMatchLimit, kSecReturnRef}; + CFTypeRef values[] = {kSecClassCertificate, kSecMatchLimitAll, + kCFBooleanTrue}; + + CFObjectPtr query( + CFDictionaryCreate(nullptr, reinterpret_cast(keys), values, + sizeof(keys) / sizeof(keys[0]), + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks), + cf_object_ptr_deleter); + + if (!query) { return false; } + + CFTypeRef security_items = nullptr; + if (SecItemCopyMatching(query.get(), &security_items) != errSecSuccess || + CFArrayGetTypeID() != CFGetTypeID(security_items)) { + return false; + } + + certs.reset(reinterpret_cast(security_items)); + return true; +} + +inline bool retrieve_root_certs_from_keychain(CFObjectPtr &certs) { + CFArrayRef root_security_items = nullptr; + if (SecTrustCopyAnchorCertificates(&root_security_items) != errSecSuccess) { + return false; + } + + certs.reset(root_security_items); + return true; +} + +inline bool add_certs_to_x509_store(CFArrayRef certs, X509_STORE *store) { + auto result = false; + for (auto i = 0; i < CFArrayGetCount(certs); ++i) { + const auto cert = reinterpret_cast( + CFArrayGetValueAtIndex(certs, i)); + + if (SecCertificateGetTypeID() != CFGetTypeID(cert)) { continue; } + + CFDataRef cert_data = nullptr; + if (SecItemExport(cert, kSecFormatX509Cert, 0, nullptr, &cert_data) != + errSecSuccess) { + continue; + } + + CFObjectPtr cert_data_ptr(cert_data, cf_object_ptr_deleter); + + auto encoded_cert = static_cast( + CFDataGetBytePtr(cert_data_ptr.get())); + + auto x509 = + d2i_X509(NULL, &encoded_cert, CFDataGetLength(cert_data_ptr.get())); + + if (x509) { + X509_STORE_add_cert(store, x509); + X509_free(x509); + result = true; + } + } + + return result; +} + +inline bool load_system_certs_on_macos(X509_STORE *store) { + auto result = false; + CFObjectPtr certs(nullptr, cf_object_ptr_deleter); + if (retrieve_certs_from_keychain(certs) && certs) { + result = add_certs_to_x509_store(certs.get(), store); + } + + if (retrieve_root_certs_from_keychain(certs) && certs) { + result = add_certs_to_x509_store(certs.get(), store) || result; + } + + return result; +} +#endif // TARGET_OS_OSX +#endif // _WIN32 +#endif // CPPHTTPLIB_OPENSSL_SUPPORT + +#ifdef _WIN32 +class WSInit { +public: + WSInit() { + WSADATA wsaData; + if (WSAStartup(0x0002, &wsaData) == 0) is_valid_ = true; + } + + ~WSInit() { + if (is_valid_) WSACleanup(); + } + + bool is_valid_ = false; +}; + +static WSInit wsinit_; +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline std::pair make_digest_authentication_header( + const Request &req, const std::map &auth, + size_t cnonce_count, const std::string &cnonce, const std::string &username, + const std::string &password, bool is_proxy = false) { + std::string nc; + { + std::stringstream ss; + ss << std::setfill('0') << std::setw(8) << std::hex << cnonce_count; + nc = ss.str(); + } + + std::string qop; + if (auth.find("qop") != auth.end()) { + qop = auth.at("qop"); + if (qop.find("auth-int") != std::string::npos) { + qop = "auth-int"; + } else if (qop.find("auth") != std::string::npos) { + qop = "auth"; + } else { + qop.clear(); + } + } + + std::string algo = "MD5"; + if (auth.find("algorithm") != auth.end()) { algo = auth.at("algorithm"); } + + std::string response; + { + auto H = algo == "SHA-256" ? detail::SHA_256 + : algo == "SHA-512" ? detail::SHA_512 + : detail::MD5; + + auto A1 = username + ":" + auth.at("realm") + ":" + password; + + auto A2 = req.method + ":" + req.path; + if (qop == "auth-int") { A2 += ":" + H(req.body); } + + if (qop.empty()) { + response = H(H(A1) + ":" + auth.at("nonce") + ":" + H(A2)); + } else { + response = H(H(A1) + ":" + auth.at("nonce") + ":" + nc + ":" + cnonce + + ":" + qop + ":" + H(A2)); + } + } + + auto opaque = (auth.find("opaque") != auth.end()) ? auth.at("opaque") : ""; + + auto field = "Digest username=\"" + username + "\", realm=\"" + + auth.at("realm") + "\", nonce=\"" + auth.at("nonce") + + "\", uri=\"" + req.path + "\", algorithm=" + algo + + (qop.empty() ? ", response=\"" + : ", qop=" + qop + ", nc=" + nc + ", cnonce=\"" + + cnonce + "\", response=\"") + + response + "\"" + + (opaque.empty() ? "" : ", opaque=\"" + opaque + "\""); + + auto key = is_proxy ? "Proxy-Authorization" : "Authorization"; + return std::make_pair(key, field); +} +#endif + +inline bool parse_www_authenticate(const Response &res, + std::map &auth, + bool is_proxy) { + auto auth_key = is_proxy ? "Proxy-Authenticate" : "WWW-Authenticate"; + if (res.has_header(auth_key)) { + static auto re = std::regex(R"~((?:(?:,\s*)?(.+?)=(?:"(.*?)"|([^,]*))))~"); + auto s = res.get_header_value(auth_key); + auto pos = s.find(' '); + if (pos != std::string::npos) { + auto type = s.substr(0, pos); + if (type == "Basic") { + return false; + } else if (type == "Digest") { + s = s.substr(pos + 1); + auto beg = std::sregex_iterator(s.begin(), s.end(), re); + for (auto i = beg; i != std::sregex_iterator(); ++i) { + const auto &m = *i; + auto key = s.substr(static_cast(m.position(1)), + static_cast(m.length(1))); + auto val = m.length(2) > 0 + ? s.substr(static_cast(m.position(2)), + static_cast(m.length(2))) + : s.substr(static_cast(m.position(3)), + static_cast(m.length(3))); + auth[key] = val; + } + return true; + } + } + } + return false; +} + +class ContentProviderAdapter { +public: + explicit ContentProviderAdapter( + ContentProviderWithoutLength &&content_provider) + : content_provider_(content_provider) {} + + bool operator()(size_t offset, size_t, DataSink &sink) { + return content_provider_(offset, sink); + } + +private: + ContentProviderWithoutLength content_provider_; +}; + +} // namespace detail + +inline std::string hosted_at(const std::string &hostname) { + std::vector addrs; + hosted_at(hostname, addrs); + if (addrs.empty()) { return std::string(); } + return addrs[0]; +} + +inline void hosted_at(const std::string &hostname, + std::vector &addrs) { + struct addrinfo hints; + struct addrinfo *result; + + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_protocol = 0; + + if (getaddrinfo(hostname.c_str(), nullptr, &hints, &result)) { +#if defined __linux__ && !defined __ANDROID__ + res_init(); +#endif + return; + } + + for (auto rp = result; rp; rp = rp->ai_next) { + const auto &addr = + *reinterpret_cast(rp->ai_addr); + std::string ip; + auto dummy = -1; + if (detail::get_ip_and_port(addr, sizeof(struct sockaddr_storage), ip, + dummy)) { + addrs.push_back(ip); + } + } + + freeaddrinfo(result); +} + +inline std::string append_query_params(const std::string &path, + const Params ¶ms) { + std::string path_with_query = path; + const static std::regex re("[^?]+\\?.*"); + auto delm = std::regex_match(path, re) ? '&' : '?'; + path_with_query += delm + detail::params_to_query_str(params); + return path_with_query; +} + +// Header utilities +inline std::pair +make_range_header(const Ranges &ranges) { + std::string field = "bytes="; + auto i = 0; + for (const auto &r : ranges) { + if (i != 0) { field += ", "; } + if (r.first != -1) { field += std::to_string(r.first); } + field += '-'; + if (r.second != -1) { field += std::to_string(r.second); } + i++; + } + return std::make_pair("Range", std::move(field)); +} + +inline std::pair +make_basic_authentication_header(const std::string &username, + const std::string &password, bool is_proxy) { + auto field = "Basic " + detail::base64_encode(username + ":" + password); + auto key = is_proxy ? "Proxy-Authorization" : "Authorization"; + return std::make_pair(key, std::move(field)); +} + +inline std::pair +make_bearer_token_authentication_header(const std::string &token, + bool is_proxy = false) { + auto field = "Bearer " + token; + auto key = is_proxy ? "Proxy-Authorization" : "Authorization"; + return std::make_pair(key, std::move(field)); +} + +// Request implementation +inline bool Request::has_header(const std::string &key) const { + return detail::has_header(headers, key); +} + +inline std::string Request::get_header_value(const std::string &key, + size_t id) const { + return detail::get_header_value(headers, key, id, ""); +} + +inline size_t Request::get_header_value_count(const std::string &key) const { + auto r = headers.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +inline void Request::set_header(const std::string &key, + const std::string &val) { + if (!detail::has_crlf(key) && !detail::has_crlf(val)) { + headers.emplace(key, val); + } +} + +inline bool Request::has_param(const std::string &key) const { + return params.find(key) != params.end(); +} + +inline std::string Request::get_param_value(const std::string &key, + size_t id) const { + auto rng = params.equal_range(key); + auto it = rng.first; + std::advance(it, static_cast(id)); + if (it != rng.second) { return it->second; } + return std::string(); +} + +inline size_t Request::get_param_value_count(const std::string &key) const { + auto r = params.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +inline bool Request::is_multipart_form_data() const { + const auto &content_type = get_header_value("Content-Type"); + return !content_type.rfind("multipart/form-data", 0); +} + +inline bool Request::has_file(const std::string &key) const { + return files.find(key) != files.end(); +} + +inline MultipartFormData Request::get_file_value(const std::string &key) const { + auto it = files.find(key); + if (it != files.end()) { return it->second; } + return MultipartFormData(); +} + +inline std::vector +Request::get_file_values(const std::string &key) const { + std::vector values; + auto rng = files.equal_range(key); + for (auto it = rng.first; it != rng.second; it++) { + values.push_back(it->second); + } + return values; +} + +// Response implementation +inline bool Response::has_header(const std::string &key) const { + return headers.find(key) != headers.end(); +} + +inline std::string Response::get_header_value(const std::string &key, + size_t id) const { + return detail::get_header_value(headers, key, id, ""); +} + +inline size_t Response::get_header_value_count(const std::string &key) const { + auto r = headers.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +inline void Response::set_header(const std::string &key, + const std::string &val) { + if (!detail::has_crlf(key) && !detail::has_crlf(val)) { + headers.emplace(key, val); + } +} + +inline void Response::set_redirect(const std::string &url, int stat) { + if (!detail::has_crlf(url)) { + set_header("Location", url); + if (300 <= stat && stat < 400) { + this->status = stat; + } else { + this->status = StatusCode::Found_302; + } + } +} + +inline void Response::set_content(const char *s, size_t n, + const std::string &content_type) { + body.assign(s, n); + + auto rng = headers.equal_range("Content-Type"); + headers.erase(rng.first, rng.second); + set_header("Content-Type", content_type); +} + +inline void Response::set_content(const std::string &s, + const std::string &content_type) { + set_content(s.data(), s.size(), content_type); +} + +inline void Response::set_content(std::string &&s, + const std::string &content_type) { + body = std::move(s); + + auto rng = headers.equal_range("Content-Type"); + headers.erase(rng.first, rng.second); + set_header("Content-Type", content_type); +} + +inline void Response::set_content_provider( + size_t in_length, const std::string &content_type, ContentProvider provider, + ContentProviderResourceReleaser resource_releaser) { + set_header("Content-Type", content_type); + content_length_ = in_length; + if (in_length > 0) { content_provider_ = std::move(provider); } + content_provider_resource_releaser_ = std::move(resource_releaser); + is_chunked_content_provider_ = false; +} + +inline void Response::set_content_provider( + const std::string &content_type, ContentProviderWithoutLength provider, + ContentProviderResourceReleaser resource_releaser) { + set_header("Content-Type", content_type); + content_length_ = 0; + content_provider_ = detail::ContentProviderAdapter(std::move(provider)); + content_provider_resource_releaser_ = std::move(resource_releaser); + is_chunked_content_provider_ = false; +} + +inline void Response::set_chunked_content_provider( + const std::string &content_type, ContentProviderWithoutLength provider, + ContentProviderResourceReleaser resource_releaser) { + set_header("Content-Type", content_type); + content_length_ = 0; + content_provider_ = detail::ContentProviderAdapter(std::move(provider)); + content_provider_resource_releaser_ = std::move(resource_releaser); + is_chunked_content_provider_ = true; +} + +// Result implementation +inline bool Result::has_request_header(const std::string &key) const { + return request_headers_.find(key) != request_headers_.end(); +} + +inline std::string Result::get_request_header_value(const std::string &key, + size_t id) const { + return detail::get_header_value(request_headers_, key, id, ""); +} + +inline size_t +Result::get_request_header_value_count(const std::string &key) const { + auto r = request_headers_.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +// Stream implementation +inline ssize_t Stream::write(const char *ptr) { + return write(ptr, strlen(ptr)); +} + +inline ssize_t Stream::write(const std::string &s) { + return write(s.data(), s.size()); +} + +namespace detail { + +// Socket stream implementation +inline SocketStream::SocketStream(socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec, + time_t write_timeout_sec, + time_t write_timeout_usec) + : sock_(sock), read_timeout_sec_(read_timeout_sec), + read_timeout_usec_(read_timeout_usec), + write_timeout_sec_(write_timeout_sec), + write_timeout_usec_(write_timeout_usec), read_buff_(read_buff_size_, 0) {} + +inline SocketStream::~SocketStream() = default; + +inline bool SocketStream::is_readable() const { + return select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0; +} + +inline bool SocketStream::is_writable() const { + return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 && + is_socket_alive(sock_); +} + +inline ssize_t SocketStream::read(char *ptr, size_t size) { +#ifdef _WIN32 + size = + (std::min)(size, static_cast((std::numeric_limits::max)())); +#else + size = (std::min)(size, + static_cast((std::numeric_limits::max)())); +#endif + + if (read_buff_off_ < read_buff_content_size_) { + auto remaining_size = read_buff_content_size_ - read_buff_off_; + if (size <= remaining_size) { + memcpy(ptr, read_buff_.data() + read_buff_off_, size); + read_buff_off_ += size; + return static_cast(size); + } else { + memcpy(ptr, read_buff_.data() + read_buff_off_, remaining_size); + read_buff_off_ += remaining_size; + return static_cast(remaining_size); + } + } + + if (!is_readable()) { return -1; } + + read_buff_off_ = 0; + read_buff_content_size_ = 0; + + if (size < read_buff_size_) { + auto n = read_socket(sock_, read_buff_.data(), read_buff_size_, + CPPHTTPLIB_RECV_FLAGS); + if (n <= 0) { + return n; + } else if (n <= static_cast(size)) { + memcpy(ptr, read_buff_.data(), static_cast(n)); + return n; + } else { + memcpy(ptr, read_buff_.data(), size); + read_buff_off_ = size; + read_buff_content_size_ = static_cast(n); + return static_cast(size); + } + } else { + return read_socket(sock_, ptr, size, CPPHTTPLIB_RECV_FLAGS); + } +} + +inline ssize_t SocketStream::write(const char *ptr, size_t size) { + if (!is_writable()) { return -1; } + +#if defined(_WIN32) && !defined(_WIN64) + size = + (std::min)(size, static_cast((std::numeric_limits::max)())); +#endif + + return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS); +} + +inline void SocketStream::get_remote_ip_and_port(std::string &ip, + int &port) const { + return detail::get_remote_ip_and_port(sock_, ip, port); +} + +inline void SocketStream::get_local_ip_and_port(std::string &ip, + int &port) const { + return detail::get_local_ip_and_port(sock_, ip, port); +} + +inline socket_t SocketStream::socket() const { return sock_; } + +// Buffer stream implementation +inline bool BufferStream::is_readable() const { return true; } + +inline bool BufferStream::is_writable() const { return true; } + +inline ssize_t BufferStream::read(char *ptr, size_t size) { +#if defined(_MSC_VER) && _MSC_VER < 1910 + auto len_read = buffer._Copy_s(ptr, size, size, position); +#else + auto len_read = buffer.copy(ptr, size, position); +#endif + position += static_cast(len_read); + return static_cast(len_read); +} + +inline ssize_t BufferStream::write(const char *ptr, size_t size) { + buffer.append(ptr, size); + return static_cast(size); +} + +inline void BufferStream::get_remote_ip_and_port(std::string & /*ip*/, + int & /*port*/) const {} + +inline void BufferStream::get_local_ip_and_port(std::string & /*ip*/, + int & /*port*/) const {} + +inline socket_t BufferStream::socket() const { return 0; } + +inline const std::string &BufferStream::get_buffer() const { return buffer; } + +inline PathParamsMatcher::PathParamsMatcher(const std::string &pattern) { + // One past the last ending position of a path param substring + std::size_t last_param_end = 0; + +#ifndef CPPHTTPLIB_NO_EXCEPTIONS + // Needed to ensure that parameter names are unique during matcher + // construction + // If exceptions are disabled, only last duplicate path + // parameter will be set + std::unordered_set param_name_set; +#endif + + while (true) { + const auto marker_pos = pattern.find(marker, last_param_end); + if (marker_pos == std::string::npos) { break; } + + static_fragments_.push_back( + pattern.substr(last_param_end, marker_pos - last_param_end)); + + const auto param_name_start = marker_pos + 1; + + auto sep_pos = pattern.find(separator, param_name_start); + if (sep_pos == std::string::npos) { sep_pos = pattern.length(); } + + auto param_name = + pattern.substr(param_name_start, sep_pos - param_name_start); + +#ifndef CPPHTTPLIB_NO_EXCEPTIONS + if (param_name_set.find(param_name) != param_name_set.cend()) { + std::string msg = "Encountered path parameter '" + param_name + + "' multiple times in route pattern '" + pattern + "'."; + throw std::invalid_argument(msg); + } +#endif + + param_names_.push_back(std::move(param_name)); + + last_param_end = sep_pos + 1; + } + + if (last_param_end < pattern.length()) { + static_fragments_.push_back(pattern.substr(last_param_end)); + } +} + +inline bool PathParamsMatcher::match(Request &request) const { + request.matches = std::smatch(); + request.path_params.clear(); + request.path_params.reserve(param_names_.size()); + + // One past the position at which the path matched the pattern last time + std::size_t starting_pos = 0; + for (size_t i = 0; i < static_fragments_.size(); ++i) { + const auto &fragment = static_fragments_[i]; + + if (starting_pos + fragment.length() > request.path.length()) { + return false; + } + + // Avoid unnecessary allocation by using strncmp instead of substr + + // comparison + if (std::strncmp(request.path.c_str() + starting_pos, fragment.c_str(), + fragment.length()) != 0) { + return false; + } + + starting_pos += fragment.length(); + + // Should only happen when we have a static fragment after a param + // Example: '/users/:id/subscriptions' + // The 'subscriptions' fragment here does not have a corresponding param + if (i >= param_names_.size()) { continue; } + + auto sep_pos = request.path.find(separator, starting_pos); + if (sep_pos == std::string::npos) { sep_pos = request.path.length(); } + + const auto ¶m_name = param_names_[i]; + + request.path_params.emplace( + param_name, request.path.substr(starting_pos, sep_pos - starting_pos)); + + // Mark everythin up to '/' as matched + starting_pos = sep_pos + 1; + } + // Returns false if the path is longer than the pattern + return starting_pos >= request.path.length(); +} + +inline bool RegexMatcher::match(Request &request) const { + request.path_params.clear(); + return std::regex_match(request.path, request.matches, regex_); +} + +} // namespace detail + +// HTTP server implementation +inline Server::Server() + : new_task_queue( + [] { return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT); }) { +#ifndef _WIN32 + signal(SIGPIPE, SIG_IGN); +#endif +} + +inline Server::~Server() = default; + +inline std::unique_ptr +Server::make_matcher(const std::string &pattern) { + if (pattern.find("/:") != std::string::npos) { + return detail::make_unique(pattern); + } else { + return detail::make_unique(pattern); + } +} + +inline Server &Server::Get(const std::string &pattern, Handler handler) { + get_handlers_.emplace_back(make_matcher(pattern), std::move(handler)); + return *this; +} + +inline Server &Server::Post(const std::string &pattern, Handler handler) { + post_handlers_.emplace_back(make_matcher(pattern), std::move(handler)); + return *this; +} + +inline Server &Server::Post(const std::string &pattern, + HandlerWithContentReader handler) { + post_handlers_for_content_reader_.emplace_back(make_matcher(pattern), + std::move(handler)); + return *this; +} + +inline Server &Server::Put(const std::string &pattern, Handler handler) { + put_handlers_.emplace_back(make_matcher(pattern), std::move(handler)); + return *this; +} + +inline Server &Server::Put(const std::string &pattern, + HandlerWithContentReader handler) { + put_handlers_for_content_reader_.emplace_back(make_matcher(pattern), + std::move(handler)); + return *this; +} + +inline Server &Server::Patch(const std::string &pattern, Handler handler) { + patch_handlers_.emplace_back(make_matcher(pattern), std::move(handler)); + return *this; +} + +inline Server &Server::Patch(const std::string &pattern, + HandlerWithContentReader handler) { + patch_handlers_for_content_reader_.emplace_back(make_matcher(pattern), + std::move(handler)); + return *this; +} + +inline Server &Server::Delete(const std::string &pattern, Handler handler) { + delete_handlers_.emplace_back(make_matcher(pattern), std::move(handler)); + return *this; +} + +inline Server &Server::Delete(const std::string &pattern, + HandlerWithContentReader handler) { + delete_handlers_for_content_reader_.emplace_back(make_matcher(pattern), + std::move(handler)); + return *this; +} + +inline Server &Server::Options(const std::string &pattern, Handler handler) { + options_handlers_.emplace_back(make_matcher(pattern), std::move(handler)); + return *this; +} + +inline bool Server::set_base_dir(const std::string &dir, + const std::string &mount_point) { + return set_mount_point(mount_point, dir); +} + +inline bool Server::set_mount_point(const std::string &mount_point, + const std::string &dir, Headers headers) { + if (detail::is_dir(dir)) { + std::string mnt = !mount_point.empty() ? mount_point : "/"; + if (!mnt.empty() && mnt[0] == '/') { + base_dirs_.push_back({mnt, dir, std::move(headers)}); + return true; + } + } + return false; +} + +inline bool Server::remove_mount_point(const std::string &mount_point) { + for (auto it = base_dirs_.begin(); it != base_dirs_.end(); ++it) { + if (it->mount_point == mount_point) { + base_dirs_.erase(it); + return true; + } + } + return false; +} + +inline Server & +Server::set_file_extension_and_mimetype_mapping(const std::string &ext, + const std::string &mime) { + file_extension_and_mimetype_map_[ext] = mime; + return *this; +} + +inline Server &Server::set_default_file_mimetype(const std::string &mime) { + default_file_mimetype_ = mime; + return *this; +} + +inline Server &Server::set_file_request_handler(Handler handler) { + file_request_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_error_handler(HandlerWithResponse handler) { + error_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_error_handler(Handler handler) { + error_handler_ = [handler](const Request &req, Response &res) { + handler(req, res); + return HandlerResponse::Handled; + }; + return *this; +} + +inline Server &Server::set_exception_handler(ExceptionHandler handler) { + exception_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_pre_routing_handler(HandlerWithResponse handler) { + pre_routing_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_post_routing_handler(Handler handler) { + post_routing_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_logger(Logger logger) { + logger_ = std::move(logger); + return *this; +} + +inline Server & +Server::set_expect_100_continue_handler(Expect100ContinueHandler handler) { + expect_100_continue_handler_ = std::move(handler); + return *this; +} + +inline Server &Server::set_address_family(int family) { + address_family_ = family; + return *this; +} + +inline Server &Server::set_tcp_nodelay(bool on) { + tcp_nodelay_ = on; + return *this; +} + +inline Server &Server::set_socket_options(SocketOptions socket_options) { + socket_options_ = std::move(socket_options); + return *this; +} + +inline Server &Server::set_default_headers(Headers headers) { + default_headers_ = std::move(headers); + return *this; +} + +inline Server &Server::set_header_writer( + std::function const &writer) { + header_writer_ = writer; + return *this; +} + +inline Server &Server::set_keep_alive_max_count(size_t count) { + keep_alive_max_count_ = count; + return *this; +} + +inline Server &Server::set_keep_alive_timeout(time_t sec) { + keep_alive_timeout_sec_ = sec; + return *this; +} + +inline Server &Server::set_read_timeout(time_t sec, time_t usec) { + read_timeout_sec_ = sec; + read_timeout_usec_ = usec; + return *this; +} + +inline Server &Server::set_write_timeout(time_t sec, time_t usec) { + write_timeout_sec_ = sec; + write_timeout_usec_ = usec; + return *this; +} + +inline Server &Server::set_idle_interval(time_t sec, time_t usec) { + idle_interval_sec_ = sec; + idle_interval_usec_ = usec; + return *this; +} + +inline Server &Server::set_payload_max_length(size_t length) { + payload_max_length_ = length; + return *this; +} + +inline bool Server::bind_to_port(const std::string &host, int port, + int socket_flags) { + return bind_internal(host, port, socket_flags) >= 0; +} +inline int Server::bind_to_any_port(const std::string &host, int socket_flags) { + return bind_internal(host, 0, socket_flags); +} + +inline bool Server::listen_after_bind() { + auto se = detail::scope_exit([&]() { done_ = true; }); + return listen_internal(); +} + +inline bool Server::listen(const std::string &host, int port, + int socket_flags) { + auto se = detail::scope_exit([&]() { done_ = true; }); + return bind_to_port(host, port, socket_flags) && listen_internal(); +} + +inline bool Server::is_running() const { return is_running_; } + +inline void Server::wait_until_ready() const { + while (!is_running() && !done_) { + std::this_thread::sleep_for(std::chrono::milliseconds{1}); + } +} + +inline void Server::stop() { + if (is_running_) { + assert(svr_sock_ != INVALID_SOCKET); + std::atomic sock(svr_sock_.exchange(INVALID_SOCKET)); + detail::shutdown_socket(sock); + detail::close_socket(sock); + } +} + +inline bool Server::parse_request_line(const char *s, Request &req) const { + auto len = strlen(s); + if (len < 2 || s[len - 2] != '\r' || s[len - 1] != '\n') { return false; } + len -= 2; + + { + size_t count = 0; + + detail::split(s, s + len, ' ', [&](const char *b, const char *e) { + switch (count) { + case 0: req.method = std::string(b, e); break; + case 1: req.target = std::string(b, e); break; + case 2: req.version = std::string(b, e); break; + default: break; + } + count++; + }); + + if (count != 3) { return false; } + } + + static const std::set methods{ + "GET", "HEAD", "POST", "PUT", "DELETE", + "CONNECT", "OPTIONS", "TRACE", "PATCH", "PRI"}; + + if (methods.find(req.method) == methods.end()) { return false; } + + if (req.version != "HTTP/1.1" && req.version != "HTTP/1.0") { return false; } + + { + // Skip URL fragment + for (size_t i = 0; i < req.target.size(); i++) { + if (req.target[i] == '#') { + req.target.erase(i); + break; + } + } + + size_t count = 0; + + detail::split(req.target.data(), req.target.data() + req.target.size(), '?', + 2, [&](const char *b, const char *e) { + switch (count) { + case 0: + req.path = detail::decode_url(std::string(b, e), false); + break; + case 1: { + if (e - b > 0) { + detail::parse_query_text(std::string(b, e), req.params); + } + break; + } + default: break; + } + count++; + }); + + if (count > 2) { return false; } + } + + return true; +} + +inline bool Server::write_response(Stream &strm, bool close_connection, + Request &req, Response &res) { + // NOTE: `req.ranges` should be empty, otherwise it will be applied + // incorrectly to the error content. + req.ranges.clear(); + return write_response_core(strm, close_connection, req, res, false); +} + +inline bool Server::write_response_with_content(Stream &strm, + bool close_connection, + const Request &req, + Response &res) { + return write_response_core(strm, close_connection, req, res, true); +} + +inline bool Server::write_response_core(Stream &strm, bool close_connection, + const Request &req, Response &res, + bool need_apply_ranges) { + assert(res.status != -1); + + if (400 <= res.status && error_handler_ && + error_handler_(req, res) == HandlerResponse::Handled) { + need_apply_ranges = true; + } + + std::string content_type; + std::string boundary; + if (need_apply_ranges) { apply_ranges(req, res, content_type, boundary); } + + // Prepare additional headers + if (close_connection || req.get_header_value("Connection") == "close") { + res.set_header("Connection", "close"); + } else { + std::stringstream ss; + ss << "timeout=" << keep_alive_timeout_sec_ + << ", max=" << keep_alive_max_count_; + res.set_header("Keep-Alive", ss.str()); + } + + if (!res.has_header("Content-Type") && + (!res.body.empty() || res.content_length_ > 0 || res.content_provider_)) { + res.set_header("Content-Type", "text/plain"); + } + + if (!res.has_header("Content-Length") && res.body.empty() && + !res.content_length_ && !res.content_provider_) { + res.set_header("Content-Length", "0"); + } + + if (!res.has_header("Accept-Ranges") && req.method == "HEAD") { + res.set_header("Accept-Ranges", "bytes"); + } + + if (post_routing_handler_) { post_routing_handler_(req, res); } + + // Response line and headers + { + detail::BufferStream bstrm; + + if (!bstrm.write_format("HTTP/1.1 %d %s\r\n", res.status, + status_message(res.status))) { + return false; + } + + if (!header_writer_(bstrm, res.headers)) { return false; } + + // Flush buffer + auto &data = bstrm.get_buffer(); + detail::write_data(strm, data.data(), data.size()); + } + + // Body + auto ret = true; + if (req.method != "HEAD") { + if (!res.body.empty()) { + if (!detail::write_data(strm, res.body.data(), res.body.size())) { + ret = false; + } + } else if (res.content_provider_) { + if (write_content_with_provider(strm, req, res, boundary, content_type)) { + res.content_provider_success_ = true; + } else { + ret = false; + } + } + } + + // Log + if (logger_) { logger_(req, res); } + + return ret; +} + +inline bool +Server::write_content_with_provider(Stream &strm, const Request &req, + Response &res, const std::string &boundary, + const std::string &content_type) { + auto is_shutting_down = [this]() { + return this->svr_sock_ == INVALID_SOCKET; + }; + + if (res.content_length_ > 0) { + if (req.ranges.empty()) { + return detail::write_content(strm, res.content_provider_, 0, + res.content_length_, is_shutting_down); + } else if (req.ranges.size() == 1) { + auto offset_and_length = detail::get_range_offset_and_length( + req.ranges[0], res.content_length_); + + return detail::write_content(strm, res.content_provider_, + offset_and_length.first, + offset_and_length.second, is_shutting_down); + } else { + return detail::write_multipart_ranges_data( + strm, req, res, boundary, content_type, res.content_length_, + is_shutting_down); + } + } else { + if (res.is_chunked_content_provider_) { + auto type = detail::encoding_type(req, res); + + std::unique_ptr compressor; + if (type == detail::EncodingType::Gzip) { +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + compressor = detail::make_unique(); +#endif + } else if (type == detail::EncodingType::Brotli) { +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + compressor = detail::make_unique(); +#endif + } else { + compressor = detail::make_unique(); + } + assert(compressor != nullptr); + + return detail::write_content_chunked(strm, res.content_provider_, + is_shutting_down, *compressor); + } else { + return detail::write_content_without_length(strm, res.content_provider_, + is_shutting_down); + } + } +} + +inline bool Server::read_content(Stream &strm, Request &req, Response &res) { + MultipartFormDataMap::iterator cur; + auto file_count = 0; + if (read_content_core( + strm, req, res, + // Regular + [&](const char *buf, size_t n) { + if (req.body.size() + n > req.body.max_size()) { return false; } + req.body.append(buf, n); + return true; + }, + // Multipart + [&](const MultipartFormData &file) { + if (file_count++ == CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT) { + return false; + } + cur = req.files.emplace(file.name, file); + return true; + }, + [&](const char *buf, size_t n) { + auto &content = cur->second.content; + if (content.size() + n > content.max_size()) { return false; } + content.append(buf, n); + return true; + })) { + const auto &content_type = req.get_header_value("Content-Type"); + if (!content_type.find("application/x-www-form-urlencoded")) { + if (req.body.size() > CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH) { + res.status = StatusCode::PayloadTooLarge_413; // NOTE: should be 414? + return false; + } + detail::parse_query_text(req.body, req.params); + } + return true; + } + return false; +} + +inline bool Server::read_content_with_content_receiver( + Stream &strm, Request &req, Response &res, ContentReceiver receiver, + MultipartContentHeader multipart_header, + ContentReceiver multipart_receiver) { + return read_content_core(strm, req, res, std::move(receiver), + std::move(multipart_header), + std::move(multipart_receiver)); +} + +inline bool +Server::read_content_core(Stream &strm, Request &req, Response &res, + ContentReceiver receiver, + MultipartContentHeader multipart_header, + ContentReceiver multipart_receiver) const { + detail::MultipartFormDataParser multipart_form_data_parser; + ContentReceiverWithProgress out; + + if (req.is_multipart_form_data()) { + const auto &content_type = req.get_header_value("Content-Type"); + std::string boundary; + if (!detail::parse_multipart_boundary(content_type, boundary)) { + res.status = StatusCode::BadRequest_400; + return false; + } + + multipart_form_data_parser.set_boundary(std::move(boundary)); + out = [&](const char *buf, size_t n, uint64_t /*off*/, uint64_t /*len*/) { + /* For debug + size_t pos = 0; + while (pos < n) { + auto read_size = (std::min)(1, n - pos); + auto ret = multipart_form_data_parser.parse( + buf + pos, read_size, multipart_receiver, multipart_header); + if (!ret) { return false; } + pos += read_size; + } + return true; + */ + return multipart_form_data_parser.parse(buf, n, multipart_receiver, + multipart_header); + }; + } else { + out = [receiver](const char *buf, size_t n, uint64_t /*off*/, + uint64_t /*len*/) { return receiver(buf, n); }; + } + + if (req.method == "DELETE" && !req.has_header("Content-Length")) { + return true; + } + + if (!detail::read_content(strm, req, payload_max_length_, res.status, nullptr, + out, true)) { + return false; + } + + if (req.is_multipart_form_data()) { + if (!multipart_form_data_parser.is_valid()) { + res.status = StatusCode::BadRequest_400; + return false; + } + } + + return true; +} + +inline bool Server::handle_file_request(const Request &req, Response &res, + bool head) { + for (const auto &entry : base_dirs_) { + // Prefix match + if (!req.path.compare(0, entry.mount_point.size(), entry.mount_point)) { + std::string sub_path = "/" + req.path.substr(entry.mount_point.size()); + if (detail::is_valid_path(sub_path)) { + auto path = entry.base_dir + sub_path; + if (path.back() == '/') { path += "index.html"; } + + if (detail::is_file(path)) { + for (const auto &kv : entry.headers) { + res.set_header(kv.first, kv.second); + } + + auto mm = std::make_shared(path.c_str()); + if (!mm->is_open()) { return false; } + + res.set_content_provider( + mm->size(), + detail::find_content_type(path, file_extension_and_mimetype_map_, + default_file_mimetype_), + [mm](size_t offset, size_t length, DataSink &sink) -> bool { + sink.write(mm->data() + offset, length); + return true; + }); + + if (!head && file_request_handler_) { + file_request_handler_(req, res); + } + + return true; + } + } + } + } + return false; +} + +inline socket_t +Server::create_server_socket(const std::string &host, int port, + int socket_flags, + SocketOptions socket_options) const { + return detail::create_socket( + host, std::string(), port, address_family_, socket_flags, tcp_nodelay_, + std::move(socket_options), + [](socket_t sock, struct addrinfo &ai) -> bool { + if (::bind(sock, ai.ai_addr, static_cast(ai.ai_addrlen))) { + return false; + } + if (::listen(sock, CPPHTTPLIB_LISTEN_BACKLOG)) { return false; } + return true; + }); +} + +inline int Server::bind_internal(const std::string &host, int port, + int socket_flags) { + if (!is_valid()) { return -1; } + + svr_sock_ = create_server_socket(host, port, socket_flags, socket_options_); + if (svr_sock_ == INVALID_SOCKET) { return -1; } + + if (port == 0) { + struct sockaddr_storage addr; + socklen_t addr_len = sizeof(addr); + if (getsockname(svr_sock_, reinterpret_cast(&addr), + &addr_len) == -1) { + return -1; + } + if (addr.ss_family == AF_INET) { + return ntohs(reinterpret_cast(&addr)->sin_port); + } else if (addr.ss_family == AF_INET6) { + return ntohs(reinterpret_cast(&addr)->sin6_port); + } else { + return -1; + } + } else { + return port; + } +} + +inline bool Server::listen_internal() { + auto ret = true; + is_running_ = true; + auto se = detail::scope_exit([&]() { is_running_ = false; }); + + { + std::unique_ptr task_queue(new_task_queue()); + + while (svr_sock_ != INVALID_SOCKET) { +#ifndef _WIN32 + if (idle_interval_sec_ > 0 || idle_interval_usec_ > 0) { +#endif + auto val = detail::select_read(svr_sock_, idle_interval_sec_, + idle_interval_usec_); + if (val == 0) { // Timeout + task_queue->on_idle(); + continue; + } +#ifndef _WIN32 + } +#endif + socket_t sock = accept(svr_sock_, nullptr, nullptr); + + if (sock == INVALID_SOCKET) { + if (errno == EMFILE) { + // The per-process limit of open file descriptors has been reached. + // Try to accept new connections after a short sleep. + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + continue; + } else if (errno == EINTR || errno == EAGAIN) { + continue; + } + if (svr_sock_ != INVALID_SOCKET) { + detail::close_socket(svr_sock_); + ret = false; + } else { + ; // The server socket was closed by user. + } + break; + } + + { +#ifdef _WIN32 + auto timeout = static_cast(read_timeout_sec_ * 1000 + + read_timeout_usec_ / 1000); + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, + reinterpret_cast(&timeout), sizeof(timeout)); +#else + timeval tv; + tv.tv_sec = static_cast(read_timeout_sec_); + tv.tv_usec = static_cast(read_timeout_usec_); + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, + reinterpret_cast(&tv), sizeof(tv)); +#endif + } + { + +#ifdef _WIN32 + auto timeout = static_cast(write_timeout_sec_ * 1000 + + write_timeout_usec_ / 1000); + setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, + reinterpret_cast(&timeout), sizeof(timeout)); +#else + timeval tv; + tv.tv_sec = static_cast(write_timeout_sec_); + tv.tv_usec = static_cast(write_timeout_usec_); + setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, + reinterpret_cast(&tv), sizeof(tv)); +#endif + } + + if (!task_queue->enqueue( + [this, sock]() { process_and_close_socket(sock); })) { + detail::shutdown_socket(sock); + detail::close_socket(sock); + } + } + + task_queue->shutdown(); + } + + return ret; +} + +inline bool Server::routing(Request &req, Response &res, Stream &strm) { + if (pre_routing_handler_ && + pre_routing_handler_(req, res) == HandlerResponse::Handled) { + return true; + } + + // File handler + auto is_head_request = req.method == "HEAD"; + if ((req.method == "GET" || is_head_request) && + handle_file_request(req, res, is_head_request)) { + return true; + } + + if (detail::expect_content(req)) { + // Content reader handler + { + ContentReader reader( + [&](ContentReceiver receiver) { + return read_content_with_content_receiver( + strm, req, res, std::move(receiver), nullptr, nullptr); + }, + [&](MultipartContentHeader header, ContentReceiver receiver) { + return read_content_with_content_receiver(strm, req, res, nullptr, + std::move(header), + std::move(receiver)); + }); + + if (req.method == "POST") { + if (dispatch_request_for_content_reader( + req, res, std::move(reader), + post_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "PUT") { + if (dispatch_request_for_content_reader( + req, res, std::move(reader), + put_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "PATCH") { + if (dispatch_request_for_content_reader( + req, res, std::move(reader), + patch_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "DELETE") { + if (dispatch_request_for_content_reader( + req, res, std::move(reader), + delete_handlers_for_content_reader_)) { + return true; + } + } + } + + // Read content into `req.body` + if (!read_content(strm, req, res)) { return false; } + } + + // Regular handler + if (req.method == "GET" || req.method == "HEAD") { + return dispatch_request(req, res, get_handlers_); + } else if (req.method == "POST") { + return dispatch_request(req, res, post_handlers_); + } else if (req.method == "PUT") { + return dispatch_request(req, res, put_handlers_); + } else if (req.method == "DELETE") { + return dispatch_request(req, res, delete_handlers_); + } else if (req.method == "OPTIONS") { + return dispatch_request(req, res, options_handlers_); + } else if (req.method == "PATCH") { + return dispatch_request(req, res, patch_handlers_); + } + + res.status = StatusCode::BadRequest_400; + return false; +} + +inline bool Server::dispatch_request(Request &req, Response &res, + const Handlers &handlers) const { + for (const auto &x : handlers) { + const auto &matcher = x.first; + const auto &handler = x.second; + + if (matcher->match(req)) { + handler(req, res); + return true; + } + } + return false; +} + +inline void Server::apply_ranges(const Request &req, Response &res, + std::string &content_type, + std::string &boundary) const { + if (req.ranges.size() > 1) { + auto it = res.headers.find("Content-Type"); + if (it != res.headers.end()) { + content_type = it->second; + res.headers.erase(it); + } + + boundary = detail::make_multipart_data_boundary(); + + res.set_header("Content-Type", + "multipart/byteranges; boundary=" + boundary); + } + + auto type = detail::encoding_type(req, res); + + if (res.body.empty()) { + if (res.content_length_ > 0) { + size_t length = 0; + if (req.ranges.empty()) { + length = res.content_length_; + } else if (req.ranges.size() == 1) { + auto offset_and_length = detail::get_range_offset_and_length( + req.ranges[0], res.content_length_); + + length = offset_and_length.second; + + auto content_range = detail::make_content_range_header_field( + offset_and_length, res.content_length_); + res.set_header("Content-Range", content_range); + } else { + length = detail::get_multipart_ranges_data_length( + req, boundary, content_type, res.content_length_); + } + res.set_header("Content-Length", std::to_string(length)); + } else { + if (res.content_provider_) { + if (res.is_chunked_content_provider_) { + res.set_header("Transfer-Encoding", "chunked"); + if (type == detail::EncodingType::Gzip) { + res.set_header("Content-Encoding", "gzip"); + } else if (type == detail::EncodingType::Brotli) { + res.set_header("Content-Encoding", "br"); + } + } + } + } + } else { + if (req.ranges.empty()) { + ; + } else if (req.ranges.size() == 1) { + auto offset_and_length = + detail::get_range_offset_and_length(req.ranges[0], res.body.size()); + auto offset = offset_and_length.first; + auto length = offset_and_length.second; + + auto content_range = detail::make_content_range_header_field( + offset_and_length, res.body.size()); + res.set_header("Content-Range", content_range); + + assert(offset + length <= res.body.size()); + res.body = res.body.substr(offset, length); + } else { + std::string data; + detail::make_multipart_ranges_data(req, res, boundary, content_type, + res.body.size(), data); + res.body.swap(data); + } + + if (type != detail::EncodingType::None) { + std::unique_ptr compressor; + std::string content_encoding; + + if (type == detail::EncodingType::Gzip) { +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + compressor = detail::make_unique(); + content_encoding = "gzip"; +#endif + } else if (type == detail::EncodingType::Brotli) { +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + compressor = detail::make_unique(); + content_encoding = "br"; +#endif + } + + if (compressor) { + std::string compressed; + if (compressor->compress(res.body.data(), res.body.size(), true, + [&](const char *data, size_t data_len) { + compressed.append(data, data_len); + return true; + })) { + res.body.swap(compressed); + res.set_header("Content-Encoding", content_encoding); + } + } + } + + auto length = std::to_string(res.body.size()); + res.set_header("Content-Length", length); + } +} + +inline bool Server::dispatch_request_for_content_reader( + Request &req, Response &res, ContentReader content_reader, + const HandlersForContentReader &handlers) const { + for (const auto &x : handlers) { + const auto &matcher = x.first; + const auto &handler = x.second; + + if (matcher->match(req)) { + handler(req, res, content_reader); + return true; + } + } + return false; +} + +inline bool +Server::process_request(Stream &strm, bool close_connection, + bool &connection_closed, + const std::function &setup_request) { + std::array buf{}; + + detail::stream_line_reader line_reader(strm, buf.data(), buf.size()); + + // Connection has been closed on client + if (!line_reader.getline()) { return false; } + + Request req; + + Response res; + res.version = "HTTP/1.1"; + res.headers = default_headers_; + +#ifdef _WIN32 + // TODO: Increase FD_SETSIZE statically (libzmq), dynamically (MySQL). +#else +#ifndef CPPHTTPLIB_USE_POLL + // Socket file descriptor exceeded FD_SETSIZE... + if (strm.socket() >= FD_SETSIZE) { + Headers dummy; + detail::read_headers(strm, dummy); + res.status = StatusCode::InternalServerError_500; + return write_response(strm, close_connection, req, res); + } +#endif +#endif + + // Check if the request URI doesn't exceed the limit + if (line_reader.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) { + Headers dummy; + detail::read_headers(strm, dummy); + res.status = StatusCode::UriTooLong_414; + return write_response(strm, close_connection, req, res); + } + + // Request line and headers + if (!parse_request_line(line_reader.ptr(), req) || + !detail::read_headers(strm, req.headers)) { + res.status = StatusCode::BadRequest_400; + return write_response(strm, close_connection, req, res); + } + + if (req.get_header_value("Connection") == "close") { + connection_closed = true; + } + + if (req.version == "HTTP/1.0" && + req.get_header_value("Connection") != "Keep-Alive") { + connection_closed = true; + } + + strm.get_remote_ip_and_port(req.remote_addr, req.remote_port); + req.set_header("REMOTE_ADDR", req.remote_addr); + req.set_header("REMOTE_PORT", std::to_string(req.remote_port)); + + strm.get_local_ip_and_port(req.local_addr, req.local_port); + req.set_header("LOCAL_ADDR", req.local_addr); + req.set_header("LOCAL_PORT", std::to_string(req.local_port)); + + if (req.has_header("Range")) { + const auto &range_header_value = req.get_header_value("Range"); + if (!detail::parse_range_header(range_header_value, req.ranges)) { + res.status = StatusCode::RangeNotSatisfiable_416; + return write_response(strm, close_connection, req, res); + } + } + + if (setup_request) { setup_request(req); } + + if (req.get_header_value("Expect") == "100-continue") { + int status = StatusCode::Continue_100; + if (expect_100_continue_handler_) { + status = expect_100_continue_handler_(req, res); + } + switch (status) { + case StatusCode::Continue_100: + case StatusCode::ExpectationFailed_417: + strm.write_format("HTTP/1.1 %d %s\r\n\r\n", status, + status_message(status)); + break; + default: return write_response(strm, close_connection, req, res); + } + } + + // Routing + auto routed = false; +#ifdef CPPHTTPLIB_NO_EXCEPTIONS + routed = routing(req, res, strm); +#else + try { + routed = routing(req, res, strm); + } catch (std::exception &e) { + if (exception_handler_) { + auto ep = std::current_exception(); + exception_handler_(req, res, ep); + routed = true; + } else { + res.status = StatusCode::InternalServerError_500; + std::string val; + auto s = e.what(); + for (size_t i = 0; s[i]; i++) { + switch (s[i]) { + case '\r': val += "\\r"; break; + case '\n': val += "\\n"; break; + default: val += s[i]; break; + } + } + res.set_header("EXCEPTION_WHAT", val); + } + } catch (...) { + if (exception_handler_) { + auto ep = std::current_exception(); + exception_handler_(req, res, ep); + routed = true; + } else { + res.status = StatusCode::InternalServerError_500; + res.set_header("EXCEPTION_WHAT", "UNKNOWN"); + } + } +#endif + if (routed) { + if (res.status == -1) { + res.status = req.ranges.empty() ? StatusCode::OK_200 + : StatusCode::PartialContent_206; + } + + if (detail::range_error(req, res)) { + res.body.clear(); + res.content_length_ = 0; + res.content_provider_ = nullptr; + res.status = StatusCode::RangeNotSatisfiable_416; + return write_response(strm, close_connection, req, res); + } + + return write_response_with_content(strm, close_connection, req, res); + } else { + if (res.status == -1) { res.status = StatusCode::NotFound_404; } + + return write_response(strm, close_connection, req, res); + } +} + +inline bool Server::is_valid() const { return true; } + +inline bool Server::process_and_close_socket(socket_t sock) { + auto ret = detail::process_server_socket( + svr_sock_, sock, keep_alive_max_count_, keep_alive_timeout_sec_, + read_timeout_sec_, read_timeout_usec_, write_timeout_sec_, + write_timeout_usec_, + [this](Stream &strm, bool close_connection, bool &connection_closed) { + return process_request(strm, close_connection, connection_closed, + nullptr); + }); + + detail::shutdown_socket(sock); + detail::close_socket(sock); + return ret; +} + +// HTTP client implementation +inline ClientImpl::ClientImpl(const std::string &host) + : ClientImpl(host, 80, std::string(), std::string()) {} + +inline ClientImpl::ClientImpl(const std::string &host, int port) + : ClientImpl(host, port, std::string(), std::string()) {} + +inline ClientImpl::ClientImpl(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path) + : host_(host), port_(port), + host_and_port_(adjust_host_string(host) + ":" + std::to_string(port)), + client_cert_path_(client_cert_path), client_key_path_(client_key_path) {} + +inline ClientImpl::~ClientImpl() { + std::lock_guard guard(socket_mutex_); + shutdown_socket(socket_); + close_socket(socket_); +} + +inline bool ClientImpl::is_valid() const { return true; } + +inline void ClientImpl::copy_settings(const ClientImpl &rhs) { + client_cert_path_ = rhs.client_cert_path_; + client_key_path_ = rhs.client_key_path_; + connection_timeout_sec_ = rhs.connection_timeout_sec_; + read_timeout_sec_ = rhs.read_timeout_sec_; + read_timeout_usec_ = rhs.read_timeout_usec_; + write_timeout_sec_ = rhs.write_timeout_sec_; + write_timeout_usec_ = rhs.write_timeout_usec_; + basic_auth_username_ = rhs.basic_auth_username_; + basic_auth_password_ = rhs.basic_auth_password_; + bearer_token_auth_token_ = rhs.bearer_token_auth_token_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + digest_auth_username_ = rhs.digest_auth_username_; + digest_auth_password_ = rhs.digest_auth_password_; +#endif + keep_alive_ = rhs.keep_alive_; + follow_location_ = rhs.follow_location_; + url_encode_ = rhs.url_encode_; + address_family_ = rhs.address_family_; + tcp_nodelay_ = rhs.tcp_nodelay_; + socket_options_ = rhs.socket_options_; + compress_ = rhs.compress_; + decompress_ = rhs.decompress_; + interface_ = rhs.interface_; + proxy_host_ = rhs.proxy_host_; + proxy_port_ = rhs.proxy_port_; + proxy_basic_auth_username_ = rhs.proxy_basic_auth_username_; + proxy_basic_auth_password_ = rhs.proxy_basic_auth_password_; + proxy_bearer_token_auth_token_ = rhs.proxy_bearer_token_auth_token_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + proxy_digest_auth_username_ = rhs.proxy_digest_auth_username_; + proxy_digest_auth_password_ = rhs.proxy_digest_auth_password_; +#endif +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + ca_cert_file_path_ = rhs.ca_cert_file_path_; + ca_cert_dir_path_ = rhs.ca_cert_dir_path_; + ca_cert_store_ = rhs.ca_cert_store_; +#endif +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + server_certificate_verification_ = rhs.server_certificate_verification_; +#endif + logger_ = rhs.logger_; +} + +inline socket_t ClientImpl::create_client_socket(Error &error) const { + if (!proxy_host_.empty() && proxy_port_ != -1) { + return detail::create_client_socket( + proxy_host_, std::string(), proxy_port_, address_family_, tcp_nodelay_, + socket_options_, connection_timeout_sec_, connection_timeout_usec_, + read_timeout_sec_, read_timeout_usec_, write_timeout_sec_, + write_timeout_usec_, interface_, error); + } + + // Check is custom IP specified for host_ + std::string ip; + auto it = addr_map_.find(host_); + if (it != addr_map_.end()) { ip = it->second; } + + return detail::create_client_socket( + host_, ip, port_, address_family_, tcp_nodelay_, socket_options_, + connection_timeout_sec_, connection_timeout_usec_, read_timeout_sec_, + read_timeout_usec_, write_timeout_sec_, write_timeout_usec_, interface_, + error); +} + +inline bool ClientImpl::create_and_connect_socket(Socket &socket, + Error &error) { + auto sock = create_client_socket(error); + if (sock == INVALID_SOCKET) { return false; } + socket.sock = sock; + return true; +} + +inline void ClientImpl::shutdown_ssl(Socket & /*socket*/, + bool /*shutdown_gracefully*/) { + // If there are any requests in flight from threads other than us, then it's + // a thread-unsafe race because individual ssl* objects are not thread-safe. + assert(socket_requests_in_flight_ == 0 || + socket_requests_are_from_thread_ == std::this_thread::get_id()); +} + +inline void ClientImpl::shutdown_socket(Socket &socket) const { + if (socket.sock == INVALID_SOCKET) { return; } + detail::shutdown_socket(socket.sock); +} + +inline void ClientImpl::close_socket(Socket &socket) { + // If there are requests in flight in another thread, usually closing + // the socket will be fine and they will simply receive an error when + // using the closed socket, but it is still a bug since rarely the OS + // may reassign the socket id to be used for a new socket, and then + // suddenly they will be operating on a live socket that is different + // than the one they intended! + assert(socket_requests_in_flight_ == 0 || + socket_requests_are_from_thread_ == std::this_thread::get_id()); + + // It is also a bug if this happens while SSL is still active +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + assert(socket.ssl == nullptr); +#endif + if (socket.sock == INVALID_SOCKET) { return; } + detail::close_socket(socket.sock); + socket.sock = INVALID_SOCKET; +} + +inline bool ClientImpl::read_response_line(Stream &strm, const Request &req, + Response &res) const { + std::array buf{}; + + detail::stream_line_reader line_reader(strm, buf.data(), buf.size()); + + if (!line_reader.getline()) { return false; } + +#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR + const static std::regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r?\n"); +#else + const static std::regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r\n"); +#endif + + std::cmatch m; + if (!std::regex_match(line_reader.ptr(), m, re)) { + return req.method == "CONNECT"; + } + res.version = std::string(m[1]); + res.status = std::stoi(std::string(m[2])); + res.reason = std::string(m[3]); + + // Ignore '100 Continue' + while (res.status == StatusCode::Continue_100) { + if (!line_reader.getline()) { return false; } // CRLF + if (!line_reader.getline()) { return false; } // next response line + + if (!std::regex_match(line_reader.ptr(), m, re)) { return false; } + res.version = std::string(m[1]); + res.status = std::stoi(std::string(m[2])); + res.reason = std::string(m[3]); + } + + return true; +} + +inline bool ClientImpl::send(Request &req, Response &res, Error &error) { + std::lock_guard request_mutex_guard(request_mutex_); + auto ret = send_(req, res, error); + if (error == Error::SSLPeerCouldBeClosed_) { + assert(!ret); + ret = send_(req, res, error); + } + return ret; +} + +inline bool ClientImpl::send_(Request &req, Response &res, Error &error) { + { + std::lock_guard guard(socket_mutex_); + + // Set this to false immediately - if it ever gets set to true by the end of + // the request, we know another thread instructed us to close the socket. + socket_should_be_closed_when_request_is_done_ = false; + + auto is_alive = false; + if (socket_.is_open()) { + is_alive = detail::is_socket_alive(socket_.sock); + if (!is_alive) { + // Attempt to avoid sigpipe by shutting down nongracefully if it seems + // like the other side has already closed the connection Also, there + // cannot be any requests in flight from other threads since we locked + // request_mutex_, so safe to close everything immediately + const bool shutdown_gracefully = false; + shutdown_ssl(socket_, shutdown_gracefully); + shutdown_socket(socket_); + close_socket(socket_); + } + } + + if (!is_alive) { + if (!create_and_connect_socket(socket_, error)) { return false; } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + // TODO: refactoring + if (is_ssl()) { + auto &scli = static_cast(*this); + if (!proxy_host_.empty() && proxy_port_ != -1) { + auto success = false; + if (!scli.connect_with_proxy(socket_, res, success, error)) { + return success; + } + } + + if (!scli.initialize_ssl(socket_, error)) { return false; } + } +#endif + } + + // Mark the current socket as being in use so that it cannot be closed by + // anyone else while this request is ongoing, even though we will be + // releasing the mutex. + if (socket_requests_in_flight_ > 1) { + assert(socket_requests_are_from_thread_ == std::this_thread::get_id()); + } + socket_requests_in_flight_ += 1; + socket_requests_are_from_thread_ = std::this_thread::get_id(); + } + + for (const auto &header : default_headers_) { + if (req.headers.find(header.first) == req.headers.end()) { + req.headers.insert(header); + } + } + + auto ret = false; + auto close_connection = !keep_alive_; + + auto se = detail::scope_exit([&]() { + // Briefly lock mutex in order to mark that a request is no longer ongoing + std::lock_guard guard(socket_mutex_); + socket_requests_in_flight_ -= 1; + if (socket_requests_in_flight_ <= 0) { + assert(socket_requests_in_flight_ == 0); + socket_requests_are_from_thread_ = std::thread::id(); + } + + if (socket_should_be_closed_when_request_is_done_ || close_connection || + !ret) { + shutdown_ssl(socket_, true); + shutdown_socket(socket_); + close_socket(socket_); + } + }); + + ret = process_socket(socket_, [&](Stream &strm) { + return handle_request(strm, req, res, close_connection, error); + }); + + if (!ret) { + if (error == Error::Success) { error = Error::Unknown; } + } + + return ret; +} + +inline Result ClientImpl::send(const Request &req) { + auto req2 = req; + return send_(std::move(req2)); +} + +inline Result ClientImpl::send_(Request &&req) { + auto res = detail::make_unique(); + auto error = Error::Success; + auto ret = send(req, *res, error); + return Result{ret ? std::move(res) : nullptr, error, std::move(req.headers)}; +} + +inline bool ClientImpl::handle_request(Stream &strm, Request &req, + Response &res, bool close_connection, + Error &error) { + if (req.path.empty()) { + error = Error::Connection; + return false; + } + + auto req_save = req; + + bool ret; + + if (!is_ssl() && !proxy_host_.empty() && proxy_port_ != -1) { + auto req2 = req; + req2.path = "http://" + host_and_port_ + req.path; + ret = process_request(strm, req2, res, close_connection, error); + req = req2; + req.path = req_save.path; + } else { + ret = process_request(strm, req, res, close_connection, error); + } + + if (!ret) { return false; } + + if (res.get_header_value("Connection") == "close" || + (res.version == "HTTP/1.0" && res.reason != "Connection established")) { + // TODO this requires a not-entirely-obvious chain of calls to be correct + // for this to be safe. + + // This is safe to call because handle_request is only called by send_ + // which locks the request mutex during the process. It would be a bug + // to call it from a different thread since it's a thread-safety issue + // to do these things to the socket if another thread is using the socket. + std::lock_guard guard(socket_mutex_); + shutdown_ssl(socket_, true); + shutdown_socket(socket_); + close_socket(socket_); + } + + if (300 < res.status && res.status < 400 && follow_location_) { + req = req_save; + ret = redirect(req, res, error); + } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if ((res.status == StatusCode::Unauthorized_401 || + res.status == StatusCode::ProxyAuthenticationRequired_407) && + req.authorization_count_ < 5) { + auto is_proxy = res.status == StatusCode::ProxyAuthenticationRequired_407; + const auto &username = + is_proxy ? proxy_digest_auth_username_ : digest_auth_username_; + const auto &password = + is_proxy ? proxy_digest_auth_password_ : digest_auth_password_; + + if (!username.empty() && !password.empty()) { + std::map auth; + if (detail::parse_www_authenticate(res, auth, is_proxy)) { + Request new_req = req; + new_req.authorization_count_ += 1; + new_req.headers.erase(is_proxy ? "Proxy-Authorization" + : "Authorization"); + new_req.headers.insert(detail::make_digest_authentication_header( + req, auth, new_req.authorization_count_, detail::random_string(10), + username, password, is_proxy)); + + Response new_res; + + ret = send(new_req, new_res, error); + if (ret) { res = new_res; } + } + } + } +#endif + + return ret; +} + +inline bool ClientImpl::redirect(Request &req, Response &res, Error &error) { + if (req.redirect_count_ == 0) { + error = Error::ExceedRedirectCount; + return false; + } + + auto location = res.get_header_value("location"); + if (location.empty()) { return false; } + + const static std::regex re( + R"((?:(https?):)?(?://(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)?([^?#]*)(\?[^#]*)?(?:#.*)?)"); + + std::smatch m; + if (!std::regex_match(location, m, re)) { return false; } + + auto scheme = is_ssl() ? "https" : "http"; + + auto next_scheme = m[1].str(); + auto next_host = m[2].str(); + if (next_host.empty()) { next_host = m[3].str(); } + auto port_str = m[4].str(); + auto next_path = m[5].str(); + auto next_query = m[6].str(); + + auto next_port = port_; + if (!port_str.empty()) { + next_port = std::stoi(port_str); + } else if (!next_scheme.empty()) { + next_port = next_scheme == "https" ? 443 : 80; + } + + if (next_scheme.empty()) { next_scheme = scheme; } + if (next_host.empty()) { next_host = host_; } + if (next_path.empty()) { next_path = "/"; } + + auto path = detail::decode_url(next_path, true) + next_query; + + if (next_scheme == scheme && next_host == host_ && next_port == port_) { + return detail::redirect(*this, req, res, path, location, error); + } else { + if (next_scheme == "https") { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(next_host, next_port); + cli.copy_settings(*this); + if (ca_cert_store_) { cli.set_ca_cert_store(ca_cert_store_); } + return detail::redirect(cli, req, res, path, location, error); +#else + return false; +#endif + } else { + ClientImpl cli(next_host, next_port); + cli.copy_settings(*this); + return detail::redirect(cli, req, res, path, location, error); + } + } +} + +inline bool ClientImpl::write_content_with_provider(Stream &strm, + const Request &req, + Error &error) const { + auto is_shutting_down = []() { return false; }; + + if (req.is_chunked_content_provider_) { + // TODO: Brotli support + std::unique_ptr compressor; +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + if (compress_) { + compressor = detail::make_unique(); + } else +#endif + { + compressor = detail::make_unique(); + } + + return detail::write_content_chunked(strm, req.content_provider_, + is_shutting_down, *compressor, error); + } else { + return detail::write_content(strm, req.content_provider_, 0, + req.content_length_, is_shutting_down, error); + } +} + +inline bool ClientImpl::write_request(Stream &strm, Request &req, + bool close_connection, Error &error) { + // Prepare additional headers + if (close_connection) { + if (!req.has_header("Connection")) { + req.set_header("Connection", "close"); + } + } + + if (!req.has_header("Host")) { + if (is_ssl()) { + if (port_ == 443) { + req.set_header("Host", host_); + } else { + req.set_header("Host", host_and_port_); + } + } else { + if (port_ == 80) { + req.set_header("Host", host_); + } else { + req.set_header("Host", host_and_port_); + } + } + } + + if (!req.has_header("Accept")) { req.set_header("Accept", "*/*"); } + +#ifndef CPPHTTPLIB_NO_DEFAULT_USER_AGENT + if (!req.has_header("User-Agent")) { + auto agent = std::string("cpp-httplib/") + CPPHTTPLIB_VERSION; + req.set_header("User-Agent", agent); + } +#endif + + if (req.body.empty()) { + if (req.content_provider_) { + if (!req.is_chunked_content_provider_) { + if (!req.has_header("Content-Length")) { + auto length = std::to_string(req.content_length_); + req.set_header("Content-Length", length); + } + } + } else { + if (req.method == "POST" || req.method == "PUT" || + req.method == "PATCH") { + req.set_header("Content-Length", "0"); + } + } + } else { + if (!req.has_header("Content-Type")) { + req.set_header("Content-Type", "text/plain"); + } + + if (!req.has_header("Content-Length")) { + auto length = std::to_string(req.body.size()); + req.set_header("Content-Length", length); + } + } + + if (!basic_auth_password_.empty() || !basic_auth_username_.empty()) { + if (!req.has_header("Authorization")) { + req.headers.insert(make_basic_authentication_header( + basic_auth_username_, basic_auth_password_, false)); + } + } + + if (!proxy_basic_auth_username_.empty() && + !proxy_basic_auth_password_.empty()) { + if (!req.has_header("Proxy-Authorization")) { + req.headers.insert(make_basic_authentication_header( + proxy_basic_auth_username_, proxy_basic_auth_password_, true)); + } + } + + if (!bearer_token_auth_token_.empty()) { + if (!req.has_header("Authorization")) { + req.headers.insert(make_bearer_token_authentication_header( + bearer_token_auth_token_, false)); + } + } + + if (!proxy_bearer_token_auth_token_.empty()) { + if (!req.has_header("Proxy-Authorization")) { + req.headers.insert(make_bearer_token_authentication_header( + proxy_bearer_token_auth_token_, true)); + } + } + + // Request line and headers + { + detail::BufferStream bstrm; + + const auto &path = url_encode_ ? detail::encode_url(req.path) : req.path; + bstrm.write_format("%s %s HTTP/1.1\r\n", req.method.c_str(), path.c_str()); + + header_writer_(bstrm, req.headers); + + // Flush buffer + auto &data = bstrm.get_buffer(); + if (!detail::write_data(strm, data.data(), data.size())) { + error = Error::Write; + return false; + } + } + + // Body + if (req.body.empty()) { + return write_content_with_provider(strm, req, error); + } + + if (!detail::write_data(strm, req.body.data(), req.body.size())) { + error = Error::Write; + return false; + } + + return true; +} + +inline std::unique_ptr ClientImpl::send_with_content_provider( + Request &req, const char *body, size_t content_length, + ContentProvider content_provider, + ContentProviderWithoutLength content_provider_without_length, + const std::string &content_type, Error &error) { + if (!content_type.empty()) { req.set_header("Content-Type", content_type); } + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + if (compress_) { req.set_header("Content-Encoding", "gzip"); } +#endif + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + if (compress_ && !content_provider_without_length) { + // TODO: Brotli support + detail::gzip_compressor compressor; + + if (content_provider) { + auto ok = true; + size_t offset = 0; + DataSink data_sink; + + data_sink.write = [&](const char *data, size_t data_len) -> bool { + if (ok) { + auto last = offset + data_len == content_length; + + auto ret = compressor.compress( + data, data_len, last, + [&](const char *compressed_data, size_t compressed_data_len) { + req.body.append(compressed_data, compressed_data_len); + return true; + }); + + if (ret) { + offset += data_len; + } else { + ok = false; + } + } + return ok; + }; + + while (ok && offset < content_length) { + if (!content_provider(offset, content_length - offset, data_sink)) { + error = Error::Canceled; + return nullptr; + } + } + } else { + if (!compressor.compress(body, content_length, true, + [&](const char *data, size_t data_len) { + req.body.append(data, data_len); + return true; + })) { + error = Error::Compression; + return nullptr; + } + } + } else +#endif + { + if (content_provider) { + req.content_length_ = content_length; + req.content_provider_ = std::move(content_provider); + req.is_chunked_content_provider_ = false; + } else if (content_provider_without_length) { + req.content_length_ = 0; + req.content_provider_ = detail::ContentProviderAdapter( + std::move(content_provider_without_length)); + req.is_chunked_content_provider_ = true; + req.set_header("Transfer-Encoding", "chunked"); + } else { + req.body.assign(body, content_length); + } + } + + auto res = detail::make_unique(); + return send(req, *res, error) ? std::move(res) : nullptr; +} + +inline Result ClientImpl::send_with_content_provider( + const std::string &method, const std::string &path, const Headers &headers, + const char *body, size_t content_length, ContentProvider content_provider, + ContentProviderWithoutLength content_provider_without_length, + const std::string &content_type) { + Request req; + req.method = method; + req.headers = headers; + req.path = path; + + auto error = Error::Success; + + auto res = send_with_content_provider( + req, body, content_length, std::move(content_provider), + std::move(content_provider_without_length), content_type, error); + + return Result{std::move(res), error, std::move(req.headers)}; +} + +inline std::string +ClientImpl::adjust_host_string(const std::string &host) const { + if (host.find(':') != std::string::npos) { return "[" + host + "]"; } + return host; +} + +inline bool ClientImpl::process_request(Stream &strm, Request &req, + Response &res, bool close_connection, + Error &error) { + // Send request + if (!write_request(strm, req, close_connection, error)) { return false; } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if (is_ssl()) { + auto is_proxy_enabled = !proxy_host_.empty() && proxy_port_ != -1; + if (!is_proxy_enabled) { + char buf[1]; + if (SSL_peek(socket_.ssl, buf, 1) == 0 && + SSL_get_error(socket_.ssl, 0) == SSL_ERROR_ZERO_RETURN) { + error = Error::SSLPeerCouldBeClosed_; + return false; + } + } + } +#endif + + // Receive response and headers + if (!read_response_line(strm, req, res) || + !detail::read_headers(strm, res.headers)) { + error = Error::Read; + return false; + } + + // Body + if ((res.status != StatusCode::NoContent_204) && req.method != "HEAD" && + req.method != "CONNECT") { + auto redirect = 300 < res.status && res.status < 400 && follow_location_; + + if (req.response_handler && !redirect) { + if (!req.response_handler(res)) { + error = Error::Canceled; + return false; + } + } + + auto out = + req.content_receiver + ? static_cast( + [&](const char *buf, size_t n, uint64_t off, uint64_t len) { + if (redirect) { return true; } + auto ret = req.content_receiver(buf, n, off, len); + if (!ret) { error = Error::Canceled; } + return ret; + }) + : static_cast( + [&](const char *buf, size_t n, uint64_t /*off*/, + uint64_t /*len*/) { + if (res.body.size() + n > res.body.max_size()) { + return false; + } + res.body.append(buf, n); + return true; + }); + + auto progress = [&](uint64_t current, uint64_t total) { + if (!req.progress || redirect) { return true; } + auto ret = req.progress(current, total); + if (!ret) { error = Error::Canceled; } + return ret; + }; + + int dummy_status; + if (!detail::read_content(strm, res, (std::numeric_limits::max)(), + dummy_status, std::move(progress), std::move(out), + decompress_)) { + if (error != Error::Canceled) { error = Error::Read; } + return false; + } + } + + // Log + if (logger_) { logger_(req, res); } + + return true; +} + +inline ContentProviderWithoutLength ClientImpl::get_multipart_content_provider( + const std::string &boundary, const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) const { + size_t cur_item = 0; + size_t cur_start = 0; + // cur_item and cur_start are copied to within the std::function and maintain + // state between successive calls + return [&, cur_item, cur_start](size_t offset, + DataSink &sink) mutable -> bool { + if (!offset && !items.empty()) { + sink.os << detail::serialize_multipart_formdata(items, boundary, false); + return true; + } else if (cur_item < provider_items.size()) { + if (!cur_start) { + const auto &begin = detail::serialize_multipart_formdata_item_begin( + provider_items[cur_item], boundary); + offset += begin.size(); + cur_start = offset; + sink.os << begin; + } + + DataSink cur_sink; + auto has_data = true; + cur_sink.write = sink.write; + cur_sink.done = [&]() { has_data = false; }; + + if (!provider_items[cur_item].provider(offset - cur_start, cur_sink)) { + return false; + } + + if (!has_data) { + sink.os << detail::serialize_multipart_formdata_item_end(); + cur_item++; + cur_start = 0; + } + return true; + } else { + sink.os << detail::serialize_multipart_formdata_finish(boundary); + sink.done(); + return true; + } + }; +} + +inline bool +ClientImpl::process_socket(const Socket &socket, + std::function callback) { + return detail::process_client_socket( + socket.sock, read_timeout_sec_, read_timeout_usec_, write_timeout_sec_, + write_timeout_usec_, std::move(callback)); +} + +inline bool ClientImpl::is_ssl() const { return false; } + +inline Result ClientImpl::Get(const std::string &path) { + return Get(path, Headers(), Progress()); +} + +inline Result ClientImpl::Get(const std::string &path, Progress progress) { + return Get(path, Headers(), std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers) { + return Get(path, headers, Progress()); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + Progress progress) { + Request req; + req.method = "GET"; + req.path = path; + req.headers = headers; + req.progress = std::move(progress); + + return send_(std::move(req)); +} + +inline Result ClientImpl::Get(const std::string &path, + ContentReceiver content_receiver) { + return Get(path, Headers(), nullptr, std::move(content_receiver), nullptr); +} + +inline Result ClientImpl::Get(const std::string &path, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, Headers(), nullptr, std::move(content_receiver), + std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver) { + return Get(path, headers, nullptr, std::move(content_receiver), nullptr); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, headers, nullptr, std::move(content_receiver), + std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return Get(path, Headers(), std::move(response_handler), + std::move(content_receiver), nullptr); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return Get(path, headers, std::move(response_handler), + std::move(content_receiver), nullptr); +} + +inline Result ClientImpl::Get(const std::string &path, + ResponseHandler response_handler, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, Headers(), std::move(response_handler), + std::move(content_receiver), std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, + Progress progress) { + Request req; + req.method = "GET"; + req.path = path; + req.headers = headers; + req.response_handler = std::move(response_handler); + req.content_receiver = + [content_receiver](const char *data, size_t data_length, + uint64_t /*offset*/, uint64_t /*total_length*/) { + return content_receiver(data, data_length); + }; + req.progress = std::move(progress); + + return send_(std::move(req)); +} + +inline Result ClientImpl::Get(const std::string &path, const Params ¶ms, + const Headers &headers, Progress progress) { + if (params.empty()) { return Get(path, headers); } + + std::string path_with_query = append_query_params(path, params); + return Get(path_with_query, headers, std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, const Params ¶ms, + const Headers &headers, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, params, headers, nullptr, std::move(content_receiver), + std::move(progress)); +} + +inline Result ClientImpl::Get(const std::string &path, const Params ¶ms, + const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, + Progress progress) { + if (params.empty()) { + return Get(path, headers, std::move(response_handler), + std::move(content_receiver), std::move(progress)); + } + + std::string path_with_query = append_query_params(path, params); + return Get(path_with_query, headers, std::move(response_handler), + std::move(content_receiver), std::move(progress)); +} + +inline Result ClientImpl::Head(const std::string &path) { + return Head(path, Headers()); +} + +inline Result ClientImpl::Head(const std::string &path, + const Headers &headers) { + Request req; + req.method = "HEAD"; + req.headers = headers; + req.path = path; + + return send_(std::move(req)); +} + +inline Result ClientImpl::Post(const std::string &path) { + return Post(path, std::string(), std::string()); +} + +inline Result ClientImpl::Post(const std::string &path, + const Headers &headers) { + return Post(path, headers, nullptr, 0, std::string()); +} + +inline Result ClientImpl::Post(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return Post(path, Headers(), body, content_length, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return send_with_content_provider("POST", path, headers, body, content_length, + nullptr, nullptr, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const std::string &body, + const std::string &content_type) { + return Post(path, Headers(), body, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return send_with_content_provider("POST", path, headers, body.data(), + body.size(), nullptr, nullptr, + content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Params ¶ms) { + return Post(path, Headers(), params); +} + +inline Result ClientImpl::Post(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return Post(path, Headers(), content_length, std::move(content_provider), + content_type); +} + +inline Result ClientImpl::Post(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return Post(path, Headers(), std::move(content_provider), content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return send_with_content_provider("POST", path, headers, nullptr, + content_length, std::move(content_provider), + nullptr, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return send_with_content_provider("POST", path, headers, nullptr, 0, nullptr, + std::move(content_provider), content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const Params ¶ms) { + auto query = detail::params_to_query_str(params); + return Post(path, headers, query, "application/x-www-form-urlencoded"); +} + +inline Result ClientImpl::Post(const std::string &path, + const MultipartFormDataItems &items) { + return Post(path, Headers(), items); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items) { + const auto &boundary = detail::make_multipart_data_boundary(); + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + const auto &body = detail::serialize_multipart_formdata(items, boundary); + return Post(path, headers, body, content_type); +} + +inline Result ClientImpl::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const std::string &boundary) { + if (!detail::is_multipart_boundary_chars_valid(boundary)) { + return Result{nullptr, Error::UnsupportedMultipartBoundaryChars}; + } + + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + const auto &body = detail::serialize_multipart_formdata(items, boundary); + return Post(path, headers, body, content_type); +} + +inline Result +ClientImpl::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + const auto &boundary = detail::make_multipart_data_boundary(); + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + return send_with_content_provider( + "POST", path, headers, nullptr, 0, nullptr, + get_multipart_content_provider(boundary, items, provider_items), + content_type); +} + +inline Result ClientImpl::Put(const std::string &path) { + return Put(path, std::string(), std::string()); +} + +inline Result ClientImpl::Put(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return Put(path, Headers(), body, content_length, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return send_with_content_provider("PUT", path, headers, body, content_length, + nullptr, nullptr, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const std::string &body, + const std::string &content_type) { + return Put(path, Headers(), body, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return send_with_content_provider("PUT", path, headers, body.data(), + body.size(), nullptr, nullptr, + content_type); +} + +inline Result ClientImpl::Put(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return Put(path, Headers(), content_length, std::move(content_provider), + content_type); +} + +inline Result ClientImpl::Put(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return Put(path, Headers(), std::move(content_provider), content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return send_with_content_provider("PUT", path, headers, nullptr, + content_length, std::move(content_provider), + nullptr, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return send_with_content_provider("PUT", path, headers, nullptr, 0, nullptr, + std::move(content_provider), content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Params ¶ms) { + return Put(path, Headers(), params); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const Params ¶ms) { + auto query = detail::params_to_query_str(params); + return Put(path, headers, query, "application/x-www-form-urlencoded"); +} + +inline Result ClientImpl::Put(const std::string &path, + const MultipartFormDataItems &items) { + return Put(path, Headers(), items); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items) { + const auto &boundary = detail::make_multipart_data_boundary(); + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + const auto &body = detail::serialize_multipart_formdata(items, boundary); + return Put(path, headers, body, content_type); +} + +inline Result ClientImpl::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const std::string &boundary) { + if (!detail::is_multipart_boundary_chars_valid(boundary)) { + return Result{nullptr, Error::UnsupportedMultipartBoundaryChars}; + } + + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + const auto &body = detail::serialize_multipart_formdata(items, boundary); + return Put(path, headers, body, content_type); +} + +inline Result +ClientImpl::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + const auto &boundary = detail::make_multipart_data_boundary(); + const auto &content_type = + detail::serialize_multipart_formdata_get_content_type(boundary); + return send_with_content_provider( + "PUT", path, headers, nullptr, 0, nullptr, + get_multipart_content_provider(boundary, items, provider_items), + content_type); +} +inline Result ClientImpl::Patch(const std::string &path) { + return Patch(path, std::string(), std::string()); +} + +inline Result ClientImpl::Patch(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return Patch(path, Headers(), body, content_length, content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return send_with_content_provider("PATCH", path, headers, body, + content_length, nullptr, nullptr, + content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, + const std::string &body, + const std::string &content_type) { + return Patch(path, Headers(), body, content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return send_with_content_provider("PATCH", path, headers, body.data(), + body.size(), nullptr, nullptr, + content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return Patch(path, Headers(), content_length, std::move(content_provider), + content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return Patch(path, Headers(), std::move(content_provider), content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return send_with_content_provider("PATCH", path, headers, nullptr, + content_length, std::move(content_provider), + nullptr, content_type); +} + +inline Result ClientImpl::Patch(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return send_with_content_provider("PATCH", path, headers, nullptr, 0, nullptr, + std::move(content_provider), content_type); +} + +inline Result ClientImpl::Delete(const std::string &path) { + return Delete(path, Headers(), std::string(), std::string()); +} + +inline Result ClientImpl::Delete(const std::string &path, + const Headers &headers) { + return Delete(path, headers, std::string(), std::string()); +} + +inline Result ClientImpl::Delete(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return Delete(path, Headers(), body, content_length, content_type); +} + +inline Result ClientImpl::Delete(const std::string &path, + const Headers &headers, const char *body, + size_t content_length, + const std::string &content_type) { + Request req; + req.method = "DELETE"; + req.headers = headers; + req.path = path; + + if (!content_type.empty()) { req.set_header("Content-Type", content_type); } + req.body.assign(body, content_length); + + return send_(std::move(req)); +} + +inline Result ClientImpl::Delete(const std::string &path, + const std::string &body, + const std::string &content_type) { + return Delete(path, Headers(), body.data(), body.size(), content_type); +} + +inline Result ClientImpl::Delete(const std::string &path, + const Headers &headers, + const std::string &body, + const std::string &content_type) { + return Delete(path, headers, body.data(), body.size(), content_type); +} + +inline Result ClientImpl::Options(const std::string &path) { + return Options(path, Headers()); +} + +inline Result ClientImpl::Options(const std::string &path, + const Headers &headers) { + Request req; + req.method = "OPTIONS"; + req.headers = headers; + req.path = path; + + return send_(std::move(req)); +} + +inline void ClientImpl::stop() { + std::lock_guard guard(socket_mutex_); + + // If there is anything ongoing right now, the ONLY thread-safe thing we can + // do is to shutdown_socket, so that threads using this socket suddenly + // discover they can't read/write any more and error out. Everything else + // (closing the socket, shutting ssl down) is unsafe because these actions are + // not thread-safe. + if (socket_requests_in_flight_ > 0) { + shutdown_socket(socket_); + + // Aside from that, we set a flag for the socket to be closed when we're + // done. + socket_should_be_closed_when_request_is_done_ = true; + return; + } + + // Otherwise, still holding the mutex, we can shut everything down ourselves + shutdown_ssl(socket_, true); + shutdown_socket(socket_); + close_socket(socket_); +} + +inline std::string ClientImpl::host() const { return host_; } + +inline int ClientImpl::port() const { return port_; } + +inline size_t ClientImpl::is_socket_open() const { + std::lock_guard guard(socket_mutex_); + return socket_.is_open(); +} + +inline socket_t ClientImpl::socket() const { return socket_.sock; } + +inline void ClientImpl::set_connection_timeout(time_t sec, time_t usec) { + connection_timeout_sec_ = sec; + connection_timeout_usec_ = usec; +} + +inline void ClientImpl::set_read_timeout(time_t sec, time_t usec) { + read_timeout_sec_ = sec; + read_timeout_usec_ = usec; +} + +inline void ClientImpl::set_write_timeout(time_t sec, time_t usec) { + write_timeout_sec_ = sec; + write_timeout_usec_ = usec; +} + +inline void ClientImpl::set_basic_auth(const std::string &username, + const std::string &password) { + basic_auth_username_ = username; + basic_auth_password_ = password; +} + +inline void ClientImpl::set_bearer_token_auth(const std::string &token) { + bearer_token_auth_token_ = token; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void ClientImpl::set_digest_auth(const std::string &username, + const std::string &password) { + digest_auth_username_ = username; + digest_auth_password_ = password; +} +#endif + +inline void ClientImpl::set_keep_alive(bool on) { keep_alive_ = on; } + +inline void ClientImpl::set_follow_location(bool on) { follow_location_ = on; } + +inline void ClientImpl::set_url_encode(bool on) { url_encode_ = on; } + +inline void +ClientImpl::set_hostname_addr_map(std::map addr_map) { + addr_map_ = std::move(addr_map); +} + +inline void ClientImpl::set_default_headers(Headers headers) { + default_headers_ = std::move(headers); +} + +inline void ClientImpl::set_header_writer( + std::function const &writer) { + header_writer_ = writer; +} + +inline void ClientImpl::set_address_family(int family) { + address_family_ = family; +} + +inline void ClientImpl::set_tcp_nodelay(bool on) { tcp_nodelay_ = on; } + +inline void ClientImpl::set_socket_options(SocketOptions socket_options) { + socket_options_ = std::move(socket_options); +} + +inline void ClientImpl::set_compress(bool on) { compress_ = on; } + +inline void ClientImpl::set_decompress(bool on) { decompress_ = on; } + +inline void ClientImpl::set_interface(const std::string &intf) { + interface_ = intf; +} + +inline void ClientImpl::set_proxy(const std::string &host, int port) { + proxy_host_ = host; + proxy_port_ = port; +} + +inline void ClientImpl::set_proxy_basic_auth(const std::string &username, + const std::string &password) { + proxy_basic_auth_username_ = username; + proxy_basic_auth_password_ = password; +} + +inline void ClientImpl::set_proxy_bearer_token_auth(const std::string &token) { + proxy_bearer_token_auth_token_ = token; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void ClientImpl::set_proxy_digest_auth(const std::string &username, + const std::string &password) { + proxy_digest_auth_username_ = username; + proxy_digest_auth_password_ = password; +} + +inline void ClientImpl::set_ca_cert_path(const std::string &ca_cert_file_path, + const std::string &ca_cert_dir_path) { + ca_cert_file_path_ = ca_cert_file_path; + ca_cert_dir_path_ = ca_cert_dir_path; +} + +inline void ClientImpl::set_ca_cert_store(X509_STORE *ca_cert_store) { + if (ca_cert_store && ca_cert_store != ca_cert_store_) { + ca_cert_store_ = ca_cert_store; + } +} + +inline X509_STORE *ClientImpl::create_ca_cert_store(const char *ca_cert, + std::size_t size) const { + auto mem = BIO_new_mem_buf(ca_cert, static_cast(size)); + if (!mem) { return nullptr; } + + auto inf = PEM_X509_INFO_read_bio(mem, nullptr, nullptr, nullptr); + if (!inf) { + BIO_free_all(mem); + return nullptr; + } + + auto cts = X509_STORE_new(); + if (cts) { + for (auto i = 0; i < static_cast(sk_X509_INFO_num(inf)); i++) { + auto itmp = sk_X509_INFO_value(inf, i); + if (!itmp) { continue; } + + if (itmp->x509) { X509_STORE_add_cert(cts, itmp->x509); } + if (itmp->crl) { X509_STORE_add_crl(cts, itmp->crl); } + } + } + + sk_X509_INFO_pop_free(inf, X509_INFO_free); + BIO_free_all(mem); + return cts; +} + +inline void ClientImpl::enable_server_certificate_verification(bool enabled) { + server_certificate_verification_ = enabled; +} +#endif + +inline void ClientImpl::set_logger(Logger logger) { + logger_ = std::move(logger); +} + +/* + * SSL Implementation + */ +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +namespace detail { + +template +inline SSL *ssl_new(socket_t sock, SSL_CTX *ctx, std::mutex &ctx_mutex, + U SSL_connect_or_accept, V setup) { + SSL *ssl = nullptr; + { + std::lock_guard guard(ctx_mutex); + ssl = SSL_new(ctx); + } + + if (ssl) { + set_nonblocking(sock, true); + auto bio = BIO_new_socket(static_cast(sock), BIO_NOCLOSE); + BIO_set_nbio(bio, 1); + SSL_set_bio(ssl, bio, bio); + + if (!setup(ssl) || SSL_connect_or_accept(ssl) != 1) { + SSL_shutdown(ssl); + { + std::lock_guard guard(ctx_mutex); + SSL_free(ssl); + } + set_nonblocking(sock, false); + return nullptr; + } + BIO_set_nbio(bio, 0); + set_nonblocking(sock, false); + } + + return ssl; +} + +inline void ssl_delete(std::mutex &ctx_mutex, SSL *ssl, + bool shutdown_gracefully) { + // sometimes we may want to skip this to try to avoid SIGPIPE if we know + // the remote has closed the network connection + // Note that it is not always possible to avoid SIGPIPE, this is merely a + // best-efforts. + if (shutdown_gracefully) { SSL_shutdown(ssl); } + + std::lock_guard guard(ctx_mutex); + SSL_free(ssl); +} + +template +bool ssl_connect_or_accept_nonblocking(socket_t sock, SSL *ssl, + U ssl_connect_or_accept, + time_t timeout_sec, + time_t timeout_usec) { + auto res = 0; + while ((res = ssl_connect_or_accept(ssl)) != 1) { + auto err = SSL_get_error(ssl, res); + switch (err) { + case SSL_ERROR_WANT_READ: + if (select_read(sock, timeout_sec, timeout_usec) > 0) { continue; } + break; + case SSL_ERROR_WANT_WRITE: + if (select_write(sock, timeout_sec, timeout_usec) > 0) { continue; } + break; + default: break; + } + return false; + } + return true; +} + +template +inline bool process_server_socket_ssl( + const std::atomic &svr_sock, SSL *ssl, socket_t sock, + size_t keep_alive_max_count, time_t keep_alive_timeout_sec, + time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, T callback) { + return process_server_socket_core( + svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec, + [&](bool close_connection, bool &connection_closed) { + SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec, + write_timeout_sec, write_timeout_usec); + return callback(strm, close_connection, connection_closed); + }); +} + +template +inline bool +process_client_socket_ssl(SSL *ssl, socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec, time_t write_timeout_sec, + time_t write_timeout_usec, T callback) { + SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec, + write_timeout_sec, write_timeout_usec); + return callback(strm); +} + +class SSLInit { +public: + SSLInit() { + OPENSSL_init_ssl( + OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); + } +}; + +// SSL socket stream implementation +inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl, + time_t read_timeout_sec, + time_t read_timeout_usec, + time_t write_timeout_sec, + time_t write_timeout_usec) + : sock_(sock), ssl_(ssl), read_timeout_sec_(read_timeout_sec), + read_timeout_usec_(read_timeout_usec), + write_timeout_sec_(write_timeout_sec), + write_timeout_usec_(write_timeout_usec) { + SSL_clear_mode(ssl, SSL_MODE_AUTO_RETRY); +} + +inline SSLSocketStream::~SSLSocketStream() = default; + +inline bool SSLSocketStream::is_readable() const { + return detail::select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0; +} + +inline bool SSLSocketStream::is_writable() const { + return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 && + is_socket_alive(sock_); +} + +inline ssize_t SSLSocketStream::read(char *ptr, size_t size) { + if (SSL_pending(ssl_) > 0) { + return SSL_read(ssl_, ptr, static_cast(size)); + } else if (is_readable()) { + auto ret = SSL_read(ssl_, ptr, static_cast(size)); + if (ret < 0) { + auto err = SSL_get_error(ssl_, ret); + auto n = 1000; +#ifdef _WIN32 + while (--n >= 0 && (err == SSL_ERROR_WANT_READ || + (err == SSL_ERROR_SYSCALL && + WSAGetLastError() == WSAETIMEDOUT))) { +#else + while (--n >= 0 && err == SSL_ERROR_WANT_READ) { +#endif + if (SSL_pending(ssl_) > 0) { + return SSL_read(ssl_, ptr, static_cast(size)); + } else if (is_readable()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + ret = SSL_read(ssl_, ptr, static_cast(size)); + if (ret >= 0) { return ret; } + err = SSL_get_error(ssl_, ret); + } else { + return -1; + } + } + } + return ret; + } + return -1; +} + +inline ssize_t SSLSocketStream::write(const char *ptr, size_t size) { + if (is_writable()) { + auto handle_size = static_cast( + std::min(size, (std::numeric_limits::max)())); + + auto ret = SSL_write(ssl_, ptr, static_cast(handle_size)); + if (ret < 0) { + auto err = SSL_get_error(ssl_, ret); + auto n = 1000; +#ifdef _WIN32 + while (--n >= 0 && (err == SSL_ERROR_WANT_WRITE || + (err == SSL_ERROR_SYSCALL && + WSAGetLastError() == WSAETIMEDOUT))) { +#else + while (--n >= 0 && err == SSL_ERROR_WANT_WRITE) { +#endif + if (is_writable()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + ret = SSL_write(ssl_, ptr, static_cast(handle_size)); + if (ret >= 0) { return ret; } + err = SSL_get_error(ssl_, ret); + } else { + return -1; + } + } + } + return ret; + } + return -1; +} + +inline void SSLSocketStream::get_remote_ip_and_port(std::string &ip, + int &port) const { + detail::get_remote_ip_and_port(sock_, ip, port); +} + +inline void SSLSocketStream::get_local_ip_and_port(std::string &ip, + int &port) const { + detail::get_local_ip_and_port(sock_, ip, port); +} + +inline socket_t SSLSocketStream::socket() const { return sock_; } + +static SSLInit sslinit_; + +} // namespace detail + +// SSL HTTP server implementation +inline SSLServer::SSLServer(const char *cert_path, const char *private_key_path, + const char *client_ca_cert_file_path, + const char *client_ca_cert_dir_path, + const char *private_key_password) { + ctx_ = SSL_CTX_new(TLS_server_method()); + + if (ctx_) { + SSL_CTX_set_options(ctx_, + SSL_OP_NO_COMPRESSION | + SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION); + + SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION); + + if (private_key_password != nullptr && (private_key_password[0] != '\0')) { + SSL_CTX_set_default_passwd_cb_userdata( + ctx_, + reinterpret_cast(const_cast(private_key_password))); + } + + if (SSL_CTX_use_certificate_chain_file(ctx_, cert_path) != 1 || + SSL_CTX_use_PrivateKey_file(ctx_, private_key_path, SSL_FILETYPE_PEM) != + 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } else if (client_ca_cert_file_path || client_ca_cert_dir_path) { + SSL_CTX_load_verify_locations(ctx_, client_ca_cert_file_path, + client_ca_cert_dir_path); + + SSL_CTX_set_verify( + ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr); + } + } +} + +inline SSLServer::SSLServer(X509 *cert, EVP_PKEY *private_key, + X509_STORE *client_ca_cert_store) { + ctx_ = SSL_CTX_new(TLS_server_method()); + + if (ctx_) { + SSL_CTX_set_options(ctx_, + SSL_OP_NO_COMPRESSION | + SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION); + + SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION); + + if (SSL_CTX_use_certificate(ctx_, cert) != 1 || + SSL_CTX_use_PrivateKey(ctx_, private_key) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } else if (client_ca_cert_store) { + SSL_CTX_set_cert_store(ctx_, client_ca_cert_store); + + SSL_CTX_set_verify( + ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr); + } + } +} + +inline SSLServer::SSLServer( + const std::function &setup_ssl_ctx_callback) { + ctx_ = SSL_CTX_new(TLS_method()); + if (ctx_) { + if (!setup_ssl_ctx_callback(*ctx_)) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } + } +} + +inline SSLServer::~SSLServer() { + if (ctx_) { SSL_CTX_free(ctx_); } +} + +inline bool SSLServer::is_valid() const { return ctx_; } + +inline SSL_CTX *SSLServer::ssl_context() const { return ctx_; } + +inline bool SSLServer::process_and_close_socket(socket_t sock) { + auto ssl = detail::ssl_new( + sock, ctx_, ctx_mutex_, + [&](SSL *ssl2) { + return detail::ssl_connect_or_accept_nonblocking( + sock, ssl2, SSL_accept, read_timeout_sec_, read_timeout_usec_); + }, + [](SSL * /*ssl2*/) { return true; }); + + auto ret = false; + if (ssl) { + ret = detail::process_server_socket_ssl( + svr_sock_, ssl, sock, keep_alive_max_count_, keep_alive_timeout_sec_, + read_timeout_sec_, read_timeout_usec_, write_timeout_sec_, + write_timeout_usec_, + [this, ssl](Stream &strm, bool close_connection, + bool &connection_closed) { + return process_request(strm, close_connection, connection_closed, + [&](Request &req) { req.ssl = ssl; }); + }); + + // Shutdown gracefully if the result seemed successful, non-gracefully if + // the connection appeared to be closed. + const bool shutdown_gracefully = ret; + detail::ssl_delete(ctx_mutex_, ssl, shutdown_gracefully); + } + + detail::shutdown_socket(sock); + detail::close_socket(sock); + return ret; +} + +// SSL HTTP client implementation +inline SSLClient::SSLClient(const std::string &host) + : SSLClient(host, 443, std::string(), std::string()) {} + +inline SSLClient::SSLClient(const std::string &host, int port) + : SSLClient(host, port, std::string(), std::string()) {} + +inline SSLClient::SSLClient(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path, + const std::string &private_key_password) + : ClientImpl(host, port, client_cert_path, client_key_path) { + ctx_ = SSL_CTX_new(TLS_client_method()); + + detail::split(&host_[0], &host_[host_.size()], '.', + [&](const char *b, const char *e) { + host_components_.emplace_back(b, e); + }); + + if (!client_cert_path.empty() && !client_key_path.empty()) { + if (!private_key_password.empty()) { + SSL_CTX_set_default_passwd_cb_userdata( + ctx_, reinterpret_cast( + const_cast(private_key_password.c_str()))); + } + + if (SSL_CTX_use_certificate_file(ctx_, client_cert_path.c_str(), + SSL_FILETYPE_PEM) != 1 || + SSL_CTX_use_PrivateKey_file(ctx_, client_key_path.c_str(), + SSL_FILETYPE_PEM) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } + } +} + +inline SSLClient::SSLClient(const std::string &host, int port, + X509 *client_cert, EVP_PKEY *client_key, + const std::string &private_key_password) + : ClientImpl(host, port) { + ctx_ = SSL_CTX_new(TLS_client_method()); + + detail::split(&host_[0], &host_[host_.size()], '.', + [&](const char *b, const char *e) { + host_components_.emplace_back(b, e); + }); + + if (client_cert != nullptr && client_key != nullptr) { + if (!private_key_password.empty()) { + SSL_CTX_set_default_passwd_cb_userdata( + ctx_, reinterpret_cast( + const_cast(private_key_password.c_str()))); + } + + if (SSL_CTX_use_certificate(ctx_, client_cert) != 1 || + SSL_CTX_use_PrivateKey(ctx_, client_key) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } + } +} + +inline SSLClient::~SSLClient() { + if (ctx_) { SSL_CTX_free(ctx_); } + // Make sure to shut down SSL since shutdown_ssl will resolve to the + // base function rather than the derived function once we get to the + // base class destructor, and won't free the SSL (causing a leak). + shutdown_ssl_impl(socket_, true); +} + +inline bool SSLClient::is_valid() const { return ctx_; } + +inline void SSLClient::set_ca_cert_store(X509_STORE *ca_cert_store) { + if (ca_cert_store) { + if (ctx_) { + if (SSL_CTX_get_cert_store(ctx_) != ca_cert_store) { + // Free memory allocated for old cert and use new store `ca_cert_store` + SSL_CTX_set_cert_store(ctx_, ca_cert_store); + } + } else { + X509_STORE_free(ca_cert_store); + } + } +} + +inline void SSLClient::load_ca_cert_store(const char *ca_cert, + std::size_t size) { + set_ca_cert_store(ClientImpl::create_ca_cert_store(ca_cert, size)); +} + +inline long SSLClient::get_openssl_verify_result() const { + return verify_result_; +} + +inline SSL_CTX *SSLClient::ssl_context() const { return ctx_; } + +inline bool SSLClient::create_and_connect_socket(Socket &socket, Error &error) { + return is_valid() && ClientImpl::create_and_connect_socket(socket, error); +} + +// Assumes that socket_mutex_ is locked and that there are no requests in flight +inline bool SSLClient::connect_with_proxy(Socket &socket, Response &res, + bool &success, Error &error) { + success = true; + Response proxy_res; + if (!detail::process_client_socket( + socket.sock, read_timeout_sec_, read_timeout_usec_, + write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) { + Request req2; + req2.method = "CONNECT"; + req2.path = host_and_port_; + return process_request(strm, req2, proxy_res, false, error); + })) { + // Thread-safe to close everything because we are assuming there are no + // requests in flight + shutdown_ssl(socket, true); + shutdown_socket(socket); + close_socket(socket); + success = false; + return false; + } + + if (proxy_res.status == StatusCode::ProxyAuthenticationRequired_407) { + if (!proxy_digest_auth_username_.empty() && + !proxy_digest_auth_password_.empty()) { + std::map auth; + if (detail::parse_www_authenticate(proxy_res, auth, true)) { + proxy_res = Response(); + if (!detail::process_client_socket( + socket.sock, read_timeout_sec_, read_timeout_usec_, + write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) { + Request req3; + req3.method = "CONNECT"; + req3.path = host_and_port_; + req3.headers.insert(detail::make_digest_authentication_header( + req3, auth, 1, detail::random_string(10), + proxy_digest_auth_username_, proxy_digest_auth_password_, + true)); + return process_request(strm, req3, proxy_res, false, error); + })) { + // Thread-safe to close everything because we are assuming there are + // no requests in flight + shutdown_ssl(socket, true); + shutdown_socket(socket); + close_socket(socket); + success = false; + return false; + } + } + } + } + + // If status code is not 200, proxy request is failed. + // Set error to ProxyConnection and return proxy response + // as the response of the request + if (proxy_res.status != StatusCode::OK_200) { + error = Error::ProxyConnection; + res = std::move(proxy_res); + // Thread-safe to close everything because we are assuming there are + // no requests in flight + shutdown_ssl(socket, true); + shutdown_socket(socket); + close_socket(socket); + return false; + } + + return true; +} + +inline bool SSLClient::load_certs() { + auto ret = true; + + std::call_once(initialize_cert_, [&]() { + std::lock_guard guard(ctx_mutex_); + if (!ca_cert_file_path_.empty()) { + if (!SSL_CTX_load_verify_locations(ctx_, ca_cert_file_path_.c_str(), + nullptr)) { + ret = false; + } + } else if (!ca_cert_dir_path_.empty()) { + if (!SSL_CTX_load_verify_locations(ctx_, nullptr, + ca_cert_dir_path_.c_str())) { + ret = false; + } + } else { + auto loaded = false; +#ifdef _WIN32 + loaded = + detail::load_system_certs_on_windows(SSL_CTX_get_cert_store(ctx_)); +#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__) +#if TARGET_OS_OSX + loaded = detail::load_system_certs_on_macos(SSL_CTX_get_cert_store(ctx_)); +#endif // TARGET_OS_OSX +#endif // _WIN32 + if (!loaded) { SSL_CTX_set_default_verify_paths(ctx_); } + } + }); + + return ret; +} + +inline bool SSLClient::initialize_ssl(Socket &socket, Error &error) { + auto ssl = detail::ssl_new( + socket.sock, ctx_, ctx_mutex_, + [&](SSL *ssl2) { + if (server_certificate_verification_) { + if (!load_certs()) { + error = Error::SSLLoadingCerts; + return false; + } + SSL_set_verify(ssl2, SSL_VERIFY_NONE, nullptr); + } + + if (!detail::ssl_connect_or_accept_nonblocking( + socket.sock, ssl2, SSL_connect, connection_timeout_sec_, + connection_timeout_usec_)) { + error = Error::SSLConnection; + return false; + } + + if (server_certificate_verification_) { + verify_result_ = SSL_get_verify_result(ssl2); + + if (verify_result_ != X509_V_OK) { + error = Error::SSLServerVerification; + return false; + } + + auto server_cert = SSL_get1_peer_certificate(ssl2); + + if (server_cert == nullptr) { + error = Error::SSLServerVerification; + return false; + } + + if (!verify_host(server_cert)) { + X509_free(server_cert); + error = Error::SSLServerVerification; + return false; + } + X509_free(server_cert); + } + + return true; + }, + [&](SSL *ssl2) { + // NOTE: Direct call instead of using the OpenSSL macro to suppress + // -Wold-style-cast warning + // SSL_set_tlsext_host_name(ssl2, host_.c_str()); + SSL_ctrl(ssl2, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, + static_cast(const_cast(host_.c_str()))); + return true; + }); + + if (ssl) { + socket.ssl = ssl; + return true; + } + + shutdown_socket(socket); + close_socket(socket); + return false; +} + +inline void SSLClient::shutdown_ssl(Socket &socket, bool shutdown_gracefully) { + shutdown_ssl_impl(socket, shutdown_gracefully); +} + +inline void SSLClient::shutdown_ssl_impl(Socket &socket, + bool shutdown_gracefully) { + if (socket.sock == INVALID_SOCKET) { + assert(socket.ssl == nullptr); + return; + } + if (socket.ssl) { + detail::ssl_delete(ctx_mutex_, socket.ssl, shutdown_gracefully); + socket.ssl = nullptr; + } + assert(socket.ssl == nullptr); +} + +inline bool +SSLClient::process_socket(const Socket &socket, + std::function callback) { + assert(socket.ssl); + return detail::process_client_socket_ssl( + socket.ssl, socket.sock, read_timeout_sec_, read_timeout_usec_, + write_timeout_sec_, write_timeout_usec_, std::move(callback)); +} + +inline bool SSLClient::is_ssl() const { return true; } + +inline bool SSLClient::verify_host(X509 *server_cert) const { + /* Quote from RFC2818 section 3.1 "Server Identity" + + If a subjectAltName extension of type dNSName is present, that MUST + be used as the identity. Otherwise, the (most specific) Common Name + field in the Subject field of the certificate MUST be used. Although + the use of the Common Name is existing practice, it is deprecated and + Certification Authorities are encouraged to use the dNSName instead. + + Matching is performed using the matching rules specified by + [RFC2459]. If more than one identity of a given type is present in + the certificate (e.g., more than one dNSName name, a match in any one + of the set is considered acceptable.) Names may contain the wildcard + character * which is considered to match any single domain name + component or component fragment. E.g., *.a.com matches foo.a.com but + not bar.foo.a.com. f*.com matches foo.com but not bar.com. + + In some cases, the URI is specified as an IP address rather than a + hostname. In this case, the iPAddress subjectAltName must be present + in the certificate and must exactly match the IP in the URI. + + */ + return verify_host_with_subject_alt_name(server_cert) || + verify_host_with_common_name(server_cert); +} + +inline bool +SSLClient::verify_host_with_subject_alt_name(X509 *server_cert) const { + auto ret = false; + + auto type = GEN_DNS; + + struct in6_addr addr6 {}; + struct in_addr addr {}; + size_t addr_len = 0; + +#ifndef __MINGW32__ + if (inet_pton(AF_INET6, host_.c_str(), &addr6)) { + type = GEN_IPADD; + addr_len = sizeof(struct in6_addr); + } else if (inet_pton(AF_INET, host_.c_str(), &addr)) { + type = GEN_IPADD; + addr_len = sizeof(struct in_addr); + } +#endif + + auto alt_names = static_cast( + X509_get_ext_d2i(server_cert, NID_subject_alt_name, nullptr, nullptr)); + + if (alt_names) { + auto dsn_matched = false; + auto ip_matched = false; + + auto count = sk_GENERAL_NAME_num(alt_names); + + for (decltype(count) i = 0; i < count && !dsn_matched; i++) { + auto val = sk_GENERAL_NAME_value(alt_names, i); + if (val->type == type) { + auto name = + reinterpret_cast(ASN1_STRING_get0_data(val->d.ia5)); + auto name_len = static_cast(ASN1_STRING_length(val->d.ia5)); + + switch (type) { + case GEN_DNS: dsn_matched = check_host_name(name, name_len); break; + + case GEN_IPADD: + if (!memcmp(&addr6, name, addr_len) || + !memcmp(&addr, name, addr_len)) { + ip_matched = true; + } + break; + } + } + } + + if (dsn_matched || ip_matched) { ret = true; } + } + + GENERAL_NAMES_free(const_cast( + reinterpret_cast(alt_names))); + return ret; +} + +inline bool SSLClient::verify_host_with_common_name(X509 *server_cert) const { + const auto subject_name = X509_get_subject_name(server_cert); + + if (subject_name != nullptr) { + char name[BUFSIZ]; + auto name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName, + name, sizeof(name)); + + if (name_len != -1) { + return check_host_name(name, static_cast(name_len)); + } + } + + return false; +} + +inline bool SSLClient::check_host_name(const char *pattern, + size_t pattern_len) const { + if (host_.size() == pattern_len && host_ == pattern) { return true; } + + // Wildcard match + // https://bugs.launchpad.net/ubuntu/+source/firefox-3.0/+bug/376484 + std::vector pattern_components; + detail::split(&pattern[0], &pattern[pattern_len], '.', + [&](const char *b, const char *e) { + pattern_components.emplace_back(b, e); + }); + + if (host_components_.size() != pattern_components.size()) { return false; } + + auto itr = pattern_components.begin(); + for (const auto &h : host_components_) { + auto &p = *itr; + if (p != h && p != "*") { + auto partial_match = (p.size() > 0 && p[p.size() - 1] == '*' && + !p.compare(0, p.size() - 1, h)); + if (!partial_match) { return false; } + } + ++itr; + } + + return true; +} +#endif + +// Universal client implementation +inline Client::Client(const std::string &scheme_host_port) + : Client(scheme_host_port, std::string(), std::string()) {} + +inline Client::Client(const std::string &scheme_host_port, + const std::string &client_cert_path, + const std::string &client_key_path) { + const static std::regex re( + R"((?:([a-z]+):\/\/)?(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)"); + + std::smatch m; + if (std::regex_match(scheme_host_port, m, re)) { + auto scheme = m[1].str(); + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if (!scheme.empty() && (scheme != "http" && scheme != "https")) { +#else + if (!scheme.empty() && scheme != "http") { +#endif +#ifndef CPPHTTPLIB_NO_EXCEPTIONS + std::string msg = "'" + scheme + "' scheme is not supported."; + throw std::invalid_argument(msg); +#endif + return; + } + + auto is_ssl = scheme == "https"; + + auto host = m[2].str(); + if (host.empty()) { host = m[3].str(); } + + auto port_str = m[4].str(); + auto port = !port_str.empty() ? std::stoi(port_str) : (is_ssl ? 443 : 80); + + if (is_ssl) { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + cli_ = detail::make_unique(host, port, client_cert_path, + client_key_path); + is_ssl_ = is_ssl; +#endif + } else { + cli_ = detail::make_unique(host, port, client_cert_path, + client_key_path); + } + } else { + cli_ = detail::make_unique(scheme_host_port, 80, + client_cert_path, client_key_path); + } +} + +inline Client::Client(const std::string &host, int port) + : cli_(detail::make_unique(host, port)) {} + +inline Client::Client(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path) + : cli_(detail::make_unique(host, port, client_cert_path, + client_key_path)) {} + +inline Client::~Client() = default; + +inline bool Client::is_valid() const { + return cli_ != nullptr && cli_->is_valid(); +} + +inline Result Client::Get(const std::string &path) { return cli_->Get(path); } +inline Result Client::Get(const std::string &path, const Headers &headers) { + return cli_->Get(path, headers); +} +inline Result Client::Get(const std::string &path, Progress progress) { + return cli_->Get(path, std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + Progress progress) { + return cli_->Get(path, headers, std::move(progress)); +} +inline Result Client::Get(const std::string &path, + ContentReceiver content_receiver) { + return cli_->Get(path, std::move(content_receiver)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver) { + return cli_->Get(path, headers, std::move(content_receiver)); +} +inline Result Client::Get(const std::string &path, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, std::move(content_receiver), std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, headers, std::move(content_receiver), + std::move(progress)); +} +inline Result Client::Get(const std::string &path, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return cli_->Get(path, std::move(response_handler), + std::move(content_receiver)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return cli_->Get(path, headers, std::move(response_handler), + std::move(content_receiver)); +} +inline Result Client::Get(const std::string &path, + ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, std::move(response_handler), + std::move(content_receiver), std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, headers, std::move(response_handler), + std::move(content_receiver), std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Params ¶ms, + const Headers &headers, Progress progress) { + return cli_->Get(path, params, headers, std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Params ¶ms, + const Headers &headers, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, params, headers, std::move(content_receiver), + std::move(progress)); +} +inline Result Client::Get(const std::string &path, const Params ¶ms, + const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, Progress progress) { + return cli_->Get(path, params, headers, std::move(response_handler), + std::move(content_receiver), std::move(progress)); +} + +inline Result Client::Head(const std::string &path) { return cli_->Head(path); } +inline Result Client::Head(const std::string &path, const Headers &headers) { + return cli_->Head(path, headers); +} + +inline Result Client::Post(const std::string &path) { return cli_->Post(path); } +inline Result Client::Post(const std::string &path, const Headers &headers) { + return cli_->Post(path, headers); +} +inline Result Client::Post(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return cli_->Post(path, body, content_length, content_type); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return cli_->Post(path, headers, body, content_length, content_type); +} +inline Result Client::Post(const std::string &path, const std::string &body, + const std::string &content_type) { + return cli_->Post(path, body, content_type); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return cli_->Post(path, headers, body, content_type); +} +inline Result Client::Post(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Post(path, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Post(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Post(path, std::move(content_provider), content_type); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Post(path, headers, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Post(path, headers, std::move(content_provider), content_type); +} +inline Result Client::Post(const std::string &path, const Params ¶ms) { + return cli_->Post(path, params); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const Params ¶ms) { + return cli_->Post(path, headers, params); +} +inline Result Client::Post(const std::string &path, + const MultipartFormDataItems &items) { + return cli_->Post(path, items); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items) { + return cli_->Post(path, headers, items); +} +inline Result Client::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const std::string &boundary) { + return cli_->Post(path, headers, items, boundary); +} +inline Result +Client::Post(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + return cli_->Post(path, headers, items, provider_items); +} +inline Result Client::Put(const std::string &path) { return cli_->Put(path); } +inline Result Client::Put(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return cli_->Put(path, body, content_length, content_type); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return cli_->Put(path, headers, body, content_length, content_type); +} +inline Result Client::Put(const std::string &path, const std::string &body, + const std::string &content_type) { + return cli_->Put(path, body, content_type); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return cli_->Put(path, headers, body, content_type); +} +inline Result Client::Put(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Put(path, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Put(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Put(path, std::move(content_provider), content_type); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Put(path, headers, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Put(path, headers, std::move(content_provider), content_type); +} +inline Result Client::Put(const std::string &path, const Params ¶ms) { + return cli_->Put(path, params); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const Params ¶ms) { + return cli_->Put(path, headers, params); +} +inline Result Client::Put(const std::string &path, + const MultipartFormDataItems &items) { + return cli_->Put(path, items); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items) { + return cli_->Put(path, headers, items); +} +inline Result Client::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const std::string &boundary) { + return cli_->Put(path, headers, items, boundary); +} +inline Result +Client::Put(const std::string &path, const Headers &headers, + const MultipartFormDataItems &items, + const MultipartFormDataProviderItems &provider_items) { + return cli_->Put(path, headers, items, provider_items); +} +inline Result Client::Patch(const std::string &path) { + return cli_->Patch(path); +} +inline Result Client::Patch(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return cli_->Patch(path, body, content_length, content_type); +} +inline Result Client::Patch(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return cli_->Patch(path, headers, body, content_length, content_type); +} +inline Result Client::Patch(const std::string &path, const std::string &body, + const std::string &content_type) { + return cli_->Patch(path, body, content_type); +} +inline Result Client::Patch(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return cli_->Patch(path, headers, body, content_type); +} +inline Result Client::Patch(const std::string &path, size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Patch(path, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Patch(const std::string &path, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Patch(path, std::move(content_provider), content_type); +} +inline Result Client::Patch(const std::string &path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const std::string &content_type) { + return cli_->Patch(path, headers, content_length, std::move(content_provider), + content_type); +} +inline Result Client::Patch(const std::string &path, const Headers &headers, + ContentProviderWithoutLength content_provider, + const std::string &content_type) { + return cli_->Patch(path, headers, std::move(content_provider), content_type); +} +inline Result Client::Delete(const std::string &path) { + return cli_->Delete(path); +} +inline Result Client::Delete(const std::string &path, const Headers &headers) { + return cli_->Delete(path, headers); +} +inline Result Client::Delete(const std::string &path, const char *body, + size_t content_length, + const std::string &content_type) { + return cli_->Delete(path, body, content_length, content_type); +} +inline Result Client::Delete(const std::string &path, const Headers &headers, + const char *body, size_t content_length, + const std::string &content_type) { + return cli_->Delete(path, headers, body, content_length, content_type); +} +inline Result Client::Delete(const std::string &path, const std::string &body, + const std::string &content_type) { + return cli_->Delete(path, body, content_type); +} +inline Result Client::Delete(const std::string &path, const Headers &headers, + const std::string &body, + const std::string &content_type) { + return cli_->Delete(path, headers, body, content_type); +} +inline Result Client::Options(const std::string &path) { + return cli_->Options(path); +} +inline Result Client::Options(const std::string &path, const Headers &headers) { + return cli_->Options(path, headers); +} + +inline bool Client::send(Request &req, Response &res, Error &error) { + return cli_->send(req, res, error); +} + +inline Result Client::send(const Request &req) { return cli_->send(req); } + +inline void Client::stop() { cli_->stop(); } + +inline std::string Client::host() const { return cli_->host(); } + +inline int Client::port() const { return cli_->port(); } + +inline size_t Client::is_socket_open() const { return cli_->is_socket_open(); } + +inline socket_t Client::socket() const { return cli_->socket(); } + +inline void +Client::set_hostname_addr_map(std::map addr_map) { + cli_->set_hostname_addr_map(std::move(addr_map)); +} + +inline void Client::set_default_headers(Headers headers) { + cli_->set_default_headers(std::move(headers)); +} + +inline void Client::set_header_writer( + std::function const &writer) { + cli_->set_header_writer(writer); +} + +inline void Client::set_address_family(int family) { + cli_->set_address_family(family); +} + +inline void Client::set_tcp_nodelay(bool on) { cli_->set_tcp_nodelay(on); } + +inline void Client::set_socket_options(SocketOptions socket_options) { + cli_->set_socket_options(std::move(socket_options)); +} + +inline void Client::set_connection_timeout(time_t sec, time_t usec) { + cli_->set_connection_timeout(sec, usec); +} + +inline void Client::set_read_timeout(time_t sec, time_t usec) { + cli_->set_read_timeout(sec, usec); +} + +inline void Client::set_write_timeout(time_t sec, time_t usec) { + cli_->set_write_timeout(sec, usec); +} + +inline void Client::set_basic_auth(const std::string &username, + const std::string &password) { + cli_->set_basic_auth(username, password); +} +inline void Client::set_bearer_token_auth(const std::string &token) { + cli_->set_bearer_token_auth(token); +} +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::set_digest_auth(const std::string &username, + const std::string &password) { + cli_->set_digest_auth(username, password); +} +#endif + +inline void Client::set_keep_alive(bool on) { cli_->set_keep_alive(on); } +inline void Client::set_follow_location(bool on) { + cli_->set_follow_location(on); +} + +inline void Client::set_url_encode(bool on) { cli_->set_url_encode(on); } + +inline void Client::set_compress(bool on) { cli_->set_compress(on); } + +inline void Client::set_decompress(bool on) { cli_->set_decompress(on); } + +inline void Client::set_interface(const std::string &intf) { + cli_->set_interface(intf); +} + +inline void Client::set_proxy(const std::string &host, int port) { + cli_->set_proxy(host, port); +} +inline void Client::set_proxy_basic_auth(const std::string &username, + const std::string &password) { + cli_->set_proxy_basic_auth(username, password); +} +inline void Client::set_proxy_bearer_token_auth(const std::string &token) { + cli_->set_proxy_bearer_token_auth(token); +} +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::set_proxy_digest_auth(const std::string &username, + const std::string &password) { + cli_->set_proxy_digest_auth(username, password); +} +#endif + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::enable_server_certificate_verification(bool enabled) { + cli_->enable_server_certificate_verification(enabled); +} +#endif + +inline void Client::set_logger(Logger logger) { + cli_->set_logger(std::move(logger)); +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::set_ca_cert_path(const std::string &ca_cert_file_path, + const std::string &ca_cert_dir_path) { + cli_->set_ca_cert_path(ca_cert_file_path, ca_cert_dir_path); +} + +inline void Client::set_ca_cert_store(X509_STORE *ca_cert_store) { + if (is_ssl_) { + static_cast(*cli_).set_ca_cert_store(ca_cert_store); + } else { + cli_->set_ca_cert_store(ca_cert_store); + } +} + +inline void Client::load_ca_cert_store(const char *ca_cert, std::size_t size) { + set_ca_cert_store(cli_->create_ca_cert_store(ca_cert, size)); +} + +inline long Client::get_openssl_verify_result() const { + if (is_ssl_) { + return static_cast(*cli_).get_openssl_verify_result(); + } + return -1; // NOTE: -1 doesn't match any of X509_V_ERR_??? +} + +inline SSL_CTX *Client::ssl_context() const { + if (is_ssl_) { return static_cast(*cli_).ssl_context(); } + return nullptr; +} +#endif + +// ---------------------------------------------------------------------------- + +} // namespace httplib + +#if defined(_WIN32) && defined(CPPHTTPLIB_USE_POLL) +#undef poll +#endif + +#endif // CPPHTTPLIB_HTTPLIB_H \ No newline at end of file diff --git a/examples/server/server.cc b/examples/server/server.cc new file mode 100644 index 0000000..c62e989 --- /dev/null +++ b/examples/server/server.cc @@ -0,0 +1,273 @@ +#include "cortex-common/enginei.h" +#include "dylib.h" +#include "httplib.h" +#include "json/reader.h" + +#include +#include +#include +#include +#include "trantor/utils/Logger.h" + +class Server { + public: + Server() { + try { + dylib_ = std::make_unique("./engines/cortex.onnx", "engine"); + auto func = dylib_->get_function("get_engine"); + engine_ = func(); + } catch(const std::exception& e) { + LOG_WARN << e.what(); + } + } + + ~Server() { + if (engine_) { + delete engine_; + } + } + + public: + std::unique_ptr dylib_; + EngineI* engine_; + + struct SyncQueue { + void push(std::pair&& p) { + std::unique_lock l(mtx); + q.push(p); + cond.notify_one(); + } + + std::pair wait_and_pop() { + std::unique_lock l(mtx); + cond.wait(l, [this] { return !q.empty(); }); + auto res = q.front(); + q.pop(); + return res; + } + + std::mutex mtx; + std::condition_variable cond; + // Status and result + std::queue> q; + }; +}; + +std::function shutdown_handler; +std::atomic_flag is_terminating = ATOMIC_FLAG_INIT; + +inline void signal_handler(int signal) { + if (is_terminating.test_and_set()) { + // in case it hangs, we can force terminate the server by hitting Ctrl+C twice + // this is for better developer experience, we can remove when the server is stable enough + fprintf(stderr, "Received second interrupt, terminating immediately.\n"); + exit(1); + } + + shutdown_handler(signal); +} + +using SyncQueue = Server::SyncQueue; + +int main(int argc, char** argv) { + std::string hostname = "127.0.0.1"; + int port = 3928; + if (argc > 1) { + hostname = argv[1]; + } + + // Check for port argument + if (argc > 2) { + port = std::atoi(argv[2]); // Convert string argument to int + } + + Server server; + Json::Reader r; + auto svr = std::make_unique(); + + if (!svr->bind_to_port(hostname, port)) { + fprintf(stderr, "\ncouldn't bind to server socket: hostname=%s port=%d\n\n", + hostname.c_str(), port); + return 1; + } + + auto process_non_stream_res = [&server](httplib::Response& resp, + SyncQueue& q) { + auto [status, res] = q.wait_and_pop(); + resp.set_content(res.toStyledString().c_str(), + "application/json; charset=utf-8"); + resp.status = status["status_code"].asInt(); + }; + + auto process_stream_res = [&server](httplib::Response& resp, + std::shared_ptr q) { + const auto chunked_content_provider = + [&server, q](size_t size, httplib::DataSink& sink) { + while (true) { + auto [status, res] = q->wait_and_pop(); + auto str = res["data"].asString(); + LOG_TRACE << "data: " << str; + + if (!sink.write(str.c_str(), str.size())) { + LOG_WARN << "Failed to write"; + // return false; + } + if (status["has_error"].asBool() || status["is_done"].asBool()) { + LOG_INFO << "Done"; + sink.done(); + break; + } + } + + return true; + }; + resp.set_chunked_content_provider("text/event-stream", + chunked_content_provider, + [](bool) { LOG_INFO << "Done"; }); + }; + + const auto handle_load_model = [&](const httplib::Request& req, + httplib::Response& resp) { + resp.set_header("Access-Control-Allow-Origin", + req.get_header_value("Origin")); + auto req_body = std::make_shared(); + r.parse(req.body, *req_body); + server.engine_->LoadModel( + req_body, [&server, &resp](Json::Value status, Json::Value res) { + resp.set_content(res.toStyledString().c_str(), + "application/json; charset=utf-8"); + resp.status = status["status_code"].asInt(); + }); + }; + + const auto handle_unload_model = [&](const httplib::Request& req, + httplib::Response& resp) { + resp.set_header("Access-Control-Allow-Origin", + req.get_header_value("Origin")); + auto req_body = std::make_shared(); + r.parse(req.body, *req_body); + server.engine_->UnloadModel( + req_body, [&server, &resp](Json::Value status, Json::Value res) { + resp.set_content(res.toStyledString().c_str(), + "application/json; charset=utf-8"); + resp.status = status["status_code"].asInt(); + }); + }; + + const auto handle_completions = [&](const httplib::Request& req, + httplib::Response& resp) { + resp.set_header("Access-Control-Allow-Origin", + req.get_header_value("Origin")); + auto req_body = std::make_shared(); + r.parse(req.body, *req_body); + bool is_stream = (*req_body).get("stream", false).asBool(); + // This is an async call, need to use queue + auto q = std::make_shared(); + server.engine_->HandleChatCompletion( + req_body, [&server, q](Json::Value status, Json::Value res) { + q->push(std::make_pair(status, res)); + }); + if (is_stream) { + process_stream_res(resp, q); + } else { + process_non_stream_res(resp, *q); + } + }; + + const auto handle_embeddings = [&](const httplib::Request& req, + httplib::Response& resp) { + resp.set_header("Access-Control-Allow-Origin", + req.get_header_value("Origin")); + auto req_body = std::make_shared(); + r.parse(req.body, *req_body); + // This is an async call, need to use queue + SyncQueue q; + server.engine_->HandleEmbedding( + req_body, [&server, &q](Json::Value status, Json::Value res) { + q.push(std::make_pair(status, res)); + }); + process_non_stream_res(resp, q); + }; + + const auto handle_get_model_status = [&](const httplib::Request& req, + httplib::Response& resp) { + resp.set_header("Access-Control-Allow-Origin", + req.get_header_value("Origin")); + auto req_body = std::make_shared(); + r.parse(req.body, *req_body); + server.engine_->GetModelStatus( + req_body, [&server, &resp](Json::Value status, Json::Value res) { + resp.set_content(res.toStyledString().c_str(), + "application/json; charset=utf-8"); + resp.status = status["status_code"].asInt(); + }); + }; + + const auto handle_get_running_models = [&](const httplib::Request& req, + httplib::Response& resp) { + resp.set_header("Access-Control-Allow-Origin", + req.get_header_value("Origin")); + auto req_body = std::make_shared(); + r.parse(req.body, *req_body); + server.engine_->GetModels( + req_body, [&server, &resp](Json::Value status, Json::Value res) { + resp.set_content(res.toStyledString().c_str(), + "application/json; charset=utf-8"); + resp.status = status["status_code"].asInt(); + }); + }; + + svr->Post("/loadmodel", handle_load_model); + // Use POST since httplib does not read request body for GET method + svr->Post("/unloadmodel", handle_unload_model); + svr->Post("/v1/chat/completions", handle_completions); + svr->Post("/v1/embeddings", handle_embeddings); + svr->Post("/modelstatus", handle_get_model_status); + svr->Get("/models", handle_get_running_models); + std::atomic running = true; + svr->Delete("/destroy", + [&](const httplib::Request& req, httplib::Response& resp) { + LOG_INFO << "Received Stop command"; + running = false; + }); + + LOG_INFO << "HTTP server listening: " << hostname << ":" << port; + svr->new_task_queue = [] { + return new httplib::ThreadPool(5); + }; + // run the HTTP server in a thread - see comment below + std::thread t([&]() { + if (!svr->listen_after_bind()) { + return 1; + } + + return 0; + }); + + shutdown_handler = [&](int) { + running = false; + }; +#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) + struct sigaction sigint_action; + sigint_action.sa_handler = signal_handler; + sigemptyset(&sigint_action.sa_mask); + sigint_action.sa_flags = 0; + sigaction(SIGINT, &sigint_action, NULL); + sigaction(SIGTERM, &sigint_action, NULL); +#elif defined(_WIN32) + auto console_ctrl_handler = +[](DWORD ctrl_type) -> BOOL { + return (ctrl_type == CTRL_C_EVENT) ? (signal_handler(SIGINT), true) : false; + }; + SetConsoleCtrlHandler( + reinterpret_cast(console_ctrl_handler), true); +#endif + + while (running) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + } + + svr->stop(); + t.join(); + LOG_DEBUG << "Server shutdown"; + return 0; +} \ No newline at end of file diff --git a/onnxruntime-genai b/onnxruntime-genai new file mode 160000 index 0000000..f36396f --- /dev/null +++ b/onnxruntime-genai @@ -0,0 +1 @@ +Subproject commit f36396f82d6b15165124a04c1007c305492a8b0f diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..cd09374 --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,45 @@ +cmake_minimum_required(VERSION 3.18.1) + +project(cortex.onnx) +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++2a") + +option(USE_CXX "Invoke the C++ example" ON) + +if(USE_CXX) + add_compile_definitions(USE_CXX) +endif() + +set(ORT_GENAI_LIB_DIR ${CMAKE_SOURCE_DIR}/lib) + +if(WIN32) + set(ONNXRUNTIME_GENAI_LIB "onnxruntime-genai.dll") + set(ONNXRUNTIME_GENAI_DEPENDENCY "*.dll") +elseif(APPLE) + set(ONNXRUNTIME_GENAI_LIB "libonnxruntime-genai.dylib") + set(ONNXRUNTIME_GENAI_DEPENDENCY "*.dylib") +else() + set(ONNXRUNTIME_GENAI_LIB "libonnxruntime-genai.so") + set(ONNXRUNTIME_GENAI_DEPENDENCY "*.so") +endif() + +add_executable(phi3 ${CMAKE_SOURCE_DIR}/onnx_engine.cc) + + +target_link_directories(phi3 PRIVATE ${ORT_GENAI_LIB_DIR}) +target_link_libraries(phi3 PRIVATE ${ONNXRUNTIME_GENAI_LIB}) +target_include_directories(phi3 PRIVATE ${CMAKE_SOURCE_DIR}/../onnxruntime-genai/src/) + +target_link_libraries( + phi3 + PUBLIC + onnxruntime-genai) + +file(GLOB ort_genai_libs "${CMAKE_SOURCE_DIR}/lib/${ONNXRUNTIME_GENAI_DEPENDENCY}") + +foreach(DLL_FILE ${ort_genai_libs}) + add_custom_command( + TARGET phi3 POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${DLL_FILE} $ + ) +endforeach() \ No newline at end of file diff --git a/src/chat_completion_request.h b/src/chat_completion_request.h new file mode 100644 index 0000000..1d2542b --- /dev/null +++ b/src/chat_completion_request.h @@ -0,0 +1,34 @@ +#pragma once +#include "json/value.h" + +namespace onnx::inferences { +struct ChatCompletionRequest { + bool stream = false; + int max_tokens = 500; + float top_p = 0.95f; + float temperature = 0.8f; + float frequency_penalty = 0; + float presence_penalty = 0; + Json::Value stop = Json::Value(Json::arrayValue); + Json::Value messages = Json::Value(Json::arrayValue); + std::string model_id; +}; + +inline ChatCompletionRequest fromJson(std::shared_ptr jsonBody) { + ChatCompletionRequest completion; + if (jsonBody) { + completion.stream = (*jsonBody).get("stream", false).asBool(); + completion.max_tokens = (*jsonBody).get("max_tokens", 500).asInt(); + completion.top_p = (*jsonBody).get("top_p", 0.95).asFloat(); + completion.temperature = (*jsonBody).get("temperature", 0.8).asFloat(); + completion.frequency_penalty = + (*jsonBody).get("frequency_penalty", 0).asFloat(); + completion.presence_penalty = + (*jsonBody).get("presence_penalty", 0).asFloat(); + completion.messages = (*jsonBody)["messages"]; + completion.stop = (*jsonBody)["stop"]; + completion.model_id = (*jsonBody).get("model", {}).asString(); + } + return completion; +} +} // namespace llama::inferences \ No newline at end of file diff --git a/src/onnx_engine.cc b/src/onnx_engine.cc new file mode 100644 index 0000000..42c40e5 --- /dev/null +++ b/src/onnx_engine.cc @@ -0,0 +1,350 @@ +#include "onnx_engine.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include "chat_completion_request.h" +#include "json/writer.h" +#include "trantor/utils/Logger.h" + +namespace cortex_onnx { +namespace { +constexpr const int k200OK = 200; +constexpr const int k400BadRequest = 400; +constexpr const int k409Conflict = 409; +constexpr const int k500InternalServerError = 500; + +Json::Value CreateFullReturnJson(const std::string& id, + const std::string& model, + const std::string& content, + const std::string& system_fingerprint, + int prompt_tokens, int completion_tokens, + Json::Value finish_reason = Json::Value()) { + Json::Value root; + + root["id"] = id; + root["model"] = model; + root["created"] = static_cast(std::time(nullptr)); + root["object"] = "chat.completion"; + root["system_fingerprint"] = system_fingerprint; + + Json::Value choicesArray(Json::arrayValue); + Json::Value choice; + + choice["index"] = 0; + Json::Value message; + message["role"] = "assistant"; + message["content"] = content; + choice["message"] = message; + choice["finish_reason"] = finish_reason; + + choicesArray.append(choice); + root["choices"] = choicesArray; + + Json::Value usage; + usage["prompt_tokens"] = prompt_tokens; + usage["completion_tokens"] = completion_tokens; + usage["total_tokens"] = prompt_tokens + completion_tokens; + root["usage"] = usage; + + return root; +} + +std::string CreateReturnJson(const std::string& id, const std::string& model, + const std::string& content, + Json::Value finish_reason = Json::Value()) { + Json::Value root; + + root["id"] = id; + root["model"] = model; + root["created"] = static_cast(std::time(nullptr)); + root["object"] = "chat.completion.chunk"; + + Json::Value choicesArray(Json::arrayValue); + Json::Value choice; + + choice["index"] = 0; + Json::Value delta; + delta["content"] = content; + choice["delta"] = delta; + choice["finish_reason"] = finish_reason; + + choicesArray.append(choice); + root["choices"] = choicesArray; + + Json::StreamWriterBuilder writer; + writer["indentation"] = ""; // This sets the indentation to an empty string, + // producing compact output. + return Json::writeString(writer, root); +} + +std::string GenerateRandomString(std::size_t length) { + const std::string characters = + "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + + std::random_device rd; + std::mt19937 generator(rd()); + + std::uniform_int_distribution<> distribution( + 0, static_cast(characters.size()) - 1); + + std::string random_string(length, '\0'); + std::generate_n(random_string.begin(), length, + [&]() { return characters[distribution(generator)]; }); + + return random_string; +} + +} // namespace + +OnnxEngine::OnnxEngine() { + handle_ = std::make_unique(); +} + +void OnnxEngine::LoadModel( + std::shared_ptr jsonBody, + std::function&& callback) { + auto path = jsonBody->get("model_path", "").asString(); + user_prompt_ = jsonBody->get("user_prompt", "USER: ").asString(); + ai_prompt_ = jsonBody->get("ai_prompt", "ASSISTANT: ").asString(); + system_prompt_ = + jsonBody->get("system_prompt", "ASSISTANT's RULE: ").asString(); + pre_prompt_ = jsonBody->get("pre_prompt", "").asString(); + try { + std::cout << "Creating model..." << std::endl; + oga_model_ = OgaModel::Create(path.c_str()); + std::cout << "Creating tokenizer..." << std::endl; + tokenizer_ = OgaTokenizer::Create(*oga_model_); + tokenizer_stream_ = OgaTokenizerStream::Create(*tokenizer_); + Json::Value json_resp; + json_resp["message"] = "Model loaded successfully"; + Json::Value status; + status["is_done"] = true; + status["has_error"] = false; + status["is_stream"] = false; + status["status_code"] = k200OK; + callback(std::move(status), std::move(json_resp)); + LOG_INFO << "Model loaded successfully: " << path; + model_loaded_ = true; + } catch (const std::exception& e) { + std::cout << e.what() << std::endl; + oga_model_.reset(); + tokenizer_.reset(); + tokenizer_stream_.reset(); + Json::Value json_resp; + json_resp["message"] = "Failed to load model"; + Json::Value status; + status["is_done"] = false; + status["has_error"] = true; + status["is_stream"] = false; + status["status_code"] = k500InternalServerError; + callback(std::move(status), std::move(json_resp)); + } +} + +void OnnxEngine::HandleChatCompletion( + std::shared_ptr jsonBody, + std::function&& callback) { + if (!CheckModelLoaded(callback)) + return; + auto req = onnx::inferences::fromJson(jsonBody); + auto is_stream = jsonBody->get("stream", false).asBool(); + + std::string formatted_output; + for (const auto& message : req.messages) { + std::string input_role = message["role"].asString(); + std::string role; + if (input_role == "user") { + role = user_prompt_; + std::string content = message["content"].asString(); + formatted_output += role + content; + } else if (input_role == "assistant") { + role = ai_prompt_; + std::string content = message["content"].asString(); + formatted_output += role + content; + } else if (input_role == "system") { + role = system_prompt_; + std::string content = message["content"].asString(); + formatted_output = role + content + formatted_output; + } else { + role = input_role; + std::string content = message["content"].asString(); + formatted_output += role + content; + } + } + formatted_output += ai_prompt_; + + LOG_DEBUG << formatted_output; + + try { + if (req.stream) { + auto sequences = OgaSequences::Create(); + tokenizer_->Encode(formatted_output.c_str(), *sequences); + + auto params = OgaGeneratorParams::Create(*oga_model_); + // TODO(sang) + params->SetSearchOption("max_length", req.max_tokens); + params->SetSearchOption("top_p", req.top_p); + params->SetSearchOption("temperature", req.temperature); + // params->SetSearchOption("repetition_penalty", 0.95); + params->SetInputSequences(*sequences); + + auto generator = OgaGenerator::Create(*oga_model_, *params); + while (!generator->IsDone()) { + generator->ComputeLogits(); + generator->GenerateNextToken(); + + const int32_t num_tokens = generator->GetSequenceCount(0); + int32_t new_token = generator->GetSequenceData(0)[num_tokens - 1]; + auto out_string = tokenizer_stream_->Decode(new_token); + std::cout << out_string; + const std::string str = + "data: " + CreateReturnJson(GenerateRandomString(20), "_", out_string) + "\n\n"; + Json::Value resp_data; + resp_data["data"] = str; + Json::Value status; + status["is_done"] = false; + status["has_error"] = false; + status["is_stream"] = true; + status["status_code"] = k200OK; + callback(std::move(status), std::move(resp_data)); + } + + LOG_INFO << "End of result"; + Json::Value resp_data; + const std::string str = + "data: " + CreateReturnJson("gdsf", "_", "", "stop") + "\n\n" + + "data: [DONE]" + "\n\n"; + resp_data["data"] = str; + Json::Value status; + status["is_done"] = true; + status["has_error"] = false; + status["is_stream"] = true; + status["status_code"] = k200OK; + callback(std::move(status), std::move(resp_data)); + } else { + auto sequences = OgaSequences::Create(); + tokenizer_->Encode(formatted_output.c_str(), *sequences); + + auto params = OgaGeneratorParams::Create(*oga_model_); + params->SetSearchOption("max_length", req.max_tokens); + params->SetSearchOption("top_p", req.top_p); + params->SetSearchOption("temperature", req.temperature); + params->SetSearchOption("repetition_penalty", req.frequency_penalty); + params->SetInputSequences(*sequences); + + auto output_sequences = oga_model_->Generate(*params); + const auto output_sequence_length = output_sequences->SequenceCount(0); + const auto* output_sequence_data = output_sequences->SequenceData(0); + auto out_string = + tokenizer_->Decode(output_sequence_data, output_sequence_length); + + std::cout << "Output: " << std::endl << out_string << std::endl; + + // TODO(sang) + std::string to_send = out_string.p_; + auto resp_data = CreateFullReturnJson(GenerateRandomString(20), "_", to_send, "_", 0, 0); + Json::Value status; + status["is_done"] = true; + status["has_error"] = false; + status["is_stream"] = false; + status["status_code"] = k200OK; + callback(std::move(status), std::move(resp_data)); + } + } catch (const std::exception& e) { + std::cout << e.what() << std::endl; + Json::Value json_resp; + json_resp["message"] = "Error during inference"; + Json::Value status; + status["is_done"] = false; + status["has_error"] = true; + status["is_stream"] = false; + status["status_code"] = k500InternalServerError; + callback(std::move(status), std::move(json_resp)); + } +} + +void OnnxEngine::HandleEmbedding( + std::shared_ptr json_body, + std::function&& callback) { + LOG_WARN << "Engine does not support embedding yet"; +} + +void OnnxEngine::UnloadModel( + std::shared_ptr json_body, + std::function&& callback) { + if (!CheckModelLoaded(callback)) + return; + oga_model_.reset(); + tokenizer_.reset(); + tokenizer_stream_.reset(); + model_loaded_ = false; + + Json::Value json_resp; + json_resp["message"] = "Model unloaded successfully"; + Json::Value status; + status["is_done"] = true; + status["has_error"] = false; + status["is_stream"] = false; + status["status_code"] = k200OK; + callback(std::move(status), std::move(json_resp)); + LOG_INFO << "Model unloaded sucessfully"; +} +void OnnxEngine::GetModelStatus( + std::shared_ptr json_body, + std::function&& callback) { + Json::Value json_resp; + json_resp["message"] = "Engine does not support get model status method yet"; + Json::Value status; + status["is_done"] = false; + status["has_error"] = true; + status["is_stream"] = false; + status["status_code"] = k409Conflict; + callback(std::move(status), std::move(json_resp)); + LOG_WARN << "Engine does not support get model status method yet"; +} + +// API to get running models. +void OnnxEngine::GetModels( + std::shared_ptr json_body, + std::function&& callback) { + Json::Value json_resp; + json_resp["message"] = "Engine does not support get models method yet"; + Json::Value status; + status["is_done"] = false; + status["has_error"] = true; + status["is_stream"] = false; + status["status_code"] = k409Conflict; + callback(std::move(status), std::move(json_resp)); + LOG_WARN << "Engine does not support get models method yet"; +} + +bool OnnxEngine::CheckModelLoaded( + std::function& callback) { + if (!model_loaded_) { + LOG_WARN << "Error: model is not loaded yet"; + Json::Value json_resp; + json_resp["message"] = + "Model has not been loaded, please load model into cortex.onnx"; + Json::Value status; + status["is_done"] = false; + status["has_error"] = true; + status["is_stream"] = false; + status["status_code"] = k409Conflict; + callback(std::move(status), std::move(json_resp)); + return false; + } + return true; +} + +} // namespace cortex_onnx + +extern "C" { +EngineI* get_engine() { + return new cortex_onnx::OnnxEngine(); +} +} \ No newline at end of file diff --git a/src/onnx_engine.h b/src/onnx_engine.h new file mode 100644 index 0000000..9ee2da6 --- /dev/null +++ b/src/onnx_engine.h @@ -0,0 +1,50 @@ +#pragma once +#include +#include +#include +#include "cortex-common/enginei.h" +#include "json/value.h" +#include "ort_genai.h" +#include "ort_genai_c.h" + +namespace cortex_onnx { +class OnnxEngine : public EngineI { + public: + OnnxEngine(); + void HandleChatCompletion( + std::shared_ptr json_body, + std::function&& callback) final; + void HandleEmbedding( + std::shared_ptr json_body, + std::function&& callback) final; + void LoadModel( + std::shared_ptr json_body, + std::function&& callback) final; + void UnloadModel( + std::shared_ptr json_body, + std::function&& callback) final; + void GetModelStatus( + std::shared_ptr json_body, + std::function&& callback) final; + + // API to get running models. + void GetModels( + std::shared_ptr json_body, + std::function&& callback) final; + + private: + bool CheckModelLoaded( + std::function& callback); + + private: + std::unique_ptr handle_; + std::unique_ptr oga_model_ = nullptr; + std::unique_ptr tokenizer_ = nullptr; + std::unique_ptr tokenizer_stream_ = nullptr; + std::atomic model_loaded_; + std::string user_prompt_; + std::string ai_prompt_; + std::string system_prompt_; + std::string pre_prompt_; +}; +} // namespace cortex_onnx \ No newline at end of file diff --git a/third-party/CMakeLists.txt b/third-party/CMakeLists.txt new file mode 100644 index 0000000..a170c38 --- /dev/null +++ b/third-party/CMakeLists.txt @@ -0,0 +1,50 @@ + +cmake_minimum_required(VERSION 3.12.0 FATAL_ERROR) +project(MyProject) +include(ExternalProject) + +if(UNIX AND NOT APPLE) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") + add_compile_options(-fPIC) +endif() + +# Define variables +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) +set(THIRD_PARTY_INSTALL_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../build_deps/_install) + +ExternalProject_Add( + c-ares + GIT_REPOSITORY https://github.com/c-ares/c-ares + GIT_TAG cares-1_26_0 + CMAKE_ARGS + -DCARES_SHARED=OFF + -DCARES_STATIC=ON + -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} + -DCMAKE_INSTALL_PREFIX=${THIRD_PARTY_INSTALL_PATH} +) + +ExternalProject_Add( + trantor + GIT_REPOSITORY https://github.com/an-tao/trantor + GIT_TAG v1.5.18 + CMAKE_ARGS + -DBUILD_SHARED_LIBS=OFF + -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} + -DCMAKE_PREFIX_PATH=${THIRD_PARTY_INSTALL_PATH} + -DCMAKE_INSTALL_PREFIX=${THIRD_PARTY_INSTALL_PATH} +) + +ExternalProject_Add( + jsoncpp + GIT_REPOSITORY https://github.com/open-source-parsers/jsoncpp + GIT_TAG 1.9.5 + CMAKE_ARGS + -DBUILD_SHARED_LIBS=OFF + -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} + -DCMAKE_INSTALL_PREFIX=${THIRD_PARTY_INSTALL_PATH} +) + +add_dependencies(trantor c-ares) + +#TODO: add ort to third-party +include(onnxruntime.cmake) \ No newline at end of file diff --git a/third-party/DirectML.dll b/third-party/DirectML.dll new file mode 100644 index 0000000000000000000000000000000000000000..dc2a7a529df646d793b067cabe5bfa324543dff7 GIT binary patch literal 17801648 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

*KsRdXNZWrTw{M}(g7lD}13Pi*Tq)(PK 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 &EF|@u}vv5K8QUNM@sD`z?n&Mv@oSNjt=Oynq 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%0A6`@@slu+&P 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%0AC?lh+zT0buGPzirt7&(E9-XD!7`-1 z(yg#m${~h0N#xX>k|tMnO_M9%ST;PJdKp5$L0*Mvmu=F`=%S=4joS{hOmi(_W#xo#vctWnpf<1wq;QH~iz`Kn7-9+xAUjEYi)) zxHP`$bZHm$4u~aOAVCpJr{xSu_!~C&H{pdtZ4+cW$)B;2CbV8f(G5Inw|nlv|0^Ds zX93Uec^>1@FsA8=65As7!;?R6u_y4`?T2-GZRwwl-}&nKp;TW@|7=XpkETnq=Eq#) zarLP`9O2#p^v^na`b+cU3Wc)XiN3X9#c2hMMtUmfc8fahMkggb=Klk{3yd#QhaHhV z;mNc=$dUGM+j09vp4s-d9rV@hSE{dW|4W(nU!2{3;|b_LE?*na{$~cZKdp~HO{Y5% z@4=EnaPqQV;K~1il9p|9#y(QA3BNP;k0o8at0jogW*rD3;9!u?|14-^(;`|GcHgLm zpHU)(5*Caq6q`3k+{bE3%eAR>B?m=PhelGD74j6p_LAV%}r@jV0v&{24|rhMU8hkRZ5)+ z18^!wpici8+Lz@|D*ti?W_YKObc25`d%bGT6*;mblWO;U$-Dd%+{a-^iMt`RQo|MY zPTpk&GmI}@4ZEAe&O`r-=lxUCMJO)7Hb+%rM7WrzoTrMXhNo7_-Lst2p5pB#$c1-P zD{rYrOe{nMC2UOPhDXUC!>d#96VAXyl@7sAz1SHsO=sW}uOTXe<3@A5HX=SuSb}ZCRX^3zSpc6fyPbZEkS+K7()$gYZKJ;c^Dys+wxe;__fL>dJ%RxTZWk z9@XWU0g08TM`V6^Lb=)@X)NE-n5-3-vSx-e`{hE7RHq#WLbHdZBN!IdvF?QbOT%LN zqi0MoGPcv6o20=pF@38;m9IKCyv}$?CXQ3%Yf7pT$R=QNJLWE^pie_y{;`n@J5{U6 z$v++{K!-lw!f(_)n{CV4MRk{oSg$}zEX*0=h&(quDm5V=AA%_pV1&mJOPMkTKSC)J zO7SC-G6e%d;pzAz0w-f4YPvZG^rp@7yH-dF#hWrW;w=zF_)jPx+Ayh5oojBSEefO# z-h$F2scqQek0j8@1ic4GsPD<@%1d%)k8n5iqo?jmur{xTNg_fRk>R;c|;x=>uRYu)esfK2w(eI$HX z3Eu`I`jbc%&}^)C#aaLlf6}g?@W20+S?`L7*^d8x3H@X^-8=toe-W9I9bofN&gP_) zZG>S`2@5kZ8;z8Bsv7LP2Y)dZD-ht5Hf~{o&2Y|>?&B{Uw^(`1&ayyFE<{` z^*T})Hp8_w6{54=USn24)qFd7`2pv(r=%Cf&D=b9AA%s(V&B)*l9ZVwYh)(LAudgj75akXu$>$-bdL6V}s>$@%+NMPW z>)S|b!D5`TRMQgkTA&`}vo`a(tCJTthPw2kuR_bG^BKLR4wn4SgukeRcR`E5kG#XB zzH^Im>c(R@Y1tU|2@!U`HGa*d2t|0_CVc^n*Vs7!%9#Y4ER~cjO#+>VzAPw35Xlon zX;L4zDmX3%^f)fA$`;H&16#m$rWU@HnW=ooOdWCnGu6JsU>EQrId?ohbTG)0L~?{t`#vInEih`xMf`(Z_$`9=yW;ANSzQg{Ua?rY~A_ z8XqvNofBceH=Ci-*wN4GXdAG>Z)V>hxw&%TdrALPNy2Ha z)tDF&PJpAJT0u3~w1KHHmlbV^MsThO#RI`5eF&JvscSf0Sp=z!baPe}5z4Gw<=k)) zscAem!_4hDx>F%5(XuLPR<_F46%rBauVBQuq%Gm7sBb{b%!~_=I7FpX=t4416|u@q zPNVFqN4-Z%e3GQ;GcF7$Nh0Xc)Ip#d$%ijAwPF{i>G$C6h&Qj8+Eko??4C$O#6zN$ zuhor+q%eQ6nwdk!-8b@`mRZmk7LBNkKlbtu%&J;tO76KtT>p!d=h@_$c)WrvbLzey zb006o6>%R|8L)TiCW&rQ@0wE3XNAEKlwxVD{vtXq%Ps;=(MD=P9`$W>U9@4%X1tMx z4!vTP=Ya{EMp1}XdC}FT(>OAITIg37z!dLF!t73q&|kWpV7k-zg>uex8sj&rBzX+9 zTqohxDD{V%+UifNt{Chz&1e4@@orOdsw*a{&z={2mm+GXKC|3JI&pfp=yCNKW7B1) z{=c}ZR2#)wQ)!QUXQeYmY26tl3CxC#J=Q-y-^YXrlZ;h2;;=v zs$PAZ5ym-<#WadS<}a6xMp6i!{9|KfpG1*Zoa~LV>eQgNf#N*ZBhG`EY+9Tr&yWin z{PW1+!WTrTC07+X4=u3McB#QAENxHirh?*y(Xx2XzsC}wc>B?*{Wu_j zT4T)|uTOk=vVWKB)QuqUdjDn=Z5Yv+{?O%Sf&9vx$C9&2xM5SU^lXJ@e2DP?6}PBTB{QRWmv2UJJ+j z^}4b&et;Y;_g{JdHii@#?_O?S@i;;`W1;h6vNz(l3R< zoo#;P0OX+j@#go{bGVGiKhn6na0km&=9T8RJhCFaIQ`|_4E-sJaXb1`@)y&;@zwm6 zP2kk8kZFuQ{pRmezYjy?}0`F7ic(eX|b@}zrh(7i(n9@RnW%vvr31h!~AcO&AQefQFJ}e z^*kw_TX^o`xu54@o|QaL@@(MIAZXEG<*@fpWawq#Ol#J0@8#)n8Q+~I8oDSGi62-( z$dPUpz}M32LYye&*YTfYH-~zuW@k;vt1B7Q_)6VQ611DH2KS8KGASQf zq&0Oz!i`(td9d#!%BW$1if0<*3fMs#AP!mUU(97!D*-@EsNAo5IE~*{*)o%p^mFTm zOE}4CdWmipVY!Btzm>@8>~!n)T5e9S%i1~p%A{JZ({HOZnu;$JksuOhT$_ZEsShj& zu&w|0y(1`twL{{BS{I7_zccx%gRorP?h*I)797MvJ>8VR>8}=ka+??7c5hn3FAAy9 zusAYSd72jCb5}cIQMZe6(-Cz;16!0mMb<=5aueF!O>M-Qa>W5UQB^4ygR^XaqCIL} z2v|zcvJBp58Y_Q7|M<`SZgfr$@uwBp7Kqn&ek;#He@~&iNpz6wV3ifB$2}Wzs!3J$ zcR6V@Otm&$$C3Y6U_y5kNAud~9PSY`J2|(DzDg}vruxx&P-BoD{=7fh{;Hxhs08*q z{_nwUs&_3n73%O}KSl?6zDV+#H8XSThoSQNBq@pSYo}qAt1f>_cpFHl86e*q@or8~ zmTYSmMT#O`!uUpvPdG(Yi{KE!wu&r)U9<>)8~!Eu;TVl?!@miC7k+9!Uhd72z5!e5JD?plmBGv2gLqjH#PPZPEumC-vG zl{w@5;~&QEf!QnwjD=4}fNv#RDijvTmR6;A{n{+}o4Exm*bMv$20y4+VrA?XUfLsz zmHopuHUs`BGF|6Ct}h1s+4G8tOU0N$Cs5e+x(9nNh69q-by11Z46|z+YK(v8za@@_TJ>ygPi6EM4g@6PMH^8^&Z0X zk2dCXrAD%in4f6m9nI_Pdn4jvhAAz1H#y=JyfzxlA1uq{E3|G z@K0%J#G_Kg;WRj}SY1-=|32X5TW=;;{{hPA)}f5P5zf!f@7E?jBwUFzs{lBZ41{ua zWsj4|CHtEzvg%;g3;T`ga8q!evV9$1QXNWyI%s9d&hLP%{LBi|pWg>xk>63Tk>86N zT@Pr7m?Ssl=m&&*&di??AWHR$Rb5SY-FWN|xgRXQDV4CB2JkvE~jw)AtK@a*H&@x*$qxJ5VkvYF<8kuw8JZypRT*Y%UPY2Hz zJi9fI%sGK)2G89*f983gXE5I#!*deP4|yuU6FDQl@-KH#p48_@77j&ke&=1Bq7mS- zetIWR3awmX@K(&lZs~_ncZ|7w;RUB@9-TF=ts|75!%cT}lcJTYX3vULuAY4nf)faL zoKaHhj%t8(hCCnDe)%z1?1L4{e7XocTK_|4a0MJu-Eqq55KRrm@G3c6{n| z<5UGLhuzYU!NTCd5u@PeylHy#8UJ3?zmS*s3%@2$;{Um;dXvq1V#RBu@*9*S^YshF zuIN_yg$hsqsl8*2{ulZymcHYvp;{W}haO5}>80! zAf}kN^XfXVv^&3{rd7!KslGSd?-xbAQwtL-Hjx>|ap#dPaTOf<)L=VCJi z+HFJtORTsY_n2*urVEq-zV-e}X!534>JEq9%H1v-dq$h%EXDjBY{cZ+2;|VO{aZjC zR;>4vqUBwV!~n&Yek)MqFl$FVw*E@yqv#;S&e#81h0Un8{-^>NEyonx9;qPpbM?=(`YR1vo*KnjR8evC22< zjyCc}>eDZG-bB9cW1^ytSH^vMGPA#qi@wD2YQG$S+u+yTg_-a>MZvqp7<}>>gP~mN z2z(jr!W~C;z`CODS?n~=LXhk;RFPh(J2SG3y!Cf{q;jLv+^$cg*SNQoBk25R{J9Mx zUewk$o=({y4MyQVk;>$g@Rz22XdTgIN=&>*|j9`xd ztad_V30bwobui#7&5`LNexKiDoMGL?58CDUdqdFqTcI#$GERF z?mW3?w7z@O$Q(VBUHkr!_s;XNJ$wxpEIpfJDDXs|NVV9%IIJ6#z(4WFy%Npqf;~N? zpUqx(uHlZmpJn*#lihp=hMtqG7*t;*6)!BQ#Jv2C245?GvnRpmN8f7f3#4WK;Ei*` z@PMp21Hb%tVmnr8O=I74F(Q5}XkrDOwK~20*!E@Vx7jPTI~J#xo_}o2aC=$=i#mWq zrB?@QHG%labWFBZ(@lq)`+qn&jCmzbk`@N&<%RL4E%ig=9K1K3WpR_SVzoyMn=L## zoj6?UM;w!wO>Iu&P9%!Et7BwW5p{c33TCEwhaV8H9P1=S8Dc1s3zZ9^>{`50Eo@7k zEZNt2w9_5r{G!uI>fXyJ!ky8)-o*9LWg!;%axw&uvQsTLl)F8x&}NwBXoG(TMTqG! zOEs3kDq1#E%;uThIsy^OJd8#-jrWqbxhw4s<9Ow|;jzlUJM%s3yAnMyRIg~mO;;<# zn;=i!!RFHo)1MkXOjDaa-Q>(a$pp7uiP5z8oSUlgo!|{07xyOi#`0FjE8Cssa>C5X z#%YZE2LF&JzyQ>BuBj_3P6-?&0YwlPGS?LmWw_>C5(VPu7IA}$? z^<}lx1clTa6>#3K3#7^~wTTas4#|TQKM1tlD4pIIC~plVXckpsHLX z7^(oFv4wn(o7XQcshaIbI4BZhqh8ZJl*P>eyA>l99dXky0ZYVFO(PoCv{G_EXOj*1 zJvuk{f7*X~9@yKl`t{awX3u>AXd@nlaxoU`STV}lIa~8aRbV9u?L{wtM9*++v6Vh}Z+)z6F>KdbvkWFl@A+vw0T<>DWhz_<{O6^tn!njft9X$~2DjUuc#1g#lSm2irv^N2_*!Amgvy9j?9{w4Uk z@VDXLgue^_X8dx)FMF5K3N24iQY65WCIs;b~DaQ^ILk9=(tAL3@_@2m8MUknRJce|{r_$eN z;yHhhj)8U~MdR~zdsv?1^NUOyy&B)2psFSj&Rw^T_%SyAcQ)Sb@=N-o6(4+mbNc&U zKd(Q5wHI}TjniRmE%qD=!|qTHD1^R>s#{oyDXgOVP}YaE{j2{Z{SQFAf&IOVD|0S1o+45x{BxB1;G>U(q&6}AR#nK7~=Cv{R4V}zSkGYK{T_n-MTBVhZKx7@R z;Q)#K8Y>y$rBN1FHiR!lC1&8rSkN#QnRdwl_c({O>1|f~%Y;KJKXm3P$GH1JtgL%G zt42@8Fil_#3bHy*_43E6+(?uaocxEEq|MQMm0hC>ZDV(ytzFb+)r>V2-b^H~Q&3U` zWMB)(zhsKBK@%LPthXYE1sI9qyq;vG{`_j02^xN6Bu@-4F-rfw-i$v1Tbvv69wClcs zLe$PuV3f|&Opy%4npyoM4mPgtyb%&7>(31hcOGKaKNQM$9?D%E%!k23hiUz?6QN?X z@8BMuPy4v<1_6u_obc2i#n~D&#fsrW{j?fCM>}=9WyvEy1bNoRo^w_G$3arRVr_pN zEWF>Q310?hBw83+VaP)_H|mXIoyp$eb53BpI`s$d^+guyNM!GOf+G=Q^{{8p<=VLP>}n|Tp5e=j z!zx8oZf2 zc2I789*GiHR^-&{1KHChG{?Es<`?XbIiD64Ap7)cq~8Pbsh4< zHwr6c<+Our1}U4E_oz=wX(SZur(BIjR5LX=nz{}djO%21&6`@`pQjl}ty5KmPE-sw zORvM8@O7opwG+!#GVcn3NoXxcK8fRD)D?11G`0s37fSXPImzpYB)jDa-u|wJ!s(U0 z4A=stLgz}TJtiY&_S+d6L}$#RL$Ya*b3}vu@Kzafziv##YgVSzj2e+yWpCZsK>snd zuem9$vbX-@p3$t;uphfA=Bc{Eae(IPk0K8kDHGWJuoh)Nl5G1;Z|yx=T{Y+P7lJD9>!WH16?{X50(* z`J#c^hXqHIpEOQE&)L=~=&7?#poe=@nzWDRa2*((L&#JZI%w01E5KDFL{|_UO?g%3 zwIE_%OKa?Fx_#B!*G&7GWnXi7S^2nlmwE-}@Y?WZ?NH+GQe_%Iyj5w~`=pSH2*YWRab%)2gsQ&c=^vF!;y&xpjGWwM$=R*5Gn$SJ2T7IFVz1qts_*4T&R z+PKu2>3sLhNauuBhj!2mKy?I0ry+ z<|$4dRJ#Cj(?H7-F;Hr4J0n!LDwl_Ug3#NSyIN~Q}yNx18`HwmL=?wK&G zIuL^ICl78Hk^xUqQF|FWzG68Z?LcZdsLE zSLoFg`bVl7l`6q*txmkDRaP-I(-PAUB|AF`##q_&~Z5`L9_Dwg9%f3~4ac@J; zihb1kr*fLL4w~nS%lFAyQK67Vg$SP9hB2l_!4?evbot8~)WtjO4@G44M+|$w*$nQ8 zvVRMF0%%6v?zn6MzbiSpr=V0=4jmY*Qd|KsjJ~^?E}B)q2VDy|!qi3uo{r*pFVb5~ zYbjSKV6g(&gLU$D8BS}$+O3dlnZj6mShCm-l;QwLVM)_BTEdCiL|Wjy-Z}w!ZSYd_7IE++cRB9GI^C7P!S#ys zZd_vG8twfH<{!iPkN} zc>fsdUL^Oy)~y-pkGzfaNG+PFu6f?QWC&8hS@@*JmIq@=jOmm{PQ6m#-_E^ANKqN2 zaym$#dFe(3bj0ovS(}twf0^z(V5lLJTmg^2{CaIFp79^Pxwo%s%UaZcXO z7qP{WXf!XkshFHlQY_UAUdZ&IlC$U3D|Ms6jp{H4+YHzn&kjPKW9p52Q=<;Ii|(4bVGsnwW)`C-pBj`y-DZYp z_+P)$V!@#(-T@LaOgS4h~f5(TPeY-o`Y6Oma1p}mGoXt&o{v9d#;ogN6)S+C5qTH z9AR-@1uG?4IBrX_FTcvUy<=@tLh1Pfg~)DcQzQOV)2;mCS;&h)TdddGrX>m_X^ROb zdYO&xw9#FeXoVBK(MJ0=dUGaP;SySYguGDinnk1h^N-fK%7RkdT5Pyq^QI9wV)~D5 zQoKQ7W4(l;)2ZSK|Djvci3G+$B7+>$iIi0;ld7vf)h1eORn3?_@`__r?@p_?;D+N!3kFaLMBJ%bK=o}R7WE%{grpXAo>oP2D)apXU& z$fsiNW97gGhz)Y}e`r5iNrlM@JPYuwZOTz%T;uv00dEgiBiBy~{8UseNFxh?p~4sW z>yYWMs+e0^e=h4mO|rMVZgjyppb#Cg!4|k;X!6ss^;3EVxm{W?m_Aj7Xf-p?dgEVB_FjYSSPiRY!+|w+HjG(rWlmnH>zeK(KyD7Mcf_sL<+@<JEt`@Dum)kwSZptrGjTBaFTHZ&NO0nA7+T z95L)oXqTWwL1)-{(l!r4mK5y`&xs>e~Zz<*ss5#AC`c=9>1z%Q~VG zu1WS{wcrx45$mxI^f`vzbj z>WiG)37xnX9d;vRB$3#XU z;rB!;w<1&NuGN03YDhCo6kpE?f>Z%&zXp~@F7e@&`eCt(sl$|8iM$78CwNdJMG;O$hm z-Z2BS!T;3_qXTNr3_Ms@P@zB3NwW;wI9i4Ud+bgJd_3tGW#=7tuYfVsL06f>DW~}- zq`7l~BW+YnpD_*ffiPh`Z1rGB3Qy z%s|(yL#gm0*DgTedsFenYr_wkj8gSWz|afznHOK?e~LOKtic6ZWeC{lcLxDxz479` z{ze6`onJ&MQ>f>PY2z1R_o>y$>U{!-+NILaPlO!7T6g@Dr+U>A2^A{JGFr8{l z-!A#W@0lo)hP=}tkURY=NE}(q`4`GI0>)_GU%7x6F+2nWU$<8>1^gvb0hA2w(iznD zG|CUTFNXTo5KXqq@>|MM!Wf(gJ>C5?G9|mud6D_&QTMMJubJGhgh1c4IPxluGw3p4 z*=alzN362PX+A|El%Ev8X@>>BHj$O*&zNgAU8rIooMDUY`K9^b%ZP_Hw(#eUBgk>Lwwf{f^1?G638AS-CXS@aD0=6Xe3Z>II>1@^18KE1%KH5$p3 zH{HAz=tLY_$;fp>%FHx_Y!*R5VnxI=#G>5g5w9Thu9(=>Y~0ZE7yRNbj!_TXKv*#~ zGw|%mX!0y<2G9hA99v^3>sD^$>`@n#=3%@*>$iy3x?Od@2opKj2%Yiy-ePons-nMd zx%L5Gh1}y(YPV+qcWsMtZ=~D(mDb%R_e0igI^`CVo(?S)@<>w)A5|=EtC6l>s~1L40CM9Hp>&iE^&g7g*+P8h_LV9iJ@$04PkZM z_r8_#^L%x@SMXP#t-qwT{L?*lW&T?a>RRU~$hOu071v_5`oA#0&zkVH{36Tu)`KH+ zw({itW@JtwkHfPY&z?N{@s#o$!gD0gcX_ILrtqA^^F5wgo(p&`;`xAlF6VtEPlBiG z576I%M0&qKdiut-fBWvgrS0D(+x6c?j@o%}u8kkP+l**1i1{W^~MJUc^_R0)@BjOL+5i!pA-T$sf+(UF{x` z{J}nW-Oh1Ha!>5z3@!S}7Koo8N=9?8+i7m+asAK}@VaxLM?#fr&AHU_QZShjUkW*s zHfVpnKIEPFvVR6;STewU!Pw(p?=RnnVxM(ahn$Bx@_NgjaogSQ`aeh+zFbn2>_=m? z5}40X`;lDGr7meRC(EdQz^XD^U3o73>PO2)_L@FV; zk{fN0#A4iOo>)0eil}4OorJpfUXDlPbBY_^ypa(Ns&Pd9`+#PnxDvL3W}c zXGCHnA=+i)Zt-!4QcHSyg;R^R>D96QhzRgDOTTCQ)%udRou&W%p{7I{mF=IzXTe^55}K9@N>yb((H9BLxWrLn+?+&&vZy$+>(*0%>rJwd>yee z49IMXwr?ABf_J#-BsHya+w4gZ_lt~#j@FnMRbw~Gy*P9#s8;$EWuMsV$`pT)s%`{& zq&&?;+>3yoL%Fc*8xnW`D2*sk0ilQj-Ji}T`-|>_3Q7ea4t2zm?(eeO|SL zO@){bdurp}*hT^=18Di52^{$Iu9p6Jzs{6F_2_Rgr|H?(qF6>`pK(5WTBk9o+}Sf< z$8Gj=t|WYR9TbGwG6HK-a-S}^+Dn<2`hQGVmLI_p!|)pci*I02AfNSqK1FG}({q~< zXRyZwTGY!7QoOT7bp|u4)mqL@bij5?y_Nw0SkGUMu zbpZc6dpu{^uPlGRpER$?h5d z$*VHFeh~`-+#gZ5fxLd$}EC9A`qT z-1=eP!ZvWW=nnULW{_(P1@~;s&GUN@I|w}voaH3H7{s+SZeF!p(UTW;zX-bPe-BZS;w-)W{z`OdtVHXrtb(7Zt=&mA?eP5J&kHhqCJ?*N;=G%LMr z)17>zHtp=+ESG1?3!249=lDOinGAO3y@!{MDbLEpKZCEbJ94mpAnDbX-Rb>8XWoN+ zM60S|-qlsrZh6lxau7AdnfDW$AA8_TBW$IHs4AwTKR;5HG9A5M9SuJ-$L~FrKr+AL zdvWw@`akxch)@~VBxGAiv7P=prFHEEyqb=8)(L9wG#B(R9otAITrW{|f63iKp1(G~ z_nP0k&F@0}27g~VfAVE-Z475A{u{H?fIj5j^!Zax5o7Fbt>&nyIu*VZ0h=z4ogkjP zUO<>*C-ZV2OOOtY$6ko!7UPuEjn`_NaVp%j(1x}_iC%dxXJVpRKo^fK+h);4$ePpk zJh34Bd0>V>yv4H{pf|Do;bUq<6e6dfG53&I>XHPe4}~cV|K)Q)B;wt*k?)aKb&}BJGLh#2& zwAVik5S_BvudkEs&q-CtRCHo|BsHOnEy0B8i6^=kfE=fB6TdNU%0?3Vd{j%?nka~0 zrd(1JHleIiH`Om!Cf@A{(vq&wFE*JrFOoksfu*x~v2~Wa%}a2lCa}UbTY7Iol~dH* zMxbnecHfR8mWnT8EH@ zo&(f~{SsHBF+J2&KldE2#DdV2&-Xw2!TWurqgvN4idKGHcW4X}CD}n;%nsKp={es};FokU7=h-o4#XjH-68 zZH->|q!u1vz_79MHb&fOn}q3?JtBZR(^RV{lKRHKEA_!|k=AVzn6YW}gOVku03)|5 zpW_wm7|cEuI|d``vD#WxRp=bte%0Xm{KKB_8T7kcg!eB)$8Hud`et?NJ}qg~dLvG4 zTyQQ5d6OvMF+ufr@1VL)^RHFug-nK`BduYP+&BMh42v|p$lK_yYfUaoOG2`?oWdC< ztTfZk3)|FctPRQ+%WH%4CKqIC-3c>V-9c77_b?-u+mLuE$kAAw@7Z^mP-M>-ZLo5B zMl92^)H7_E4qx|~s?*Xzux%Hb^Ke34Tq+;#pFKO9sY^Gh*;3>CgYh+e2Xcv z@s;|5aARNHQ1Y!G+SpcKK&7Cl4tq0vSYLI^V+pDiK5Wa{rbZkL=@4!^`A=M7&b5!_qUk(m z-V-JkD|d@+@cyQpJFI6+=nuKJ2I?e)`Q0-&cb`aYLXYMKz6toe@vlobeV$|?lArET zSCIVl+WPTAVjoTVn69cn(ky$aYg_u~+$74?g`zV1o`7YP@aNDrx^4Rf*4;5}ih2DVx*JaUlXd#=mXIhpG%*Lv;rHB{!a6(MfPu7IX7as2q?d zRcwPIMDV2PUP7{}XuBN}0D7)T!(+(-hJ`gCLC*_j{X_RQ5Maj-4pAc~GJXAhn2g_= ze^^@&3R6o>7J{dPG0og!atzMFTgV*Y%GA<@INWgScQv9;(}Q%i5ts~9^+~WI!$rKS zc#mP3N(c=`JmP3XR<)fnv zL@S)=={9<%jh>Z>R(N&lH-!p!mzqkJEp3sn{fj}#j$KkqhvRYMx2C)zlO`-y9vODx zv)e~+qau>mw$Y7?sS=RYCR-Q%@c0003cc1Qcw{w_@e7z*&ZE^Om!VBnQQdML_Z_sr zD^SoZDOjQV2GQFN(y4aOZ^hu6zZB`5RFit7Tedtkz4uMFX>QEHcpXaV8aTZ)ZezM9 zKmufexYIO|0J9*KP?_!ud}jSA!e@xZAvnM?;Im3>U5P2byRAg{RvFfbZ}yY-Nw%qt zM23@9#!a*=KFLq>uNW@;HAJ#)IX#8r+H_Owf;Lm}=FTlp@z_1kqLuqsx+_u8fxNv^*hQ4=?`5UZ18g_^xslaGrEfuVkCF%(ye zrs8dZRk2j~@aohh6{-4T-TGTo^;HlBWAuR+kNCOM?7?q^4VdX~KE(zI3Ix5B>c6Tm zW*u<3z!Vjn{f@$1gaixCsV@spMGl^FRTNLDeu}mEV^8BQD75*Bnd?8uVS%RaX8-01 zY}_-1fo}B)HEc5o^%&I6{@k~U0b2y*EbdSADiaULStQ6=1Vy79Y04sh27+nbA5(ZJ zx$T?vlfL}r|73qj+sv2n1xo|)+Q8^y(PP>oSREHqmG1j(X8YAoP-d2tIg?BVR%l9g zwj5(BTUMYp8i1`oD)!es8M(8_qRnQpr_Ca3HWb<{(z78`vkJh0<{QI^)8OvItVvG= zhNDe~yWqfQ!P1P3?Fdiv%^&u%_+ASt>;dm4Fqwb*`Qm#ms3NgJc5+0pYNc0dsd>3g z<<@6kfv}mk$<%j&_}v`wMo7}qv{_+Z21nOs;ppkOwTfy+*WfnXc-#@(Z9#YyZczeC z!`9d=-*N+C293xqyx$U}DW+cqd5rgB+DFsOo>IMgldsM1nWYkQx2MA((w&4vUG_e( zhek#WtrDCKSG{h}hBwjxKX0Tt8*Y<(_lwkJ-dwpK_@Qyv%6*S@i^u2RV%?@c=h*bB zj=$Gm?eVaNz<(dxlR&o-UQzjj{o(occvy4FKYNg)MiEr{~s@-5Nng> zU-Qxj+S7|Plm&;c<3L;2eEC2Ak+OetJ!$=2lyU3IXE@7!8vAHGKjF#A&CAWpGml=m z)}vo}?dw1P&3rH@{mr0^D;;9rgY;)g%L>nYuA1cKUPAq5@TA{oZ|APVpMIv})|2M7 z=v{U4w9~8&nH$bYvsV`19I#g!OA=-{AG8NS?w(#~tF|j^>NCB2iQAP0p+K#^?ICR5N#ypFvB028xKWJILlVozEBM+{@tb zRpK-qWaVcL9=%L3BA6QzR ze}~e#L7(t$qf9Xb6MDlCbZgDDZpC}{nJ7d*@MF#3`^@h>=J%)O_ZIW(={Nf?!|y&N z6kN%5ammZemXMqO94N+~ZG3W50I=cR-G)UVF^oMpMGc+CW#k%SZnsmE+DJeu{0<^x zZo|E}k#6ge3B4zE z=Izy~Yd36X?{_?ftw#=n3HixCL+&SHXr$;*w-eF&)=*`8s{SQv`jVM`2wyxE)IO-W z`*OP8&wc(yUzj={S3-O6o3qE_z(X6l%fy$>YIGUVB8bx zYl8*6!RB9Gx!Sp*i2WEV@$Le{d={K6zO(?Sf0a2iqy8X#m}S7BMR0cEnE{+Nmh|G6 zj*DA5?mf{7RWbKD9dm2jE`KEKT{l<(g#^UC^9>)l0!#4F1yC5(EgV`xNtNhuwp3QO z8eb(xz^3w9Cn?KRIwp3Z>(S~yyffh}&M zw-(eD@e5CdYi+`kwe1;fQE4^9$Wh6Q$LV9*Bm+^>ciND~aDr!+!Qt)39GG{K|&;M`btc*S8O%q7wB`tFYbHtL+hO^NY(d zkr^~a?3-%ZvWIEQ&T32832)`#Wne?-0KZUeX;`Dd&VmVWRbSI~*eGq!;MCI%NXTCO z@Hug7cKO3%W6(1(_x1nQw17E?wDd~&Ivq1I%#bQSJ)nWE>s&D(`0!snpDH0IRZb~m zdD8E1Zs$G;82g`+e@l zhQIf{{)7f!6FbML-kAJ+541J@{sn0UH#|ew5FrK~U#)?4xWPaC4#c9fLe?|4iU}hN zaVB%z%}(QPba?W;{hY?t1SH?ft-Ch)`DISim4(9JO-rbLw`?D(ZBX_(p~p#YT6jXx z!fKMJH|C9|RR4kj0P2w7n8|AUG~F+e0B|V5Rus6#G{V2kbO~Y(f`7?& z4fWTb!)f}XZOP5K$bRRozo>oRf@jgk&RgC6A!tx_Y zKwi%%uPLCY?q8CVKr`ak94?k0iZ8U=eKy%mPsvyWTxMA6>ay;GoyJzNP=gTD*keyIu15}IzpzT<5ZE+7Mmu2s+p5#6;jZ$Iso z>Gw>BNJu4AsA{?ueu_M@VpvEw`}I34?d)`E3|3x;mmi)AAga+~O_(Bq9E+muFk`EM zfpkauN8F<61rlYl5uhD&^5|SQF`o|!Ds|>vD_(~L0%0HmX(eD`lVhf4$}y;Sq5mhM z`<`{X8a}sYNK&-|m95_k11#r0345Y3=hk7=}d_SZl#-ta5AqHt?5*0U(%lfL?t6r{`pS`dokTYgxf7 z`h%A-bm@YA(H}euZeTiizSsO)ywrVSPoh7`vHf3mBN5-{HGj0TNj0f^n!Nefh64!a zj9uPj;5|Bs1(g{1$J?LlmaJSw?exbS&O8aK)V&4d(I4|ge;;|5|AyxhFCYC`vlAn3kbGeP$&XuYOo!;IZ+8}iz_e_|8ntp)6yV{CrcW`+GEWWz2b zj3P$_v+4WRJ2mi5v0g9m9xHG2fmFv-<~w-N@hh#pW|w5&sQRJ6=|SCNOq!aY&y5*M zuQ{6jYFqG)rO1jKweTj`#8}x!+97wV}KxyITnY zgH{oIVRfFb*qsB6U#}<-tD?R97G}uLqqbhB6Jsg9lj}tBS-Cba<*myt(f1a!)qm%7 z?U^sTnqQmvfPslG2ol#S@d_nwo$}_$ob!0D=DC^YQJ!ac-sJg==NoTf@1LiR=SH5z zJgaz~<9UVL z;l7_|InN6`@9_-r(f{D7)=U#j7^NoFr_dD)?@%PPdmF$1Ow@b$! zSeE|ipzj=fNco{@U;q2Cafcsqp>8(EjvF*qmr`F{1o;80<$x^8&S!O73RSwA*;{Gj@h#Bn)w zdqrK(>^B2_`uz?Rc~_UeM5@khErXTj9Od9he%qPnnqqeA*@JAHrc?1LJmS9O%#)ON z)I|h%z^7%*%2@d-Bc>vLVa(+oQp|D2t(cirB)-NZd%nJa{a^j% zk#kqczTojq&(E#&#-qwS_dAh=@v^6}>v)4q1)dg49y>HgH`%t$o&p)kmWjq8eS!pv zpL^x2#$sS(wPA(AEzsdIU2ixf{;NMUJpBES7Z0CE|C8?_Ywg!xp%z}M-+_O2KAmbs zVV{^1%%y_2uFkNqmr(bJy9cE~cKXaH=TYQg8%q*|>n-|F??t=~CwC1{8FMi=oh?JU zLA==wJ2OV7nd)Y9zLTG^ce;_U(%e$Z*xlgYv~OQu6}lpg+EN085zq2P$31U&%eCKu zKQe%wyTQMhBDQ0EA5F519b%+!pN4<_g@3aBIE%NtK}_%p|3Kvcc0j^;axO^$;7)&k zQfqZFodG-SUz6#nKs-~znJ_y(93Fh9eixtKeB6V2!Nf7{n5xG2U}=9QmiA|`w5^?s z0%M(mhE;pvTrv1<^Ze$6zTB`|$UaC(g^WmWEy=3c)AMnE`~0iy$J;k-H~&O(NGDhO zx?y7X`IXy+n%Z~oq^K%Z$$`+aZk=V>9B!`{Jl-+a3vS*Vm^d&(XRD3O*=liKb5GuoUx!=N{exAjxC%X<(O)CDk`ehfFY+a^F?*B7lpxGJw zNJ#=eD+4Bv;y396$+h8|05@jH=m$T$A!qqQ$P)iG=6uZE#A(<|Jg>7JIE^}5!SfCh zgE~;=1iu{TJvb49#w9sT_Jai8b(8XwO_io*Tv9j-U#~RNF0guJ&&N_H6={#h8+?c! z*+{suPrzq}D?9BpHj%N^G&twe*76V>z8x`udt#~Z{Si;@FdBLBvoi*g*7-M|ZZyJr zmPqdlq~{gnJS3-#uX+UsJ#5_+Iqm-NxHglKYcjlts@;zN_GpS(%P>V#^Gn3SkEU)d z5p$ixzuWx@SLATQ=oL&c8JYYS{kA{<`RV+l0Ig-&hc7jzwBE4hh9^lGX>zbdho z5u;^u{DY3!+80Xwv1Bd*A&!);;T=ugS(4x#Zh53c)(yhM&*#lG9wQzpX~jhgpYVTB zPYW?}0@ljbAp1+(-k4%KAAIvB9OgiM3_T`)pYggO?@6cB!V}Y9VAjv^MEiH$y8i`y zo;Yy;e4=J%;FA;Ze(>CRE8w|_8vDnCablR^&IZqKFpUH7e2A(9;3-J8T95`%jTYox zf>aBh0#pRu|9=7Mvwrt<1E}K-^n~gAg3}%pAR*%86*St=e-EZj7D_z}qzf`Ide3YN zqZb&!H(76cAd~g4Y$&%v1!qce0F>+WxKa`0U*<~1P%-Aii}9D^#{gKU3O|zAGH*W_ z17H~c(zS}|J07tCHex(hO1cwH(NJf^FcOf__#!?aqse3xBBSwS6eXj{WE3K!@ip*$ zY9p!fwQgu;YWz$rMJ^T$3Vbg)O5pog8~#vg=^9?))Y48~7zAA>U&~`Jn!x)u@)7_q zeHDj+-=ANu*1Km;&Y!q<8ct(8W7P&j->6d%K%uB@PdjA&E+VEVy5Cxn5 zLhc=X@q_FyZh|#Ovv1MMpA?iki+yi87rA$o%U%O=sWIs77QOt2Lsfe>Ia6V&X1(0x zEPhkX`gN0a#;sp;#^&;BY1S{*Pw1rvcg&lPQx`hG)P{65CpARWIz>q(az=1?#7@Gy zr4^rlBjzsYup5066E>5f^sfrS+SDc9EmiO`{TVjwx2Dl3de0gi67Ec&-k-W zF^K1>Uui#sO^|}u@0UxORt3Xx(UmEXIUWZNH1+as+GQUFX1?do}d73tDO08f4B zKTr(ZZ+Vtt;3J0!q@JNR#iw`QKfX8Jgmif?9%ovZxN;2L@^al!e^)-}m>^%;^r@K$ z+4_u&>^HieW~+~oNMP914(0~`^P|bqSUWVciEAy$A^ZDU`#t5M64}sh#MS24YQN?h zw3fh~SSbP09InXl+$vnEAOlu^FwODY;{K3xZOA6NJV6bANYMf3UBoS<>t;IDy4YwgO4 zcvr}ECQId))%^qV+jQ)J{Im%B2L<`nW%3iXrTh;5+WcB=eik0aWiqG8LjpupHV9~J zQCE!`jnycq(fHU6S={KZ1O-W}XjD|FXc0CL>x0G3O4iFtYC*B}5#Ly~q}E479vgxr z$io1(M)46v?M)XIP$7t#|Mz?5-n)-1h^_s7{`>jN-nr+_d(NDhbLPw$j9o3mCuZB4 zcpfI|KbF@Q98YdIkJlF*K{>=Pv}|FkH-22YKL&d=EA|f<43oi*`_=94h$kEHfok0DCV`lL(i8+KQ^cxcf*zAOTpdlBCR zy(3?hg)t-@d_h^}GXXgg$g=RG{xU+U4;iqa$gFu#3s||u zUP=qJNaHg3*jd4@UR7tgaN1{#k&3TU|C5!3GhGt(h#0=Tl4jH@#UQ1vsvr99RiTQ# zMH_Kwl*<0|qM1!T4d-RB41-3EePJ7Am^Ne#ndF|;*-;a*6}9<`AG*~o2_aHd=;Rlw z2dORuEl^ixjXjZh{A|WLaQ6>Ng5}1%?8b!brmPCOTa{qu3(Zh(L#9%bx7CMKpqnw{K%J7J-=1+a2@E@nrE% zbjjS{h9pUAi(Mt+BS^+#qZT1!jGs4R=UX9$ZiqQ8fmrP1MIdh?8;j+MVL+sp5j%7d zwwx8T|00}$Q{GIpjgbtj^|?{@>E{^be$Fhn(u#^fv4T0r94J!km#$ZtTx_80Ri+i& z-}NeMhcjP1k-#g}9e72jjHxx7eDuK(E%GQ!raH!QA(%3ncOLEt+*)X>%33+RFasAo zK!VzgJEy*YO!YDBdzQk!(F89DWrg6|O7~V!7&+h{^}`r5Y)nKGGqLYN?=us3RORAp zQ@OZ1c(pKcac|97>CT5lq1%WL%OLSWzS(8Q?=s@!>MEAfog274U*hLy4DF`XatJ*+ zANwNL;gH29e|}&IiI}bG2ybL6#`wx$M~3HyXc4L}2$TusLy)#ue*lQDZtZmjERD>_ zKsB_t^8IjAE>?E-GXm`cOjHM3!h*U!&{7w zvEK>pN31gDMLAHkaRDwLK6{!<{#ub5pk3g3^r^$B|2EHtRuXYnh(3=N=>ocX!y!H} zd2Cg0e0aiQNW^1W4EduI$>5MgHsaMP6CnnvXnz93Ij}@XrvHS%k}e`2?C(S(9q{Py zAMVS$pVmm6LQjEf<&yvV8LM3uNfl~xn zZH25PaGa#5rmj)+b4?X-ug zsVQJv6N6@xK(L*Hw|ti|?UE$@UCs3!(#=cGCf}oB1yFoR4n-CG%A|&y>nrHSEJgK}SWs!{#kv#vJRKZSXmrniBOt@F}O z$}X;ev`7QM;Yb6ji&YK%zIq6A%3!pZd?sw@P>KNG2VR@)1rDb+edG866aa=wLGE#c zz2OiXVejQX3iiz~Zqym^L&ZMv-8;8*YqRh49*oY(e53m#oU!bM9VIPNi;Sp_R&gM( zhe_7Y#b#SOFq%o|_wubZ>|OwCbj>@r;p`la*P?{p$V*&e1eOHYoXyu#yZiYfc))sh;BxDBbC+;#v=l9Y9K?}q16{&Mo5vdzjM)}_Gc--R#0YJpvhJ#W_jd#Lcc@Y}0-N+SJzyciX%Cy(4 zghvZ86mFFF?-%Ua-`u55XoiWHLTQ$}4MpUrMnUv-@8|La0(Ln=e8(YFcq47_64ard zk*#<_dJJn8HcVr9WUB|w#^R0EV)39QcRXmx9S@qpmQ$id@L)0GQI87sn4lijcyM{i z2d4hcnLQkkTfo9?3^n>r-GQ7nB$fG-6;$n|MH*=ZlAp z7=TZY9nMCqwt$rc{!@TO7SKUp6M%@7P5(>qLrBK}fhA5ZW|&8jc#wxpJj_E!$@E#0 zTn7s&z1K?M6am&-z*+*wsXQjrKT7hD!~;tlTmUkUT=5`}4l9pV`1GSCxu^wPKwy6X z1}xwN0(TuI^(d$RbNE+=Byk`Ehkq$XUIH?(p%pUlqyG7~7BcYNM1~y;_KXbZ`Q+Y@ zccr@yh!ZfRjCD<4^l}D11NBn~cGOGXb_;u8;8Cf)lwvtV0pBdvj5#e3bzp)A3p**L zZ-M^C^DGPI4Y`sde&yPRrzlR+d^o>~gNVS}1>lp_Z5^+uPZ6mSz796p!U}Mo1OSIe zw0mI94$7HjbTBQ3mXTp5H^B%kgZTyt4MVqVzW!q=9g4KmKV^t?gAAt6*6-@>ycN?r zXl7lok>YB*J@f+!8urp_a}?Qxi|d0B3;jCqXu}(Q4dABo>!#n`FsT| z#N$68UFA?R)gPk8ua;2s2sI>ILi%AgF5HMI^y;(wL1iTz%0C>KR`h&+9*}wncgiDe zh@w9X%2!$|U@Yz!NC*!pqqNhxz%%UWq5_I;O-e*n79fFcK}ML4Ze92kl7J~9Xdi@q zAX*-SXb}}0o)#Ms${Vhv070@`{Up(89Oh@)s{mNKb#5Ve`4*v-QavqF4YKKpjLPzA zp#Z!vOQbJsgZwf0JYTZ{OBUc^^B)Dwsf!1lZv?GTLHPs1AcF09!u!uF$tO9Ii0KdoxA*)*ty@Y8WHE~ z5=hHYzv*qOdkwj&KA)FJU+#N?ozTYK^0Z{AF1jikC+P#~kU`??!s~-M3vqV2F?Dva zK05eO$V=E~O-$C;LL(|FZ%s_rM`vJ3JsZM5grUOYdPXmg{2Df~hw+_wmk{lwnr6#!(nA1a5n-&3eavQ{bNCh-tKANiv`d(Nmb0GqI26b5cxuYUy z@sP8fkK5ZzwW#K<2L@N0i*g)?gk+(Vdvlt50lrjfvVMlI0_Pu568Or=FL^-K0~`lV zPkf1st+4TVg_L&X11sA2nd>h#i`D6+4i=o94C)xp@o1R%*sWM+$Gf%r5%hQ`?a=J0 zssUBikqkm|XI1qaKul99QIY#dRiE!nsA^?WRV!H4a#dAi=R}kKv?>kA*@r5f$STFA zsHvn)??c*a>h8=QXrsGp4=&v|Q~%EiBCIbv8f6!2r=MP8aHutT zoZej;Z1Q%Qo4w$|a3sxTtUIbo%CuSzr!p-d+dIa%p^!7Q2}7&&%v0>44e%g9J(^eU z_gRj2SFos$J;dP$rB~5A(<2{Z5?0<`=W-FF{5!@Bz!U+i!=*S7AK@^e9XZfEeQ}8> zL2zpX=#DNO>cMyHleFW)Tp!21Q)G+_aN~Flo;d4pp`gcj}DX_<8!xK z*>7IXo`p1JwzL4d*2d&!Pu|jU-Z4SEYD6{pizu1%ya4$)$GW#0H_>RZHY>enyjLi->9sX*Jtu}-rL7<;{ zBJ@wjjtRH2Xzi=T9Y7=7yw^Ob0|FZ>8BY6sE4e1Fbk%cahf*hguPitn-Qj zuw_e71Be9t4qlh?0wD0?{<-sW$_ij^Kq>Q9K`8q<7n@HYEC_WuYyH$ZZlo#;?fz51 zgGIsm>Gj8&*HbZ&NI;L5y%e6Ds@7+QXt7JjCq|vjEq^QOwN}*0@u(CyFzRG|ghbuK zcjU$L53?fF#Us=w1i0iVvoH7y{(t$UqpZX69KlBN_N_rR$F`L9jzyu8v zJ0~At^D4Dz-+k3xTbg&3OFP}IosshKmP(v-Yp1j|90{P&T#))i4*crVE#2suoaq;o zXmcMe%%gN>efP)9My`9%Cc<@e!9v8uCJW-k@|InM53$3R^`FpYiygeIzo*U?voCYv zW2v?S#uC8f!iNLiz#1GCMC_SYF<*!e@CChb=aq7$+aw6Lp1z`&RD0o_qMti-6$B7! zzbFz#;8$&+#I8mg#yEDsDjiS~fkf!RUgP z$eI4U$xc{{%iM~gHv#wHARah5NC^}H_!jG6rd3wZh3o1vdDRo8r{3_q1$c17r{)fN z8nN%rpBg?%A(!M2^xyiSFT*Rw1Tzv*c97}megl>X zyigABhZEPms`}&X0769paoJ0n8EGJFW5B|+G`8K{)wu?_LGvFc&3AW3;fHBkdx(bT z^gsN@+#emCcNK=oBz@tpdvRaS9-51QC?D7vWfspkvG5_TwjpNjAaw^SdZ8eD+2$?X zCED!A{DP5?7cR9h5}Qr>5TFjO2#g)MRPgZ^O9dYXE){${U@7r2)_bW!M%VxoWR!hb zeLG^}Y(}fT3v(_y?kGHnE7F*y;dyN+BM?M5%eUYUhdv=>KuE^}XwiiSOsCmURXe=3 z0>|fU0Pr~%4}5l5p9#lj4pV$CQlFjHXTn)&`>bK;BvkzBk5$DR&5Dctkl*ll?eTi1Vp4o6dQomrYhyX}+Dd8sCmX`Zz&_lHwfV>k{X%S8yDdIx{Ko!I1oS z?nJ;8_@!T zVhX?1PT%Of@!@$L@G1N?@6GDMAl+IT9@7=}eHX5Rf_E0ro#plND4+~SyM-rH&am-++>8K9w6h!?H;(1 zqYV6JS-2d!Z&b2c|0IOMQ1%VJGlzpP!?8TIZF`tY zTNTSyyS4+=rfolC&(?+GNteC|WdY>1@J$e2C<}CE!Wv+4lRad^8a6!pp&DciySd@g zhi>z9W6hPm`blLjZns(>!+z%oj7pP+hGBP2Y{+7Q!%%lG;Gr9JK*tA&X@D-O$rd4& zN)|L z)?tvCK&po6OrN0qjr3ox{PpygD}NFBj$wyOc&Tms9GXzm9%4D<1kms4feH^FxYqzD z)Gjo}#FCehrKl-=ScM~LDvGA2_=1g|;Ky6J=1#o6&!b(|45$=kc%0edrR%^tBki;o!WZagB2l>@A;Oh67ybJm0?5o2 zT%o7%b2Dl2Y={e7oxTHGl7^+U)n}T#8XFzFzy)`L7Z|}dt~?T<0LjK3HR{&ydk8Tm zIoi<#UrzzTA*ab9uFCzy5L;9q3ZAk~pNS0DIDRqEMpprMzVW1=?o7iu6Q1TbJ}-jf z^MxVGeTwJXaD19>75sE<2~YDIpC7>S`O;wnZR_DahwFX#K-*z(r@{H)u7&f%1>xqy zJrB1W?rpd&aI25T{_zpmUv?VNGqn0=UapCp`7x*aBg~_GDN3GQtSA&o0D$~~LcOEYM(o`NDnWp^L`!pZ)p~rxK zN;pG!0(OOXh7d~pI72uDZ?R$SQ=>yy;oW}%s7Ud0d$2daI2JfFW18Lm`0A;>aS}5I ztH{x+f!$4{rOT&$1ly%Blsxnk80f*&u66*n5cv(JY(Nv3GHk?xEU4%S5vYW-=;mBm+rQ z)PI_p%%7}eNW+r2K*(QilVl2!Oy}MB%$uTWW-{FI!dW8oO1weyvynY3IXzeM{~9byj+0%-_e{y%jDS0y(4OOw}yo`-O=nY zLynh_{NK^+G=UQY$p0P90TVb$fc!_frL~S%+JPH)ZrHJ0m0cB^A9pObitU$({NJ(M zDt5I1`M+biRqWdY$p0P7Q;HoBpjGS|3CaH*%dKM93XuOhmRrT1EkOBSaw57w3zY-U zRj-C0qP7YQ_~LVb8fPl^?IFwb=37{v&pL2HG@* z9ls$Pou9;x5BX#-?06~Z?oZ;!Z$tBw9}k%PIF6qr@#9n^N#@6&51^ciAFog4$16$3 z#a5sj*F5imA78l_etgGI;KwsAjPv6+i^S`Q3zGTqRKyyIZX{xTPJSGiM1FkrMqx`A zwF*M@;Kyep3e=zXogW7-DSrHFppWq56R}DL4&Ceh|9~Iw20uOoorH>S*q|zYz%Y&^ zR6K2jqoB$U`el z_SuXzuLY2M62nAV!P3rf-LMAic4!s+QH}b0^+O~9y_ThC94%Xlk3DFO@XB8~AOFJMB!sV(G#bg(O$)-McIj~#wxqk|K zy%RSsX{`_r*cY~%4EE2#RgVN$&4!6{)(wiYz8!NfIP1nZXMF=8;H(>DD^v@Su!1`k z&YHIZ?2)ssMyMk0M3A%g3vi(`w$ zt{|BJu+jtW*zkkhRxEZofB`f=1Aw#V&IEi;Kurdl%(lsR7sCG|%r?t|#gH)D*~=|v zdp?*?Q8gB3yH>_Uq>jwrB`*oHT}}V>{e^ihq<{B;;uj|TOXar_zFGO_li6-j;iV03 z2qZDve$0qV>RB@|+76x2|?RS|jrh=n0e|A>;RDE49@M;$FO%;+_#mcH$n>BKz3upc;*LLIpe+}UPt)~-pKd_H)BMKg5paB#oTywC zp4Y?iX}Vv-Pgj}nG{5nA6C9uJUk$Wf1$R5#9Joi}{tov#+*@!Ra9iMZ!}U99pzTn& ze7G~dTb-HGrIg*(gmPI%(}WIFzO>o>sf9IF34+#5Y4{Pl{{ zO#Yg>l(;|cLATcB)&33kx&iEUJ6UY(KvFRg2wKgDoURQ8#0xd4-AL~;n8}5i)8fRE*#IfnUE5k5F4#PunTpCfU?8t z`jy}=SgpBGKnH|FmopR=brUGW#GY z#_mCCvn$FdtO!r{t)ymGnu^fSpj2d&cu5tzNqjmTeOn{~&yoGVdoIl$rZCEc0Zm%wJ%`NXpE^_oxOM zf0KYv=4u5(?LmMzhGN%J zuJZ)mc&G`A6mRP70^+#i6?2or5$kFVk9PK?Qna_{)g{-d&Ly!e&1Q~&(?GP9CyO6}zn_?{zKi+h~3L+f6kk-lE; z()!?m#Tsq|N!}V>aUQutXl+)aPPU;~eh+rNzNI@dy}#$05Xp3~D`)!oI9F0P!eq~^ zePWD|%k{620Mf3E9i=oEeyKDU1}V*j14VOz0b_l%AMk{oF6b_}AJjJLt58H?OxwV-M#o~rm(!Brd5!Sm&cPj+ z0PD~~-pFD7S8VAHcJ;B(qMT7~Yz)4I_A1L1lj3)cyf^^=1cjaBm_UXI~?_ey;QDd;?3lMTR3RaE+N+oXa=2e3CJ!~Du z#z82)@%{kcd*L06{Lx@m&!5;z3E#}7{%?VW?qtPNKHRezAKKD<=>HWyypra_J-v{} z!)ZSBKL{T<1yA(mjV2zrGS|eaQ#0&;N-taN>UfZ~u`#a3b2fmxKHb%LIiDxF8gJ$E zSXbkp_&nUz_$r?VyBgd1?C)ya$!8x|9&EdRg@baMi&z(h8bVfm}LX;L{^#V61H|qjp^+ zigmR9UWRCnbCI?Yunwf5w-Uzo!#q^wa^ZgSX}Rb@6ivlxywW@*e#L!h4vE{aCWp#D zQb(iMV(0OYxEm+UPcajbOr~0i9Lhwvc?@eFYV#O6I}St-FJVX}U6v6B@)SP+4mB1k z_~FtBs`}y2fh|Jp;X^ne%@wI9Z}46Nj)8OUFd`*VtB8pD=2(IYI(XuErP4#3pnm~_ z&!yV)q<601_xuoDjB` z3VWv&wk;{_-HBmg)rRR_im;+0^*z{9$)GtY&IptR)j&bAIwAaG;c;H%SM)(1!Q(JX z3el84?R?CZ|11ff-OGmQF0hQtVVvGA(`L;_n-T2q2TiOHxmayiHx{qUvx2*_rmXdb zUt$7y6yc$@wA9F2o*kT~IIqA^Ho#J%QAX4Jag)G&5tuwpY??p6mJrrxn(NK5vncjS z3O*?@xY0UA2=0r_;&udbO$vTaVsIR!U}Ns5Qcn!$E}BF8QvMT>%zU((-a9c~ZxwI- zyFcLi$~CCJ;PnXzD^jULN&70?@vqt>I5w1HIl*# zBRB2svdA0>ySwfX%z>?d$Bs8kFg8v6qY-~-)Pv~~K^Yx(n3hT0C;(Wcu|L6Awc&xG z)cJVNasrDorrnH@BLnv1)d|%!I(6wgxVa|c{u+d0+Ob?eR;Iy*XAlvnAd_b7R0)tW zJnnxrAw-T>Yu2j}N9>W{P88`=Hc2^h(;ng)6u0Vj6Em7(*+g}xeJ;-7&*OjxRjkyX zo=BO?ymrbNpgw`_(ueKX2_faY4oql3Vm>@tq+Px70UotYz43u&t3$_t4sl#~!t?6! zz}ayf-)ch(2-B+Cz2Vba-1TTbpKS!@;7Pk;C^CA6adh23Z&XpYc7 zLiuy)KTG*-^q-{s(xL}_$M9(FS8r4|>G^-zoCJ5mg+d6b}!IRI+U%pMK6G zsus{mV6^~qEuf9SYXC$n9nGPSg&&F5p?@V&iUQTiNhfK1k;LaFz5+T3JX(NVR-zqD zw7*KUmHu8#lr6&s7ZonsTqT3fW}cU*pqzU3^Nncq7t=3dEgPE@Vy#tQlM{Y0uM$gh zh_xt4NfK+lgF}~V^o{brR{rn5l7g;3$iF84JU_Zdp8>z2W-=bfUtqu3=s9ns_vR}h z?izVI=5Hh_~k5vj*De1{Om{1CCGAeFZq( zw+T=48=u)m*nVdZw9SQ^33oHx>2PD=o`8Gs96aHkgL@HfG29BcHE?gi*)sa}>f5(( zCLDiR>S6u&wtVS5ecnVKAHsbJmyPs}ggXoF61Yilx4_MTv*Y`oT%tV8d5LkI)!4>d z(uoJRqccSUw)`kV0%lxa6_IPuhHk<(xEB<<+^6Z>2Uo}XVYo4)RNJh9{dGF<0%LDE zoG^hc7Gia9vGY%g(|#98?;=%AD2_OHEgqE zVs_ACsylOq-YZIqDS$V1H$osPb1Th!dIB@m=137jJG89rFf=P``DXjvs1gQc0@RKI zL&p#bU&Y(-0TAkYRt-cW%?cn1$OvlWVy)QzEy`oF1gO` zo#}~;=!QuXt!CC_d`4OVK8k^|wONw@qj8j!FrOf*R=Pb)i-9)!c!S&4*LVdS+K39M z#m#cq#9s0a<`^_aW(>A?j@NVRlCEgufq|-fctzXFf@VphYSGY59&MKDf>~A`l98(~hu zItVL=Z$E-6eaglvzicG{e=x2JUq5)tkP6JK5>yD^1$c#pRl@KJ8>@uLYk66?q|ya5 ztFCYf1gA6W(d`%n^Z76}_P=05p@SE&k{AT#c*ghV(&ImRw%lZ6aNPx8=@L8lYIj#tcgRx0Z{T#$OA+Tg*8Y`hC&fQG8E`hLxC1!6NW+|LnI7^ z#rTX21#Aw5M!*t>f)VCKL{&qYUo%kZ!g;P5!x7#{3Z4iEM+hX+xb!{hAFWq1(x(+v-?7nqZ1 zpYPc%#sGn)$u5s3w_)N=2`Jg}-lyA9m{N@vMMpzL7fkGyMG7nMvQ9r4UjxfHj4+&L zQAE0kLL-qM*|`O>4s=Cdg~rkDr=?D%r|rf@0aL#m3cwJxIK@6<=fJyv;6bvK^JA0p z<~Nd>>se+od!I1G7{~7NGMZ++oFjKD4^v~T;`G>PC?RA0=)?u_q{*zS2m9nC#tejE zqtxpWa57fCB%|Cbtp>?*z;AP{v}LU9m4Sal?1p(E?9RnzXtsX%wj7(K&$<<05V$d0 zDKpMW{NliuLfE+S4-xuD8S5uobI?z%B4PDvMX))BX<&w2OuS$jDdo@&r5er%O@w9G z8?iq;Du?z%@PvZ~(d|qUr~hs&grUh^{tJWu`rc!hZa5Fp%tlkHzOQ>R&FCxr#LosH zTd`buS@2&!P%@j(mEc8G{x15dNls>x?|jN6*$Me*Jt6poW-}I{3LYB!`Xw5zj#BS8 zzm!IKO%O;cM57E~qqJgK9eoW;J&269@Bg7!y9$kRZJ76sE7? z6vD+JzO7)>>@^Lj9S%czwecLBlPHqE9NH8|pc$aaE=JRi86G_Qe!2c-cs3+9bs1Fy z@%TdqEXDvmC#+a4oBD_?cPv`LpHp0z&v;;QlaJuT%+0h(DBA zA*vC=#p4)B<#cNsy~S8JhWm(hrOz8PE35`TTyUHTx8zuS@LA<;)2=-r-5?bXS4HUAK zC8JOoNOj_21t0cw8N@oQ5J7r8Ui;BUgN(xp?yb0#mj#jPLV<>d6vpII#U}VMc9EiH zf^tH^r#X>e)J$-Cei>NzxkwC%UC#Mz5@-~UC#d<%xb_Fuob^ja@yviv{?Et%8r>!S zV);K!{!fi8s-qAZ-b6{Jfj*|kdBWaDC|K1W{1H1~z=}ccHKo7~Mgq%!@^A`cqqz;b5Jc$Uh zOC3>`OSIuRo`U5{ofz{Sc3N@n^ezS>$;NhKm9qRW6(HV>a59NIHUE&=zD zaIptMxL~=~g-*meqm+jA*W%r2^J&ZREJ1SriAw{TzRAtp{@|R-TbmA^r ze*ymvrcz8z4jL3f;~;JWRkt3Al6m4gTRh>t6nA+y0^|z*kO8*-z(ZRC>Nt6+Ha9Pd z5BB?_HBr~AHjGg$>hlrZK6V4PQdil>Zo-LetO?5OC$wv|?f8Owz+rs%ldnAX6V~Ir zA?{$u4eTIKqU6BK3;`*(sUvUB2}tz8>~>?@XKh zy~pO5%2v)iZsm$}sf&XLiv!#(jYSw>6*S7B1-Q=SX1x8?ni&~3`{PYhdplnNL3f@C zQ(68z7yq36D=CWvND$oS>vJEDD21_;{_{9GCdfGp4^AE*m-2Eh4C0L7XhsRs|hJ98iJos)8cEF?c!%6Rr z9s9R)4=mPd810^~uYLwo22aAkgoP-fth>%*zhk**9#t>_ZKa$T6_u3x0Z4nQtG}s@ z@=@o}jD!|+)?g|+SW-&*cR-{o^nW8WCoC?Z;3W+L2PtfJ`)*ox)xzp zM#@@NEfPN2NccD=e3Y4R$9ZWI&eFb$En?!JNcOw_j+p>EXR@dFHwJIFFZ_Ub`vhK~ zE>m+a11RH`Kr8+8`J#c$x_h{oIL86Q>mbq@E^Q7`6%A`Ax$GD0>;s(Ll~L7OXgF#z zbOT#q=MJr%>6aq?QfRfTwl7=<(zTBDKF5X*m}1vXoXcpIj>Y}F4ZuxH**(Nfv-?T@=Y$fbBBbN3THF5vKP-&$_x-Kskqnq;2pEB4X6fB)J)+A{if;IuT+6F9N^4|T>~BDY!lipVzSp8bf=_z!|3ln1r>{f*eaJM->F!Vlg?(GO2TYT~ zz8uWyu;Ao?gLJD3cFU?@2(Ai3ohlDpIjy6(E8r%;RYQ@e7P;dw9}ncY01s$*Kz9e` zA;#x9gG*SbURB5AJ^_E8$kkArMp(YZR$?RzryRl4XEs4XwR0P+`!szFqwP^o1f~3X zG`7rXOSubF&gMTJ{mP_JO$Pw_X}|muIu22fHm?$|5@R`HcyU9Nfrz-uBcCEfM1t-U zRxn=Uj0Hp?9vLmZR(&Zgtt)a%tC0E~f0W%~Cs*owGnjj63%89sxU7#G%ykKnx;hG2 z3!i=>fG9Ne(sc*?D?^g_J{Zj1zLI%Fr6}C57K6F(3ou{-#b9nLfCx|ysJ<9}!(i?{ z7#F@rl1nize2V~6j0=xfd1PbxqE|>BVq6%QJRc1wbImh5ca(&)o-vJjatJrDQID74 zV(Am(if9Q;p;kli$+`H4KG6M~%5X_4tYh0}t!04u*iRnyXB=qNW(VpgP}#4w`=hui z<=8>W&p{mP6P`yC%R{5VCG5mrRr~Y)4h&}-?B$4E>}%V=$H4sBc$zSTaLY}rZXpI% zh|s3L^cXr`5UL8J6WVA%!KQMeU>i;MRZw$91lkwCdMD2r4S?m!5{F@r)f2ABmJGRe zQEN!tIELC(oedSbhOqBN#)ni`6C<4sb}{~W`(BKHMy~1=J2n{oy0~fj5w69oCK3vy zGX)D!+SjF!6Rv%!Ya=xjYL z&B7q)d|1jZgBCAjoj6w&;y~mQa1Fv?G)n71ivmj{{roz#UQ383a*6$=9DDq8sD@@3 zFNd9sG;f|qAMvQ1t$r8ffw_TJn9kF3X+@G*QS1q^^eW5&WH>Cvk{5iiq$gbj@{4L5 zm0S&P_-54y;7lgN`B@iON>P=;;uy67MoM|7Pu+o8L24B1EhQsEF`3~#N-T` zxdNZ!K8qdT7@_FOlYY$j_{+o!su2PDev?>RKWn?jG=mCyqknV>+Zi&}s=BhUXvsjE zod!>{y9a;jrA0@QCD!y1?$4H^<$#Y20K0)JBmji-up^iW*}Q`ORYAK6?Tc*=1)VQY zsL%kR^*>Lc0aHjc5d_VOeH|uOrGmgFQNi~#1?20}?_Ex+f%@!My$dl6%W9WPbYrDF z5-;E%V!yywS$dxf07S3oh8;dwJ;Lpz9xXy1k)pv-8$>inUNWw40@0wdDS7lapBoA! z^AR4y`>}JN2+{&%)f?Y~x`h+5&>rg1wsE85cf8;Un_Rcx@`VrmzvTK=_(XI;Z~flMN$1zlSC?W)F}xUa z*=ov3b8*`?q_@kD<0>pdZ`Tpi9h8$!T7$g>40ITR1WO*q*$RlOosdpAu4vYW;@&Nz zd=BF(u4tQ-&#SGM4ZgB$?3a}lUy$R!ikoCkmv)M$_?@c5!l&@ed9WlKv;HsC4jt0< zFx@MgaleFDYYJz03z{WJSy0cC<>5wsJ+x$Do>FV^gpWv#=7S(v+gPT(p=);lAHqPU z7M9jX)s!}^S)=Y?JXn>~qxC-9W{3u876|rEE0H@(TfwF+_h@I4TzbkP3-UoOyfldF zi_~+irf@EUtSd$kJKd-2momWRcZcxcViux-U zh?tQuCTb*tCo)?-!=R3@tGzeLZRwfJmy&P17U?5P#5x+h(AVVjg~r+cXrWe+1nFCE z75zAsmVWQoKxDQWgq_Ho4Yq78+GFMlwv8b_gnXaId@gO2_BxN>rM<5G{%2~hA;13_ z+G`eu+dj3|!_M8H;Z}Pc;p*95n~t>FEBgDy_PYA39_=*;1Z;2ZW#@NkuhYK!nc8bh z_0P~=W8d7z_Bv@y5`KMoUeES=)?u|*-7Sgjb?WvW?RDkqy|>qgZBi$|7jFD*?7%qHpIv3P z+4@~po3-JKoBOSLoQ4&F#ax`{1pn)SdYT7Mp5!fhOsLs@rL|W%I=3c~GY};bqu*m% z^h9dZHVFt4f!^>FdBVa%@2?*3in=`^x73@|jTA%i%d_*M^qbV}9gGSuZ)8AX)V(2f zlcz=9iU^X--yfzL6cDT*^_$K?gW7ZYPz_|Enw%NxbH22ioGnHYxVTlCoJ}i>vddHMT$c3`CveAD*J#%m=?5no zKtGxh3p${LCmN;OIBgWdthGBSUCWf}4$?0UBzW9g?%#JI)5vQB6^W?Z$t z-!IWcQ3R>-&3}$p*-M=+$js3| zSV$hC3hLAPi=9W#dt97N#^mqhMAq2{rPc?qNJjrn%5%uHCWV@iP^fKOkY>ozC+y1c zXcwSdC{S=|{mJ_N-}dtC?8L4W7!2$|>*rzRWUmRK_dShmhkV`pcGs0yJ+;|qiI4}S zp7?G9*6W;wU;2|#cD2@})nhDoxx_2eZo<;%aEuz>Kj4sM7XPqX#NjAU@%#Rxd9({+ zpqpF2?e@%Ukt8L+%x3WyzhCvfCwvFm19LuWjU`gGS@mZ9Tcan``bXU_JMDFYXkfQ| zm4813&hI?x;qPGjG3jz>L}7bn8|!bU84LUXmWN;o2G_B2`QKm|nT7eV3VRFCmqk*% zHCW}>$B1cPI+Jn|PQh5>HF$siI2`+O3UG!S zz(-SncY6SYVrWwI(`MiXlj$kI=&=ZSbqes$#{=j~0Zuy-z@il3RVM;?G=OE`fiPV; zA?9nqKro~}PTkgu!=c!#Rc+|Y)xT^}0B-d{#K7rV-$WShIYz{TIO#c!!LnNaXeO^- zurH19o2R?U_&Sey=zhpPI-mM}&zT2}ysXTp#52OiMq)dOFpF$H+o zl>k1H0&JZG;N2;}%>e+bQh?{)1z=?g@RmOUcwq`~?#17Acb=XCyz&KvJTe9N?c3<47-dUy!S4L^oIvs{@ZJp;Ofd&i!=)@$@9gxd+9-0J- z;bOUPK{>{?-*ZP5^!4Nmvm~pEl6;7r4c6>)<-z zw!>vjhb=0&d*PmjTMV}z?lZXEa5>cjZO6c!1ve6IJlscc1-A^eIpM~@{T6Np++4V4 z;FiK|gwx@^hdb!^uvZ0lHryz<>)>vMtAl$IZV}v@aG${Kg6n_lK-m-3|8;TmxJ)+&|$u;l6{j-#*ZG6x?ZW9=OZkZi1T$Hy7?{ zxJ7Vl;X2^Hg6o4eI~49jxbxsHhBFt5=K9dTDBb$<;pQJ(-{B>9DYy4qp-=8-A z4^QoD{9)M_;19f}COs%bXte+u5f@3Y z3nv(_&obn#P88X`kF&_?y}B%_(oqd3Pw>9Lb1N&f@BX|N;0%&z((;bp~V2`@W~dH0tQ?BC}k zynKFU!b`xJ@X~x|sP|t5N3I8SvEhK~b){l85QF$@Gs=ejZfU%amV^s-L6$ ztZd*_(rEu2oUE50k0q}P&BhwJ6?P7+zpOlXs^na=Rt@LkJewI;xTlu9URvU08w(#wE z0k26c%B51kTB*eaELKF5TAZ60=#<2l(PN~%IvcD#0!czd%ckF}vd9On=uYMLV4~HB zDgOjwO}_Grw$Tvfmz>*pr@N8!3c26iXq;E@0v#B$ttzn6L32<$Pv7!{G>6XWbtr!u z{ckBhmvVY5{GGRgyI=#ebFP<+OeFj@-ta{#>>HQRCrU9~mQPw1pTvo zQHL((z~6Zm)F2QtlR(uff&_XlG0>GN5IeZ@4uv0GM40;@Q)7&NP5EUo z&Vax3RIn>ZSw`wj2_LUke!-SY8SoUOXqBh*G-)jv3;C+hG8Tp?zjS5W$5Kft^9tn` zbZw;HtXOQLRLlw1M*k3gv|J?>n>H%HC{@i;k!cM~e@($#v*BN;{5s|y{c+{brvHBB z&u4FF%Fq1*eTMQ+U~f!Sej)qUE5D%aWy&w@GgA2lV~301#MsmLW>%r=-w7|PLHMjM z_b93&lwtWtK<1Co*v4x4y1IjcSi9b-+)H=CHZ0!X58>_;_)nSzo3U_w(mC;M3f!HT zS!dum8}0$Pr{MVg?|4Sx*20--ybJ$kxL?;Kr}sO&-v;*p+_!K?AW!CXBA#>)81D=4 zWLi7na!@9-T&Ka$@V~)x4%{@}x8C$2!q} zKHQaXYvB0KG>@&t+8>T#F30mpxXa+509OS^xVbjwlk!UuOy`bmoJ_Ihg$u2P3S^er zS>&Z5w6Dpd?6Hhj4Dy=KF)x8F_C)^3F~!ZBYz`Ht0pt)MP=-i>0c4*N*hsQ)-`~E4 zf>E#tNLE{uHvtd4ovGd?;(?Ka_A;8YLcnQ~&ZNg9R_tYjE+c z2u&d~g<#wpc`%RF!IniXwk#l5-3;M0e&%|9{9mP-6znI+n?Hbh*52jCro5N3-a5*9 zrO^&nsfn5j4yB)JG+L+*qtt4%BVUv@b7LbcG#?*~=35!!Ah!h;u`O->9Ec*a^>6+T z@q~PUCd3gwlXvUm4NA&pen{j~>DP zCYy{BY!m--)&81l%GJ-s@h_n%Ym)KrA1|cAzo-J%2;vcCYnfl*59FN5^9}*hrq$9`4%3s?);hf z_|~)O@Uj0NeheSY_;b_7|KM-?8h>=!`0JMcSbP}|iT$^~N+@+Gr1an5ze)eq2;oTR zDvklPF)2rKR|$dnutB|eQI-ka=(D~(fXu&-7G8zv96L9_@3IBg){HgelSbM~OrfAd@%4vx;ojTE~Y4$$VRN;G%`DW9CczyRg-+cPlH1%yWfJyVs zYXE9N&Nk>Z4tXs&TfI~}#JaqxKRv;!%h{W)Ufb(DqG}T#zk^gYQs$GB3V&?; znB(`Yr_+u9zYg8k_;b_7e|Vqi$LO^2*Ln9f|3PWvKMZw_|71R0`BWS!5+;G<`E>nr zi8z5tGim@7K14b|L-gkqEJWH6p9+Z{D?=pp7NOu2Dl6~bBZm4$GC|spFQgWFrID6U z32P2_Vq#nw;=(>DEn!qz((8_c9Bc*qpNe|D=JF??5qfW>YQMi7mGa zufKroL}iPxAFX5|Mk~L_13bzv@_@6IU*rLW$}c=np7IM1l&k#g6#W4B1Fr?xGyXhs zh42}Ys*HKUmF2`CU(OXs8~WA=^S**eN3MrI@Y(`=R7q9DgT1VR6~!S>C`cE3QHk8{ zRgexq^t&XfHh69RBT=dVJVvk^`03VabnJzd{@(iK@>;}K2VQ-W$c5Q@DLi7i=Dx$YlIm0qmYowEGZFPXkgS=*cffBCkJhEf^viK+{_M+;LY*{gjl zI>^W_b`+0>14ez|%sGYPqaHHA4!&qg6&X6yD6=w*qqLHth1?ff$jzn}a!I+VeSC`2 zKHgq6QLXN&98iu{rUtUEkzc%@rLZ!7!;^Wxm2sPuae^*#U+N;i>&aa0iHt%v&_&J~ zx+B&Pc56JD(AFx?_9@j`2X$?FPfKpis((sr`XXY7iA_wNgY6pbqqkQj2liNjh4Lf@ z9+9p8B_;GPtk6XGq@+jW=(nYW-trH#Alz+B4xOuCloEQW6g9RA_0j5m0(s;le>yuAVM}-hO0-_)6hx6`u#b zHRAKSTC(zL+3`?^g4z+4>Y%1K_)(6P2bB^cwY;DNqm1b(Ho`)1rN2B@q4kV<8AL$q zC)?s^4N*4pM|zlA1h=6#2_-&z=xTHbmA0Ax{{Y!NJ&=7;9N9evvhT*BQ5b|!{b!&! zwC>e-GZpWD4BwGcPkc92$sOoAeel%e&JAr8G{dPc;ph`Pw~ww*Ne*0L1x|=XD|9-1FH8wtZ-q{W@4Zq&Pq9L$!}qstPHvM@BQ#WP zi9H71$8o-;@4WzbmUGDSCQ{x6WLadL9oylnSs+G*SM6>Ypu}fkn7}>(2rQ5(;-(zO6Z%d(CLtC zr>BH|$_gz!NFsU1x*$6xbhQzh#x51k{k-+XCcAkLmTru}t?_M|GME%*Van#?#diU)gU+)eA z^@ip+*Sk%7T<`KUB&c+WoVGjF6E4ANyKPlzmH=IWp8>VgE&&pkya(NojM{gu7K}>2 zAtFM@OK1J?e?A~-$1Pn&1r z`-89lD8B!k{9Vr8NO=xx2>vdcM{NJwB`yrats{$+3 z#rX~Cp>ull&`ooHtcOzj$D?g&3?LnS;~&i~+SP1yk-Mu5hJv+^VJs#aW>DHepY+R9 z3bv-jmm%Nc>vYIv*B!^oo>Q!Z# zc6CzPVw@5s6fU{y%bOsgfUzd)q%;hdr#T@FE6OeItrJiZV(^GtEetNx4v}Nh`^2!} zq*xgbOOHYxg1wt4pfFEJaIEr zhF)QT4R16S1upTt73dR99~sGdh3C!%Rsa|QfaA28eb#5_0(E|j7XjaXMlLw$8*tcX zDYwgzTYYM7FEN6Z+tYY6QeNNOGq)vxCFWM0l$%}UhJ)iv8&qzMskxn>l-rr{+^$KJ z+sKsM`X%M|=;=~7oKRods&Z>f&FvkCLgRH?jW?ri-z@K0w~qiztlNW(EGO~Ul0#K) z9^}@ca??|DyCEsJaq-+{A!QsEOzO9(Ms9#hznx^|#-4utG#vWWFzmv&mTUKPAtzv3 zW%$Ah&P1mPmaiz|(J+tZ>!LuWW{#qCvJ9TNB7h)?GMT{A$!I&6vAAnK@`+Q3hptYh z5C@{gA+-cD#VJG~HsKkw0*Dxoc}+^pji`^r>@s3@2bXq15vJN6n#STs?jvnt-Jbb3 z^lmD-#7eF{Wu5@G{TP=Sh&IY3c{nyf&%NEILm8Q;{$5oAtPZv#qe)<1=t z_eSo{1&LE6hxQsEAr+};BFVXv&Dn$M+z6T|REJ+lb=sy0)e)j+h(~Fl;U`g^Kd7ws zMttfG;zJ^o3nYo+>AdhCA^jkpgdc1B{^Gn!iV~)QgL!3(JAt zdm>A`%{4xl?!cQdm=-MSIhf`GmN=M3GO{(8K08&0ZUu7N6InVuDYu+>ZfB**?bwvu zK9ZryL$n;a)hf42(&TZV%?@D<HYPX>gm+s0 zBQtSDk1_FEStqo(+bfJQv3Tl#KPE;YpS=wT4ul*7(H%f^mK?`n{tz0bdo zBSah-=HbmihGmO;BEz$QB_hLhjBFwL_b318{CiqbZpX!Q8y0&-|u*ACEos`>=Dz`n)zy5K|=}@dNrK!S6S>QY+&BVk>--+4cJ$~A5Gml`HZ-)_#n2xpo?F*< zJq47D3@*9#F3dWEKRUyRj{vrZ=}}3VDVql{>CG-OrGKO zSCZH|2=824?PByT_BDc?6YVuO!ynw0Zx6jM!aTKL{@-nNILwi1?dv7TIUIrotMr`7 z)~XrXdrA_%uk)9+wTGN~@_mV09Vh%IdCBpoMFz)|ZmZ+_Und8?(FmL**3Z@=lzN0O z%CWy3c~N}1nkWy1FB$}y6_hS)otFas-;%>Uijvwq5!kXb*pj_9@$)zR=j3qTo4BPS zxz)~ibuUf)rkb=SX-{-f+y#J&%R-fGE`vy)b?TdtKhl?NwM8QX0k` z^L%4uy*%k>7+Lu;vS9xYyXIc4(5rUMX>G!TTVb+jxM8?1h z)th?wZ_>6D>6(ZJlC7V5mLYb99_&Tvq~q0NBD_<9H7i{(Qt1l!FAHCRq-m%XQlXn} zS2)wiehRLrOcV*J2{%>#trT_sd7FtZ-#usH3uFqr3~N!c_l#Tf3}MSp?5aJIaoLeW zJEiW)fvcp=Ky+5V$LOr_*Rr$z8yz&YAqT~eZ<3VIBDCElG(2CQF*1($MAa`B8dTt} z4mPL}Own@v;*`M4t-wTkgH*VR7RV$mdu;ja?O&!u(^NEsk3rJ>x(^aNA_C1-Nh2VN zeo=CXX(rx_lkFd3o&wXG*vE=Y-=YsELSEJp%J%h9vAlTzZo_g86> zgyI%*!!0}_-zx5zDN&wLQBW>wq^gD~G;@;GiQBbovQX2AC>5N{pDNC@$ud>*7zv*XfPVr zZqd`G=gCpSfW9J)UadnvDWQm+rh&z>~XNBkvWvR>JMJUaZHlP<-DPBwFhO=1KPxlpVk)q*iy{&)!BD-tceH?^AMH+_nnl9v&koAVjjPdM`w>NB=t!U4MDH z)&Eah{a^Thu%61@82EkZ01&YYwC9 zexDNf-!OfFjUG_oH1k@V`5c}S?e8j@MZVRnc9YC%ESP>!N`yOA1cf44;Jgmv?F##V z7gcfc9r6DNTBOH^9aBww81jUL5C7kc-`dN623+{j@%z|_WF$BU5*q2(baJ?=l)#_D z3U_papg z5G#M|JcLDW&s6i+w~6{;CcSO{4g2dJrImW0B{x+?h^vSjdGFy!gxO!+T#XiaGO^T7 zJQA@^-(G6<7cNO?*RO^l5wi>Wl55l=B)s8~Ag6NH$`c-$Lt=WpbjEE7+WTW~-nY&` zpQP`PmnWP3@m~G^X@96i1+3$z>kkJj%K7itKSO^gTADRzZrlF{vs+OQUM*o?p~&cu#<4#G zJwr}C*CUDh3L9Kje~4V6kZ2N(IFX9I`CxWLv9}r@O)fz{ z;)G;%#*y)~_o&WTNKrvc9~jEQOgc?wQaRBx{KmZ_-k#{QsIEUX$;7`k4_f%=OpzCe z2D`b$`ZxWCIM$hSheL_I2#Q_`x;a*<@Y|frU)j zdC7?Q>LY0oG2d8S4M_<++X|c@XjFl*aQoui(ms8>$tKy*yu}n-I zz}pGLD@qTNa9$$ck`lS|VGHMt$dorAvLj98vr{5J*CR5Iq9SsBn#kSfBv#gd}?xJ#47Te{((}T6ypaJ$k)geIa=Al?0qM! zsjv4GzdPk2Ui$(yiaR`9bAw^NNJxcRbUP_C$(^W3#R7bQRFPW|*5Nt|u?MFuxq#yxa=)b9j8rU*)p`K%I&>X%M1>B(*LEqYSn(>e_KV`uVC(m$}` zC}H8*>^C1bDSmvCW1Z zJyT9hA%>G{j8Do*P9kc}H_u%2p#`;wx$->v4J-GoR_jV0Q*yy$um->8)pk;JQI71m ztLMYnanYy;O0Cs*pS2AcnNp>-`VD_JM;|uYa?spg@mh5>G;V$>gH$WKtl)sWvLyrG zy>PoxsZCa90VO#UW&$i_F?;$N#@EB5?xFTv(4Pv!@n z;;-zpJ|;F6d_ajC^-5axnFruTg)puAo2`2%muF~T?+O#fD!Aegss&3Z$t#MI<{VEO; zlm!=0bI@$QRt=g)7BfW@k6u*c#mVtf&USL@r`E`zxwS$K8mI09)4E1qJqP>c`jeOP z3bHx4cgL8Q%}0;%h137?wJIX;Qz-*GjG5BUR`fhy;b$rTQ56T_Kz7hJ^dQ`ZeGID?2r%hFf`KA%wp2g zE*`N(Pl@uO(_Z!OliZ8RVKar0I@$m86#o7JtFU8PRu&R0%NKY`H>uJ}jKse9(jXjD zxI#zI%7U6k88LbmjM1_CB!x|M31|^LD+eiwj&jyPR1fM1AeR|z))fkiX5x+Vv52!? zL4i)@pVid--}|f1KYSL{ZDzJpj3b^vjy3;ha{hNkG*hk-UBnZZdxCrN2j6eaC%KO$ zP@6JYt*3DN42$JLXaGBr=_DS&;|LQ*GnkrKI(S7fbvR}$DNeESM}n_RTJ{+U)45uh zL|4b?lh5agtS9q%$=$!|eA@cAJ)aJG_M7wB9O?#ow)F2#LqvQ$)IFu=BBDp9_N%#` z!h=;|MWHgKar?7#Mjf+vX2R@cmhONUL6HgbSAu4Y@t0Zi_uzDU{sO<2zBDm`D9gBp zD}8CAIfbr-(SF6`jVw#xLPr*y7ex@(oG z%2V&#yDcWL6DreiPvv#4jrp)vy#frAE;R36}|97(9m1D&X>C8@mb822}8?#ifD;?(qJ;~YzL_*iIq zk4vf?DTZc^4lmOqk4R#iQs(5&;M^DkE!nD)b@7y`{PiKDA2m8@`2^+f8OUx>!q^^f z{)QyLmQCgF$Am7*Z*eJqzCnekmqh=|GWEYEQ~&!Adf$hp{`VpL_SVPsKlv2Z?~e4p z@ujBzS1gRrssCN9_}a1dK>sVY^*`u$N@7jmj{)+>Q5RYKanhYOf8>6h+yBJa z4HnHnlKnb|{|SdD`rm20DzgNHH+nbgOo>$tFDbuq<8@gq$qHw2#n+E^7e3uCOs;4y zbe5Mz-2LQ1PqjX(8p@l#ATEoh4C_yxD(~E74NHtjPOq5ZSw?}U^b>aJ0IWu8TuJ;) z(md75RW--BBys}nMy5+m+;gNk*A0q%RoB{jRKXFV*X5~259YB4JQaG|oq=}%?XXAO zl=3gkyvuc@-{>7L|B35A5y%*SfrZ}>*4X$>eavaE-yNn>I6YAwPwuU(nYf)1=!T`= zbg#n2y-sgsr@{WvqukSU_nm@A?nR$ERtPb^z8m5$e5GC3vFNM9P{@{hN}s4oOIyP; z^$3@KrRUF5Zgz8JJ39AU+<@3qlS8=2pa`rE6$eB4_eBonlRB>QLM@qidpMT%pVkA- zyniwe8OX=2j=q{rAUWJ{4P!+J=+*wiz?9YTUFC%HG6wI&(&K| zytfZ)tZ$3=_6qZ2X?Ab>xq3TD^#aTZxcv@BnTEx*JenRU&GjH=$^-ahR6|_wlu6m%Q zJd7Sf(c1#%+E<0{adUiz?S*^L`JEHJam;P5vkY9}%=?=WB`Og_&d{C`x%2|uW( z;6Q`MOF6ez86jWw0bq?)#!Obuw!>EUMf=gX z0PdJcd{WSTOd?Dl%=nQ8o@TIAa^r`=ZoU@}*7 zv_Cg8YHnSm|v5J3gstb7(7;Mf7MlcyLawpMC7Z`yBLb; z+>6LO(LZIN+dxyVCrAadTL(%ogYVpP4p6CTsYdI&1eS8!#Jf41nTSQ5V?_W1q*%1- zWWfq$hgTMzojw9>pKmfHqpq;x)5G0ZF|s;2R{ZYC1gtm;S;?^C9#4}!Rg(z_as1Cg zh%S+!w2vDJ>Z&?Ng8ZglHvz^QH_Ig!D)!fIIYyJ;HTmb86aC+lx?!U8l?dF`ME`iG zd!onPk$j@h|5w692a%O*q96A(xxZ>MVWL6q(@FWoit59;i$b9IP*pqDYutW_HEl(O zzc|w9i!9|+EPd&TmC);&&x)l@fwuE6JhdL89?~Dj1M==yB|-(wzMAQTWWj5`nyE;j zaa=YXLVVcAaa~MDdD?M}t$P}Sej1p9_U~)-&1>{<8tle&&Ru%%=|-%RrgV;2c}=}S z7{JC^I4*8nH^IAr1xB8Si<;%0ZHC4Pps3LhwidAuCz*>_QJco=&T%LYn^<2=+4u;` z`KtfHWo&DPFS0pEKdF zov=!FXm*OrFCpS6uQO}B zwOH3sH7lWN&{OrN0YI-HeNS}VRdZ?C%JoQkE z2l_QUiQkQ<00k{pU~#0ua357W`psHuv+Yazi#$m0s6;PaG9?zE=yXq>FeN2A-7k&> z6rFyS7im0tOuCmTC1XYpAK=Cx->nH)%fTgKMpt=izIltcW~a>PC{NYDBvkE`8GXIK zd%Tw=RPB@*J?E*Kolvz?W^}Ws>c*SB-`XiN`n{*>(+O2OWk#uQoIEM;UFg1$zbkVxar$E=uUf ze+kB-wtB{QR;<8-za74@yFX@e-nl`ZMIPX#|XcQ7QW>(27ZTgmO=!`ZOx_l~627x$9!TF z4iYcDHZZf7CCu!JfgR7R+P|{y3wq>Kb4K6QqVV1d`4-mYgKf~2%U`TFYaNSuB}~A$ z&9==cc%;OWXL$dRK9vSVZ~+`Zo7O`8Dt8(s8%I3P>Ck`R z%~gzWZ+x#mq>8PF7o%z1ABGYVb4!f-zZE;681k<#3Qjr$iPj~UEoJkJhH zq!kfsmGRUk12LNGV48SngY@>a!O`TlYKyj`x9u=Ztme$Cjf<~*5w!*ICe5Bbq&FJE zpI~p2_to`c2!BEh;n=vi899unyZVf^`#+M>JGeH(^j5<5q2854YtI;{xb=V-)sI z}4H)$s!XepX&7u`MrMHANNQuJ!P zb+WZS|M(}H=^|R?ChX7J=leh6SHPthF1r%!KqI@s!Msr4IASPIXk(syusT?Y; z6+ZyQO^0cHmTW`nbGc=qId>!Xf|5+o4wBu-?NGSQoyVicVG_}#AMpH7>%nI3e#m8p zypbKrS5UvdVpD0X@;| z4sjB&f9I?D61EC!mvEI)t9p`+NPU*!?dfF{j_*f4%O|xTx#1dq-3C`ruQE?|KQ~BE zcQ|@_)i^};B%6@>tQ2x~=dSKZvnR|Nc6CR@dm4{c395kfg;^8mmYRLZ8|kgT-5VX+ z>pvKnqDT6pm#W6*s`l%AHLK`96dUmNkF6crOy9ifo`JsoQ}ny;I0!#l>MI=|S#H(8 zbgQ7#s5&i(c!zx&B?auS4#&Q$4#(#6v_w9smu8I@2MIU+h01{$RR=wZFqsfl2j?DA z%}@`gXDH8Vao0dxovi4YjCjj{pgG~_6?t&M&IIV9XXfMho5(1LlmnBi?V%q$5kP}D z-++;0QF8^$*{yIioia2%85}hejyD~$E329bN9B}}HgpGY6rUf7sS3tIP!gsAB=X$= zjR-(bN07H(|HLpi{_Ce*4>{W<#@TXbGDul+XXxN=fRrVA{#-~o0R*s|La^K`dv?y) zRzH7pwo9-ChQ6mrF|5u-bJIhPK&k*&0TYGt4(bNLC{jce!XKP_9z>8F7z%|JVa?6R zpG5_${3!cAf&ah+0@oggx`qXCopDevYxN67FN0@J9cl%!n;=w-hOoeZnIMr<9KAlT zIQmCY@5T5aIMifp{2eySb}wmm23Zx!#v;zQ4(JBRnjTX>8?qN(l@zjz({>iJ1aSZ$ z4md!Jo7@$M-`%#GLEOnIq5y26ZpHrH0N|ZmMH0B5lcsf(=MfE028=e&+q#?K)5+@K zM!=C--2k6%T^%eyadCK*fQlhx^KPZpokFCe2X+IXx&x8mbgouUV$vN1(6}uf9V%Gv zV(>OYw2N7O$zd%3mMBUz~56-`=>Uj0)J%jlo7 zdawQ|kM7w&r6#R^%GZ7RINC}RtE`G<~r_68P;$43rO@{{m^jg#}#AYE8z2E6xgWn zQHI^ppGaf6Gugq(u+_-TLu}IVq_5fWj!yc1W}Wo)hf_a-o(jdD=f_}H;>zefw~J`u zp+y}%aR-~W$T&5e+K$7%MO(CJMep*W`0?E^?L^mNL)`bY5z=9J!l77wrLm~vODGvA zo{G5WV|s@ceV$gVHw|4&Rbucu>e*vDiuI||uQiJ1Waov;FVXZ5eS<0ikreGuOV;5h zoZ1NByiFs~ML)Gse^p0u$83R7vt#*AHLK&??z=ZWt?6R`+=?x(gTJp3vd}=)!QYqo zq;#Zlmr_S-cOLwGh;N+-e`{OlB|0fP6I(7FT5jyP% zzM4z%Vq>aQ>{^cOc4D~JOAKH1OU6NY^8NoQdYA@5(oGM~{@6J^40y9U=s}R;j30Ib zJzNP?jnjjQWiK{^OD;~JhkTZG(!<16ozugIz|OAdVbV4?J$!jla(WO}aJHxL%Z|b} zJ&?US=%M_Cq_lA3{z>V8#!Tb6L#e34(p)@{yROkAl-_ROoi=4D*BVbm3b`EOdGNv} zEmr)zv91sp92;=x{xllm`MaV0Q|gS|k_1KaVT$;R8_+4BXT9B-Qq^EVJ#IX!})TKelSL?Z=Am)>&ttxP#=iKdSXI1yg98 zGuT=$Cycb$OZeFF3{*bc?cA33x6BwAD%_cVzjIMEBabl#20YAavxJ?V0Z%=3Ii_n- zL=226^pHsif^h>F!PoL8Hu7t(iXZhQBk+3Bkr7ODE{s;#GXN4U&H8Kc;GGD8akuJ9 z9TNSj2!7ywu~Ok8bTK01zxz2GxoGG-~e+*9^MN7>;SD9lCA zK1oQ|0;x9LQ>_D1R@~Wb8J);cmny1NV~nT9D!T>>kJf8=A_|_Ha3^4RC#2v`!1zu` z!JU8so{*ZPTmIvvw%hrYx;TvEEu0dnRk?ArYwOcB3Picn#S{Idc$|-=I6vr?7c}6p z{PUTTLq|CJXJ2_ixL~WV=63j_x%uPWTZBI%mJH7Jmka#!0RQ!X|J!c(UykB{e-1u-qJn?f&cgp? zz<*5w{HK8fy5WD{cLM*H75vw@;NSkLz`sespIw^+=?wmtCWrsX8iN0*Z=K+O*#`fP z+cm-eB+wu9GWlf}_-SB|ga0UD@q+%RoR*BU%Rv5e+=M%J^}m#(4ZUq1HKjTKc>L{ybJs{uN3ege|JOH8_&;XDf5#0w;QtKZ|CkH@cVbnD!+#Rj2x=^=jTg>Ifd8d<>w^DVO9cM7 zk)i0BaBk6KIB1X-)Eh$uI9$*Rg^O_T9Vde;U(UzZr<4!FDnw65^F-5XW50LX9a_t3 zW4QF$sMan`58yC(PDp;nW)w%KRuV7>ag^T#3qnezggDZRAA@#M9)vXZe1c}ui8RJ@ zgvJqB{ZqgwshP@b1BYI=T3WNSE&15e`vdKkgly5$+g3}T?`%se@omOE@s@-EqooeE zL|N0fvn|!IB@Hb(WX*#QQnKb~j2E&dD-$Z*B@itDI#mm-J9|te1VLbAruJH zhf^S2--mzSk-x9Y-&Oegs`30(ilWcT-zVhnqx@@1o3bY(o5*Z$FV(^Mb_YjD2agn? z>BQlD!1GzL0Y})S+jBUa@ySa+qe{2;wFdu+l-5w1vMc{t{z@Yo#u8k!4zOg_C1=WAw5hOp`?$F(c_ z3UaO9a-_G_Aia2R2dLggvm1R@skgVkkxubds<(Ujq%0XXn!V+@db`BY8-lH2Z@bjh z+mkQLx0R{hCVG1tYWAjf(FezSOJlpbdl$X!O!Z~fF8XG0n)ojIY0}fITIp$So%G~5 zAH4#F>5-t$N59A?bw2tpY*lvAh z%@*?);PsqNZ@slr{Y~^Mcuwe znRhk|xlF>h3+6lezO8sl0|t@kwbrBJZY8bK;j~;DR-C$PzZ{YtPt}91sy4VQ7aC^OO#C{k z-sq|N@d)|wIJit^p~apT*F$Ts!g1}rmb!Nr*WP!@wbU-4eVfWyVnPWWZAvtJDEZa7 zKVtPV_eu2qy1MhelY3OqMW^?uK(!ar<9#Z?DO{`qWmv+Fo(8Qnn_tu!D{B*{Iersym%zyp?*|(=;?k~| zd5#I36Mhij?3zy~x)CoVxoD;&gE!XD+C@<;+7lm*kH01pAD%@Z;NvUgyA`p*(I^xh zg*xHvQW`Da=qD_wEG|7NH*l{#P&t7QXK8i*BWUv=D9gM3{D;->n`3x)nVIsf4)e1ct=>gHNRK;togm`RC|7*Z*SfG@vb_(pC*UgCC6_P(05z9ZH~JN zdDZu0_asj~%{j?3A-xgx|9aFxTj*YkEFx zgL~5Mfd~eXDLFlVzusN=D!XtpdT#QRK1r2!&@%i+pGw&UqT% z7HS^fD2UIabvS1m2pHbxkd~|e0#T@{{UG~z&UJXU_HQ80)e^z1rEzy2({Y^k$~R~G zfbY6twk>x_m#V|NrYu%#4E@kOga7!wIo(q?@Z+5vxtGz)Q+T{8tmz6=Hk~FtvC{%- z59P}4K11}#*&TT@4^e2j&9HCwr!YQ7@-xNsU1mpt_B%mBm zj;Z5da&9LP<=!OHyHRd2vXbG)kdtIGc>=9Vl)FQkG*K>{sC-kh=H5Ng#$Xq^xiPr> zBpZ9Bshng@O;=6fv`%lbxsCVnu+CA(#;t>}4@&$PFib{|p{ios(#ztRvrja6W|84! znN>!quX+tszbd1@uX+klysG^-Hs>6PXA@t;yD0)1n3?BvBLaYqT!;Pdbr#e7^nbgZ zX^vcHbgXlu>-8rmpzFwWf{(q7*F9xVS7oiBW|VU~IpLUqyuh@i$XmQlvCB8av{1Am z&Mg-s$Cp#IPQWC*vS^)g!|^tvCBs{k7EU=;S}R6t7Naar*4p8!wa&Pt)ta0$i6Xv$ z%_EOU*4mpxZ3g)_Af?S9iw!DgC&76V{Lu`phEx2%GJ~|yEstY^Za@CZ-Oe6?Zgp?D z(Jkeq&e82kPuVw4+;!$?;a53HJnF=+%aN0SU;U2jk}p~qafGzy#IOFzT3d3gjjhSp zqSe|utk7E2+1hgCB#f;>wMNcZPR{t(-5s_qQBk*%$ZsOiv0rop5+zsDEkO@Rbmkjw zBzp1q&XH)4r|fi9c9&LIg+#cn#Y7;iUMngFCrr>A$0+2%1eJ1vwlVzK^+!3EE>YN% z+hgW+>}$&X?;jJF`~P3D$7n`3EKbQMT5VoX9yTst>z?Sf$C(qI?EcUbJcS>%3n$ax zdV5MwP^A@KB-&%HA%eR!x$!??etwxfrUZ={Z*8~c_s8GZ^BeHkW3ZixSa(D(STwpb z=*s8>`6J1Fc2|7HN#2#{3g|}p-R#i z*1Bi)%$;sjPIjN&F`mi~CsgLP1u7@I&u-Id_cveeu8dmA?z0o$g`K&@ZeJ{8JAI4Y zXTRkh?@r%h=c}Gf5_R5W=NnXwENsyv-e(Yc9?mSg@jkmS$705Gmiz3qZHimW!3&6e zJHF5E0iL#s4cPEyM4UQujDPpGe0r0w7gM)d{N%|YHa~%V_Zz2u7yQIzCiLYs1Ha*P zNoukijQcn97CZX$nohi?U$57fH#l0hyH7*VcTGP9`!*T4T38(pRR-SCga$;+eLp5Y z@p|+Ayzq19D3+2QVnEFJEyjiUbJwAl@*H#T8zj8iIQ&%`oh1)y6j~-8KH8YM^8Tg))7$loX~hBEwkXDLvFKt!%r_(wW8#Pw8~Kw7uIMk8o-6 zq1DEvo@%Rey&s`iNj$`*?34=t4)fH#N7co}AozrEbOJ7bB`ZO+Nj-A3B!=k`ZfD}4 zrXD+>9Jvw0BIIVB2SNLk~kjw;Q>jNG^N}xfSm~J31ce{`p$?g zJG)$({yt`GqGvW+X#M69Hd@n+4OGT)F1o0}BYDb39UbB_Kd|(wt$X?+KhWG}x_H0| zWH%W<)s88!KH1h4EfK`}gV%S1sDz#pP2DE0`zb1&w8F;RHT3g%Y)Fz7RP9FfGWPTo zzQr!=SV8TrtM{ATO^5B$TtU&f*e}hM)Ogxc`Vh0Uu4X|M!==RZIl>aAN3N8_(Ykp} zah`Qe@$q_$oAS}K^7WWpQ+(DiJ;osD(X)V@40Vo>NP3Kp>(R5afqaan9z6@FN~8!z zeH-5vn(g{9(=Kfa2NI+xhw(dL&Ho27|GQ>)L{B@I|0ee&J$7VQ^Y1Bqi(NSB{4aMm z9kxp+oqtd1LsaQ5=3QoaIObhlMt!^o2zA(d2_XzTUYnzIg9W3KZ=N-H3g_5`lVQ}I zp3>X0tu+lIrd#>KZT9r!(|G40cGL>^{VqN1e{DNjSdz<2qgYSocar~Co!_0>tT5Jf z!=jOVv%)dOJ(swr_{PJ#nBq4Vy9*cDg_BM3W1i9j?b6AZ#?7A68xOMv!ezp}#AF#~ zdP={jN-GxQH!shmm6o@i0%`V5aHg35zb=p_0bfdibjA^^BKQ(M#KxBrP5*+&<JGvU}*eU7tJ*L1RWE_)QPuuudrN7Qps{(Wj*^7JojdV`ez_B0;_4xOe13Y` z_^s9B&NpoC66)HIFAacCJW_d1(#0bjD*{B7G-y1w(53{DM+Xivkz46pPNA`vaf_$$ z7l&AdmD=T$Ff)v>r}Rs9X{B~KOJ^E~cuG$*OMB(fag-h@YAA6ed*lC!^tc-%O(ss2 zLwdBPYW-T7s$G*FcRXF~FS(~{?7`LyY#>Rvr)#CBaDiPo*>uhFlf_OXIu(Y?r@3zaAJQQ#j2&BsrC;^*Bz1Bt#kPg>1nZq$_Ce?m2LiC{tghWHPRL7ERr^iZtcXnL?=pe-1Hq z6)5_-=iT&?oh8JCfG!(2XKo%^<0-slpo7oBlj~EW_%LiB;_^B*2@>}76uwavR*P*{NO(8!B#wktf;b;^xXs{w<n#L?y zru2<&2c$R6ST8XpdCtfo+v!jN&>~6`W2~2DI}z(8=pWjV5bEX6R7e7Tf*C4dfQIt# znn)oraj(*6STYZfzre>;P`tTHC=V{u*x zIRH0Knaio8Nr(xm$2MSuq1+h7A#X4acQ_J)F;ISFJY7be}mIqH_TzNpu!{u~x9S;@#XpIvAtu#sOMY(~+7!9`VVRTk**zT%$3J%4*|)b(DkPE*H)o&5fo1 zz0c?5A(b(kN*D@I04pJ|0>Ka970b}$RB%Zf=fq0DiRbS$`{9hQh-Ts$A zPXP?y*pK~+{xGbMO;0dj0M`s#fB4w8rR;FGwNJA;iH6@ji2@F}-tS`;)s!R30Ai z6z;7Go5}<5iSiBzO;m*V0{%CA50!_IzJPB+h$K&pjjs;nlQf7YavSrFvMQ`LCiUgF zw?RjE*u0H-wJ{cX%s_sqpnbxKa4xh)!Ka0lMCtKxNL@->;c#?VY#Eqk=Q8%LLa>>5 zqm;|wrRJ&LCC2Qu&IIqb+6B!9t+LqpH=mn=w~A+A?r*Mn$3mm;_ps5(V^134tNuH_ zx~jd*wkP!yN$md@dy+%4wu}^~EGEPgBx{@y-5E7?$JU99p0qJdj7hKb5lpi-@ZFO2 zZ#;!(*@XploQ2^Y)bWJ7>FdqXF7uEXG+GQ0JSZ)8qWdI)U5Vahz>JNz5-)e>#Uv)( zC*N%LV+f@C`bN%#6}42BQn+{gOuK<1eUFssvhJ<;mm6v)@72YGJm@Lh$1a>~Lay_a z{t!Y91Xv}LIwv9y{}KFn&-s(L-vV7Fn1Y0-C+FwGSwZ;uxL$EWgsz*6pLeG#URGC| z$XVvRu3IScs$`>IY7atBiJQoAj=sj&G{-%ym+#@`=nl(jFJqaf@CkNd;o%-Sd%#n= zw<>K;tI2#Xk%@HOfA(hQ%-33=lh5b)H>~-5Fzr{J&qO+P?BDv$`OH|5gkx%{=FIL4 z*Gx*J&dD77n0qp3^zLFZ+yChwM;oiXTj;3nl-IYN&@wX{>3nrv3XA zbK0x3XNy&9V-SJ6xuy1wXySA-)bGr};0yDg{SH4B2!=3p<4YLD(6zya02NdS_@%~^ zlM&trH{ng>CzXaF%pux#VRl&xN-!eOMEpWCz-i0s>`FDuiI;NjC=0gQZF$RKt zgn1r2S}hf{*j?&3ikPO$sGlLu2z&eKF1V6fkNL(k2+mp;#+&>?C^Qr?R~pw2Zttj5 z%16m8Jji}tDwu=C7(=nW)R^qWhr43yi|NyO#7?}uZP!I@LJY^kXb{Qa)7%A zuSt`-0bZYje0K_7XYnX%9A3Ado(QjkY#Uzw$xe7J{yqU-U$0Jtmwg^E_GGs4zmATE ztbH(}SFxll@cK_CIM4N9RTEWKCfO2s}i#6i9EF*X;K^Ixa ztFxjJW`&~*n)%ceX~B;|xdrQhQVQcD8zf1Di?uOn;oD;%op2NmlhFuEYq6O8L^FuV zLY#RFekCZk@^u7W(_;6F=^$2|Z@ge;2#1cvGBHx)pUhhxnTb*CgCTNkqz8lo1J?4Q z$h;Te7a=55Vhq^>MkyRcE|DY1d75uwj1{$xMJ!p$`SKgtv@#%-hr!LpTVqL3=1v}p zY;2!=n9N>m4vUoDD)T2FW2Am(PG5|0C$=BEN@kDq!zd+kovn@U0n*_!uUfPA=8xvA z!A~HhCo%^TI);Yx$HunpKLJ3n5adDsE4C*9CoS6bhb zZhg1Yg-H`dxVTHYfeQd}<>7-s-pMxAbNw{r23HK)=Tj9v*&|oPHmD z#e&?*ZNG$mxvl7>-zgKii+(=`Chsi$?uE@=7yWKqW7F!sozN6rs z8VI`FDR}*_$hDq7Q;-O+YY(#FRZ`)E*QT!$;5CTw=mK63FSp>eY;!lkYtl{K0I$zM z9XkcDg~MI&x*f4qz4Btgfi}GSo#lK*f#)4#|Ms6m(5&KB z&@OsC+bWb^@qIVJ^XMD90iF+lZgvWuX9ZpB(J_c8>xF0Q{x&>YZgj%)#?}OQKD@M3 zcxLmJg6GyPox!tXiCHLp@ORw=&-cr^0iGj3S33t!H-4@^DG{E3&9dQHd4m(4hsp78 zmp*eg;o+fY=lZVUdcB4QXgkKT#TMjRH<^%&%%%r{{*6}=#3cjRL(}v-ls4EPLVDjI zOitLc&EL2H*dJf%sighi^==SOa;bz1c;3L2&w1hi4ziTb>zK6U^WNY)=K9Xk5P{_< zsxJ1iwZX=79n>8#{&u1Xy?`lNLOjhkE*@yYPcs5#0zYZY_(Tp>^T3pnS_>$(=37#0 z2%o2 zw+i1cM8gz#6ZwbFDwKZ0H{FEqU;f!WS-(hszW~I#Q~3VjEiV4?_3?@L{=@(q-|Mb( z;`?!*C-9HU8WZu|gy(->w&D5sVNQ5D>7o65&_f2UCN}0;#na#W+M1)3<@l;oU7|4wX6!ik z9Q+)D3C7OOG~Na^C#4r`+6ektCV*07*tIU2`SVbVW<;kHoj2b&vcF9;eg5pAnP)!b z6qq#g`*1W)Gkb}qr&t0B$07$IoQ?tG^GOaSkRBiPeFtu~HlO~Ar?9@p>>dW3i!M{s zrN=k{q@0NhWturr4$86gJw-p?EwJZ%>!!}ui#1lE^zXmwCi;2u8u#4&BKjE!y51@J zdFXP-?7{wZY$E+!yN^vjCD%IXXVWJM^fQR?@T?am{XFuL4bMMa>ZBj@eRcf(M%Q~M zeZ|+Ckyi2aTfemEi&=iqxu@XgkdLxIJ^<=ZNztT(5w2IzkS#-WBJDIzfGi<0-sGU{;^JaS-c^E zUcR2+DZP~Qm0G_ye&OOjia(tne}Ca0lhD)g@%Qhz-Y2K0bgOuJ?#Aw>r+2P$Ptnh( zrxBp`ouH?dGk%C`{{iEpqm$9oU;EnhRC%?7o(`9j-n$^bU4C;H^t9~Q1bW)^d~$kn z*cYy65h6kQjL*A?Ucy(pC*v2<%k!Y)ouZdR>Rt45c5WiQ?A6Dnm$oaN^m5M!3H0*v zyd?A@@PhX{U3`q+v4lYEiqC9_RpL#N{tXU!X}TqN<@x4SXSd^proWV(0uc%u2fobS zz9BF*Z}MfHow>=^kN)s9Ny`paEkk$WX|%EbmoQKl=1h)lypFQCXecCIiQ27NU$pYszEXz4GBI&lhZ@ z8~^$PF|;~c&Prf^jG5u+BXZfX)&zSyp4HaOBiVD%ueBS(fGNDg24!+z(X?AG5EC;`3wh1xL_Lu*W*(PW?+va@}N){FStnlmegL2`7 zhCQ)$2t?Mvz#qmrtSY!Z;S+NvBAIBXh;A=!@y*u&CgRbV>`$LNo9~ByRha)TnT9=& zYpgArz3~k|G(Hc-EyfY0oP#0*LDE`qLl;9^Zcs3P%7Bz*s@rXn6m^>~ZGg`N5r(5< z0q_V*Lo$~iTiq_vV(8=C(-m*v(;VaYBjb=RjYGPOkd_^^oWj~G3F$TPWtt-@QgNlR zP?^As>y7716)$H`#s%+S_kCW`?CQqy%SkkvUQ{UrS~L@1GZU9Q)!`SyPjM}NYZFPc zxYkI;KBiD+j4ksj{#bdNO`LG0jMNFFZQ2Y7Z5EL>HJdh1By9$S zHu3o;F7e|iASxuPnoQc9JR780VUy`GMNd0~@#s1f4M2A=M1$=A0k90>yx$mjTQ4*~ zivn6SE_4pc8qag}zv6fvbB$-kyAB|!__7ZAsilrSkve)mYl!J5ZLsL4bWfol9t*dZ z3ZWkZFT(oVHohPFRR~u?-ZPIXJ6xbeT_=(l55FbqI@46w3-g~ADl00i{qt;4ft2}S z#P=ORqKvP4G?pEOo|u*xyB7ZcjG!5Z=t46WfkrOb6$0G?OioIm(C;}&ZWJpb9dogh zNT(kTA`P1SuyhkrCPVC$Okn^3nGRGoagb@>F%B}V$H{Sp;p>0u==i0CdXeI`3c9m~ zf8Vk3Nwmg8eFUiPA;eSMgqYhIA@X8bwMbqALfm*Enl#GRIS|Wa(H6ched<@l_X}M3 z{?6NuVI|;ue7!i-8e;m04=jA=Y=!$Z@kfoifM=blJ#Pm zGJXRQt1ogO;*oH-*wyvob?hs;*Nc8n3L*bW>%|qx){BL2I#9z}FG|6hjQ&s9_&OWU zSS)Zz1?#SsDLh|f8;ZyjLn-=F0t$#sTw-K>WGSSj>QWk$7WiY)!*l<#+ZO?Dx2{Ju z`1bgEwBilNM_c2`{x!$rULQ|(ji+;YZpz~($kHEsr<>_>)Tmvd&t@R2v4-Ui!RY&aX+IhbN=YL)JP_Rj7#mwKyd< zE;~zuOO*eD20sYUxcV^@HK4@4qv?Bye8SMO<;QCJs7&j|(ka_gGI0beE360GwW`HO z;sRVP#$@}T2`5r!`ODwYPV~3hqR-Q`)a~lD*auqlHpqhGvIAQ5(oDJbl?Tr>NO%6r zmKbO5<2+7jZov@R{T>22Uk33*tqu&Zud~83!(J-!_kv@h`T3>;nY^; zg;P@I&!Ot_Z&IVaj_!}Od}pe8yauEC7)V9TAm`C^7&D>8YC2*RAdw%AVw(WNgzxVn|hS@eSt{9tZfey zFEBiul2rKDz++0r)oLV~KBX2V!}=?lelBnpI055F2*HB@mgt_Ls$fP2s^u&Z7fJ4` zZ65_A5_7C2DnUNdwr~#{J3~eftCRF2->~@a>mlXbVen$ zTYZ+F`%2L~4SWsj&NT6?LC;>cI!H`wD|W#n5! z3E_nAUmrDxGRz)|HHM>hJcik>G1TL!YGqH=JI>9PPcVDs3CP9&vH`H#7;N?WDh8|o zaJ6qxVf_1_lg9knLJ{&@qX%09nnZOo|`1xEO7!Q z)9a?*4vgt2KMZ%igS}U6JfeJH)y5v>dsb~tujmV=)tZ4~HH>e@1{t6>s1E|FwXP?C zR}_NXmGGkDa+r7YX~GyXKLotnjr~8^jMaXfnX64%luxd4#iUIgFk~(9&1(TU41OO) z+lH>-Zd6KP!3N)m=Gfhz&g+qq`ZleM(MQGqL!BUw+y^p^MjpXmjARae!qGk@_7{I5b`o zUBLZGG?9l&WN`TGzw)!SSWyF)veLrnRSnURFEtf4O6{VhtQwt+C49ylRE1d8Vieyc z-lsD-9AvZ^!^{j002!G^E;C>wYd|&WDyFw#5{xUN5U6-;pT_RO+ADF!A$nzY9#f`i zjg!)(&*1RMgfL^qPv>v%sKaa(WBm{mGV_Q3VS9&6;_{(um8G=*l{ z8u8v$XCJ#x5KUnXYc|$bN+s}vVqeiRZ-tLatxi}0A!?e9r&R^?Qr}50Pr53lveM0{ z#1$0;$bq#d`JVBvT4}6xI%=ULjryZq-*L)~&S9mi&mX`(VlxOd%tD?K$=t%{iI_>i zax4*epIMtRj2V?!QGh}G(GU_>J@E(YLz#Nwj~106yI5<+az3In7}?A>FH(zlwGv|$ zzQzHf5>UqtCmBIF`DG>BKi9w|Hl8R`}rC~=E-C$Vn9FfRdd0IL@9>9t(tx}MU4=IRIC+m z6>RS))G0&CWp8^KMb~gL9TSWTVK_Ud5loZlJ8Ay=;{Mu6l45B--tC7`q^re z@%|~>JA(6pPbvEAMKJ1Oa3`OPj#lYQg1%>#r?%&=)EDU+E1nO7>EuzYpUBD1A=E1W zitnvjnlEQHOo=FoJiqlX0+t=i^Yz7$=Uec}#>Wq#N+!;Vtd?>-X(M-e8UDeDYoeI`j{gVsUm(18{!TPFO zEWx_<5f}c6d`;CZ%ZwqQ|DT0~&#thMFrTMdLfFK~MLd4U-&Gragc8@s7vWA#NYB!$ zen|C2n(%W&e)J%1AK(QV$)y+mb;>Vd(H*@dX7d%U}4LNGlF_UO=2}EgG_N$f#pkN-b1OOtA zYEVcH?p2u*lmO5#9F6fBfBuKibE>U_I`xwhHkZ4>(oZ<4N&qtR`dy(Xj9SWSh^6M1LX7^GI-Xs1Zxgf?V|PA{j4EzNyxtv zaQNk*ENTbKi|z#)6ipWk#PXuQ^5Fqlh}D*!F?G8SdqckJKm3d)*$Va#RYN(>F8pSz zd1kA7u~o?4qjq+*Y#OmQx@h{%AJu^C`RR;IRQ#|JEZu^zD}YBxom~uw{)uPfBF!&9`0wRb@EQl}v=6#cn{lJWN=>P4ID~ukjEhu&5QWK>jMsLy> z&zKg1t(NdUCtkYkHULCQMPTDbwH_NQ=`i*E8A_0YjvYo=eB_7G#>B8L!XNJ7pez@T z7FWWAFcV1_&BC;2P$bJ?Q9l?7u5Z!w7B2If;A~&rSTQ6VJ(cDhMC`=a_|=b-DNR|* zZ*YAzD;>ONG{(z+aR`Y8_If-r*{0(Uqn zVZe&?(-2YWjI?O1zwn(Pq?RpPB5Qq-D=>;^Bn!D1WhQ89JttBNeXsloUAMH*1F41X4K36cS%OmV2oX(GH#JcihJFZm`Q@*PA__-g{dELL z5Dj$N8uYKX0rsPfdsd4YYQD16(D&iLY^tF+iE7MRB^81lYl2lBd-!U`qf5vrS6|TD zahiT#!|11QQDkaM$Hzn0wjL@5y4C|;AZ%OreSuu2wa*KvkkXp|0w)2H8ni9z4qQ?7 zQCcc=?^s$W*5|aLYojx|RA!+YG@z}{lv%u9r(SQskJ45tVVlYd|IzpX||QuQM|Y4vE_A z7-l5VW@p^u(q_j|n;l1Ob{w_Yac~qFx}wOT&6eTgjJ)AWo0S-CBWr=tl6~{JvOEG2 zsLaCkLsJ?a#ivr-SZWt6u?q%cBjLb>q6f!|j&&9t>@3<-if+0=t-@%v%vp5XIac>* z6#_0=Z9-89c9^07C#7GcME#WFhs1;?CQ{qPqxBKbIa>i0DkI`;R-f>HaeT;xD;!-y zgGHC;tCGc$|CS$A3_Ns{zECyIVy(DsNm>T5UZ9o2I0*GH6ao?j@{GHBh~g^-T~qPh ze;Q?x8TI5I(Wm&M>9INLi9b+$XR9avbf)+=;GM1bX0kiskVzHa5@YbU9bl%%Xa()m zdSNH_g`<$1!Vo=`);o?uD2xz15}uRc(0W@>iEF(b_fm^hTJOCoEn07lN{iNet4fR3 zd)a*~4=D8NrLUy=UAO*Lr`i(xUYqhxEpMu+GiDAfHGX^m zZTSYJJT|9)$`km14{)%5<9EK9=5wQ&Zo+SZKJ(&T)++kZOSaJJ)@R<0>oXi#NYB@* zIv{{Oj|Zndv(ll@q}^lbGi$51^{CiSc7*gZGxR{($-%UWgM%lRq_t*f(9y+8+qYve zgBUj5xb_$7FW6XWHmo2GB+r0YAQCkoi&eC6=+IqXCzvK{{Pu&l2I{y(~S#Vj^ zV&k&sH?*)!RJS1Z%!`&NdyUHxR5g-UluhPuWeE?V4tMT>6EJ2B3m{E z;T6k^KA}8pH3X?O-i6uft!AsR%_bS7PNMh)tqwL@Elu94f#viUw7TXS1%W-2w@NGd zFKG23tHnzk1$8zzZ zc}8=_M0`e}zMusqxTjn?^u3V&8maSH8Dj;mZ##tXM{$)M9lkKkndr!uWA-v-DLeNF z#%qkUR<~fBhq_IXd~sDavHQg+NerJa?EB2;eX2t|?N86ebU{@mR{ntRL1d zplpntJWC|*A4)|a&4>)ll884H=|*%G1>3kZoQ5Y>gEag-rQ!Fm*hM8iIHcheyj0R~ zAEdae!VLmS!(0ZVvnWbyvFXHl<2PSG*KYJ(u=!ifcT^j4MOhwb<~B07@mt@eZKyq$ z!nPKBz>GW7#_GR~Q6SUL2G1D*uL3);a*4W%{r9pyLo~%QR)H9_jlM`Ovgkvng3pu$ z8{n%7#1{X-n6!DzmE320fY=B)k%o*W*|gB7k7b@-L(_I*XDewthd$)!tN~e_b|x+N zRh^McI4Sr-<07*&DhTL|As`bwo0r(xKf3BnTAqD{FGYWt5QaLj?=n-JXrelCSGMRA zzh6S!Z3mAXYn-;&)F;$COQF#J;7};m7~w@y156b&UkSiqL1Y+Qb%~m6W#M5aUWB8v zX9c;xp2aYVTFJ-j2KAa^K4Tf#ubGe6>(pxzvYR4p_G{(`J5~j&wnLM-4HKos20VBM zHJQ8qmGL4qnO8bKnt#h_X(_FT&cBU62h6{NKl{#~%AY>-@8nPV{Au{{&8t}o2nO|* zU_%xLSKS!&6}F_lmWrbh(HXoFZa!Y81Zl&Umqk$bYLVR(xeI?qU4Zqvv@rTq9iB04 zKV~xo?qjMN^<272Ww-CD`sm2#qQwnOMK4Lc=${)Qlg>mn@U&(l>jtG}@bi&j7`@F5 zelRjJjLl_A&8SB;b_3^zHsFczTb>x+!KPV}zD%FNfdk=M@JYrB*yFirW?dWwVt~M} z-t~nFqEr)W6RS)Lnn z&cao$!q7Wd_$(AI%zum%=c}HMiBX?H*5ax>JYHGZhRTe6t$whUImUEQyd<*C-LlWG zw7!`f!d3puLcEHVXZKc6;)nNAWBWHM0i+Zd@Xl4~u~9HO>Tjtks&us~O_+L1-;B~$ z>!aixPMI+h#WDAsKOjVovFtla@-s4kPMA7M8OFI&M2*QLqmMqyA5D*Cs3-nFjY&~Y z{DB%Xnm7@S3FC{-7>g(D-(}%ltz1)tb%C7SQe%jAScr4b>qJ2&p5(stGpaF1XlnBg zYRul@sGqWCsj0?XNt=_Y#{A)j1LRON`!%wED{4%D>HHc|W7>()uTGWp2BsTTx|!+c zR9e1trj!R1PTjg$Htz(j_xVPtF*zKxs4;ndrN)qqjH(+%jcH(df=bV1`dXyxDi_FN zT7FdJ0$S-)%KHGS^+*}-mwnk$xnPc+S;x#K$sB8EmN4_*$V4s9zwu9`(dY)uZVDTv zx~UqiL&~U;`n7gu88dH`OwG>BW9AsuXcp7ws77V?osHI#KgmeTNY=+m{jqjt2{R9t z%p5y2lbIQ+(RMcaP2sdH}CYmV&6-xeZ_mROO;IC)?oQ)Xy^;{ICiovZ_mavY57)m z#vPSd9eKm6Q`A>&5Co|)_>&-KUzOO=xm|T6E$@SlhBihcPm(C2kp})?^(?WJfS!{$ zkY-Bl)jvV#(xG8+0n&qM(Fhd~J(!_%4n5c>8lkS?s=xO3czp_OteaP zDmZ5Sm_Yp=NBtYk`dsv+e;V|qevVcDXh(ekWAa?m1?#2w)pqYHtUyJ^~R*C{ zQ_q}@XP^;bYpi^4I~)QZQ8}4h;@mUdfWRfasC`6gc(~M6X?U{jf(Ob@*fg7i zAE$;FV?JI}%);wt_1f0(V$8?ub?UXDUfUX8jQRYwvfz})>!73+#nLLFXHpxhUR#dX zs!dgGJ*pZrTGOd&V^(YNMk!=@c&6YPRiU-|MH&G%8bh&in0|~Sp^{-GDU24^7ep_{SfgK1(U1Gq!R3(FsZ!woqd7ZeqTv5SZSK6OG}cEd_0Xh@q?VjMJ1bP7#CQrlQFr9e+5U57tsd40(&g6^C0rVRo|G4DwQu2 zhoG3mk!yufN%iQqWvg_6UI+ysr9DU-P-rz|cPF-BtK~&H8}Yc_wt{qcre9eCny24f$Mj zv$0$xP2FtXO`@BXL8=-0o)(?O1hliU{E5zzA3aj4p43lr?Q9~7B-PG{gdXi|tWp1+ zcvsT?XnI#_QJh!Vp9&hBP2pWhYd`42RL~l~awuq3P@XV+QP3W^Ij*4PsygGtXG^zebgbQf3H!WT>T7mp9y2FNW`>>F2H+TfRE@4< z`eHVU9=N0%m)?sL$qVS0VJd#iJXw_<&Gc_rx^h84N?-^y5U8SU{I0$6x^jVGe^(1L zxBfv?TsyOlng2y5dY#DhI;O>fO|hI7?6+=E7HpB*;pd9A%VohfKK(1kVXT+G@5tZR z@%L3@mHcgzzl-GWi}H7_{C!6LJ}!U%A%AD#Z=LY~)9RnoKenw*6bL8|`~A({%FD6+ zW9tAu)BkKUZnN8FbPu4tRALQyag_s%fKYQ<-1Amr(Y%Tzw z;2-;z@scmW|7`!g(b3NM$CmPYJ^p77eYv3&T^jFQFF-*cKlo>gU)eiDzk=^UK#LCH z%EYxDcGLR~gRY!U3|xK_DnRbGjSi`&n(w9)ii zObl|yi{Zj-JaL`C3xU~0!^9Q0baKiGBkWF{jO$4OM=|`M)geA(>y$LwvCGnZq+-0gO%)bc#+B(K9-&UhokNcq%hOa%6C-WJdQ6Mb82xr!^4& zqSMID@k2%#!e&P(*B5%}wH z9;NyprCP^%^-v}-$CudycNpVz`WcyYR1RoWr=(y%wCa{jVCiX@<;6&5q?8XYj;y%t zD7aQ*#&OAYd(Tk8qDjY|5lf3<#3`X3fX-rm5{?g^hK5$${NIp{iCU!P?g_sv-ii&k zw#jRZv5rlBr$2JzwE`98k33}&;cfhQG5NgCX*XK>a{`oQO4jGE_vHGltHY?s;n_*z zH2>LB!=0ZhkO&ZC(4kmE19fu7lAg94ZPpOIrIiB!UVd_&?afTK#H_onCTDVbGh6W8 z3??A1kW*%2I6uRmId-tupV@ofeGd17N5ddw+--G|{`_AoyA=0V3&9^sisAeoEp8$E zE!CnUvt*wKM^&IK(OUsbY9{3iVPKSv|M@+1u(Y5&s40}T#A*K|lJ)36IIe;`atg-Wg9 z!}1~OydX_Ipy*Gp2OOp}Ne3uCQJbB`AvDdlj$EgDS{AHfB+ z7*U*xX5x1?Fk}ux7iDlu`XdNYaMP$Gp49nrif1E%BC(NxTk&k;PU)p0y-5GMHML0p z5`ZMAjK%k0%Jhgp8XjZ%4cGv`AwygAQ%@e(D8=lf^Bg!Hg!N*7D0f9@p@nulo8-kj z*r6k&KWr88_#(KGd-c#b$i&s-H^YF5QK_lLhNWuJ1+0x_0^5afd6?E8hk~OE@+7Y) zha+ny?Pu##3;4q?~~pav#z zjq!BBmk6HQh7qtLmNm#BvsfA7aMTF;$OvYU|Frf-KqQt6=|5_EjDym0#gA5NuvXIq zxcI7XlN#Td=Zj5wa5367} z54_=3!@mN8U$fajG@MrmpKFK>YP>W8NQnPkP5}prUdo3uhx9Gtq2u>Zf-~B)xMkF$uP5;eUWi2 zSJ3FIxdMsuzIDE5GI2&G4Otc61*7K#Y(iBOyx-h!$yIO2rYFv7sDZXd= zR0X4b7HS^!mhd+x}#glNMDuwu%i;)&y&4MJ7OL;W$D=IR1R~#dNJtt? zL~$E}E8ro(2z+W*ptGS3g1T8NSmcX*lEFS=Y}lRz^=5^c^v-1XyR-c@O>p6)*mh;ByQ#a8kfA6XVWV-1U>A`tD zz*LUgTv$8Tk8&>t&PqvXs04KtRd4nct@BiW<{vc2trU-HdMme>e0<=eklfah-m%YD zsBaj$A{wLH5olc|E)D5uq(5`|MY8aNZRQ;QG)3~5iT-LOAFuP(YfZf_v0pPEuScub zW7X?2`!(~$Q@!e^v_jvAFM`)D80sQ&~xwz zbPj-JvZa2JHi6s20yFG@(7uNiy-Xa$#jhi(PG^g8Q2Cgf4a^o>;EXJ^gSns`)F?Sy z*$wkm9*v*IFf)(iMLAkLjU48|xFp@hX2=*!1LBylNL;f@Ij-DU!t59QkQ(cMU{K#~ z85RSz2)!@<{$W`6T^xY}n8{UpeuKN!a*K z!Qnjrayi1DQh7^O3hYl15(tsE@K(KmDeCk9_A5Li5`|m za->&lq?vd!j+PpHfst0t=0Kw6k@>1Q>M0*D^{RS2V3|T1r*4Ntzzszy8^9z_YB z)R*-@R7MP^qZwx?C**50p`R}u+}fevbw|#6)2*oi>v2l!pazJ>DXm!)*Hc>iHJ}o< z2ITNeYidwmrY1m5d>K#(7+$G<>hPl`o;}4`r=ZKg!>|y&4dSWTqfi$rX!WZhRkf#= z`-0*Lg=MACSJd3vD>$Fs7SRb`NhU^cdq?cD9#u^};YAPJ3Hs)(Hm(5wft*Q z%y=0EVV#o66ssFQLp&G+wq<9F)y>Y7DY{rPNlU6^JyOPSWTJPm51ztw)$)u`)z>|+ zo^7Xl-wb{h3h-Nv|9egBvD}wJRx_G6j<{6pv3{(1aQWvCmMXfw;E6xLYUM}sl=#u$ z_C2;2jnVk0Ma2yVzA`x|SsPg=T}8-FNg??_q=1>uLwdHE&Out(49dXz5hK;xJYZxN zCCm~7@wy@7K_nQ{5{~Bbat@w}ho3<>I;6AH0eh}fR$C6ySOtv@A32BVkFF4_Z7I_g zDy=d7CzTfK=@^w3paid!@&dC@-&BTM!qI40B}!eaou49#;afj`BSuMbHDkzGG8yE0 z#=$C`#dJTUp$oCAHk#o){Cr@y8AOIl%|K;S){5Fhj!Zs`D)gn zj!`)pW}mQ%VNLAhQUijH@rOhs^eX!E6eqU;Gu@wlGbhGO{6KPZ=HAlN#MjW`2Jr zzJnUf9$Kt;wDB1pkq8(csD$6BPNU%kx_FE#Fm1qVFNO|2WhqrVa~FUOe$tnd&`@22ShHop*pBa?28ySM$=QMu4h4*Mcu zCrnm*!BQ0<9+_doveD9`)wc1b%+O8iOh_7E!CH}9&|Ffwg;kTXz`xU_oWSoi$5H7`3=NnSgh~x&;MREg_ zC|~smjFp>82uTI`kX!;R==|(JA^a5(imfPhnQ>AM*&Xumt;Q`|f5gN6bI?YxYFSS$ z^>vC8IfeRf+D|zU%TrIZTwKA~`SCm(&w0_weGr3uNO8S>8n#c<^wR>- zB1Bu7+#k0zLVBaHvF|L8o3 z&5>npL6*KoB1J4yks=E9trah+aBtYk&7&lmt?5&_Uji*$!=oQ@c7kENH(ehqDJ^tArFxSeEcjI2W=PGg#|zO?l8CpLG>k-JPC%vBMG&bB~S|yGfpiyn!tI>q5|*d z-gM>#>h^^FSc^w}x8Zmtb}3{VbSl5hs0Gs5}yvv*iCR7N$so*gf zPgvihFcz2}x?)jSUmM0;Li;$YD6(Q=C>RTNL>edlM!TXJn&wSILpbQ9_pilKsPcV7 z1$*9fSO`|l!jsc#EBZl$ffaLOkDK4B?}6^LCC7meK0aq(_%_iWFbYRNdH~WUyu^4K z7u~3FT7TpFH73JS03NJ{hfr=I#wh$4VcbLq8OQC2A)IZ6iv!-zz`hMP7LC2h-e?Q? z|EPNx@TiJ2ZhS)mL`8NHg7F?T)nKemMQt=zcVSn~%C5$HYC+?TMnM~8Bk{g*v#`hG zYHW>C6-}$Q)M`a57*r%7Kq4pvwF31PubmJt!3zXL^8J4AoU^-$Xl=jmdH&BoaCYX* z%$fVV^Uix4+Z16Y-{u#bZ5e!<7EBdrv4K9%Ex^49w`>as2jn8n!6^xwKMR9{V_=pP z@k@RYw8j*MGK?3lQ9G+d_;KrUhx2je3n|XW2`j`4f{0`>yNQcZ3qlIR10yR-2Z)ef zu&51pA)eVs{nyqF|9j!b#DkUSHuJ?x@f);8at@?z6|PvbFH8@?2IbeZg67yNT%&d? z&k%hK#!hlY#*mtZ`I@ncX|FKFbJ_zp(`b{0cU_42?C_h!K7Ml*+N+K~+n$Q`qNoH* z5WM4I1ELITQ^04cqi;dgG{E5*gh8Re+Qfvqxfxu*DbWEu?V9@>Ew}6 zRbsZ*D=-_b`nQdB_1qjT`}UUO<%_lWg314laHIG$07Ih~wk>&GgL(~N!Y;xU18dX@ zra*2zUZd>mnxR4Kv!3IEWuMgyHQ+mvDcZU`s0OZicttfk-Zkn8@vbzASCIdK96)A$ zpioH%tO%hk*tqeHG=B=sZ9=J<9RXT3wgPn$RtaZ0QJ%2%vKYq-7Pq6Ekm>a6D~4(J zHl{ffVl=BVN3**R{p_sQf#X+;6N|hY1s&LsF z_nnZ>a)pYQ1(9amw}$nvAQ~7>9`iV`*_+QHozp7yS;v7}6kOMRT5^BODBJ3eosX&n ztkI#e_3qedT-30MZ;g0*!to=1H*>Vn-b!tzVDi^Fp!bHdTYF$uq!szyvY1^|8M0mr z7q1Uu)1y&w%$gaTHB&HQu;0kk5s=W!J|LWB-Mi!^L?8g5(+%-3jM5fbPFuG#T)bQ= zZM}tod7AaEkb37^H@O^p3%dRjtr6Dg$uVdH4Ex-}EU_=flJrOeZaaR&b2EpcvOS~h zMud~++l|omM-3~2*6LvK%fi>v6MhD(&ixH_8(ekJCK!x~fV~ve;@DS(tyhB9dQvJQ zP{zYR*JciMn>y(Rn=R}N_shXDpj3ZGMbA3dcTRIPJjw(Nkj?LLfu4{-O}*gPZ6Pd=1<1q6AAIbv z^+7P!ofGU|9V}ZHskBbr5iDCZv&LtQ3zlt~c_m6pz?9PbnXiMjWW;u6)r<-ie*shG z%Clvx%V(Z=U{69iIE3Ym*0r#zfO(uDTyN;%OR?0(Be;7CmFbFK3l+l-$TF~&g2`Zx zdg<%2pszb^2meCVd3QIFp_7>9wevk@LLCklBeVZ zC|QsjD%z3qogz*dwcG-_6rwdbRhGvju7yV z_|9kUe_Uo}Z3gOd=jYPCcQ|#6(MoCGOs2Lb?Fc6)?eLkW> zFs9IIOr`vQwXeZea#N8Ctc8b5FPuDW2d0Q_<9#zn`H3Kav;uMbM@TEAWll7_#To z1NPiil<4r1@dPkf5~6_|9FoFT7f*k&z5@3hOYxoNkA{+qqIe0GfsuFzJfY;xIYFyG zT(%ROA-vO^GfWj_Td>{G>5je2nNz0Ru{UH2LEk^;uH$q5Ix~;EDR!M=4E9>}>=$EQ z=21NWS?zwy3sY$vr#(Vo3dA0i47%O1M#d*7!jB!Q2X# z?X0;q82h9E;5ZoDQQ*Gw46H8#17ypk$-{Xk=hd&U2?k@|qFFp`5PEpS*4Nk$(Tfe3 zCtXJJIkr&*AwrnaWxYXnXl1AvyoMv^_%U@X@EwPQ$~L%TIKg28wYXzj;4xs&Aeg)w zOC;wH6OPZRn>i{NTb9Fmmi@D4lu^9B2Zs#?;5@QEG8FKm=PASb7WcCRi?>UMtWl3| z2AYr@aT3svU~DH^f%`f8Wf#Ftj@g0rg-ue$k!&(HM{ZX|>_`9}7#;MY7TAjj&}YKC zG>V^4+2=Q(iX8O#$p;vsu(e#iVL2Fq01_J6U|k|R#7dNy1AT*e9j;@M(=AIe&ngCP z68qF-fG`IiAOtJGXKMPXDQqB$cVO^gs}mSJ_x$7o2$9ntTwT9#@zzt5CoT?`Z4FxO zsEOV4!E7R5b<-OBILxv8(We_`-h!^5c|8s)==N*a?SM=~@*vghCEStLEbE?B(H?)js8+4Eyyx#1Pg=G$>yMSrLmxXU{9RnS_6h8IY~ zMW&`Z8_Csyk&LFx9?2e*%`IPOE~##~G$`Ewc{{*x8leWj7MwJcya)?u2hZ8{Cb}V6 z{UPD5vtRiJEvP7atW3?kfs@T%Oru3kOh)R;&j~Y+>Vd7lb~*13Tu(FoMp^gFli6c~ z*AW1atRs+$v6lL4fLKl;ih*T11E@nro^u}Ww$hmUErv7_Xr4B3k9HD% z+_HDb*=vYOUf`R0;neQe$jwA&0V@G2!#%TH&;vnD9+7>`u(lfOJ_BYR!iAfL<)pd*?O+R1t!l%0=3IN?Uo*)b@m_tEmumf|$7K|M zW3=`IanE^?U3wufloV=}nm>;H_7a_gmPfKoQlxk)8>(h~ycy?xZNI(j*&iWMG^{m4 zEb9-y0P)gVt?oKCB~io!GlNc;fI1J5DEf{)h+4}3Bt-t_6ltJg4Sn|7*&ul?2dAeR z#7_*rAIK2!>2sPO+|dEP02vX6sWk|!CB4Eyc)ExXy>2B5$OOwn4us}~)kPcP_a3^P zcI1GJtW}ow4+T>eESyDIOuF|WU(mvI0wgHQt#-r3oM67xbdLPct28>CiNcHQhJO4E&-#G`#8{$`UIFgSd**O}h?6u)R1rWMd^dQ=ne>6u12S4A z+q=gT+J?!~%xRz{hge^ZJI>>4?79(PS!d+Lwr9_}Id*(jb{iKVYf;ge=2-N(XmOgx74cTFtm0rDy}-C{0tO&3VhE z4&;WhO6~EN;lqFUI^nQh?eW*)Ly_=pfDa5D_}+pKqTC#`D7X+Uc*WEOo=@hezOvm6 z&&33n@k@%4e9UWw9Fb-L(nuR&!+>L230{^o68d4gBIFd;!B3 zQ0uW$PZt9eVVNDFB&4LkUuHoNDj|8VQmw}VvXbloIYUDPY{)fN1;)RMsbpNzD#8@& z(Ha<`h`;1cybLeMkABEL1_h_O6alB&+$F0%uL+Iq?{Gg^pT{}i&+ZI@B^3fki1=42 z()!Ep&MQRJ%%Q&i)}Ciz5tc?9p_J9po6BuTip778avABTFP{CjT9sdb<+;3#Jf^NQbGX-i; z!l*~T?O)eZ);7~a7|?bAMK>b0g&Y6wefEL}O_xil`#=zxV@udaIkQef4{}m-mWdmh6#Uisxe%nMtmc?sYgwgOP#h z?{haUXHCsIj22q3MqQ{zQb6tm`VZChKgwr?!LNPu(|)TLur^QAXMh(zQx7U-+;Y>TQN_p zUf*I@)(|Hi?b#E-2%WzCpg{7^fBOJ(C+EXF@Xl{t>Pz&Be84w5LwxWSJFAzb8Q%v~ zgKW+o@U9ncWDJ9+-yq+?cM*K4ysI`0ab>TZ-g1yXy9?I`h)(1@1NAlMb>SDu&&2V> zZ?(kwvaUUh8d3+3f7KG;2J4sOUxL-1M$9%^@afG4bm2$s@e2HEKth$uBhiKAuv9=k zrV{VMb%^)E2ZnT0N{uei36Rj#9_U1J9P}@Hy*+@+A-lj^l7o3u7baB|Kcn*82}f$F zn1l|O?rhFWPVS=Dj0{UPAs*(V6lIsi!Q&j=qaXoCg ztL7$jU95X}z7=qKp zh52hP(T+CrpE5R^K!-poq5>%swrrDz>)0hquw!(x1K_751Yxob|C1bYjJ|=|2p)wk zphCS4%OYA50{B%~h9rbx9#7&Xtu9f24YM^RiSBwCsPz*>vLT=0 z)3u+wrn*r3$*EUoX}@&DFD5cQI_VuK(l#I$8MLP!7wMG(&H_rWD2#{A;OEFZeI!Kz zI#PiP7&uP?6RE&z1||@QOe^TW5q^lo$mYyU2dS4$mG3Fep-XCjPZ<(el?p6p;CP*B zDgB2tQ^QL3vB%L*!_-gS)B+n^bE;M+<$_c*w7-h}O8SMzPc)a@%g@Sy0@p1kI-EWe z<4RdIbQ(@bs{b8ied`MzX|1~&&`q{V*(LwlfmY}%7s^4+QLpB5^^jSNC76d;EZuO@ zW`mLEeWY5tkqqwHXJg>U_k&>$lWL{+5P-Pr&qMQhi*z$;;kS_UPp;T+Ki3kn(1Y2_ zNmmYT{R*u0Yk6v`B!6AW`L}EZ`Of9O#YOm#JYK^+=@sWXhK(xB5*HWSajY6D@`gH2 zf>C7pmWJQ2XWg_K+H$|ceebS$FvRmQ2AMo?n+pk!v@l(eov`#u)WQwyjbAR>cR#Tc zCru1lx;Y{l(2lPS78ry*Wt=T2!pBzhmaX`q`X`a^F6w`+1P`eHYj3drYeaaU-KqZO znx>vSGsmugHwE}i!!?J4K?z+ z2SGJolAsI@9EgV1xgvOmjV%Z!T&V18_Z+TJ!}>Z{yoE{!q*s7|cgyIo1^yoh5^EIB zsr}u{FtF6n`UCYM*7X_SG!}12N%r3YNN%`8ZARTUF07?%A^EhyfVm<0gV=xTtP)7G z-&_o0Sv@jBR>=`mk%61{UU$@`@(GbJf#RPqa9vLg=>H($bf{naayiieQ_dk2gw8E5pb9SmMefIcRu-! z-Vm0y5u%_3I~z=c7%G5H06XQLU|HBT^V(q9YcsD7S^+TV5)gv_ogHbE?J@KGVA<<4 z&w-q(9d~bkyRWS8nuX+WaF_{eZ#|A>gJ#Y5y5*b~X_!0J=`r_gH~Ol3fBdLuC4unu z{7wCFQVhQT@K~8#|Ji<0R7G8j1r+!0|}mSLi)P2Ew6tIlJ>v zHRrW7y=(F#KZ4#h78M3wqSX-pTBzw=fBZ#?-X%yO=v}A&jN=H#00o{%k89KViHpWd zO>kc!JM6#Ep9_DCvSL4UUtvD)D^$AysGZ>yGIZ7@4*jeX=w`rrPsqf$s(^PDRsjU(p!3czDSf8 zFl9Ybu8cDr6g813_rfm{<(Pl~5+Z&rd8`!7G%a1;$%&ng2iH}^%ggzh7B8>RIaJa? zEh@Bpc`aVk^5u+FI}2C~Mo_*ynoe&En9m*X3FFmj`GgUuc&v$aG2>1A(sBgM=i|*0 zFkhf!h&CWyGv3ky<}G;Bje~%>3ord00HarI-2`&th*>{3=0d>y#y#`2-ApZDexMdG z-e)>Tm=Ceq_1HkI%7ge&@j?ztkQ!(<4Gd=ugs6Lu6FL|%8;qO;EkBw; z+HaJ(Y4WDe7u^cEpLhuopm9P_a(m<=E?m#(VW3A2If&~*u86CYlyYEzZQ?Fe(b72{ zHyz$R`d^A|8!_ud;}Tc~85-NN3A5?$!~!%h$SV$Hmw{nWqEw*Hkh2Bq49NyPBWxjr zo@|glj6-qaNEVdr}LJM99D^7p!^Gz*sdV?PBWFP~^Q6i*NJQs1&ti zs%F5`hsyvDLSa5Athgt2WUq#l{QA0OOHa;mCC8i^7{3KJe5x zQYNc0IBL^}sk1c)22@3bA(W_tvgPoMYXo_q25n*|Y&@V$M&dnRUG+yE{2F=Q!Z+mF zt8acvw7zix02fApj)B_&^cx+}ylI*PadfZ-4K@IzD{&et;NVc)jJSlpG0!G;0&Wyg z4FK^t{6hX;ARtdqxW5L9Wx#1d=5ZN@TSDf~iKI9e1VAt(b?_ZNUmtu~v|9BqIrx^) z|IT=}Cn*QqYqVd4(Why@2&12`{nFTzj$wLq#7B?ngRgX3^E_MrA6e?-HK)kAfdZ+fEFEoR#t=DD853_0!^2po7ZAlz?<0$3|7;l?3fxCbe zA#VF1JqVEP6iDa>y!)wattAEh(8Ynb1EEm$bU~iRwuDmYSVF0?EulaO6xa#CBj6-t zP5fBxB|Mmv6JNj-NZUvO5CF>q2NPOCIcoASlz>CiAWJBRJ+cc+C|CYOW2at1-%Lv= z)ftvhh^1pUtl8Z`Pro@P6Ft@aIoJk*fzw5EGofE{oZY*STj~?b_qaP9m*>pDolzo} zT+LAgR^fjO{aa1i=CxdpJUhfGuL{RQhrL^&-}C8cg%@A}=oS)`MgPU0cw#=Yvl=Ur z#$Wmv`yaQ1^JdxcKO-u|Xy8Sn1&<-f1^XXkAZkUa5s8z|Afu+0yb8HwH*m7ErAxf!@~>!4j&aVuYz{(sBjdT4+(ez4dyv>xdm0} z>I+Xyv$TK>YR)GvArg7jlscFfH7#YKm;sG%2TdhH#4rx{N6#-}>BR zv(YOX(gzo?jwj$|n2~?74=!&Hykh;#L-o|CMhTc2xMF>89+P3I2>}D3B>JHbX)s03 z#4R&gaCyVg=_$gKGx{w;p^qC2^C1aQfaI#?aG4ie$=k7ft&P@%9MhK*UCa@4x$9kQ zT5K6^J8#WZiQkZRM}rHK3)DB$@M2B!;>hQj+w}$)={lq;$7hvD z19x&I-Yej*P|eIDd2bY{fho{Yk4mm{niynitl63)bIBB}*_y*OZi-eWjO;h-baZ%K z0Uewu;dH->9~8<0%hf?^VH}yk(37HUS@Ktyp6H9VNgTJ;stm0}K$kk29_xnA z6zo0&G~X2L?kqrFb#1kr2g!+@M%l`mW|oZ#*k@5)zU-HdDnvQzs`k~jAms~W7|4Te zB+Q54N*3<*3_kaVDZbF(3l2Lk2ys3rY@nL0JBJe^5Tg>k&>qZ%PN2ln*b1T?dlSLM zi*KFFuOZ#HPTP41C9go=Oa||NmtPpxDq|gJZm_Teu5;(LGbrVV$`paL6T198Hjd(B z`P+KX6MbB`hH?28X>)cjBnjygS!)qWmg`BmpKl<#Nr{_~wHmTMp|Trtks*M74J6~w z%2j>nh919>%oznKg<#nV!#%M>ilq^UIWHr&`vyR0i0&woQTZ)~in&ovm(pU`JSn-| zU~eQBiEtot9tokOkcCr@G}&l&I#Zj$$mlEM@>iu9_7$r6RLl%oMqdb~Jd$2f%$#)s z?*60l%SQ)70g-hm3ts+;Zv0wISIDf5I1#RggA-d`o&k2+RO20>-m8bk0MMw#d!@mR zrjJs18fznc3GFbzGt5lL&Wqp`5U7nfCy9m-=LuE|c2!DwmT*2FY8$z!25tl+H&P{Z zP?0kqY2+qEswE^?*D7fJVf5NLFUu(lR*`Y}>#p<*VGj&;6`N_MQC)S2UNP3tyU(;S zyg2WU2~Y}K$?Vm_rc}@y1q(2g`2oyag^Rs%`}0nJfOxxkVJ;rD_riQUSm_rQt(;_F zhFn-~URbemP8UWJZx1Q$^lFEb#BV;E!v$tOq_^6KWUDnF%15C25cfAL-ht|va|*@Z zDgGjfJrchw=Wq)G@PD=xF1QhLcPUA^E7m|s#5^!)UXY8&gD2m&@|049UEuYZ7Z|>k zvk9#6>0dm+0DLPot^~Ey4JgA^^XtV#;?z-G%UsCV|05&G%Ef%y_@_Q}IOGIpvE8{a z-V@1VnWN6N;RjzD_8;wn*pPcsV+%6mI2{cHzx#32GYIu=l)+RFUivB29~vtV#fA9! z_-%kqLrXrrSxWU1k{OsNB69+830bz4fhgjpCd{b~D+BrT7T_sDia^QAKm`LT&8bx@ zfe4)If2 zYVCweI?h2#u~hms^-4#_Ehlp)cOAAtb*r{^lK*bgPR#ub)8&sVFf&Q5{& z)#}rIN82+fi=sK$=+>$vFu(>LV!dht(gFZsVI}1{B^=crItZnM#7$ZgkP$ASG*p<{ z_PtFR|B}i0Du$_25PrCxxi?jSmZ|P#AJ_q)Wi}5c@bpjpb~hA5WA+CldBSwuP`UifUmlJ zV&vkha$M~bYw0Ac3M4U1iz!X3O21Uo0mL!E;22MOI~N=GphwP3wGpy9`;2y>RX|Ft zNh8dOIE|l&xiQ(JZsvqc0xL;QE>TzG1xWU!a^Sxcfpk;=7qcc+niDInNtc=vFLf`P zRF#-m1?Td_#LMAak(hXeHED)9aRy$h6BDc9T%DMBwKXYXPK;QSYR!qYgYdYYmTaR* zojGg-iiy#+?qp+hldL=0BGclpb!SBU{I!pX)!1mnFktH1FHP@W31}iGPak%pGl2Z> zhJ;1k{ac)2OC8}IebKx17u2oAwAh!E|LQYRU1r<->)9LG0+-4Va&^8x+xdQ@t#5i2 zH)ia^>NXV0JvhDj+Pkrs==y;@IEek1`*7wSe4xDtUxb?MN&)q!xFImrHhP@;J+q%Z zD>ni~uT>xYk|_1$A~j`%pm#vrY1HsEybbs~^?fA$eO+rUW`_EcWMRz(Y*Y8ZAAP<7 zURR_LIJy@;8)>%oU;!3^r5$pe4(Y-$+9AKuAsq-&zlJ~hd^5Z{E6xQwnO7$>(jiCb zklb|0{yK!vTzMp`E_hv$gHeYDc*cQlmfX!L){&7{wQHhvW2oQZTJP_1x02t_dr1PJ&JfDpF!td%&b%)(`4b z7XhsVMyaeZqp`oi0BjopbS1l=`vn)bn#fU5;rj2H->>IOFGUwG;3NdT7#X2j43H3F zb^uMrV&M{AJM!pF`kMiVS{`C?u$6Oc?>E5nljjx5LiqqMgoXw}Y6%hHnOut_D^9Bp zY@A|FoC26vnV47!=c2^Ki{MB0HkNUn5 zxJVdJxJcI$C}|3ew7bY=@}*|y!1-e&A1_?+1#s7LSeR5#6L^Wt!G=i=?&{qWJ2E8C z-HSAhG6<7Di=J|Ey9O0SE~CBwu6;!^IzAm8OY+x%`vpL4kE){2H~0HXtBYzd6V|Hp zk7K&E>X6d!OW*g|=Kg5y+1OvBXtV+Av(X#85M+>k{`GL2Vkdfa@bmd-x7dxcT=1!r z7#Wj5`OF46`$wNAf~FI0V8T2}D1ka*C#MD3g_aP(zaA!McRg1o)(Wjh%;vu)`3e|ZPa{*=a9X>BK`wQ40X#06eaLe ziZNw|B{|UQ4LcZ@THKmIVZ1ysfp74B+wJ;2c{|>%TUixYd18LZ7B3)-3&?#9*t6fd zlji~O6VP3_NFoHKj_FHzk>{NRi4b2_p~~%eWyCT$zn_lkwYqRnaxcpJ$BQ?+)bltF z0fR#W?t*xwAUn0WLuw#&H)yDpZ}VnKC?E9QnBTlW{1n#ao)T+wFEJNQEcIJ+SVMc# zs29&fYvyn$zmti~q<22y%qViX?*;@wRjs-vwA^o%=foD1Z{>2wsiYTMY@=g!c!5m* zO-Ay758}6=BYyb_oJ@TqfFEv|t*XFZw(i=aFm%?kt(*PUD%*!6+CG7@j+tXH@z(^b zWmMH%t7iY4rFPQrXRz$un&$#Yb{!y;oycds%2bs)6(gtcKy2M9M>gwT?mj%2?#n9? z;8(N7&Xf2JbB;u#i_j}<9yA>cYaWf4GJ8Mh7sxvYc~k7=Eg+&GU@;e~y3(xag#s^h z{t+tb3Qy)@I`W2rN}hdjwE#y}4nT39h7 z%z1rqcwnJeB3>!}h;;ge67%LfuLO0-FWF#BEzB`Yny2v<(}1oKZPFCuCM%f~ZYe+yQM!HLZE9t9=-g>lPpk zg)wJUj24(vdkt%0K1%?ZTNhLWCvpr68Ug*xSe(H*J;!AhB0=dwvQUV5U}gc#QLS1^ zR7tmNO|SHUObL{UzT~OQ3(r^dU`yly6Gr|p-s++Ycsi5A6Q*meJ3bQ=PtOIOb8zy; zQD|zup00s{l>yQ~rk0yiD^|w4kbpB$!QoVsC1cJb6!9)@+Bhz(rIC z9Ddg+k$rZg3#-kXmy6$(0#e~r6RNBf;Sfx|hFVnI-i+P#=i>#C(W4H>(N;VseU&k? zHNben1x8u8C<4Ci=9)d70Sy%7^c<7X(Rfey^8JfaL+RmUl%WI%_L3LvajYppwx!6{ z8##*E?#AH@l;-r5WM)~Kk)?qwF>o2#m8dbu&R%WJn4hUO&F1V#CfTp59Oqugf9aPQ zEnBD|lyC|#XW8q6=Pb!lgXXLRr5pP6!c;?L)#*9QoYkx)&YacTRMLYIP!Kov%sI>8 zL337u(uIUk$iO+v9MxD9V7I;$a3|Gz?zLz!Cy6=}Ct}Ax?TgITbMjyzaqgf}#3u%~ zo>7BZFG1;wJ@d@2TF;!-buT!r?_vp7Qqd_B3xS!fXYiobOHjIy(^1I4)-y+yj{@x0 z=X3k8F^1NHZD7F5gpZu&1kM0dvtbofvwA~ToLdstG5A_Z`qf`ggca|ppl?ew(I?SJ zLbRY#w;|e@X>3SRF3MJCNonPPqAn>-&Wt+&KL(aYkrQSIBs)pJDjQJRTss;R32psx ze?&tAjm7k0c~Vx0OLhsj8&~9fU=bcwTh5Vfr? zQ0$8mGb?cd((5FYA!8-%uS(d&=n~zf{EA(Q)<`{b_r}44vYMT^vACb)~6gIh%gA| zLPc=``T5g0fgF!H8nTvhX9!u(ayh|TLgeS#enQYX&dCsmH~CJfQml~KQcAFHWi8r+ z4{HATJ@b6ihpBm9{Uhi3UvB+@d48KjX3X>5LIMahmU!d*uQ2J8JXlj$X(hmCefPNY{1w0HSL(z_5Nq`WljKte zU@>GVSH24X0UEl%akAD&Iv09HSa_IMFaX*sytx8YNn7VJ?K_AtO2w0a@1Y^sy zgRP$o0kLChmCw5AQg~`E4&bLUU`?Ik)BF~nb#Eb>7O?IufaAm64%iRbQ@&U;fh|72 zyA=j`JW#p}x&47AKbSF936QG5ZmjS^Jfxg5B8DG><|Pvw0zoBy{1gH17rVcXn{~va7ZF$D<}2eB_=S_80}??4TsTeIS)iR3?R3K7hh5rD_S)|* zEI8=z;?jj8_>dx5qTRUHelLfM=t?;L#G`Yy)2W?YY@W>30~cuu;7~a?Sp*N9QtcSp zAzKcCRobc5P67_*+gv!zs7brY1@?Q3{oV-|1$4nl#B;GfLmYJkoP-!=#>*JIAOWp4 zGoJ$OCQEcM6%>7za7SZna?Bcxj3dp;%OtgZa&#T>3FJcAMM%yrfFmpy2}g9Zj;5F+ zqB~R33`g_^9j$b9Zz`JMm@N=sXJNtQIk^CsbKzA#-9&qB=McML9_j$R`>llw2nSj} z8{#)>=0Xnmc0`#A8}REdy(|h*1)>Vpa52N}dl4@#FreVff^zz1eA9q$C~}FGP{a*R zE*$&Z?|~QNSgIqud@~<4bYLeOOf;xP$nlqM1tBq}7FH;nChaWHPK$QB_!Y#0;RH(M z?hbeT-pml!&Lf3rYmb4)j2G$;C`OG+mBK+cdKri|B;pK5Muv{2J|v- z)zQ&ZG{d2-J;O}0u=aR9e(@i^{o!D#qYn$<6VNcX2rC%)Qv;f3gF950Z)Wmt{I zHP?cwMF~XUR}cdTnFoi=ivVi1%Csq@3Tzog`~v9KP*wFurr#R`zb-Ti1&AEupFo}y zl`ibv9Aik$an$YWXt1-*JRJ6b+jDLsaE6VE?@M;gTkY{2e8^<&ab}JGD8;U_F6<|L z#9&&0S2L1Q44tS)0bbN&zEAsmzzryeWK$(tWS~WrKm}Z3vj9EKG(ZT7#Az&n1AG*} zASY`p6KJ9rbt_?WA!Z|HAIHQ|3R?6ZEQ60HMm}xFUa3AgsY~z?FY>oX7mGmVBgfc` zKZ0M(C=Mj%V>62!tpAT_jwzxy=;$sudb%1fUw9nEme$Ld{AD8Nt5M@}eT zY2b2q{4aRVoSC?3MDN1TsBbpIFSG|*kTXt4%jL_O4vffr7D-{qk3Z3qkTpU;ullDQ zz&aqnqn0xO^n~WrKMbGo%w zf0mG98~Ns>`ZCAOvw{ezW^y?quo9)hF8o@JY=YUCLw}M@FhzvjinE#e0`vCxk??cnnR3~L`^gS7 zS%@I_ldGVELXStIW~1U=nAFgLk-$+&0$;2k>3^)CGttvB2>;~@>cQkvh1>SxfCBo< zXkqH>@zj9qR513?n;oc(I!XKI(|?7&&`d!D0^Vd^#JQG zbcYXTVRq$GJTAlSZx8DU>n(jzumZP#tFLq^rvPxZe}|H@=K>`{WHtH#A??%@H4Li; zIIUwIm2x!@!-Rwll~FTyIy1| zs5s2mLmb+8z4K!>a#7k*0m(o2NixoNo4XUOZcGc)?DB)o)0L+!5 zn|BGItT+iXxEjgQSAqv#fT<^lOIv}tW?;D$XoAQzKnC$00anK=4XlXp2(T)$12*UY zkJ_67Hn3u`;L7!)Bh=|1iJFPFNRbSes5MuLeh%#saOR=U)UQQTqOpMoEOUuCRx+XA z#6flSn|8DkPD<^t8g+nv&Rir(h!RvV8Mr){4A)Yu4Ecv)m?DfT5!hEw*Mb&Cfx~hN z92%H>T$zmb62HKFrXPZ{aiaC~m%v}aX2B24&o*9z69Dvo*j%(6rVrPnZxU)or>Oo= z`P!N~pAtK?cM(ny6WGfzZ%U--D|(oZE?p#J%1g6X6|e|JB0M}Q>If0Ooe(yObr zzmxvUv|oBK=n|!$64iS(m40woWnEF;F!kA7t>+`N{;A8g8c<~_daXp;Y#8}q2}7Xs zgC5a3KjNW!PZU0NM|Tf(eo}#z47^SPHDbY(1q{3tf$$TfQ5EnL(r~`0=XC@plX_D7 z=hFYMorudut$b9vgNFn4ubt8zJW!~sw7;4Di?yEz5OuEhml7JDV0RxDntBJ9dUoH3 z?At{J4-JQW^08ZJoGpmm!7>G_tZU`!Ru{dFlO~KuxfgZf{79&-4m<|1f5Q&}K+#|m zo+u16@K!JB>cjpH5UAywa0X=|A?uumu(elE^OBu2c{q8Y2Y}(NkY3QiWR!5k7i}gS zAs|^EPA0nOjkV-rwtBJp0RkY>M>qhWhDk`0pDwjw-(lPb{=2mgJcZqYQ^;~tkQ9!F ztb5;wgVueC9l&u!3XeL70lQfD=e;**-M?}9ch>zSTc{x=>mD0c#=7VB#f7KWJ>Guw zx;L=yrx1LW!h;o0abkPPI!pOGOIGWjPFu}Y3#6Azc8?GcUrTROSQL4vf{RPWk)Zfh zb;iQo|Kaq)E!mM?xXZs0zbxEl?U#l7xc1A!ZIJW;i@(6#sRI}8v5grEx9>78Tzmc8 z@Ubi`SwFwkepx@4z|TaoerEqEy?*YqOXoT{O8aH~9HRZQe#UCQte@@l)n!B9~ac8gx0vEjQ;oF$7Sa5YTGuI3><-yqf3O&A*zBU4BW~CP%@cMe~-?=MgO}3 z`ym>TB$12swO@XX!vN@O6*#|vzQ$u*ri7_Fpc0BPYH$47GBP5sDZ=;%Um-)0l6kt&p{OlDjcqHZSVdmB)@5-o0uAdAN}TmDik%_gCl^cLHp*4O z*6x#o+3O74i%|nvtTu}9AMpw7Iha@y6eH>6=gDxF^8axx*CI$8fi6u73itAb#Evjd zT9*~zf!yz9Sjm@RNnhs0gMI$8avpaA6?m%f)M7CwkSCnE%-W34hXYJ6+<~+kjIwv# z^}_%wjO4LrF5c8Xt$~^XWZH@hb`M2CtaG5fan6QFe#kroN)Wt}Di`vkoaC`UCvO&k zDLtz3z6Z5cBnOn?xQ`~<N%YvD12t0G;%HGExu+-g9J(JsSt9^b$h@% z#+?w5)qunY0jcG2KlyvgdBR`;>TjFio6m|viGB9jr{+P4ea(+Cy$8e^#LeNfqvFSL zwcR@gx#F6gZfvv$m>r{|&k5{|Tw_?bZ9tsgvRE)~EeYmWw`P=H?v$SR(WM97Pr^!e zs`P?(Zz18dU3w8pN1@FK`rbnCL{+58FZ?fs78o|QUpE(Q7p=JwH=nhL0z05hd7~d^@!pJBE4qooUc_YrHy!CdWr>)q)bt<;33l#a&-o!jFX(KsY=178uY$_&KBTKO6(dH z(3sSs=Klubf>{|f-2!@dJpU>-R4N!*-=#Kr!qzU(_ue%5pvF>KvvlWUp z?FMeTWZ3{In|k*Gh6cMV=!T&6Ypjf!M$q~|z{->hr?v^fUOfW}y*6s4@Ez#)*)QB| z8?_2TQqVSib;saTZ$Iy(Iy9ZCYH+G&Q>nh)j=W-%@?1CKaon0g{@d{GJXgWbC(Fol zZO?GO9OTbMyz_j5I6l`R?6-Ivw`!38CcHb(Mey_4H9YOa}3N$!BV?rxcmP{BXoo|Ow?6IUa;<`p0fzvWK-v(1`=#JN$G-QEO~8IK;B5hFPI&7D zyftN6%@6y6*Ahm>x=mr9eS^`wYSGz}fJ^u-C|Apuf z0r!YA|3|<*7<2+W3z+s%UN74coL9_&xaW}C0;{no&HKNWR?_Z024m&`>eB9~Ib%)O zxd2BDH!(-0Q!Z<058Ul^Nnoz-5#H+N^?;_=)E;<*z@GgTm~TfmA+kV&eQtApOEx() zX4HVKrkE3k{T2DqEx=ZjxzP=70V=ehJ@5=Mcd1abU7-c2koN~V^9D3Qcjo*bT@_i>sRuK-h>7|wGYi^p+~8swjdcjq}Aem;-kc{sy;V37YQygN@L{CsAd zmgl+*kKxn9BJxGM+w-^9D~EQOyB z6f(HFBZpXbHNX?wbXa8X*ru$=Zn(j(W=|}PHpsl!B@ji=(3f7m*)`w>0l_aa?I(6& z3aF1i7OcWO?wP_)yu-p+fL1jAMMEn%q8T8|;82H2g*=~;dmV8h=Zr$XVIE;#q4n@4 zK-lRDEa3^Fhv!XP;c<_efb;(qUWADv9>SoBH=z;*KojqZD!gA|UIA6SE2`TkXjQxk zqKfBDJjRJ>n2#~7`4|uDc&Ua12<3+Zbm!_^FeGM+yagzST065J(_cWVmCP7r;8PMpuW&xRRL&WDQX5RMS+lmBLl9Mfw@7@#vv{=)YTK*GUr5mloc5p z6`laDzTGm1SJr1ma-g;_w-+YRS8Dh_3GpCTr@no?r{8Zr&#B-yA0`4NnmZ2^65_dw^z;Scq6;yZ zgo~6$kJe}0@`22E8^einL~$o)a_Aj@rO~t7qhrpa(KFbhZ{`k<4VVT&hr>idHng6K z+M08B8S2?(Xu&Q+y}Jt4N1?w$mxg43B2?(xzuye3rbAoz^@17nGI-Lh=jOTohR1Om z2l?0I-Fa?-pO4c4nfLFolT^?9(iMg^bku13KmlVth=DNAHlNi8{R!Cah2`^hSU&e# z@5A_)zZfbNyc}25E&Nt6$7i)r48m|9(ZRhr=su$LOZNpG;8Xd*&|Jg`Z&;ANzA86z zuyti6K!=xcS?*{3g@I|9X(-HJI4OarCkHkJytF%spAAN9Pl3O9EvBYJOyorw1w0#r z)UihW6nD5ZKx1Xkw zvoHGwVD(lmNLA{v9L_eY87b6#uX3_kbLqc>e(U}O{3#vo$FM0oiic|4+k3f!b+da> z0284ZYtca#?%G+S?m~do*8`IZ7kFSlhE=94+P-bbtnQTDTGWCv=HxMfhKvtNUg*c{ z+reqyi40Xkwq65KzGO?axcs)QW2Ii zkaZuj#wID!w_O~f>NZGE$ac}dT3Wl)sLv4dRM`&z_FU+JbYKX&I|1uf_A0I9{xode zrrY*Awk?SJbaC-y1N&-~QQYB+-DvK}s@bc*%~!VJnr>hFtk^BHJu%pIOaWk(6Hw^oZ2gV;?&3aB4ftL|jPm)OV z#$vU+Oy&t@QOgTv9%dBwRj&X^Qa!P#OQ3<%nhVd_5R=0mfa%R6G}buSB{vq<8p&VQ zo=%IkV5{;%6Mi!V)c{)0LCQHojo2~UYXLcxA#B52%*X^3trwyK$KD^M#Dr& zo@*=C0&m|zv%sipB|?I&ue)@^UM{saZO7|Ba(M>XOa6n-{6E`EF255t&qOZbRze;? zdzg+(u)E+k(52P0HFm&Uy8pesWb1R7{z?v=5_aq*Z=aB|m;8_f(q1x|%x0_!6Pf-} z_$i~|oHI)dOW&gyg4M8)c|ATjH5V?X0j`EU0jU@8OVc8{5He#el8>8Y{5@01sF#@&Us_8{f{_%xjX(LeUc7C4?sCBTrkv0Lf=SRohy}tZ{ zY%u}#TU7bGCZIAu7;FLRD%%2-+%P+RTZopH_IZ-~S)T?G)3=0->|USSGt50|7@X5^ zj5y5$&nX4&QK!JzqUW>{gp_>2ATMa#r+9tVDTaB95t1bb4#3)QSy#yQ=tyP~nD>93%vj-{uQ4Q=Tul!U1B;G_Fg-;@j6)F1s= zb?R@cF!E|ehdus|{e;4eX?QR9vx6?g``J?!#(n}e+V|G^d#`4ngbEXW55AgxG;5>v z;~o5=39tcBMcW*!Yvr0yQ_#tVWpOoWZswb_$cxl>(>-MT2wUA(oGIiGZL9lRw3|rO z*KdB^@7>a#71{GS0uTm0_!?mdwoBVSnrw$Jf9HO>3YZURo=?Gs&Fk$h8@hL{LrQM| zEjMUw3|L(bK|Lv4GP98mOgHlG*`yd*R`0zn{Q2LLcunpq&fF@zQo?kC1!KgFvlrAl z#8Gl~wbe-@N+(o$tI7mg13ypp>W-CS^im ziAhA(*l#8~88d2Li#T$t7e-lT{8<`b{;?Vu=z1cHn(CDW2aL1+X9%UWtaHARpI zw!x5c}0DPU#>b8raFCEQrEQQ51 z4K9|!Ta$^uZpK|-tIZ^fZ;z8M!>zSF&T9xq!w1pk7M-gHV-~a?BJ~5K#2yC2sT>X( z!Z(N_;}^2+_|tNXRb{K1lFvYNG3`-42 zBdY9*4j{^);8Mq zk2SooSGgTI`7aV_+w@Md)#~ttI{>3a*qmgS3UyCF8UPdH zLI*rws;c0P4uDXlexrkKO|ZUZvOyft(1hF|d1nb*Mb-v4z=R;z$1dU7xB~TK+XQUuMBA+rc2Gm;w&q=lXkzeB?-4$1bBWbx{=n?(?&n*JdhM3kn8 z{(IJo-$Vax+E2Qfx>@_B!52$<_C_u)M#U)Wu7A^~rTX&O@2J2qwXIsq4spO$Xc;yv zj5>4nYJUg)$G{KtLfT9e<6N|XYmo*D(wp`!u#6!1kG54w=&>(5JZyRUc<8l}b@!YP zF*-CWdB@AZE2B$FxQFm&tUgpw3kr3?rzW;ilyE~Tu!Vs~N#NX6V3dLTAP`NcqJK~L z*>u_LT$0*@2`B|@kdi2YNWpNNKUjclVIqk{d2{uO1lFcfRx+>|f%r;Cc%XkT#5vCv#PJ~l z?LAAbC$2;rRM%PuAsFVe5dxeGLcF}H8|UN(bO7v)leF{a-=^)2WA^Q#@*d=BfJh)? zD-a8N|4mF^CPqTsu@6vyVLo0crx-{@S6Iisw15YK8z~11-kT4^A1)pcXEW`sSQ8EG zqx~J$8s2vKDQ>&OWSPMmnEGUY@|7(IcqjrJ9CpZG25hjlp$d?N9IfuUil)d%pUs$#G_%$RXn_>>C(hvAPiwK|J-ISl6|c2g{noacN33HHV-;g9%^FG|I!;#Z}yEuRDqci`{=g-b4&Yv#Mz#*@qKHqcx{7^=&UXR>=fBxL#Jvo0a z|D|*Oy#AQf`SaeB#f$Uae|=vMwt6p*KXPM_<;4+HVY)d7*q_}&Yis9 zCQ8U|Hqsdn-9Nd^rksOz(W|oA{=SO?gc~Z*P8DVtb_2#=eJfR0=+zR|s!{@&&Pl%W zpCf4`s8`?DNg7inqU7s`*8t;$(A7A7Sx#nD{_9RuiR7iflJc)iedQe-_5N$lSLKMZ zV$E2Brj}*5D_?#TD}1TMQY9GVFc7&#d>OiHr3gtQV7ihALV*i6*;(%{<$CrXy)`l= zF||H1r7%KLStW8pQ->DF+=Kjm#s$JiQ({=qR2ISp~HkwrA7@ipwSz}yDmYxv%SFH$%kwZ_nPNMARb=TK)%z6vbY zDBfk%!MvF%&K6FnYyak8c$|fqNoUM+lKN;hkSY>EBu-&> zkbYiVmWkYv*{V+I$UyEE4nXb}4nXb}+Q?lcD?V5$L?d^#(k8u%NZ?H&cYzYrLRL3$ z%yM<@=6Q-~t9-B7uoiU^N3z z)0tM#KY{)Mn3lI40C^XfRvMZUU!rZ^=2Fx|Em-LQ@He*D0Gw2Qn3NxUKg+e#()dyV z@uiRM*7y=$)~F)H0&^K~Kg($K>Ses2<#n`Q?q|9GFW9L1JA&COu?uY70xak^G;?0d zYkqDlEU}btDG?}NSvy_}d~$90ckXA|tZqcEgYIY9c*&2vpQV89jSak?rT-;D+I(~e z?n>U>J?9_rfKnTfYl=Er@8%X_7YNCXAz-7X z-hn_2ndUwpV#?_-&`*M>?HD{CMe zg@%SwkK$*s{^7F@TYNXF;C^`9%>7}Ka)j5tXa#yL)-t3g-;0lql4kad7~j&9JH7=W z;M!_JE131AJOOxl768FXF2>Lu@ZLx14#+!Jcl7@3fLd^`oFNqcbNar50qrYarr}HS z4}$wx3XNh*t?g{9`Z-mrbu-_X_y1ipw||&!=25`yDXt;Syz6B&GuFB-wry|R$||$y zs5yETd9IULyUyhB$vH80&C|Gj!tWI|C2V zC7zBFu{d5v9=cfrOL__6e3oQ9ZSXsf6UTR^q09Ezowqrz+Y`E8ImnOmwxO zRfi(>XL!cpIo5t$Swph%Z%CGlZrYQRlQSf1NS3rGQy!vosh)qWy*m|w*{T(~DA=({)7zglbYZZX=yG#3{OS!0A?!YRmHP-cRbZMi0 zZT$(d0c({k`&f5&bb!EjmhP18Qv}IXVWSE{8 zXrMg`HvF?|3Mkio1!%YFA^M^9)%&8f&u?w^@pkT203^7MNNv1tmuCes z7aNS*qU&4y?m!!)e}0nDUY|SA;!$rB;e00C-w9>W2S~yLoS@cC2TH<+nead-)LMo<$4hRj+6U=(gTRQpen0FQ z%wZTp+z6@JU3S$}6^2XB6!*64nkzY9$()7V!#y!0=loR8-{KqQ>`v#*ojR4XM{)+m z-^qEDR)pyuon4Z9KRqxEA_=*@&zx~O9i1`HCMH68ZBS! z$1iv~OGWP?UqGWh9mGD`y?GxesCCl_`4)iEC8$X1+cA<5oQ?Fi?1kN%iO@-^)=hcx zZ4WxTnV>QC?VgelnzBy9k&^IZCWJO+I^kGJ2u6vMaBn1xjB4K72^rranJ&(8U7t{Y zdndh}y!%tVo%|7bstGHxo#-@kGSWP6r{S2X1Jh|P$w+grorZEIYWs>*J|}0SnQ5mP z%`|VM)9ja#=5#yFflTvsI?dL%({(Pk(~M)9JJM-h%SbcaPD24wbwxVOlNo6~I8wL$ zbf!5aoyN*Yv(!#=0n;3kPV<|LH22$Su4I~>%TsNin2~0do#sZS`Bys4K^bYzveQ^h zvnZYBo43+!|CycU9;W#n(==RsW1i~}JO|#K=X&m@Jl8Nh=fnRA+)6wTBJLi%FU9i= z{BPq)LvP^Mtvh4e@@E~aH`vc^)?45)b+QE>2}icT1zBxJx3nFG*Kv3>N(lrK|M=hb z5WMR93eVC4;JjkR%W3oPX4weB*5;sn>(XW@dQJ!_9gpM9971a`>! zdGz{yTs2pb09Yg|WwdLJSD3P{)>dkE&QRcAyf=e+tkHUl?%sJEZm z%f*xt$ez0GPzb}YU^!S^*!?_G4CuX-{0Z|=1y0e_TL4fsaW^F|twiTZpGjAhsEvzJ zLlggT^`+^RKFUH$SYI41%6(_%O8bFE(Si|kpkxuIT*!jnb9t_eLfEi&k6wpn9YAi) zG#J;cM-|u*D9}NDpd(s~mTV51Xf5uJJQbPvJPfPB-0Glufh73SFi-XL>>fsSVEz%c zq39QIBrj%C347V@-%w#L)~xQ~;}_aJ3_8n3HTjsWeS)%_gRsi18OO_s9!>@p7-c@YkA60Aa@XYt4Q@{QR|MH;JFW z*6c^b&tH5@NRp5XDe>}GdEqZ!9+MaT8rJLubo6DF*6e1ym@)n$83n%*G5)$evs>us zdn?_ZJ38gf62~*UOUH@hxuaLdiQ}2gQ#!sA$8(2A-YjuEvkP<_9cy+8e$5zvQK@6- zm@zumZ0>w!jK9`wulV_E&8Bd*8RM@t+Ymp0QSlI*M2x?93CjzA@p78H@YfcrGLrX{ z<4wH>ojJ@5xzGw>l?;2u4y%^r_s~&`?Xaj0qoW?R!y0rL9d(x-)}+JesGB5AOI?*? z&K9IDj#LQu@H>)b z$2@`7d`HquH#n0%+5m8+8C;9r+Xa1eF4|+?Uw!TwgXp6xZpomJ<|0rP0ufUF|~K3I8eMiaxlEZB4hE{)e*{}bQ?gDd`o!>?C}Jw9X)&at?fO-d=#=1 zUHS#GZp1p2dUOf|POWg>&8JfhA%-8aL3Qe_;k~4Jf6Gj zPtFLt=ZulKS0}6HV44s`E^@jx#ZVq)!WcwsuDs_4r{9Z;cVm{QfNOk5|T4XWDM zh1}6hI%?cjK%`_NSt|$<4$D{_)S`pvsB9fXUJFvuQN5VQ_^?R_(NS;fpava8N3B8- zE<{8FH4CT#KK0Sx0c~JbXO{x;VCw3vJY?HVZ(;N zSPob&U(&l1v(i21HYCzxYOTVkg5E`iRZi>|5aY96!XnC+IqUX!WP=%)%sDl?BYDs2 zCxo5cbCAz!Ws=1le^~d+#%xOFc$4@1LlR8TY+n?Y1;fb5QL}yF0WlVaq|p~mctNF0 z&?Q8#Fw^drwU-Qo0URO&I7|jGtnfj7UOqH$8o>O0X6_*7@56S0LTX|D{*D1Q^H<7A zYJt90G$l3uP2lTZu9(CWn6Uz7qOo3nWmVLz}# z%>b4Jf4*`@KNieLUS1?uss^m(05#Hu)@%K30c)+WdS6U})f;QarAyz|ES78_6_A-x z7))klw1;H01l2<>6qAGy##-b_+h*Vx&tf*0pwo@yp8MSn_4%AS!dJ|7)&@yRROA3* zBJ-9U%;PHLq_Q649@bcbNi0_p&||~C~^CPTSWje=Qs+`*e6Dk#@6(7GdVhS9_{DpS}(PGJT&x&7QUH~Gycg@f$E zFst8czi^W;(SG43pQruO>aqn)j~;pdV9iaI0b96_<|dbN0tycEnvuaxKI}eO{#;sW zU+tey|48_|rvgJ-oaJ>z)t%rdXl47k=o4_={=Pqq+#ihLQiacuvLUH1ADk+YO11MJ zU?l5Q69=cdn5llsyf&m$9WXf6iA+Vxm3lgzYU}Dj^%~1mCot9RNR@eH)B309Ha9Wy zxASGYhhZ<;gRBZ!>u^1_wR`Zztf))=LG%r)v)pH04i(cO0qa+}KyZlJK$0$s9Dw1B zf0c(ePDdZq?TG&XvCLipEvTJf2OC?zMjlqLL#IF*W)aM83vT@~WOWkGZhg;MLsx%+ z${+-W#@qsf|K-EGomXp*8&R}cSqZ)?j)qeTYbj<<>=;Ybe56pJPQJ^b;0fn>{#vhw zP*t9ALgovi)5Oy#YI}_6)lX{(l)Z)<)F8Xp<}dC$9T*JmTw!1yhfuV6li zDTH`oA+Sz(z3KC&uk1_f9en;~@s|`S3B+G=*Eg|ete-(!;c~25elFVlv!HI+g|CkU zG-WQOJh=wSzVVw^mLLISV2%m6Cw*XsacCS#uvCoOzo0w0B4GU+=%7b=Pa(z$;se+K zNCMky5Bd?3J)`hQfG{HlR$!LhY%~(`gQyS*F%TBS@PxSivJK=ER{68PFd#uMt#QYX z1F<25IKX9C8z6)RBB_TM+rcpgly-SaHGmFCzp)eD@fIA>LzeE=5RywbTY40*O|l#0 zvdc{QL(V6yujXh=aR*Z$Jt{Mi1`uSY8}~wCC&K;iarK2Q+H-s10_}k+nD*cr3V5I{ zB2=^YaXAFKoYLB$nvKh#npIVRYDPg2b>ClMpF__^gOC7JuX2G1z~_P(Zw3$tAf>7r z?iYTyC*P_Dep6pqWxso@|HIz9z{gdUd;cj7B|u?Ppcv#9B|

0!0XxOVVb_44r`> zlm?_SUce|Q5fTV;o05*rxEY8-ZB>wXL3jov!j2R;?;M8SGP&(xs!OeUoA6DQrcd zXj}Z|Yq+_52C=ofD~1BEu=AHJaY3c2-IDpw^jXPNNnCPDQSH_gn|1dZ5(s}VKp2nB z`pl3IuOA`&6A51!RfhZz#=_^XylT&Pmy5n2g>~*@_*2HEhCNrz2YbqeC{Gj0x)Tq2 zGhWk=Ne6$Ce+RFuQ!~16Em77bb;Ryie3Z#4nFhZpR(px#=ZfKYtakn&KMVW$Iej%h z?_U+UD$^M(uhYA(Mpzu|n^_jA^?nD-7Ri5JNpsWJZ9-)~UCV&qAG^DWA$hXneK4eZ zy4G_crz|1F<@e*l(4UiiADXsAMLM6Ty&iv_>O+jN-em)vhoE_!oSM%-0 z`L(iX;Co8k)$QBzM=trSrK`eHizqkLA2BD*Zl{_x;l{pZuwhN?J$!Jp;-Rkl7oyfw zi5|?Wy9g^$8Sz)gb+iC-L1m(FNmZ(FSygK8%N>WSXVdo83{4Kyx;8U{1zdN}w8+0J zk^dxLeUh(Ehccg9@1B-Ut#CRV$f+6kI1jN(Q!*tAH;w>UqHu!(G_$=5DuX_Iy1|0V z?ltzb+=9wrz`wJgvU|wCQ{Xm>?5!j`tD2uE7Q?)HV zyB(2t#u^4U)?4Ct>?!{pdkV~p1>gC^m6pgH+}TZU63=jBgTC>8vz;JK75=lHIhH8g zqkubwJI(`jYT6!`2+*{0EU){Sk;tOIYJ11<7R#D{;AX~bqD$p6Fu!LqIE4;Ag=6!l z(BG%f@9#>|=loU1?hX>F*Q*m-B%8PP++aye8==MZu4QJaCAFV2rhnOiJ;p#^ao%8? z`=oB3efN=F;;0u zu4A+8#$0l0{_xI%O1tTjcbY%E({$jS1(i26+EZXb55e+&1t>ZF(|~`nAXq-=pA^LIUOq(7)2&}@ z>-f!g>z5b9_CmkG@?Y?qSh~qqVGmp&b+}CRUVAbeZPvT4H-Zw_XluPsjJDt3hetrp z*~U1ih?*>7^DR_tXTDg9-dO3`*Eb4YG>b>ZL_9e zI2Amf@K)-n;MWtTux%{DRIpZ_>VviNRwNbGoR^dA1|;jyhT^LN!8Vrr8#<;WU74(- zTcgC^lGy!FIeaEk&t0!-J?HN#r&}VkYREH5CaNQh>522zuK#O$>gouS>;pvNA<_f9 z6y$WSFlegC+r>M{;M5Ae6~AL|pN-x+B2f+EaHv5X4>jmXN4C!lYtXaG7*(hm{%jFy z5Mj-)ohd5baJSHM2YV-X_Y-N#{!q{O3rYq*RKk{>u;@fC)THCyEO%DJi{ni%FDReZ zQGu?we9p^Trg#4?*8Lm|w_Wka_EA%?r+d6n*7Cnlg-5IU7Fr5>i1Q0f#L4%@-cF_>jfr2awmp1S)03hjz^s$vO{=2mqts6zm%g zj%yi~LmPJ%hvLkEyC1U9d;8ZfEqZTff}Ho?WS#7|ea<*jAMbcq*3{}pijQW=1%<^s zp)shWLU$4R=3YjRVW`yLd3_;4Jx{6Nku*|TAv`VVzqsX`(7b)Uoi^52?qgTJidax+ zXC|Z}e}zRZD*s%LKKWJ^7Hf~roj_KVNae`vRqnepO^cC`Qi5|J!X9(KD2%tFg$2y~ zvmhuW{F4PiuF*gFAZIi-?++yUlhmAZY$Z#NS8o&+RZ+Gkr#siQgZ|cm(-)Y|p&qE+ z%AbnF`9p&Xudul38BX+Zsd?NSA2%2`-Kspm|H)Y|vy^Zn)>;A5ID6R%%N}EKGzTZ`!x2wFN)+aeW5nDX zEUvbgelT0egNW81fVZth(FzEJBf;My7`OZKHwUEtAO<)4$3;%0K4PUEUguuHLE~v_T7#AGiZ(a)) z?31^P8&J1dKLHsWnLpKTVrIdJi$u<9)NrbhQ_Y&&RNuyveKG^9R(V z=8kmi#{C@0e0fcRyO^aG5SgE%kh`Q(Bpf%=DuvfG+*jY@HD+q8`}1c^W2T;P&c|C7 z{{``0hQsj5i8I72aP$J?=KeI#7MKv8JNhwOR6>#N`O7TcrTDLWTqxB&?&D)1c6a{G zpV9RFw-C>+HOgX#UaOU%i<+}*tB87y|EK`{a0rg#yF6+j z7*2SF(sbS}1l7ulK_!_S@@mPA zVY79(7~fH2rJjK5TmvO0gAEiR)<>HYyRCpNTDn0j(!{2O&gcGd9I4xzg8w&XO}yfA zkgpJ(f3zD4!uJWp3vQK45+zmEt(ltZR^|Gza>bR)-Aaj**+;XFs9xN^MwzN_iWsy7 z8$t%n8~n(D4QjQP@DQ&ZPZ?zE)%|MDlzrFqhcwV<)KqI)wz%tg4_n{IAW8R}fp1?! zTnntxtF8_=g}N|TrI`^aHKEgU)xq*V+h^bmX_2x(2;aZ_1rlS2v*kcpL&UX=g5{1F z`(rF4XYsv=?RjaBk4t-^aQtrUKXT3>K=Iv1Upn%xKm-~<*~ct*AzGy zRn8HSAbwF{W^X>-y(zxj_V_x3AbxH>enUKeLR0>f@}^A-DwN)ozjS63$^~2+uSA`+ zpek0G{uYr_P@7JG)!cK{N^;zz91Y~yq#TJ-D9LdTIi66CR&qS29BrjQlS3B@J>i0D zg=o_ExNCi6rMsMn>4wweHviR?j6#|C*QFcOy;=vMA;g5fQPy?|_5J0av%dew=acK3 z(Hn{bbsy3i+rjzd!&EOCyj7I_FZjp0fJ2#3&6{?SSse~OcmDa-tBE1T7j}Na5|QK! zH`)>i=U%LGnjDW*CUHE1^O4G?YW$5<^NeSvlk0hIl>ZT)TX=5aIm2@%QTTio5P59p z5o*0T8>`$kHfuLhC}z zQlej5b%PBsYJEB1nznUVF8I(9#}fA=+pfZiOCmPUrRsi^dpuP*>JEy5S!C@`@&nt=G z$1i&PH5gb6Jx=84H3SE}%_KvF9`Pj7~hR@ZDM$5<-ZN;BN1@nbb&?*tN@3{|xL;Q4REG}Aa0>~>Q37->OwFD2!3WpGeI_e~ZrxA-cHORf#NZ?^bM;_y(a z&i(9r=JHAPktANlUF)k@Q7b_ihK}6slS=cvk^B5S$^Xh4_?Js9LHS@lRVrw^&wbg~ zBEbz)6mG>~n*?+N?qbg*HmeDAlK|a-yUepYxQn|}cy8f2!~0C4kk2yqJht;Vnke-8 z$K7JHc8yhnwq}98DnVPbKwp)hty!S2%99&;Zsa}}P*+n+Ft0V=)S3*gHzh|Xe|-*r z$NoS+_csPZVY6O&Sdufc>BXCLweeUJyu|LIM}tTCqM6;!V1?%hz0m+}LfLF;xey=; z&$x~-1>4<{;>%X;R<>(Tu}ch0i>#<(l_bGt#ItZ5@obW1zx-ULVaMJub#&XY6}Z;H z=M*nGUphY#yZQn7%*!1|mh)qmJXsMYJs8U!P7)V+HgPI}$lS*``SU>2^uY@rI028= zP5lRxN+F~UEnWW`Of{xIH2pzLjLI0Zkgdp-6USmjDYJ4_1Y8nQOMp#Dy%H&+$I^M- z;9n>F>z3kcrSrPgzc#UBlgTLlYo+H4s%VqBks?BDCc!bp@^@7drw*d34MH~ zT2N(by}30A;8R^aePoKOCrynN750%AV-}uRbPJ%lFIKai)1RnvTWp_vMS{!< zv+dx%G`iQlvRoYXihA+=`P&pE(DnHz1#(vBpA;m}R?;;freO zYAr`1r}{JOTJ@>GYIVz{SJA=n!%zgsPZZgA;Ut5Y`c@%zyIczb7MhCgvXeLdP}T0i zqr7OR_^%2kn6)c@v5&VZe!h=4Dt@+)TVqeSUirZ~zvU9d-e_3*w;D+)^k}@OeTMt* zL%k@gDdG->6MK}n-V!s##Do&ROCn#H|BJ6#hHA?Ipi;E@>W7HAW%hQk zn7BrX7g?g{y3Z-%>dy9Mwkm##Wk^^C%B(Er98=@#?d@o>@xw~o-xAjp6IUs5hA%U# z_}@B3{;}FGh`dT77|TK3mu?Uljt+xJ9-g&^UMjT@ZdX3DcKyO#A&G7lk7J}c_?(~* z?Sqeg+Y~wVw$rt$Oiq2oxteg1FYg5)Z@hbq`#h<^@-_-F{|WCu|DW@p@E$s`XcZip z1V8MKqtq!T!C!pqc1(ir*^Wu@$THds%OnDSfaum;h!3d`7=4oUslY2s!tg4`I~scp+k+hnkY+L<|jO(dp6-shfI6#;L0}>#VRyMIw1PydW<0*yXjKiN7oO66*p=G@8l{(I^On*Xp8vYtYtD4=~Ju8{eXb3|xMIW-; zR`)&Y;&kD*KEQ(gPg!Tw4K(F%5zOk5x^>CIEmv!{$M}m+yV;M1v;`@E*QR=bnu%tK~bHwKg;buQvso zwhlMN5}Ohq9!$=C1c~^ssk*I+!b}qxlhYqQrEru@ka%wV@;w(8%28E5rp7jGsgRV} zfRkokAql5q$zLafhu!B6MM^Bx*!McD$0-x$S~}P;=W+L*cbbeDTXq|>_2k0LL#@=4 z3*|>olqxLLz~-Va6``9m@sGHtigpuN4rihbwrCosSFXjKLV@xJ;De zK8x-2v&6;+n&u8%{4Be1Dt&;IbZ}kGAYrPGJ5m2i>3;>n2S~t}IxHQQU9;B8ep~Up zhsu8-*8LUU`0}qKrt;UR{D(9nnhIB=^xWe^f4Q2{1_B(%?0i1)x^>NS*RePXYHI8x z_IqZfg<5jGJQK!Sn&ysQdQ9TOY`LZT(y}p|xikUSo2naXsvFlPE%&1a)8^%u%~BCK z(S210eVs2@rBKihKT)?XUibi}#)FBuk6r!tbYW3ry0FjZQBK$WE%b*wFG$@o5HGwR zEVWy@@IGI{^JouFqKVDwe&6lMx@9&D$*`l6b=O(PX>UD2k2QfT>K>TBe)>b>=nrzN z+vY;!++SV%!_Qc?aac;-Wj|eI*AS!|-IZh@2}XH7HVE-d zFh7%zbN%T2w%Fk!WDC1uhx-{(X$J}Mm#6uF@zyE@hZ~IxPGV-tv&_O-{XZFMb?g>;>?g1U$J)G6g4P@^;f=tnwtF$_Zh` zDo+()^%h;;!^ga6w5Jfecpxudb= z^XP3bULwRzLJ()SY+<{3RFEh1(~_9JQ6b_5Wd)0B6LmNc-6(6h7vBOdp=7jucl)e` z@T2yilm3wHYavzBaQeriGtLpP6?<<3O0{-~1%Pv*bD>7DEy4MZt1FSY#BpO(j z*RG+T^Sgu%vMtFh* z$Lnp{3X$w%@Pq4K?ee%zXbD^gmEI1nbH7u8rowz<_-z5Ddi-|b>VFEqtv&xA;J2H} z@V^gePsCGjNi`kFuVc$_HF_5e;R)K(tXnTpF=O=YrpN8T>r@k zuYK<;5ndC|nGQxwF8yOFc<*-Q(w&!-;5Bqq+sLKQp7Z|!UP~7)(&fcwHhdEMVNZj}rcP-+NtCx8E(IDRa4at9) zie#AxZ&UzmlmOVUBLUD?`!5TCg2js+|B3`y1g&Ko4AR6E#}$Zg&A&r*8xTv8zr{;Q zISc6c3^JQ$;v0~;)VCTJ^fr&WnH{!fH4unGy)MP3+Qgc*EcuJIW@l_8Q9bs4TeG$z ze?+`j0})D8ciB5u`o_fEUv)kd9_+bL>e3F>Mpzm}hKH(}t(=aU>M8dTc7NPzPY15#K0?aZJ!^Gi zy3adRH_ARvc{0+t#L{S7mhD6LC&#gGN^)3E%8YVpY#)1G_u$A*Y4FndXt{KLyjsh0 z-E+Ku)cxp$;*zXQc0V_onm)#bfwt?iOYx$>L0uGhh%O2|hV{5xGI%{XcVi+pf6TU` zl5<(@H#5##zJ(51w*=N#?#sr{scbkEZwWk*q^QF%h2q9NGo&3Y9_W)5tq%1ifxXb= z@6*Ja+@O2$BjH7WbCTwaw>lbmR2*5;m~KLoleCI*!C|1T*Z}q54*3OjegMG z*E-qW$@Ukcqs=Wq?{@o`b-eWuovnj=vNE!+Xa8(uqU&cAyMDTL{hX;?&!Ml$U4MEK z3pcvH*1G<8ynn=qM0aC?JT~eyI?`SAirhw9j%}7n(8jjHkevE#^#BZ5ci|=3W zUVmI8Q*o9?=B*$$EU^Ky@{pemmG@* zbux{9)Vc3yb;JQb&C_UxU&Q8ba za~^N%*Bc#~qs-&8Z_r1ZPHOPQVkQTcQw>WuWC_fI*4iV8K`QKB zs%6!@b4Q&Y_TZ@5vCU%B1B?}L_aU})jTPgw=TJ6W_PKQaIqawXp5x1ab&7$`C7~#g z>1Y7o-2k6YBQHXIdr=F2t^8&9YvZq-zph07P60%qsYTH1gH=B0Q&6~dwLMLomCj!P z%ohkN*<}RogIb9BHUQ$3brpOE2c3jh3!5NA*GtC_RKdwcv_L z1xJm<>mZ%|2%Sxb(AjT&S|jvHI)Q1U6NSRsA6QbfB=i=Aarx7@Kb4=AVk3zuiSf)% zI8sdI_hQJzEMck0L3Eu`Z>i!>AqS3|Sa|D_`6Ne>Ppe`xsHr-gKMfC`r!|0f8>=ma zSVCLZNzz;DlbaeF)Yf=UOLYkhYHUTY)10TMGk6@29;x6-?p#gE$RVVXj6XlRC+{$V1&gkecvgV}v5e_|?s4b8fS zW?fU&+;dF>VPkXtnnXI7#mUi%B!o}{phFB~yVyR<4+w!KloloRD9}SUAqt0)j22VeMu@}CL z7CkK&n&Y$6zu1o*X4F}9@mb&%_M2oR3X78Q0{-fgqIUB=wFCKDS%&Wx_h;0GOjt(n zWcKnzSqGTv!N27EnB`_MnLH zdRnlrf#M18#`y_Kmru0r4Vj3IFSbwcfoZYN3JLFjeIV@UClOtPBy7V29W4|7h}b8t zG9OKY#3~g#L@^*aZm_Z8vKCx_G;pH-N2f57g;T5DeToDNt2qvWYoCSHoruMkR3(nR zq(Y7|SeCi*tKWY9r1Ej#1X`FmrkZ!VceQ%%Yi9veZv2{G8+*q}PON)odXc}|o>Pr? zi@&=-p9Q<$Td5At&!J|T3Kvdq(D{*Mv$>gU?vMxU>{&Qo)v9&PlCUfGGvl7Gs1!_l z_3F3X*y$I{nXG%@M71?AK<_{`LcCXbK3E|`(}i7b@RQ20Fyk(=5*8-hH%%bh@%Wwj zL@DEB;u=mFVW~AyU~PmNk0ej;y`GtS$YonO?4pL%8{IDwt!Vx}drma0iGa(YALvMn zn}&II-^O}p2aNOfI(C0`>|WF+2h1=!@+HGWu=(zO#SK%%sb!I<{*O%5&&}cLp0A~> z+jjX(q}tuvJoj3{SOyC<6>`LrGOYL2bK06$(ozMAf4x3wD9r=drUG7Mf=oK5cqgT9+ z4F8+=OAhxiyn+3a@ss`!+%Ng~JKykr$@uFqmv6-0WnUV)LwlEh!vhPFoa|k$Pq2K7 zmM8zu-X+)1dMfsZDL4QBW$%KSESM?W5AOYd9wzKvhGfn<+1_Q3CEMRGS;QtE`g3V~ zU6S~=`z3RHj$tZvhgpsZ?d+TE9opGFiA>%vnR(_L*)Mrn1sXy({IJ;?6UXEmi=@~S!~(2$%*9KkP6<{n64X2a@s4|{Wq*V7t$7NNM%U+cr153PpRPS zYJ}g~WZh2^WJ_4K8q4-nCq$iW`|{+?_Y)sRd3t{=_ax=>rbqrh5E63(U2{32T9}zl z*A2%G#*@bVvF_jTE*_NcF43=JFC7@`{s~FV$L`wso_OreL6|p)2?miE=pJkW&vnN3 zi*w#`28~3qGsXun?jr=}azU54*2d!Ai(G`nuHkTwZN;?dWtS95joitQC|p;Qne4hhWa9`cirN!tvsG}{ z6Ul@P*!jy3>3Fs}kDZxXwJpI}zEn*Ehxv56$qQEWUol3%;6{W`(BZ{}FlhFoteW2F z(x2xk&n>tJI$dJ>-cl5}=RQ~z7oK}q>?UREV+8PQQr3v+0r#%YZhuIA_nUA?IOJae z*Kh&0kORfqgEY+g10DNVRX`$1W|^uGAOa1+?+jSv@Z)zO!rKQ2`VTM;o&YVycXRMO zo-W%MuP8fmU<>O1wETV_pejrUR#-IYi#Mw#bYPmP=}Jw}#QXdj){vrcM{#rs3Z&m~ zOl8S>8~-W$o7LLi96>|tzI$46{Fg?2$S|d(19KB=N`qEShJ3mwf$JA(bs2~Zae0eZ zyba&=EyPp7T^R-Wy95UNqB=s&!BLEM8_j69IW*c$ICr9FVlp-lJQLG3VYHiZo5-*+ z-UYWOqupGVQIp-SnR|NE-Oxzatatl(jUz@e+HCZR_nxrc9pGtGZV-t0Pwe4hOg4~8 zGnc1#JWH%Oe}^_}bpF0zpCpb&dk~AS1B41*B+(5dkKH$x`zx7~bI+`lg?^k<&pPS6 zprU-sOtd)Y-yU(_dR;6Aah*cdSIRt7hm*m5%2}aYOUacEj;l!`si6|v8rtl}mfb}8 zb}AzgoY-_<1y8BE=TfN3+tR@&h`*Ssqj;p|bifnpD6OXO{uVGFjv0ZfeA>L})7bL?OlR54ng_QdKBu4)tsY`6W!7mf#cfgC_7 zW)-Ym;d+2_-CIH~sok|9aF%dMjgfJ0b3W(0Cf%YY7A;>_slW2MJ_4-PvsZQ5_As+6 zCz+MGnpNPN^Pq)Ay zt4anlnL5oi6>@Ncq7+Yff?e|hj6|_ckDQPXQ!_r*=opz;x5`vTx$^JD()HHpY&8$~ zx-6h?K;M2jSU+(B^agkx@ zvg5%GFb7S+UyS2u$17MW@A-^)@JBp`bu?*9v&78*l4`AM{CSM|by|1_8qV8mvQ&a~ zzx-4Tx<|QHM0ZOBD984U2!|e`;UXA4iX6#CXw#-jB7aj&Ryk=kt`uhBB%G&(927F+0^#r!1#3|!0*I_m!$4F{~ZTPsD1MS*DV2`usOxy8i|a z*k7@yI+OwC07EB;^K~`W5j4x{(L2udFeO#jqx!6$q@Y_nOR7w{NgO0d6nx7y1u{W* zpWc`@I;34K%8(^h84`L>bM(-thraLu#@rWcQz@8VLxx%=Izcrs`FC=KHN*#Q*SLVc zxu%LS6$V(kL8BXLk*4CKMB({Z z_Gn9fFAYtJJ(`G8LSHgPi^q{Jd(SrN8614Tc?s%{o!cOc{I?c*rU}$ z?JaT?{sf7@a8rMr`en!?BCkZxo*-5?#M@+-Mj!h_NP!L^<@(4I#JfUf1k%p40Bnp* z)6{K{SPMAe2EXB}Hzp)JB4($X@iPKkkhmdz!97t5B2a8L`D0AkwIcH3H`b0Q%&!%5 z#|N5cKqQJB7)zV?JPTJH*_#re8kJD66HJITEWTSrlu5Aw@H50U_0*Id9r{UEH}xM6 z1R+cCV|RU84=V;N4ePTEtd$vTd^GzMmdK9l0t9>O_i&YFq7cmjNZIq-PS&BY&WQj(%emff7d&%%W z*698#mZINO3&liCtju>+?RaHEE_GHgTAAxNPg$8ewiF#cVh5I@7d>5EnP<$Iv@+ko zNx}a+Ek$37&ALl#gmA4~3H*;NM=Ml7#LhpS)WZtHJ+d6#>z7m3?xXJ1M7VYDL7Z5MC9KFKcp_{yz$YjgW_9m~_(9%P%kTQpu^Q6t-q?!>cT5<{IGt_JdP*7KrjhFkkjkGo)RE+-tl0AXclIkckgqxvO1gi95#V;P#Pne-bzr@p!z4*wmf-rI zd_i3Ql0gHj1g4)Rf;frsfn?nPjW3sh9runr41p4LFy=8KBG!m0Q8~NX_b0p8Rbfg~ zIrYQ2Ll-|NF?t4HLB3X5AFSvlNOJ!FpKpBF9!UiTg*9?Y%Xya`PMT(t!gi)|jM2KB<#e6Q;q zuf#psb^P7T-|etgfpI2ik>i7sOM-YayoHW}BZ0A;jMI@raP&(kgqfV-#LUNgFwyEI zWh5Lh{CZ&c)R(CHd1Bow<@qJ6S;uSWEY|Waa#M)eb|GGg5`B*fw9#h&dG~(OU-$e; zq&k17z~tyL?@+N~kzg9D!X7`^?K<3{jPj|U#K9X@`2bh<#gnQAAA}DMGr3{c$N}uEBdUmf?T-nkM zLi&@~y#v1~LHn?GKrY-{?00|tG86Xx4`zbxDSYhbvT>RH*?0NrcI?)ie{Z6DeoOh5JwsxL zfzRxl3e#B9;P;~{sg7j~Rx+{Qmd?#UK+Qd#D z!0xe0x+F~9roemNjemi;5WEr$+?hWG-Y2$&_j)Y8RSiln=3)`(Cu&2WA0Z+brwQ^A zRTLKZHXVgy(6$Gh$VCL4#SOTw^ST`nJ2c*eU14~o!f^8;r?&EK7NNJFsJa|2&I+HL?s0n_Dy7+I zs99}w2mP9rlJZDMmvsb{LJ1i+<6O;)dhNlqH1(?nPG~ihb)0Q;N;#VUpdCXPfHSM% z_j+9U+f*`(z&3eX-A$YAz5f^|O)9tE?a5bmz{BdnU;F*a)xkx_m0_M1_x$gbR$r|4 zSgY0w$haTdOR8P$t1Z+_uJ*vm)v^Fo?Ml8Xt@ce;Es7RZYk6ASB~~)qV;t;Z#F~5V zQV%BboqbT>)m+M~PQ+`{8n#6T)FUBI8uU0R&HWkI#2r6rV^1p-t5OHx`88KViAKf!aRnyCgmA%H-~uyoyswwC*{GP zX_#j)%rmr2U6t+(^2qty81LA@G${xm`rHLLvF|0;;?~s&D2^Cm<0+u%lR301*jU3T>@x@Ai!D2Zc!EKYm&;eUC96asvIBX?vW-v&X1MMmWwG5t1VfKsbxTi3l=?^a?E{ z8f|4Q#XLFWA+`q^Ig6yu;uAcC2kk8pXf$*7j^IieT%#p$eTj`X9xL4EEV817xl`JM zrvcPe+0A{{gXUk#J@H9EVXRS}s|Pt?inBG(>S*YTU|M{FB6~1D{aMdV@bM5$*MPb6 z<*Ivo49_h``#xcrwwACHzdP8o6H2Ra!#vTUr>R3Lk>N|Be;@OuGrRdK9(t>6zf$OR zbxGZP7&UD=F?%%$=zwAqEIzfT@5!qPc>f0eTEYKK)&tL(ZMlkHyoa(x!F3{xv%n#n z`8G8`2FnL{*xxs;NIzT3I?lrPqVR94EBww7XGlNSxb%Ug^t0Xl5{3Z88j)>iV>;_v z`DlWCX58?-%7hoqBKgd?qpaYDVy&lHt^WHeUun|w3Txc(0i~6;y0+3vZPg+TyJs*H zE3NfI)G9*_Y7O&b+z%`dM4Llc?7cMia8oh3CCkyJo>(oo==>N~Y8lTG!QPo~#J#VU zwh)|czg!T-4QKiRKP#_i2wL4v@W%1ru2CjH*xRR9H#b~a^S+LE(kpA+UQsJ#T9tKQ zH`P8_jRDHI-@q5@yNu-LC~;3SeXEK$tgS^1=x9jdD39{pp~o2Ut8K!lf){BvCih96wId7cKNqg#ctreYH+a`nyonwk= zp-BBeBtxX9If(a#1TLPXd*fN(b<`YPA?0!UhcIwKyRurRvpBo266X%<6snKsQS-4` zS`_dVfUEhAA|yYcZICAyMlWQEN4agSQRw8o9kTBx>~`QDa_R6NjZcF9T7lWf3c% zd&>qRYOH~Rc4OQhKc>MlQUR{IMR}%B3@M2+5m9?nVG*szC1{;EsN;vn5NGkezbi$ zd#FJK^(u-%9R>(u&;>-eVzNghsMAwewotR1SMm&`YXE@`w9?nK{as-H4ngz4wnV_v z@a7#rdS$&0QVFCF?iX?d>xhJOcBNGG5m@^HmT-OBl+gtBXBej<>bLj=_3|*?*X^kn zA49zW>^sbw?Q#ImyxX^49A*jWssk!X!b+=f2O6*|Z7mhdCd+;Lqm#fZC9aw6QzjGD zJ$MIB0$r?C>Cs&}fl3cZbh zMdw;&_nlt?{S@Nbsvbu5U+iIvPY_q%gtM>p#FY;69g;(E=yC`-h3au*N2 zskDpl<;l1MWup~is z*38*LpV;g6`Bf=3Z*||hLwFpT9dZT3?*4tk`o%Q#y3>o*!%9%S=@|yx%|4fD3#jXz zCAFK1pw0c96`TsnwjAoK4;2SD+3p>5qtY`%M^V4ol(J2Wybo#X?9F$siq)n?)I`jn zpp1{P40Cp$%rfvnt=Eu~(en%3j}B`og5TcQ@ShEgB1Th%pp1x1yxXYzyMk_Anvg1V z>yiW!ckGuMiHh}OuF~ie9#gMWm>9(XjV21+hN|;%R@Fud7Mi43!-{698|TsP@PRg0 z5Ve(`kE7R6cC9e7+k*1htNaU1T3*;h^)IT~O!95fX<=Lh1@-Hf+yZU&8l1F|c#2r+JtU|pW z8hOzIt55}!P(Jtae;KPF6P+&c{~JFDoD=e|@`$*UQ0HdmUu(oF99hCDNGd@7y-G+! z@^6L8Kl2CMr_0wLu7bxB6Lk3(+C-Cj@+U;3Q?>b5NVmEpfvHrSEK!~_qOE{k#KRV! zz{4J-$FGbeU8h;Lo(>w~ON2#sJh#y5uDWjrg6{VY^Ub%+g`(d4wMtLQSg3FdFY=@g6@D-h z=E^pIgQ)tlO-m(&`Iu6erx0ODxUJjgBW(Y~1OBs5{{?h=VNJWI2d!=cGv3hNHWch{ zhpJPDIbIkEw+X=1X+w9SpwBNE*%)_d%}oWIb)Vfcq#K6m+ufVlNkD`R=~kF+)P2}z z3)Rf6?j__iPqz$%b2#R!Z&$@to^JWXK6lO&rF1LfUj3#@N38R71M+oKjWisf?@>37 zdXtff$L_{f5)3P6_PX5$)X*p8Y_H-bmdT;qQqbdSWoh?W29%|1n=FIM(rQ@{PnAbJ z&!l2tSCpwS%tR+ItI?%7Q!;faQ>|r6XO*XZYMwY!bG%PdT_2QiK$LL6Zn_`_ikC>; zPLy9=L7{wEvmtKokqWdB@6*h#Co-T&Z74K~(iQjyjF$~X;Z}FLX_SDI&ZDpqE6j)@ zWI^|UGdq|&XrPZhnU(|%I$zw{gyJ~M7adJf9P3;6{9#62?eZ4grz6F28==aQ;<$%+ zG@8G9ph#a^5!YC`%RGYf1XiUBxv1i+r{LVYqh-QCa+PeDcSL_s$kU=&n@agx-%jlA9UiuA`o z>yFSTa(J@y;#5RGr5j6nc{_u=&8C+pqTa#(ZS}myC14c<#nVxLS%BXKt|t|0YBrl> zYT+?eFz@r=Eq&>3{hsYzEQT@iTYsNC+haxM2E6z!$}~l2lL+1z(bZBBywT|D9+yT$ zY!xkcuiw1`VeLI{RYk6ZGIZ}AQie|xNfcK0i}4G$r=P%%DkQCdHC2iHk9T`7>x`i4 z(rC5q2&!A(LY=f7tW{JaZ`mz`>lq@zHFbabNFcjSvwgFjMG7~--}d(*28tpfv-kvc z_5JvxjtFAgpTGOA9rWYxtJO0jCGgIT;60KE6!u6c!O9WU7lQWL*1y}CMpr|Pyv3)2 z_V&r3?Y|??-e;hd692wk!>(LO1gN?y3@Wik?$3*T*Ejg_EtSHJ`r4F3{G+48-Taab z^Ocu)vd_muMrc06#NMucd+ou#@t_m%agprL5I|vCg&V6d@TTsT*RvMZ+DOZbqSbRk zDbyw0CkRNyrZ~nHpI}z}82|d>QmDNl!jJ!R`;6$$z#VS$m%@FDAT7e($P*)8kCl<+ zje;GPiInrQr8t5z?#gJc-X68!$}=gLDR2Egg>`9BGgyYjW>|dce0Z}p!*00pZP-<9 z(Cy^gur4Paq*fp=P44}kT}oT=X+7l)Oo3c%Ov7$`EH2`KMG?rM#=yXy7HugQ)RLbf zje*5YW3ZdqSh%)NspCr^Ui=?Bg1B&?uM4y@8RnnPD1~{WJxNMkdVkgKWyKv4v>vO< zHh(?p>{td=;DE#;1Dgd=>}-oq?d&_+r+|L*zwZe2#}A+^ujweAGW$;g zd=EY4m-GVXG&sT|%3{mz0ETFP!&t@^cNyD*aDF;6EeV)neN(m1FLgn?ds}(9Wg)3c zauuhi+?qi?(;V9VH-DTyq0rFT?WJUw%7Lk9dju`+&YOKoqbh7sp)Kyqq-ii(*iqJ0 z-mLzMrY*XyT23 zt-Xk7Pn?_L;_8{mP6kDY835Eu0m9bXHE9{b#9I|>Q>+W6Ne}tCNw}9lpUTF8fVYJ{ z|G0)AJSx623;9k2%X<_|vUsU-pNYLhpRN>-Mh=--OwLj7KH_t%@j1lCPR@~V^L!3d zF$K$Qw`Ni;8COk?VEGu|`Xf;?nrSr@el&MM_tN!(+U2K#g9;dQW_={%F7uIu`=pQ5 zyYqac%AG?bST0T+p{VzKvA61D6QOLtg+aj9R+El!?azTDCTVlSJ!Vh?D!f5oyPv$- zZz%@LM|eyXmiH4_Il&FXM2mZp528X4@(Xqe&3tjzhL!KvKRd;chKU*NEoT4Oy~W4X z4|nWtHZ--gXVTsx9cAjn_$u}mdm>3^qV2XbYi(zx+t(p`U-qaVUxH`gRjtLD9LUFvT(=JGnb%tXm>qv;1B?dBl$=3&wM_n*|V0^oE{XhK7P-Iqi zUIP*}=&+!C?mxbzIcGY*tR}#lQpycVF@iBkrwJ)lmLi8>@d*wgV-i@b=Q4 zaE5*^LTmA<(EjqH5wzC$M^ z<5Jz44>knl76qLH1yGn);bI=V7OE>9XWMP;+w7$rU(X`xm?FR@Yqq6rD*`@6(D7Y4 zc3vsqbi;GsWSF;O9?p&l!#o-R7;TWYy;2JF**r1ery&?D%EE7(k}m9y?pljB_zQ61j-} z$ifHr5u&h+uZC?Ih}agdJP%Ex$g#pc3Q6>-#>I2;&=?kb6EZBm=#XL2gE1_Y8Zs;v zj~JF2OFhG4gnvIspl4XbO^9JRY!_o##C1$&SoXYlD#Nl3zcTzf{7Nl^#x0!@@hjgt zI^tKv(PJNl{{>EZi&II=!I_syJMb<&;bv!V$f)#*uSZr(55TDOfDBA3+Vxf#6&=v_ zdqE>^xLM<6ECHPDEy^TPFJlR#x5w((%bWqGPNV5O@Z*#y)pvAdgdCXr>2`PFSGP}L zzcEvF443S5{^>7Z0dWJHi9`wk6U-Ctd^Y?vp(5cv8Qd@?sI^6$5*~ zN|nw4jFb_S4T`lZR7ZMIj^00l_l55Vs(4!dlM0kniDNK39%gR zWTy~njAyz<{kEWj+ba1&m$blW-BD%nPr(1*RZSG3eHBNaB;@!@=Q(O>$?-l;nD;Ij*;&Fh%IfVxNhzG~D1)~5z| zz;pq%R?Gxodg(q%PX7YHPC}Pq*98ZZ+@o= zmBdncGf)HLNl33IrMbrrFYuy8Px(SCK_cMr(A|lO9#-NqyMzVb+B!LGg}B$4LX^oo z%mO^elDqsF-<`S#UZ-W5O*!$_fPpW+j$*7UjG-#Y5Y<1bYa?oIxa274pr{Le+))! z){G&|CXvYlr=RUiCB-rg=1_R$_i*bVZrdV!I1_38BEFF$b=T1{!&s{v>wP9FPb}qA|Kg3`FmxxE;60y1FBSrAcA)=t#ONvy|A9cUDT|6koC%ZS|4sm07vipT;onO=^ zfYC44h~S$~^lBjloomR&D4mLTMEfJYOFAF(BaO!Za5wZs7#m^&o(?);CT(K^iuTwG zRAr2#ca12SUOFt-h7Ph z{|7Dj+!TspZCT)53KoGfPlnNr<3e2d+)w!hv|bBrIuxNBRvL~B2|Q@RVY*yT*ozlV z0ms(-lh6@fkoe8##*|dBo6Xg;MbL~jfx-#(~2osEqgq+>^nd`0jF>nI}H2= zxqU4D5q%RBgvzM1N)Q{Qo-t(1ZS^L zw;*rsn6}LB9-9`+J;IC4U&ZJy<&!5M9^y?tSIx@f-g=AI5C`HBmBqdF3L=PW^$OQd z1l&BwpjRkC7uPEnexU5rT&2&}NI;YMWnV!_1*>Ng#4SGEg1ng-z&wBs0LjKhs3D)L zQJnRh4;_q_<8IH~Jb+ZKUX5E2Uxkj97mfC0nlL>k{L4Q7QnQ@%AXaRvy)j)d{_V7qJpa0ak98GZQSzS&_rSlE##mJM}?8oasxc&3mf#C>r>nDyrm$YTkW4Lk(r7Y0QU3h@~Qx<9w5zUnf^c@ZnhT2Uh6o^8Z5 z^}olKjk%Iw1Lk6@euYLgq3xvqSRrxLpQMlS{6Sv?O9m41m#Gm9o$T<9JMww)@BVz> zp~P_!u371G)GJ4&&!L&@%6$&4FQ222nEQkFy+X6_XNXgVkg(4o^xz)094PPC>$NcC zy-KkYDB{e-_4WUC7EsOR6m!{Odm=H*Z14Q1BpZMne&-7dI$~} zWUfSd$a;M%yTHQ~(U4r{@1tW(YSe8@H>f-ti*xXsqzine$h#NTZ0=Vz?xw9#H{W|$ z*v)a8@{F8P1WT?#IsYw~@H^Smx`*sQ!bNL1RY~8ID(u{I|5Xg;qHp2+q;Y)q$3Nvg zs~p0#i!FYf)v)M?o=c2Bid-C=w0co%zCCg3QL|&cE27=#7`Ns?!J(}o#AeNZ>&}9cpAOG0%8iBg|k*hA-Gg&C-pci)} z4klvr5V{vmbH91;c})#fg6?f=RMDXOEEUb$Sbk!e0J&6pE_n6y)Bo^X_F9_7{B&pj zaTd(@RZoLp+oVIUyNY9z<1>U40$u z~1`GuNrHXFKUtI3OzOzY5PIUI78ccm=xFZZk_ zOZWZNiO}@-9l!CiR+*6p6T~G1Rtb-0Kh3o^bg|!O--(?5MI;1PlgWg@S|XtkSZ`7D zW8P@d$d9?G-Gm?W3{MgQe%xNGI+nML*Lchz>W_ zFjjf}Dtoe>A5Y~WuC_<`k(vyG{wS|gb$2-eojgzHUheqV#68$7$=LFPph_&4Q$iQX z@*&-_DO{2vrEX15->Ak!B_@IuDlt{}Cwzm5^gX?5ww1rIP=1dxw#r+wvG;yBnuE@I z@%Jsv-mLrMh&P9m3{dSUyLOnEE+WX?*N04gi)(uZ(h8qfPs`zWM)-}Kc4|82&G~pD z2t9jyt~}!N8u*4j)m&o9HF)z+*t{~I?l~&s(8$$7VqlC}-uv<_7;C1cAp8OV9j=)N zOJjkTFN%=;lm1aR{B!H^`M+{0x49 ztkQy9g@S0*TJ_+ikL=n89^}0BwrV2mdbjCiboqkG9D&`wkk57L4K7&~l#W@}r&|!p zbNO3(E!Wyr7T9qdKJ|&7Yc>9tVoJEyc8RL(DqCFZ0B|++zm;E2>V#In+O5LSE7Vx# z_$v3>XG@t@%ko~lmCJEQ*f8_xs+PH>Pm8Sh138_<#ca}(A+t%$o$GUSDSo=;nDF^J z-`?T#^}YVns^X_*%3k9?)p~VR#J%?qYa%3Q-xr~gg_~OJ=$p9w{+?sK2 z(+8TCG@S!IDjNZ)5?)l%33|g-DrZDay~;#s%D^b@oIgaA=GucIN;5`l*(8V*mh7b^ zf+Oveo#`2?P0v^p>KSX@1HbSny;1$%xE+tMtI6;`_6Tb#MRk>_6w8Ttn&S5);vR+& zQ5YCfDK@B+i)5}^9lgJRu@{j_vC#_6c=0VHG%cisgeGIrh|sj#Q$%R8JlXEsUA@F) z?xfdVrPxOlFGO0zycp6`{;pwyc*A8C9eXE(H-(Bsed@mVIo+Nk3oA1MHra!`#`sC~I-t-zU9V1)|Yy$IVRpx(Vr zNvXo673g^oQ?2=VucHZ!W{{}mp;^YBgKdh~K6tpD&=_=9+dB7h*_@wmtDO?!aStvJ z30K11`BW+4dL!4H&3QbyzhO};SUApfx4StKK|DjW7tr8fLs!~`xM86pP3RNgg`5Tc zVviEcOP@uwP4haRJA+?gUJI;GCor$lytEG_D>T7H5~_W2oByKGKeZEpdie$QDrv$S zb`dbmVA3t{+Ww}7#TBt-Uk2a_5H&@;nk&fNWbtS9T~O$=Ag5_x1kve%ks}a@gL(wS zH9mPvK@cjwOwWbphcuL3hLnwCnnWEceYypnqO-@7UokKVLJh4~kOVmqu6*tr`Yb49 zEHG_W5kgNnydFg$_9zb^wkxC;{3pHsX@CHCPW(d5mBcXGn-ao0m6z^uH+Gj&+Az~2=7sJY2#gd&8U{~I z+ljeZ+GE6Dq2fCehu&%~`5c-}?nM*y3YvZHH^j-&P|Q)S)F1mC6^gI3922+9{ky$O z*Sgh;Nc~W-rb2JO`JAV>B9RmH*3;T^xTR`>$cnyB_TPMA&1iq6>YGL(Uh{L!SEPmfZRHpwtdSL`L{? zbJ)MfQ7aa{2+%Fby14l+qPS$xUXiS;$2sQoeCM)cu!v4Rqoy_;oR?uXCF?eDAi*w; zu20QVPCXx_bhr*`dF*+|1?9)pRWf0Ck z!l<^T<}MoSc&i$cVLNIk)+PGBKM_5dX5U|>(b(L>*J@ZM89=7f{qDL)|2)3s6WwDw zbcM$7Zd*Ss>)7JrarU^H@iMi=9s=1Kr+DQ9|plTO19S2&Sv02l? zDr2*7Q7u>14D^=$AnH~l)j4+{)kXa{zMjsmXqx+U?Aix00x5QDvU@`#`#g;r=G;4Y z6Lc<<;MbTA%se|8+#=#-s^Yo7iY+VfaDH?@mu@14)-q+dSeQ*mAZ<%@U!n0&6m-w< z6;sB)JvBGIrsLqK+oCqmZArRq9o?2*y=8XTXRs$65N&mXKq4~<4KmcIgwBD>h8Zy@2p9)mt+$< zY7cv>Ot_{BO$*D@@%!$-O^YqNm1(8TtP5odg%9VZ3cc4@1x=M29zP?Nj7&6b`oxS_ zNYmESv?aq^s=}sWiIN_2SN&K`TQW>5#@Exi*QQXzMa{D|tBE>Rdkz~7)AN_W*ezOx z4VV5{74j6#>dWg^=POu9r=yIOXXsA-t>%3nAvj`wbt=EGmiP6%$3Cf3e>61SPuS1< zhE)FaM&2iQKSG-RhIv0k2rikA_oMft+&Dc0TR29V{zl2`2p#EdTo&G*%FpkzX?N%b zrk&b%ppW#seSDv}1Pv&%Ba7Yc*Bcg=$_|w@ z^r3Nz11%TgBb&cKHA>*S;bP)aOI#`{Puk$*N`|bGp@~W;aH%LiSx2J!1XNg`v;2+( zGbPQ(N6F+c$}`AixXFiO|BJad0gS4;{>KNBKtymRiWry5sHoAPrebR}E;E>cH!#tt zAgOCw7311e6Nwdda55y*$J5vnjjcl?Fi zw`59w#mRUN5|VFBfz$o!M1*wXjlZ*fVq|%GreUUGAo=i@8A;&9avUBcPRH0iCvWYP zFanXA(9$kdD%r0|fcV3tS_11ibjE%%S_G3&~ zc_GLPn_tqxJ@p-H|H`6wh7&k!Olu3b{tM9cVJtenBJ=2qI9R5lHSu@0fW zIxXyU6AYrGqsJhsMgW;NfrxCWh)q?PDP$|Jr}{{2sT++}k) z9brY2BwFeSpG7L(0+=nV=n$_Xtmu+2M_AFrsFaF#v4oV0Q#xx)#mQN#zUOqoJixS@ zi&F7yd?pLVK=leR-NOQriu)yX6f6fGTPmI>UXh9i#Op}Ki{;CaikI?B%tqP&J7K6{7V@nfC)KAyfb2}1eFVtKI2{8xyHtwk!=IB9~?1LX9Dd$ypjhRyDz>!$4FgX^blR^E8I6 z#udBCO8f%}hRLR}@bs5~@7cL4GVq;DGiA%s`U2;qydi$YYtG(MH_~CteXwDopAqK+ zXjnQx>f+rN5qC#rL#ehmlv?%oXZ42C$R#FEi@Tfk@(7|0?94JCtPM5WTS=&e`$(u= zZz8ax?c)wo)a9zrhI-s%Q#`5-9vKqlmcsn0*%e0`<}8p&Q+)>Zbhy~}p}+%i4W>Q! zb&L?KMEY_W^g<$uDZs=#=ZPu691%$fcaQaq>>Du4Ts=MUeP}ivLT+5yYpKifZN9B`hdZM@Bz!+(7RF(J?)#)O6(fj&W(Wdj(a1X#M-WTF< z-06bkevk79_fe51UQ(cFNd4m#r#FU=aCUm`71-%RqA)ETf?UiMjQ~TG0F4*@X5_$g zh~OICF=!TNrw^4RJ0_s~K;St9v@l9Qu9p^?(@P5zMP+u^l-tV9Q8b3zJF*139b`2k z3=Lk2K6imL>XV9~Qx2%NMidOBe;?fqex19qFTUbRUf)CYURT7Km9@ z2w$G2u&@~+2}(K8TV?322{ai38}ulHs=&OhgAN4fVw$9cJ(3eBH(_(@OBSPy#D2VG zk=boqm6%+^Ys~eGjjoNV;pM!V=a>Oa(+9jXN_+xL5Xp;%oW@$(#$83tTO-rInf^-n zQ(r~9RKg%jJD&j@FlP&fJ75a&sdeqyyHu-~{IZ_U90mhrY!|pPHW@!usiHzvlv)4j zZ!%)c#qv5SFPPvai)cJxMify&qEr2N6;Dc9coL9@A+FZWM_r>gXJQl1#*;syiwS%eoCs$%y43l2&iMGqk^CJ^>yFE%l10i*VM+DWac5jBP1Ww zR*eCF2@3_WFEc6+fQYA6F*|u=F zGuybFbJP_V;SMk_DBv9`Q)IE2Y*AcDhysD9e^t18Pz66tb(cr93Z>jXz-*J1avU)J$*u zDKugniu_{0-CMnYZEE%g&CmMFL#YM|Q6!Tyyhpa1>HCm!g|}sk_ri7vTY+>JEI z61LKBr4>Qu_7^0eg(qNzWXQiQ1W zDNKu?e)pdC0N2eUIXmTiow6Y*k2KJ9ZptfDQYM-z)+q-BR~|<1mon7Mr^;a;bkYN1 zh@LYcq=qJX2)l6+p1kHIhL8s?MjtQg71iPLOamkw@N>xB1bTgDE!MI{YRWTM+b~4^ zdKHspvYbWu=aoX9V<%g^5)0F$zQl^1XarEj7|4k@8FRD?O9(>!yHMxsA}>tO<}o(Q)ANMO)9JuET2rTTc5 zUMx)L9<8o}Pi#m0%wz&WUhvDuFI))YI%3(X?MMWEu08C`lm~eOTrLB$078X>trBd0 zfcb)gEyXJ_YWpif!LobN_buwg%Tp;>L7DS17s?A7AyGvyu{n|i=u<0X7ZU>XG5G5+ z`8Zms3wRdhfsAYjy7>Ua;8)Uzeqv@6;;Y-*vurL_vIk90P;_3nXW#Zb_7ChmJng3t7mg$D;pU^R z!Fzpms!V==hF?b>+y8yjI#Pd}fa;C)&VH1>6R+1zT7%J2hI%CxqrZmMo4GuN*0YK5 zeze|kK=|G|Cyr3Ua2}|@ikyeX!E<<_)j-=1d>p(6m4Z+r^$Fttxu1>L!vQVST8f zEsm?@pmUYg&beyA({O#&0%NNSADDL{E4RxbdoYTUhXUi?0E->LsT%;7_Hi z$4D6H>U4NC{Vb)!TpYem&&6i0q4U;oKJ}Z6pE4<1Utaj%x@NAK>I$qR`dGTI*Pe4B zteQPSNx#k^g|i~`Cr;h4*ZOsx6O|=~IW53Nax7KaX>^`ehEATmFPbU@cB;~+uW)y& zpNwL=%fu-Pt2eh@^G@Z$)ZI3o2< z?g^ktvE^&q?l>^URl3S{mg*2)sya#HVI%=c079JxiJ%Ibwm<# z@{17vVBV53UkiiSXT2_EAre#bo#;5KYhQbsF^s5(5f#?nBL(Zc^{XUCz~8s`vCNbQ zZ&GOF2vjr@P&sc4o&zo}7yxlMjp(+(fzkp+{zyTqq=#l8+S>t14-Ig7KGWJKg0u=Y z2nxejN%-~o`i!lV%k#%;(X|)~=w^ovA8=n{@q~6RzWH2ye@bk*nNqXWS$sKlp!$dF z61b}%&v}+=Q%0O%Fl9uw1R4cs)Z}1M6F*uI(1Ft?&}J6#)cY5bIVBYabBN0!sI~1F zmBKmz5ws7)gD32~nxa#gfKu7!cTlQ@C$j!DfSng&KJ5vdW9gQQP83 z@s^<1cNgz9({n%1Fkw`H_k)Ax?PYKZYb$Gcstz#=v>Z|%X8#s2np=;ppudTydqXY-5b2>Ojzj zv;zUAxHy#mWINhP>>$)}{Qu&GF&?~Fcr=RKiEr3JXo7=M_+ba3170`j%YM#euwI}z z}#;AX{oI2u~>5Eu978( z3rceL86f{d!{Ll{RDt_M51&iklDBQ(}FS8#emK$QdsY%a1X*UW)nz1ah;2W2O9ffT`#FHoNq&7 z8sy_7(|-}9m>fD7KbWx)LTLfi5q1qwc5|C~tzno~1njIw5v3CWTQ>-kfY|f;u$F|ghF2zp3Tdc*Ra)bKhsg^(EIfB0o zD}=2CG|E(8#Pspmd0>7ALE1qOG248hToSfDMW;J0wjo_EUwFeMm)RC{fGOQ@(zl+ z4w$mrZGH-49&;P&NX_$qn$7=dzXS~P>vA6-m*85Bf>qa!Fk(A0uN#Y-xkm14qhPi7 z*2@slNZZuC$vui3&k|!!S7zgFG;d9W2v{G=Xx1Z-3ttYG3%{@gqyLF)J?eMAVGY(t ztdlyWzG>`CNg1`No~6XU~~0!YxLof+_jTl3b%HpsfVuI8ykBYh_CMB zSsdUR)^Sp#h`Clhi#Q;WAaU6MuJ;t=5l+Ku+NKsGV45}hcpyO&;Xl0o2%TG5sO zCJU-d^5keF2|b9n(;Vg#-5kWL@T(3F=e8Rby}je-90V#)U9t>aG3)}=4~++s3CW?Q zFd*}B#Zw)51o%ev*;PG#&#TiP9ZG*7(_Ts%SJ+(&#SIM4X|hDj0I5}ZTIv#U_wkyR za~2U@`P)pBWbQ$bZo7=bjQYFHaAe!$amzGUf6t)a({dh$02!i%+2Ti4lnC zuq`w>9l=2mwrS5A^IE^^Bf{rMgX|@qAVvh>Fo|&5>hKp^BDf_9S@9QdnH%Wp7$^)N z(3xVi1}>Dd_QQNd4TFTcL(I{ z5tu{c3bTj#nmYO?fTUeDVPXg?aO^5@&~~*^$;yW?YBBy%TrOxOw7OBsI>?kLO#9S` z;gu8C#vA`JwEiLpE9ZiTwGj<#-~c0viljx*Rwmx9V5MRoAO7OT z2B1Vt-3!fIAatFN;)Pb6_T*jgIh$kl0;X7=;9yS#Zjc~{|>0O!; z^+ys1k(R(V4mxG;!>+!?vy9qissxmYJ-!s8a-8+hr7G^p=s^N{2{5ZC(1HTCo;;dv zGjS9}PK#=z@L(}KB$BuoYYu^kLtH~&JBK~Mz)q4$M8wr5FgooK^VS@uj)SBVUl@)e zWt?^_cexSpJ>sWt3ew7$FTg2SNhI0%jgl&|GZOO`!S4ugP>$*e9s+!L1AKmy_za&n z>$Vp02K<0_XlNdwT^bqyv`0gW0rj9kyuLswpgwr9!7lZ~O*}&lLF%BLdc;o36SOu2hsk38(9o?qR6#pEP**30r{83sHtd)+V-Y#^2_ zLp?bQs+yKrjEvQdIZ_AHVDlq%U!yHXKmWN^m~yNTg(mw*y}n3xH1*w#f`k?s@;&zi%+_vl*YupM?5{D7%nK0_uqH;(?F&^ ztOC`I;R1RhVt#;=fo5EJYTzhL$kW^y)R@_YiAx)ctmaM>9QVr?g{`J06gQOLsA=`W z&t&s1vYN;ZU>j-*nNcz=HrZdUqD5oT-}&CG6@D~Tp&27*BWx{BUewPd6r-iG1;-;I z{2+L`fHBHMHm@VnLW=}En%_-SW{O0UyzjyYJ;%ru_CS;Fkmv1-02DN?p7|%)$aHkzi;IYMq zY6pGGAzp{V$WWgur*Qvyi?B#DStRKY%M`}63?*_3LyMVTR~U3k!}o5LN1#8fUV1Fc zgHz}jIe0MR@kS(zZ`0yLtv?}$lT&Gy)4=-HQJT#9Eh5aFpfJ+=+tt!V$vX8;t|2e2SXB&8S5C68V) zIjpaJN1NBPrz(z(HFv<{n{!00`DJ>p^{+(HJ(IS!Nw@jnZ;NyM(zp3T{MZQ>n#(#7 zA=tMeXl`x&D5Gy}(3(4;&wR7BJEL!Pu=S%6!M?SvACKs3Gvk~}v0nf6y9Z-C$o*3H9%-p9Tw*mmtiZH@NO zl}H+Wj0Nl&Zn?VD0r9ca^mU)$ee8{3>&GMIM#s@eFI4@mxB5_cB;ra&bSmtJUsqWB za*zlRJ?8G}xlg_VRnrB6rx2@7nTeaH`jPTaK4w6V+V;_Becq)|2=3R1r`^`mSLj{3 z+PkzPh+R1SBO>=Qm4wBO2wN)-g|p%h!JmjfK}c4-84m2{wZnmJyAA?Th+2UoSaz#~ zC4@v10x|87B{~JYAXhn}7o8}2w=|&+`J5e|{DAtmO=>bSvd@+6xKoTGl%MweP@P!)YAyHhn z5z+?NCrGS8G*;9BdF#u#KhPHX2czJ2296S%5d~s9r5?Fg&bsQ^N&sZ41{=V30U$@! z5CCBq#C-M40(*H6Mu%GYThJe%C;}V{7`gc*xG9Ruqp9E={`h5FtTpRdYKU075M9lh zy`xWCh@(ENUYc~sz1Qxby+e@0WINi`)xVZ+$h;Tz!>a^d(7JHA#ME$hIZyO&5(T^ejvjuyd9Yq*T2<~NK@7@QZ57xWr@6`Tg`k$wt z6rV*>jUt+J|BRDs5V1nj<=8acyfq~G`biAcPjScdd3B!r9=b1u0ORF1ERem#KSq9! z7swC!3wm-El{=R;cVXrz>rtU0K{NjKpEk`HI^OG>*T`C!tDr#gq}P{_F=pOTC%|pq zBSMgibOKAp;}J!#0i^?B2zVb*4jgD~egSBYhK>Z3%mBI!0s8>&aFtd><`LYEHM0hn z=G1jJa!Ao%^rTuE+0h5isD^9Zm1RD{$3xLNE^DeU{TTqH>5~2Ie z(2hi?#tdyqgiJG(=6x*Gmk8ai?*5pArRaE(e=SCR=dEGgFA}LMiDEz1<+QZ*CWiBj z=k=g>=_erix%5E$$=fU_6x#gTxCLPsW>%-p4+4H{*iM*NzTU_f?FPMZWt;1isn& z(a3@~t{ojh#YZ-CYwg~v871;`k7g)#mHk^{EyF4EG7LO~3Z5S&?_Wpq;7R_Q3X293 zP}}|_eIR#Nz;%BLK`QhK3Mm+b`c?|p-E;xC?p_Qr^)}{=FvMD_Lx#DIO-inN6FmS> z8UQt4;jYDy8@cC5;*?0@W(-2%fx#3*yD?(E;Ih-}Rrd;Er=K{4Of*c8Wt^Ku9|vy6 z7XrksPH@YONM5+*80U`HM{e2V!~qBF_h!Kag+Rgon4BvZ-GKmxa*VTu>(vQ=Na2Z%*r~jBN>PlyW&|ntc^Fwx zi2x5g84uoQ9=ILHRY`eB3jh0vbcDnIvP3Ke_+KN1|J`?2_+JzkOQFsG-fi>0i(USg zok;fTmk+TYQAC&j)w1~a7D-7Ab6zJfDUvhK%Ct|Ipgzc#gH{0BEF=RkOgJ3Ho=@0gq&LkZ6 zHIi+ny4Cc@$6#;k2}HLJORSi|dVwA&W92^i6G9+QIYLM^7kovN1NJ-EOy_JDoCmNO zdjgY7^TlL5IMv8_6e5g_2aTxX+cNZbti=wG;G3z{k0K*d%#`*=QQmv+D@~R>YeJv> zb}mn9&wqUdCPeN3u1(zv)L9rVjk(k<7@5Q05lT4VUAlG>&i^YW6zAVYS%J5{)k?3j z?s#_TFpo8MGPMV}<2$5pHT;SALPE0Q4RD~9C1g}vTq>%A^*8K|8* zAs-7`9z8kyAzc|VpEZRx0-;cfsH*Qghpt@9;Zo(mr4YE?Vg? z?TG0PieT6ViFy)Mpzam{r8ZtB?V?A#P0_Jc&_I4P5N8jIRjfYSW>a){YMSaMNs`Wh z$}X0yVlF*<@w5oL2+lJp8T|M_P0|%38TI&?Lek~azxGc;(g{(2uJ-fDTAi-_E%Z;; z{t}M;!~Tc(XpI*R&?KESf8$t9(g}klB;7NoX_Ah;t+MKcq-&->L;D-(-?q>p>9~53 z>ZsweHg64AnSLZ37Nx-1LVV<7bSe+gM8V{+m+b|JVp`b&4f75zeO!pZU9LUNA)aPX z^L}^rqifk^^07fxA(Z@qRa3`aHo=gcxu-f9P&~o_2(Dt7KkBZ=4#Ja^q_j_kBCBv=MeP3Cn)Rppa(WB5qjW~0~~r_8gC+Kdf;IJ{zvox$pM=h0PO(j zx!HrBB9%}|DnV1vno7vzR0YLADuDztmRD#MF>D}}uyOyPsf4}m-DN7_fLk3Z;lahE z5>n;k#SciwIP`%K>p~yg6-d$t=Vk2zeQ+2G>e2_x?$GqXU$6|>@^K;Zv2UGw5Bqg6 zeXzDsN&@kU5S*P+R^vpxoYNKScL_BlS3T&^1-?{p!6FCjcfeG8nBao*9B>%y zCYP1n+@L^8kQC*khn>WV5fn7z3$QZc9t1w9K~%pGpY&LD^mu*f=S6SWWXPH%8DjoJ$dHAbh9X1W z_+=^?()jlz8L}1YQT`I1R5(P)E1C#NEcq4^WXU2d+MqF-;AkR(tGG*oENR!l9d0le zd<1tAo>-!EaE}{Icq$2k>e?j8e(>QuqK>FTk{~6pQKCr@i4=N5$GEf~3G&>p29O}j zY=9JqB*-EHh9E(@YWk5N&?2E|D?rf}e>4fQ#w9_bD1@4OwkAPfS;3(!1it1Xhq7=; zkYC@TcO9%u#r;t4c2Q~SScs6>8n?*OYRoptA_-raf(^}Xk}UZyHiuEaw2%6QQw-}I zFlWRb1#FNOOiZ@)UwVbWX-*+3W1ZiAW7g%(EbKyo=v~VthoGfC;#K`u>Q_l!)0;+ zfs;z#_=zR-&6M>+&^KJVZTjZD69>>YGcQk}ZyFFfkiOYZO$HQ?uOShkZ+4&i-RK)U z-!_=OQR>4J2GKX+{9UAP>VAv*emi}$8_{yRzMZ~liGaT03A*|e8~E4JHy@)S--Eu{ zu~_Jv$XJKIxx(YpH@6G${~>)t@@4>aBUFS<-EiCgdg|trJ%^@lezb6xshd-7aHyL# zzt=L5RQjg8K|02vZ-fZZ@{i+_^v#W#yFlMeK~Y`$=Ji@l-@N!cm%d@Aiu~g@?AO8c z&3kuANkHF_5d04G%}vw3jlL<_0{R9N0^}b~CK(U6IrL2(o{#0HnSgT|_Tf9S>Nxm$<4r9&; z%aboTkb&*P??LG_&6KcszUmZZP45oWoVp3-y(~JOk4Tk0 zzw*jgV9Nrhv-jG}4$xYs;nWVA)!1siXgv1UL9dd0QV4taMf$oZ;)OnNyooK68(%~R z*ZN?QZ_bEGedfmQk;{-D#9foE^dqip89#6J&ksrWq^-u?Io*bSh`gv@}4yiAbI949Uk=l2fE#=)8E zrRZh}yWkwz>L$GuvVuZ8m8v7Jw|74o_x-Ss(b#wj5WKmKzN6AXZ;|1Xl6cQ$5~R_E z)+$xc108i@=BQ|zt@J;6OZ71(aG%SXuqVLu^j8EadC;CDKahH1#aFFdq0NPBHL~p+4+`DF16EL$8e1 zgi}6JPz|SwWXMnd;szm{gjfn_zYt5uY5yXuN-9VDrLv>%7Q!i0{dJTkoTOXkgOjN< zOnovhlA(uws0k;I5cS2aLO3v;s^uGx|ZjshuzIrN-jIJmV&uDaZ06tZWU|3{z zfqnuD1W4LQU&`%*PaUQcZKr=fooG3RjwG5d9wzFCPwkk;M0t3t<9i5vPk^0nPA$yo zMF0_N5&h4?kCOT^3?xy71=u!i!6p2U62ILAHW7G-0Bc=fIe~L^q9yc~3xXjCsJ+j{ z?B!N*mW1}et262(@MHm!3fI5}0&{elQTh)MgmOVZn)xoKpP^qxrSdM&L*QlscDgOn z!WMZMKvtgqcKWI8YjOJ{eY>^}`|rFp+$O()z6}sd=-b&XL(sP#G^|bEj>sE8-&S6j zLf`P~8PXMmbDJJIDr-{#_dobMvPBP%&be)ql_jZ_E7?=C-T7wOxk+fmbXMSNHh+03a{Q2>X)4p(?7VQNCTCNu^)mCaY*3S29Usg&%u66 zZ2Ks0%@iz!5o_=L&)(c;T)Zl1R^OWQ*f>u(ZB<`a(EDUZa9&p*)-))-kHTm5Sv~0s zJ;AgV;`O}q8+faK-IKPE*TZ~Uyc6+TI}8%xC)?e4nDZVZSMQ6LK6g3qN$Yf}aZB6hJ*M^Aaa+9Sx59JX7^4}zz<*I}MzCTsvBgMh4gUw_ z)5ZHwo8&)l5tem!;dd+Wf07$-xcj{4w$S|Zu+_LH)coghp16yPi^q8a z_@;j(-1qVK0Q@(=b(e-VX)isb+#kCNVclNy+mTm5mw#YRbFV-W=$N;kqY& zx#JaU31zABJo7;x2WAym10SRK@Pd1mkV(8A*~a@XxOD}6$d6D$b3q1?5^zwhzEv;? zk{;WhdF?+P0VJ!ht}-17dLFQ33jkXOZ$GS8>m01&Bvxq(mNcT@O^fu5omO-p*00>O z>XKNE@D{>01p2Vh)MElI205(75uv7_sG=@mH32bkZ!>>aJdI!T3rIeJf|)X&>c!*u zGYUG!m3v#i7~bs@UC{2`%rCk#MDzCl!`H5{2jj9fa<))h>{`X6 zgGnvR#$&_;V}0q~sjX?Nt<##t|OG^4b3aqe$OC|R>QduvK&J-ay>kK_$vpeS(u${3%2U`z%HqFSGT%sQ`t1Uj zZRALF#+!s4W(WmYC~Bu775_~0dJ(*Gg}C}s1@&uiXz=IL|HogkK9=YQoT&Z65gx7m z!Vw;<{USaeVGvX zI#yt~5tEbKc`J7Gd26^~_v7T$Ubs42r^XDtK%07gQOdZ&-_3t~2>y=pKAXQg?BD_X zU41cUi>;s0d62{3v65PoVxqbgP_xEBvj~4T{o?P&-{qp+2Jv^Vs)Ms1syMKLI6MSnEY%xO_|T+HK`Q`#)%{|<;3A#^$Y`M2PM%?% zykW}bKC`-}q-7i~hPU-~d6#Ad`_=_x+km+MnBj|C%>^~p61=hRE$@@b;H%x>CMVcT zhMwVu{=*3+vxZ~pRh!QRBZJ3E-HZ-#aWh+44rVl~#fZODHBusU?+wl8*xSR57nQO5 zD%)0JNeeHGwT7V9Vz%;1MXTCp-rIeBw_v}0$-8txe%ArufByEt?83B#Q@gU^r!ov` zeW=G1y`^v6$>^R*&Dg!bh%9XRTUTE@ad%&}%rh6DIFekAs}i$=yRVvEct{JFl~uD3 zX`NkwG{800ubv$`1b=A=gbpfngwI=T7a5irM6YJG6dfn-cCZazg-Wn0c0G{V7H&30@mJrTDFf4+4T!hT$lH+1C#>E1AT%i4u z;{rn_IW)WrS8-%uT)Y&Fx9FkajEh!`iw=y7)`8>VZx|OZVqEN{$AvQ<*rq66va3@A zws_x5?Y@-BF~Y5Avr|zgV(q{j24*?%+i(ERRQxZSLQ*lOY%(?ajeCU1bdcfhgcN$8 z9LDJn=I}*%j7!fx-S&_*40D&6r!m*{ka@RXOF|mbQVZ)Nt5f<5lXqeZO_JC^3N5Bw zurI6#e1rT!iZ3xCgb;%!{gOnAvs04P*!{CfNg)N3Y&+g>l0dga&_r{pHs@cuTE12G z>M59?4pA*MU%zT0kujS}Z$h0|YBNJzKgmsA9}$P{jyLsX|H$DNxMP z*{B>xA!h7<$8=?ZoR-F19j*t(?7A_}jPvxY80VS0Y@Fu;{GEcoO;3&U9E!gT{3(P# z4A`2d$9e9+-*&*#fxiX*ckq|${}aB)B8-2;4ecWC)4=~N@<>f9)&HuUCeyuP`8dzo zZ@^uN@YFK=Z&%xgc`~`r! zc;z@xHvX>0UpoG7P4T}9oTKo4C;qg2D>5O|wm%`}-kXJA_oM zIgZ$U8cwj163YRA8JLEgFcV_}5#{hOc6*7D9XZ*b+E z958H{?d8bvo8_HJeb_T~@gVP<^9M)XNxoE!qtiep#dQ($Eyz3rY>-5~IOd8{aI`o% z?f?)QoP9642VYtgT4XJvx=1iTN*$4iw{UZzxh-hc&IJagQ~N?X<&Bpiry{ed1bk|d z^$c}Rx<}gIVJk{~Rft2o5XH4p@hXJ~W$N#v#)4*_Pi+Cix>GBw5WWg69^Vb*HtmcGKj-xCyP&3osWTl#jIrv#V56b_U#AjUNRX5Pl)s;VVl^+8NBqkkCe z3jl7mQ$EVq783Qv$jWKn8SrbB36zl92a$xOw%de)BvHU7HSGJA^;XNa*4HgDqV+ppPgWgbUTDz4V4yJjm(W?^H z43xbYa{)3&qycl$TZxj0mjF)N(V2ZM`U98x&j$<~eQ`oxc*%IBWO+d3dcb*lG5EjMKQLdw(xd!QP?76qU~y-I+jhj@~Y zEjS!=K2|RCJ`M{Mwlaf-JkhZ9IB9xyM<0wqWSQ$@n@3k1NTKe5)=x5U4|GRHg}0e< zADC?OhE|)M-5F0IFAo&SfA^>!T)3oBs&2!F+1u|%JU-A*ay>q&)1t?xt*>E4(Gcpi z!?7-5^kKjl_=Z!WoiaG0y*Xdct9k}Q%pPT$=V2?>}n$q`cOi}Vwqm#kCK zGuS!45ah#wTxhOmsb<*bg4)%=I!6C=IeGoiZC0NhyQ5E}D+E*wui>}rIi95t}UE54u&1~)Dz(JBlgDMnbf(T?NMX$)vKK=9wOPQt?c)3YHvXvGvvlcsPo$VLV`|iiG*3F5plD8U1tM=j(zv z5Mt9o?3r;5HufPDw6VK*qUyD}4=||PflskBsFOQCxXH8p7wA}ZRTadd8tX3uvC4@x zfml<3rD>SJ*|TtuyM@3XUM=Jc=!04J+Vp|GmTlV?Fy}R~6G-0NQO62W&vYY5%38#x zJ*X;3Q`M%?14OCQ3OHmSN~K913!$J?Yg!P0(o0}lVY~xf6(H;hNgV(I=ZQ`SF1+EH zTJp=iKcfvW&Pre44zspbR2j`={IXTp471OqFN<^!i0JKCdk*MdV;Wm0Ac6TEQ9kNaIoMr*@w&?G(WBa z{sZer?iOM|;1wR)2H&WDup3sTwesHOvxTq)kRuhM=|Aj}CuPAX?QDSzIvtq@>x?j>9!A5odO~OE( z{63YIM#2Wc`VRW0B3edNfKxRCWh81EIZkERCu$bKkNw1Epsd?D_5S}>U-J5*>?Ei* z(MjB2&W&K8wZHw}$wqxn37b1<$;Pp4uu)xfNeb6x(AwXg)X|Hr2?&ejnE1mDAgo`r z!wz@#Ax?vm+?CcR@zIbS?DzUn3T2i_Uu$dr=J3QYzR?@8re(r2s?Ffn}5 zF>9nvWBfJD8kq!%7#*&Tbh2V}Xj&nkSN07`nl8fIT(gRiC(6(dzIn!&ZqSb2>IWD{ zm%%p4{-;?|;ZpnaclcZ@bsU^FS2R3*tX`Wb^z3zhHhh3BwRTFjw)Q-lH-?`?I3U&G$BYFH{907)H9{q>Uqvt=j^ z=GSX7lKlE~5ao5ox9BI0>q_C*A2~kr@#lzktTOAh(ZS@Yn?txx6`SntpUoV4k$Xc$6RbbaiFNu`t>ZolO5{BCfYyZ#y&cQYd zS+RfEsy4N^%V%j5aUN}g+>$SJ`r}uO@sL3f6u(Bv(~hY#?>hz}f;{}uF1I2TJ)OB!g4;gNzZVeiyuX)zjGY!MWVeAiAjVqHC3 zygwf{+xr#Q=3(#$efCEXijzMN`kgO7zw(?fmud?nkXGH=Qq>I)lWB(DnOB-h4nMs^k++v+^y8ASZ4r~qF*J} z9}CTmh1OKuxzuV#%s_4YJBURm%c#z>PG{MmvuqqP%gw$)S-uKTN|wki*o-X;eXa9j z>guA@{K|BGRXV?RonOb0`Tc%yes%rx166|?7wJxJOj~{OdP?nzb#A3Pw=SKV8Zx(I z2IqFbH|EB)RV+2P9`4o<8R^`5b#5GHgS+o3h*<`7-y(p%sV$kh+Kc%`%tw95Ba-_l z`!n47B|zso^ZPG#R+@#8s17e4qxVcABvX{p-99! zCo^pB8K$l6+*S6KBCp7u!loE7DONKk;+_fLYJ?gj&9JIHkjC(YHU&q4-~3kz!JaHO zZ;aTs;okYH1(b=U1vvtg=AGXppwWpqE#H8l2}qOaMJHFka2VT$QGOfnaOCf;j*AC5 z&SgyGSgg}Rj#o%p$Z>`SA;(z)LXIVFj)ek3j^_guwr)Wk@b(HXtwix+A>N@B1GUU* z4`RYlYN^ECjvRJE4Mj}H^8UOL+m0MI3kW%sX%Oo4s(_FKFVmw=Il4}MI;nMn8B|@T zzlaBQ;)Mm)sa(=xE8a;6TTw2PNh`(#gdD3h7IG{X5OSOgQ21h8{T?01akFL~pW@CCW{_^7lP9x{p@#H6d` zLLeAS?_=q;kR$4EqpuYMH~rezxS^GWbKfvpcOX?5eyr}srVY80xB6{(VCKtP{W?5B zbA)YMIJN`*xmG|^P~2)3F17b(Hmi!*0gk)rc;qDfyDsIK%OBUWL+X2Hw4huuwcGQiFI<`FrTWASbC6#_JEVZ3va34^2#tb~#U(VrZ+= zAlot#DSC6hhc@!2_yP9;(7ihjDCp50JtY8mHa;CXZX{YRcn-~1A$va6tU(k|EQy|Jpwl+= zF%s!*9ozy3WC{+UDA`2pcES^4Fcq=8++f1Z`8dw;#8f^GGQ9D(*?TMU@C*BHa!A;F zjko3xAj+Y5XzhLOftz8jxq5h&8V8;JTQ7lQq&?U77FzO6)MOKyX|gr?Myu|{ztU>m zw6qr!^{mI{%aMY2>3yVQ*y_N247g?oZa?2>jh+hBd8@)O%jZTA<#g}THCsFPUl)68 zI3l&BwO{$-_<5^NM$*Bw4m)ArpoGsEl<*Cy3BM^doH(F{tMM&0tonhj;Z9vcHK2yu z?sRInY(NcbkV5|&z5v|*HQbCiP7S+%f;zp1!#$^pY0pXZS|3lTUiWeRll_8;2>ZTqDeOP!P*lrVda|ZD};f*d>SBy9cb9= zl^iFKpL&>K=b&j7d63LZUnci>a*pz3Uw&QV=26lqB+S6U`qrkMXdQ0 zWDJN@e53>-LQu^2=_p6i{D__az2{YA#Cor(JQqpykIS{81e%wJ1aq*cLqc-avWWhDw4cLF?G8WWIrTj(YW$^&iP(faEUK0dB6WtSCk)&@ z68Wo8ooF5+A)f59R<2T|F3Gt$I?09ty zam&dNH98rO--t&f#LJ{($IE7j8;>FC<*9D{_>Fi(;<4xfl<`*;<*uc;R9^1TSIi$o z3^tq}cuvB3jOr%L5OrfRVSXcFA|YNr9lJmVL)>@_QKu#2@f-1o6kS2#m8W6`?q7(9 z_bY1+!=b5dGUu|3dmHiL)qD{YS^4skIY5I)$ir^Ui?0Tz+pMe0JTNZ;kUT$Di-*ah`nq zO@3z_gr39GzvbT$2t$C<)4nAc1P}AnwIbhp@b@wP#v=d!gEENVHT6D5N3kQ&+#0n7 znp`#(G0*gwXJ!_~U$R-%T5dYH+${z?@rYmL z8Mp;8-J0ANZ>d^uG!*4_gsst01YDOFGSf!|W4*&F_TcA1g(vJ*xp&C>Si2G1oX*p^ z8(z0FIkrXeQmbyj;Kh>1h1yRcFP3pR=Tf~_!zhupcW`n{R&l@D>w+v;ufKy4xUFk_ zNY@_t=F_Dz-)AhQ6!Ip@0eaK2bd3E+Qvh+!REua8~qO1zR7%e+R@GtTcQO0=KM?5 zU(73#jvIU)GUvmOF#xpwV!?`CI1d?t@?xXb`ipn-#0`fZci>KyeICM2C+I|!|69&O zdij19KHWxX!eLcFjd@%LogIC1KG{=3;nGS|OiIJDY*r<+kF#<`9;v~if zwWo_wn#3rFmqqx)pDBoq;wxyTPoQu=3~C5cSX|3@I9n(_1o54Y&>8e_a^lzrhe5%7 zoTpWcCbpl@vhED_D_BeDKM+u^1)R6<=#xXjl^AQ}pCy|!kPFVB^|=B-$OHVBdNU zMPZgJ&aB&nqk;!MlGX>qhqv8r_DZX;f_w%g=CD?cI0LLp%xp}A9%>7b-i4X0#f+A? zsR_h4sa~)H%_{ige#}*;%CiCO8lzW@Cjc~iqf4{v>&~+#r7%}wC2P_qjIX@f^C#rs zZy;|~hheO?e6?M8t0L$%*=IlkFWB8?Vr*OJ#cH=)f#CJleu#Uzh}PL+8>?8osTnL$ z&eO+Al4R!rPLkHyViv1dEdeGf!C=%qTOIn8utFsLKmitG8BmW;6;`N&+)?6QaZHPP zY4{Sy)K{-aEuEkW=|t=L9NUAtZdcVYRp;P`WY8tE06v=i&!0t=U3`T z?dQpvI#Bz0P^k9QeyQtL@uMB?U8%Lzq}|G&l%-tQNXV8Co_! zSbh30Qh(e|h5CEy@PX9dWkXSaHoX^Ib`U0vOZ7P+P%VtVQ=5!~-C+oMwk@om#niJwr zhDZw(x~b(22wCpN2_!?LaE%BtOGYQ|Ek=MhN7@a$_6&TX`QlvN*nF4Z+l;f}>{Bmk zIDPPi9e@o-2{I(>lD_VdmmeZQR{;nlIg$Vy40}T{6r}5jXo{hP6xzs?BSE0dFy-VE zK26@4ZGrq1&5Yv>$E#kmq=db7nK=eQ75*7qk2^39#;DP`t(%5K~YzVt>AhpA;zoBr&&5uV=vt1}sy*Ub=$^Jvqr?h5q@!F)c|8{qP-9K%$=rUFXovcv4QSUG zJ*u7nkWV-evZcqG5`7^jg%bS+!#iByu+a3NU)1HFX-X7gbhf`kWJ=hh9-DOJdyk?7 za-&}$K;{JMha7d0ZNodos>sFmaje>et|Wa{3bsv^j(4#+fcs&O-P0+EZ5Y2;eFD25 ztiB{%yGu`iO(mMExa>8Taci?Zg9Y7w8Cxqc5B- zjpqZUR_;sup-gx4JFoUZ-z;(-+G^P5sA*zrdtDcHTVpJPys zgdY}ty3n#>yJnGiC{eD1PgPB%M7h=lmJ@if0J%zOiEm|X0&NgS zJYoP($xDg7ZqC>8{iGuy@V zF!XQ;}V^KfhH>UILp6~EJ z(}Ae>Ab#T=H4&)};5QPl?IOR?aRTc5?fgcVXuD$H)$<|v4Iex3*pm_EYxs?iQIYS# zZxlp?-$-wE_>Di^@A4Z{1^B-%pCxBeOwNLX)eMv*Vwvy^GT!>b$A{)DDktqSXK{13 z!&#)Cra6mL`D@eh(lLYOuV1{Hl)pap@Gi(-=l>-|{dkS2B#Z}ms;P~pvk)c{I&(4PATA=HLU*B~g* ztrJitm=g_x?%YxVK{IJIL0Zb&u0AaQcVcUIrsjJquqEFc#Djdx86Wxj+$=a|$`+Qkyn4tg&&l143JkdE0rP`r3V=6@Iv3hI@$; zYw3kn_jqqjFIVdQe~9kU<$pmP`!(f%513N^e~Jg?e;FQ@-|v=x6(MZ532ylx6A;Ru zOL)sV9%<5`S^dHPU$CwWP-rHK_K`2EhJ`&$Nz z?x9|x72RCkvEm)gJGNtR2F;LgS7EaVJs0XPzYp2+`w$r?%~J*QZ;}i`eqp9~_#hdC z0{pfas=XwGiYx!K^9|_p3_RbEEc%~sJO%@Aaz^k7co;b&SPW0l^r}Dnf}(y14XK=C z?qk2cp*H-S9GH3yx0=06I|sbUanK&F${jTB-np6@bUozOg#EEk3$&1AAr?7wSc5Ei z)*?Dz`#_o1u7f)m2d!Nz&t@QYr;e?3FqtbIOt_VPi&+%4MhE+wMMVfWvjuSWflrPJ z>KHFe>#V096VNhhs4m4Ys>BUF!H8N5OG-~Itn33dd)5pT(A-^Wqz#Y~QVVPA4>Ws5 zuCA2B-`2u98aJw4Ev%v0Gu)kbUo0y}RP`LBxm3bRk^c*P&n-fAg-rLLpiA>e_S0s? zAS4BG^QR7?%a$#5Fx|5U!F()Tm@Fh|ony0P3xJ7AFc?+!tDO&$&!}I735oPe$Ydps zAuU+ngw-8PmN=%hNPmfA#vApQc81oOY6gm{GbKA3<^~T6*nZ%2{VauU@LDxRUu?%Y zPva18kGV$$mC2)mg^y@Ps~AbBS^p45E1&)=f5ZxD)2V&OiNBM~)fVkXHQyX z7(nm;Vds`4y{}#vOz-cbehsKu^BEdI=>7A&-;Lgf3eaGBzgwMzR0q)ecdy??dcW%^ z)OP^AKS(}pP(IyE`Sh7Y7j|gQ1rGhz2+k^Gej;i&pTbBL=r%4qpxfx+GNBew3l|rh zB+G&$pcZcNC>v%AsGGR!?`y+s0d*~UUS-%YEk>|PNl$)qEQHoeW8BGW2GA8^53 z#-ivSgh**?+z@J~*69!_^VM!hJNQzv2}9qeI3Gom+Y3@g7|0-T!M zQhoR~Ztz#JRxo#7jAy6n#2;#aw^4f+!P}(0&G5EpZ#%pl;?=KFLHI9UvZ_Ffp$A_B zPQtZIJkzdhA8*B~Ps3AFt%Zq4JuDD*OTINlvOQsuh{i`YoJitP zp+DP%?34Y@A{@aS7YG)Dt4-Gq`P7Of5CpUR5G)H)o7^|iu?g4wL7T7yC@;21asvA0 zs3ksl5kCsYaNnBh*HE3KBq)K{9n6?V=%~W zS*9*@(K%20px=Yg(4RI%o4F@QR0|LL9cDfd?ZZyxr9HImapRBj;*wu{-EBEJCL7h zds+5l*&a6?C3|o=;Xl{@68bOJei4+;(tfFL!O?=x0;xCe*ITl5{^NJ)ExDG1Me9GW z)mt(LqBDMV~-XhCiS+@BX5F8eb#jDGvGv+E9V ze!cB5*;l^({JQCN$dgJjF4fydBFfjulMX~Le-C+5_X#3T+WCMZPde9ffdGYQ(uN7ev0SWl++-4p_BS{d@oTQbf`lwOr7b_3qH)_B6D-dgsv)tJ$$3DpROGq zNP#ZPuV^9(26gf|VYgob#>qOv%L6bzYPK!%k94iY{2_C;D;R1VT&QUYN zMcp&06etgV|7D_s;ZI`Z!OMk?=}_XOOcyJV#41j~BI%?qb+Jm5Smh~LQl?W~tY{Le z4qm6w7tSXku?P?=cKd6?u@NR!$^f)a@p9pFPVt1~;xd>y$~< z&|)3$(k3j7wQN%=m3`>dyCIt#0N8)B0n+$ZQLlQA0PKd1?s}?s!{M}y<(R4~ti>A| zg?!$cKJ11S$>*)BBx!kqQ{CI?FpKiMbqN--CX`P7>s{GSa9^j`zOMs=2+HR7Ql71L zBRrua09mf;5PP2H4uP$ySw3E4CqF+0TeiXyb+(JG>D&}-W2?QlA#K?SOVpvjM*Ue< zv{JUJUnm=!l1*CcqaA#ZY-~N)SYhOX4whx5zvy6N>(XCzu(26zmx20dy$IVieKgQJ z>S!ocQkgK~K5(6BBzBJ^pul5GFR`svq-<+P{Z4Od%v<%mAlq6V{psA6ZH=^s!^AHd zX$!PpG}5BlU(5l2iQuCpcE^K_+>fLi->4gSp0{&l%6Z-yS+b{btf|wqzn1>v=@&MW z>l3%JXR#=P&Ez`Pe;Z5X7Xw5RhG=&2H}i`lS_bfol^><>i_I&gzwOHi`hAF8^)ocn(MWXwzj*nIUE~*=#-qLi_(eH?pkf@XtyE0No+U=L{K#7! zOl-E!FER~tw<4Gt4x9N!Cd?=va9h}#_>57o%{zY{Fpb=86(`HZ_gwU>5&yTh`e5<& z-HewRo~20@FbqaPn|A?q`Ma}jplvndi%uHby8R2JP-LC-Oi{rX-kJ~a0eS>caOEM( zh;{9Ra&*LOQO~X)>*+qvz`?cAx_LOsozrm-B5Z!O<$t;hubXV-Zmc-L;N5#!(|Py) zewHl0jzw5)I7MjnE~o*#d&~{HQvxqVxTVUlj=K%LM)On!>*ri<)AT@um}g^tFW-aTaW<**L)4y zaDv5_HGYoAi#8v(W~@h@fy-MCVP(5X`YOe~*1x;uU%;=bH_j-6c!o{~^6qdq1_I z2AMZI=}uBzgUy>o_vuG~BxNjJD|x z{nY|8o%Ww_J)kFI;)Oa|YbIr5vo>N7q7JN_{XSg-1v0e<$sT=Y7pDY-rr07>g$--w zSb#PO)=ky5o5t(VFcD2WZ^M*^RS~b5FtGG^vMpW*07)}A{0ELY6V#KDd!L66ZDYhY zRa|E@Q{I4ory2#F-kQ6?&w2k0uKEBPWJ09%>XMJ~Y$eC5P7&q>m~h%^0GPIuu6d`V zoBMZ}VH?%ITR^rk7c2dKpfVC{;z)x)nS+(jJzJC#*$~`i$bD4#rJnU{2xsTHgfLTw z*LIMKA}Ro+F6L+eH*Zs37LSr8t2`9z znm4|k!T8!ozCN_SU?v4&Z}7_sb zrRuoT`IcX(3uJi}ng~z%_24N#;a$ym8Iv|e7UrCjifOA$r2y+#xE61Gmi>jo;VW!^ zX^U3{`~umHG8MI>TrD_=ZbsRf0B6~nShgl_P7w!fQ47e?Cfy-C?`S9@`JhJ}-VkO| zIEv+-C8d~P=cG$9&i>M+$h5z7DYnainu#VVqBb0uqnVv3Lzj!Ns;@&Q+6~kQ?`-eQ9r2bMMuQ|P?OQj@V*AbZ{(RMJ?{%H&2yC$f zFJa)^l)%iCz%mAsYe1~Ok4{PQDh5M=07wb+0Dlg*LM%=Xv8Du8P4n-_^oqwvmvA`Xek8@h%>O zpGl-HcqhFyX&qDr@FXM^pv>wqY^+4}7$1f?pM-4HPeKxHw%A|O$ORgi4G&~K8J>ci zn(>MQos4^u8GC>aC1U*Awmclx_svf}#(8ArxY!CVBN>%rU=^f$_u!MmHcx}uJ=h5e z)UGH;$WwvSVaGg*RtZ%1c|$me6q6uMGR-r2^eE=Biz%>`MeLASHXHrhGvVn8Rrgi; zg0ZjCZyB|0I$l4r&OD_%bJ-QzCuSE`kjtYWwgq$WGx)WX6d#!=0xy8W!BXyrquFS} z5uBrg^L22*4JI7Hh7K;#!KH36;i!(4zF%dUmA-F6@@x|;G1wZwita=igry{9RG3)e zVN@KV!f~}qi?T77qJ@c@vJ;^L+CqMb8JeIu(aIdKRGC0GD0ThWFukg?SO65OGi?A1 z0zkP65P(^ijcClpIkl|%3Ot6xiOTgRu^jp530%l@zji3F9r zy1nlyj3`#WayLBlNrdhnz%Vx4SZ_wfX!K^R7wW>H_U;kEWoQT7PLpF!9JU^*xkm^g zIcQST?RkHDACt^9?`2STHd2Jk6f=<=299kOUIxorXKm?HuYJCq+$Rf%X-2t|8arPY z&;~78ZO87e9@tYDP)Y(Z8blyyS`GS(4wlF|{Y3}6Ed?$hKib9l|JZvI_$aEZZM-3g zL83vmf95Zv;Ao^z`zodt;c|GszL@AsmeI(7HD>vPUM_uQ%$ zJRn)Egi2NFrkHXAEar6^tU6#U6|I-H7#GiUWbv&xgJ+Z zk|&kc9Dj@ENo&{|B4;gnLi42TSnBzK!jrPssd<`CCH)|1sDnn(BH(6cmzkVHYL7bU*d?4+ZQj*sd@ z-JDvOQJTlaU~B0IKj-* z%i6lSZ3$u4ye`QDdi^idxBu3X2fVCSC&QPj6LEbk#NtV~Or`z>89}5W%qC~I@mMGQ z6L;eTv>i}y5EiH!b1@Q)VEhjd*v9+_2%Og041P6f(dbWMYaIw{#&pJPhR%z&D6ZGb zK+aO`a|E6n1z*Z1@?lhbm2+NhgPO#=pF7<41lP+Vy{;yRGiDi&wLS>W8)bj;afGy1 zzcJX;%cm%TyxG_F(zDr*dp3iYMV3;gW&Nbo19MGQ* z6}ChChb$%ALDJHSEgo@TIP_=<{4-1<%^dt!FSiPkg|(yUv6FmU;A=%^oEdimlpo_y!u%RxiF7NMp^Ib zu6Xpek_#&?nt>z4C2UcC6FxPiLUwF$1c*jZ3xSpK7h$ptD;VJll0l8iVp&U28Ef#9 zlf$eE`KauYJ!vK`_%3#*)r|)Cv$sJoykBFq^}wrFo*YPeDG62`=f5_6@$HcG!Y-Hy zyPv5apQpW6(Gt&j-3JMaLy^57dax}v*T#f+LnaZH1v zd+|OL)d2Z?4M@cIAx6l$Pii$DtmkJJLo{D+PI#dy*r)-~QXS>;W~}mD{V+APs53ic zUaxA_4(-ZsJ1}R2@TsHd06G+!+#>2rw#7rB6lZ4Ka3fdHe(!sc&xBs%{hs*wt_R?o~Aq+*a>?iEDhA$^gi z6`EC@sc8|T2Q@7pJIcrKsEC&78m34cKX`+NDI?jA0#g>%YM8?2R>Qu5dfjHK}U$5|$40$RX5vz>!aXL|2Vv*aZ+0E)=$Isq6|Q439Y5=kL<>m2PZ}axaOiAN%;c@9n2@J0<>cHoiNj)3;u6gD zSBti(l$s{u)d|jGY{VZ=ZviJ(pT$!DmdRzd@(w>XKJV~j!{>TO%}D341u-kV9hHV# z{qnd03h~=^=!3#sPRR6fed79N#D_O8fE1R{PJQzW`%XUyN+=KDvN{B9il2%U~?La(=av_{3xjJ4_(5!rU1;J(VFc=uj4- z=0;wPs*PiFi@W*3NXVK10bFy~x`p!(nEkjh7t zW*wzPN7;Y}FC%Q#&xP%H2611Z2Q7)`Y#*Muq%e(-iuvhyP;i;~CmDC{-Grw~Nu{G$;IJE_TPHzlZA2|KLd*{bMkPd%#eIa_L%1^NY%p2&e`EU_iI8a!b zp}`Q^6qP$e-^_v+)UVzgU~8ju&PcC89O(;u5ra(dK@YJnPr*x?x)lS8>C0e<=6I+q z!;5YUFTkD%w1UF%lI!PR5yIdf~-X;>8Z)#rKlz>P{In#=(oNn7V@2raa!Z2sK_UMV(NGt}Tj|5JtX5 z;d|3a z`WajIW{?56Z@^o=9{djl?pMA^odkZ-SFf|~Iw&)z3#9CPh`ha)RNQfI##_jm-zpEe zxDKTPEE&mqh0sVpIQ4bK;n+8F-YGfkib?}Fl|g$x1z%-MZ<5^21_?cViM-{!Q;Lhk zoOEiC4L+Wk2CSLwct8-3znEtlRo00j%2&>NBY+gf*Mvr_JFUo4-Ipq8TIeP91ga!4 zi?++7O7W2?7VU9HkBA6a{#}uey%DT%a5KpDZx%?NX#SC<9 zfu#AAbQgnUI4~vo9O=dCf=9oH%+EXHUo0hZ#slJcmRWBQCTXE^4${J)FV%wMBk>lB zk69M7-eJA{S$0!tiBR@5y&!NKg|~b+y5zj$jed{*Wmq}9apzRAXM7SbX+b4bs^?eX zECWTOC?^~-U1NrRq{}g}tn>cCvX<;-M33Mnq<+pN#Mm|9#k@#(1%CJ`bzEvdaGn&j~yTbAJAh5=)Yc-9w}Gg zN+Q^n9SMbdCWPG{FsLxu)bP(?cv%MLR5-Woh1Mg18fLa!kTSO!-2cFQdbn-F60IQR zvyv%0m1gm$T7xUh!FL&*i$ggrlm9Ir)1W`5L4QoAd`t_1kKT&xS{Y9^ft{_aK}Jr8 zw>*Xc%@48OH5Pr4!jbjYSMVKBJ7k0;EQ)g_>Y|TR!WIvi<0CpAhsfKU%kIx>{e-~2 zdgfe-v*_Ct?wOrwSnqfbWEYb1KmipWXjp?csN+*LJ4b-PJd-4zcSw?V$mzaLDD%Z+ zU}fqeEb2%>*>W~ae#Wq156YS&gVWZ{IvJ;>A)wwX+Q5O5QkoK&FMVKZZpAZ=C|;Lf zIyhr1>4*YWRM8#Y)!MsOd)K+% zbcc7n_HNeREv`4+@o6O~kWjY`qzx`++7v6oU(OFru}PpZLFJnNECz|R3_J{nA(Mj@ z6oMiMv~~~&f^PhUpc{X665rurCqa;p@m0noV7mox>e0=bO=C&nmO-~WZ8s@4c4z5! z3*8_zWgbXEN?{+ndG=#s4k&S=5JqOanvZTPg!QIul41puMPfsI*nZXzSfu?NHU0{m zuA=G{i46XsK`%5aN)y4TR~b)%v(vMFBQi%7kSD>T6%RsDT;V8%ucEgT>nv!hP!VH+ zxW#<@ax=zy!b0Jfw_s&1?*EA&`G>`-)46}a8LazfS-8NGA8Vb8qj;=SBYrlfvp6eO zjcJowJ3DPzj5Ve&ry2@h=A-t3ul4}CIn|GRv*2u<3L+cCG7(*SBF}TcdAu`Z+&P63 z=!;9fa3T;v5gki`*0qY;CwpXOJ-cw3+{@dQb3Svv7p0=uo$u8H4tUxQ;AXL>Z3Gdsr_EQ7xSqD%>oGHX z+6M9t8782ceI%L}?VX_?*?8z?X9)B~dOOX2`Wk2>Rk1%n#Ijm_^5FNF2AZk-iCb3m z{hG$Vzv+b5U9@Q+hMsJYFrBtEU1V-&cmvO&<6&o`+a3uLK@!YNr638gt&J=*1>vkc z&0$KF&fiS7wa9hM2c_;8#|+oeN5@%kM55BCBBZ0sQbWjp&_4hG#C1c+O z*_9?m8__d$kFMfKK|=fz_3R{(Q1HkXoHB@2bGK7$Th&O`)qF-CI2EGbG>dpuTX(^;UUmm^FDXpVcv zDVHUBV9)i z9iN9IVkss%4>Z49@mo>Cvrxhg`EHgFs;R?X!W-t9T^vTQKp-{y3-|jaJ%}_J7n^zX z{p!BYQNT)&o{|G1Hx-cWi|6^(5iH|PxN(E8Y3f(<+M!=t)m~EAyk?a`f(%xi91?{) zN!!43;RakxM-FqV&2ewW9eR~&*g=^8)n|xSsg(SEAAeV=RpPr0e^*uRd&&sUQ2dsX3LuPXI9ugh&94B6d*^RejSLSx9RlddtS^JLdjB-Q)>~nJKUDq#1b0 z^#*Z-xs#jIY1Ea@06wICOh8r=k?8|OvA{WS%Zgn zRIo0{Y27!oovu90H7c(WPRqTcZp!kGDupBnXOj?%k`L~Fd57fHE9BW3O*-Y_5;RR z$+c!~ywZpx%L8YyFL}K4FpcHa!7u_Y$Xis}&TH^cYT!d3(ZjD_d37W{IIjj@)q>Ax zMN-3w@cNQ>!yBX}zVL27s|kh09v5^83PMRs5dyabe+8~@Dm62+xY5-SXwX;Z z`l0w@=O4&<$-F5a!rwZ`+|R*Y*UMP>ob9emb<^#=)N$Xujr&?_aL(L2Z)t8)yWZK_ zUJCqO0?{0FK_N=PZbmLl*QVjxHPkVu+#)8rqhP;|@%CFnRvF9V(E6wrbAX`Q(_ z9aD})7vQE#5vLC}SP|cfS?B1KvZ+?4uK5eD%kmvF0`U;t!|0Ihu>S>fe(>Hh4NIh9 z#!r5qV_5Rn0 zLW!xqJeyBWoieU|roHpFWRbUynL^cDOz|n_7m%VY{gms)k@j@7C{LR+mq`K4Bn;qC ztmgHJIrBy#jV!owHi4@j*2!D7Yd%~#dBC+0t};((bLQ;MiRR2HEv3vg%P?(wodhPP zm^s(0shA7xVZ?LURehgz+T#_(0XdpEeJu+hnJ8xFVTCVaQKl`If=xnq-LD@fEfXp{Hl4EnA&X zK6u%o(h@>R<~eR!SzV$0JwrY0rj_3ns!&4dZ&;eoZzzF_H8+C4J#3Ah}e#SL9SkbhKFbHu z09@Q7Wz?Sm6O7~4uv30VQ?OcM1@F~SZmOX~1mUsJ*Q$Ho(7l7@fJ3vo)plUca8T+7 zI$%Y{fU{M{^ntP`U?s~{c1QHkvfJTl=3_6{oEp9Daf8>C9eJvMUY{=4{6KTa3AhK_#`$1>Nkkd8O$G^tmpt^=*r=eSA`<6Vo3 zpTU!HHR;BaIg1aTiRbHDmA$H^?Dk80!I9mNO z0WYgn0enT?R9=b7)GB2MtATJ$u)nx+IUvK2u)mmw%II~z?mhK*c`rb}`^331WI5gydV8>2r3zXgCa3dkl4BLMPf(qNAmQQPz-noT12D2@gi~#ThK`yKmm{$T$06@zQFV1Fh zIyTIs4D(vJcWwVdG$im$CXaBsfvuL1wNJ=ep-Lo&4zvviC@$?BVnCgsbNK$35~<~c ztygi{rDQLA3wwnsd|xBAEJ5kq2HuOn2iw4`or|~^JS&~W$98ZLZi~^!qdwb`0M(>d z30@JF8(~j$2*A1>57|6QIqBL37dO`%`;MY zby@+e8~XB0!xyrQR6KEP(vxR0AZHE3oZ~^O8s=T8(*5%@5F`UZ)9_3SS^klDf*~pw zzR;Y*L4v?(IbtGO5&0uAb!OBLDNK0g}{AcSHerTgTcf5f^8;1Ij zn`-gXv((#~7^&8iuvRku1)G-PMNdLq{l)Go7wCjI(6-}11wUThC5g;ottm^>tZp?; z(`+X-g|szCnq8QJ$x#+v_ZV@wln(JZ`CP_-eU7YPb7WTrzR)%(C(VDZe6;-{Sw&?B zPDLgCHR{HX$t5fs0QCt}Uu zwB0Dj#j?e2uUg<{MJq8QVlM&?R`d>`zY>}t5_cG|&cH-4-8vl30nlMwIstX5IFoIP zkwyqCH+N<*gXy+*s=gw38FU31KkX1PNO2CfXoClE_p%+pnhF?PL?Ipn8E*ker&j%p zx7+U?EWPyS5)2^6MH!C_{m8;2x8k2%wSm}A#Dl01F;Ps(`P`2Oqs3eB%B~Z@72en8>(l$ZH%EPC8PHd%5Wl0jT@>mCkZ*yu0a0wJpOn?z%kuJ~dI& zk>dm$)qa3dmgmO`x_yx4s&Q}oz}K-kO@S`BS%GvcowZ_#2|R1?t=Ra$JEYa(cLeC^ z+dXJG@0~H$q7`E!n=w`;Du-yWt8!A|s9t$yQ>V@bg{4bVas|huB}V_zu3s45!y8o< ztjnoY)k8dZJ)%)-$m2?wT<^FJin$8M#`kZKF>E)~_hY~1t~M5G**dik3t{!{c321; z1Jqt@BTbtj*|m31i%|~nRuTQE#6w_>Fj8m%dONX(fiFQR5xPc)uG5c3Hxe5hk?8G2 zT7!*R9m%gl=j%tI8;PxpNc46h{S}cwOFz8kRC1|V@C^V6fE)ud(!eVBlw6F$+SVBL z8RC3s{AxGo_=Dw%Gg);)qAL%g*3dOQ(G_AT9d<8q-MDEhn#Pj-I#C&U1(V=|-+YfT zut9&02gOEJkXgVZ4G(BcA_DCFvAePtK%`#iz2yk( zrJ(Jw^aDu2gexm~;&O8Rt-Witcb)4^ci!0{6Eli*4zyJQ@tH^9)MV)(5PO1v6<~yFijgJ4 zhyxV{g#$!T_s9oDfqq%ndBqB@gJrqqd9s; z=wKP)(5UXW9at(jw5m!vfP1fC_ZCMj=xBb4NTgYeS^J>?d{EfD6!=oF1ZHd`gTgo= zADFFoQ}ut=%rp~LzgWfDKF(ZK=SraqNPh{st1*}zD#IJQ2qW{qp;b`%pMAFL%Ks_# zenL}^dLLywuzIB4N76ypJGVt_C7ZLB_Fe1JGGR&>?5rD>`2 zX+ql;@A7~@!y+Fl!#as3%0|_z!EcCsC<5Gt4$cRfmUiy&#s^k6ZSL-2+uU6i)867*Dm{Y#%m`%sca6~L}fa)Cy;FACp^Kf<%iBlse)hNF8u44@y z9}~wi*Rha}cj`0^(zi;0YzcrgWs;LL6`O66__l)788y>!qBz#LjumtqtJ5qdeJp8m zFs@y}F|UJTnZC4_T|u?qSZwEa36RLYC7zcw;*-+b>wO#wx4mXFJt@!b=4`E}^4bCP z<)X0lJ~@$W9-zbwoR1@pVKZ2d84YVokaSC~8Qg$pD|T73P=nYyWc?bM?V>Om{Q*nw z!I-BZSScM!z1!F@yg8dqZHJ0zgPW1qp{>JSbjdL8GIh-}hL-0wJ@jJ#jv?JcFLwN+tjiA3i{+p-gYBZH-6M5N z^F3l2g=YxX-v}jB<`p0OH|U!4%xBx~VXL&A+sPS$XagDgJ-o47(X!M%hYm<)6Fvn7 zmJ|#dZ4Y_JHKHn@hZ^nhO+FpAnA-WhUwW?{bcOc^*6JY8<9znZI3M5AoVPT-WjSwI zMzqO~YYu!+MlWqZ;w2-T{dH?lQX?ca(I#x~Z!g_~W2+Q7Kqv16R+&{r{#Niw36O;a z$rWVo1`blFFCWknLcFX}$HEr}SvhjdU^A$&P^$uvrAs<7%4@7-EXqJTF%R72eP3b zv2(2>uT7o-JOF4DvKBJKfb~|uS|9x(b@Cqr(eDRN{R3fAw6()K@h$Jfbz*-4^^|-U z{)DTlukdF3n^9$N#K$Jnxtz{1*LiJpacTg{$}c0xddL0;Y;XL~;=I5Z2w!f-3EP!H zYkkgZQ*O+)zOa^ME{=8#oID{EKLa3r@EpwX)#1!0aaRM^Dx8$Hpb+xig*^XypfyxeE1lQx_hPu?R5 zG67ToD$l&A9@W6A?y81ANi`Jrs0OH8xcV0VFV{z-u81&DLIyjHIl;u0hNy8)OZO!kVr z%thULMKgMZ5kGO<6iaIoaoBt_Z=dTPV66ll?g0 z1Da^sJ&)#%j>j8P3nJHX0c*L;_Ujj;9|t;{*RFsR=7@mR9Libajd~Fh)ex)hY#eLi z5z1NajeY|lacWNTEtB^+&Ac#H9mFECEYP_$HwQdw;CXzJ$9v01xE@>Tf}rJCIi038 z5Wm}{23{3$%HWlh3+APAD`w*w()XqpVP(X+$_27(OXecnaUqi-CNC}L_-6&=92?6W zIR~X|ojjg|JXN+0c46cIdBSvcqzM>x+_%QQY&Ag4^Dv!eSP6WdV{9!a-Uz2s$blf&9 z+Bu+fXu^_k9h)4*%=xzT*IjY@n%nKwKrm}AwncK27IPgbhFwGT*u8okDQ0)c=E}M0 zkGAwc&-%j8zL$GEb|1VmA4GZCz1{gLV8QPBJbUG-H-j(0_LLc13O+veYkVyihbF|y z!x11^5Z(w_YdQ8OM^Ezq5cLe43PWM`n!w>-DdYUk9gP2(KXd%A4O(yXo&qkkr-0dd z3Ru?X6yU7a{TTmP+x@7d8E9+FG#LM=pyY+l*vH5mgDS=9AQcWxD}TIy3d>w+~VD@RH6 zq=DbDLay#nA^%tEW9olrePHd7j+3x}aL|5rC6^Bs-JV)cp3FP0Icd2)7j-tnsL8r* zTdY0*{+R3$)5ys>F>+Fp!}UU|eLD6{UZRpGs{1)kR$O1!GX3Ntq`!u`oYr=(FO$;q z^QF91B#<4@EihRmAQ(m z4A_=3j3{abk^iX(!-^KCyfS`EHNOQDXLNBgr+F)=fWd>{J^^mW5|0V2q2PW1VD1v&US@^bH>ql1J zh&}IAEYoW7Dz0vQ>qowiG~LZ`?!}4%A$MZ2bsaWO4x2ZFOQ0hhu(P^P*m~JMk4_c5 zm2b%w@g1jgH<6oZ14GukWDfOiIt#t`l78zw?pNzaHs&r?F%w z^Md30q3?Jo$_WvR)^~jFSu&_A)e|dReMdGToz7p(cI>V1xNMn}1e`cm#UHVMdC?8K z+P|!){d#IxsY{(qQp&f&T9fEIQe4f=%Sm9t!>9=K|3YoHhjI(ZQ279FuEw-LIdDFJ z?Hno=t6$@lhIayytq^OE!>XR}2svq}oE@2A%yuAd1usqugglNs|DGk}d?IWC(#MM}SDI)sefZ)sI%7 z86dc1IOdVVlu)cJNfCLB5dwKoZYCG|oJb;;Ar)i@&Dt26xE4o7+?U76B2x8G?O}&q;uUNPqhi}k3mw4y5 z;N*eI?);vcN5xh-aXx1HqTq~;C7HPE8y1j~PK^(qHhu9i?E^hYEwFvmcGS^t;mDmg zmIr12z|#XZ8GPdCo(?`RX%TM*N5JWeQy6EhHYORtIKez7J2f*vn=x84;$90LFdtZp z2X<=e=!iD15O;XjYj27X;oahT(;eO$w71gU?XEZ7%_?TpBu6MQz(CEy`*2V^-!KUl zBr6$yh<*1R-BJXO%g}k{@?K@BJ53odV zXjQx04lDy4pug}hy+2TkXob?GdS52%amb}Hcx7uiw*ves_mFX;0gl!3PZ}Cm>_}2x zitbg6xN7C~wgRdpMy$#l_n|XnD~+9@n1_6@tEAq2P~2c>UQRo3J$Hh?f?a02?-U2@ zD-FujzYqb1WJV}?nmRx(dh2$(-D8d9f8=&MG+Q0|tf6nWV_F2ZB;U-Rd%GRg zXkXWNh-0ztW;*G3-M6tMiIGP%ALd#fEPVC^y{V9odQ*S?qiiZuzX2VzDaDsm1aP|JhKzZe_AQ8E*?y;I5ryuFVxay@Jxkb%F zsy*%>*mNN>dRfjpElcVUh`g!vS&Cq?3~r8Ukq4?Li{BgVsULYE&Wl0+(U)-lfFF6Q z2Nv43b3A1HyoJD<0VM7VTU)~M!3_ujoud6=ZL7`5dEGm6J>Q{lNBo%+eV z!W+#toPc)4IdAj<82SK94g$_M4-Y|iz&@_Y`w8a3y=|`>1{>P|z&gEi?!)^PhWF;? zQ2fN*A@ldf;&ky&c_URj=fEt;pWzguEr{ztU`~Vtb{&3=6!B-Sfy8?sBl_NVqt}HY zV#n*J0D#8db}u+N_{G*8`sD8#y(_ck)$k+c6fZ+d67z)@enu-LhNffZ@Q zlkbG+a0TbcEPmH(IxqQ7oef=AvNf|p)}WAeZfeMy29!OxJY?;L+P=led9AcGoU^2~ z*vNVH`l}7=CELylw-AnD3ryt5It#Bi?~huM+ZA$}rv{A7&8U>H^^!XH_qgI=!N3t*>OyX8!2_!esrG5^vOO~iTK6b{|4)~ArUXYHoYyQJ`E%*-~V451s zfxH9$V<*fCr{(K_@T{i3hmq z=%o*EH3}&QxLUL;4{)_=S3izwwQE-%;1c|A_259l$MnsCRL<`=2Xgm44hM4Jvc#ql z{;=2iBt^VFl6d`z1@?eXd402k*NO51)^iq7en^8y0kAZ&xyp8sa?xnx^K^iu6|7~Iu^9U*9UV4gj&TkwrH0JG>4ph_0Z*2xBi;VI(5a+1Y8o7lM{UrweCrDm9`*2h+`~w% z5~=uO!Ms%h_>uc#?z^dTCTPUSc2<9XL=Yo8fx1W2&7|jm)+cI&dj%x=6{b}nM$UiT z5#tyfBISgcc%G*68E1l=|6w0^k>l9Li|0=0ffrwjCg8;Kd7(Y7e~l+*$p^iynS&54`911Fqfg!Rv{Z?8G(OxK z5VjVh$V5xUMiTAmZ`&HMijqgK3t9y@o6#bpIP~Ixh)4c|fI)&ko?d~pjHH*0ZC?|n zL3Kl)$L0x|PN);C2*EJk^hG~l8#1)*OW3!R8=u~T^=cB@gL!XzFSJN`>1KTcL9gv& zEc)CFFHuu5ETF6x(j&}o(IziJ=^PBH(d(?`fh(7ApEK~h>~@+DrMDwc*nB*_22ZM% z5Zd}NM#d!WuLN^eVv{szeFmxZlHAN@_-F8>Oc^yv_e9cAw!HEsCJCQ(jFxni4rI2y zUl+`23tC?Xz2m+NW_~8u(aPrDeaI7xe$Y}^u9i|+n*;o&#Yp;y#Qbp}h+IN`Ag2vw zEC@U|3^B>}(k?i53olDQ2lk$~WqyvG-p{P>RTzz*i(+J8c0ye1HT7sdT#}}y9|0?3 z_)7i#q3EXrN*~N6;0(hR$PY#4>6#*bf)6t5 z8@8U71NKShq>sVPIRo74gzye#62b_^S`J&f)-fX4y98kJtdbxX{ihH4_Vy>F5AGUY z)?Mbvx8G;a-T}V+2s!@@eA%{C@a5BE9DI5HNEcr=9pm83MEJ-_z=n@?Lhj=HKbQj} zA8dhG0C1pc2Vy!}kf&4>4mFn{xSzY*qfw>b#2;rSj2vlqVXAihi`zC5!|+R3m| zu5WelCB>6szg?ukV!xfs1W+X(qu(L|EFiQjfz2#^q};YN9&6Su^>bhiCuv3Jdkau`o=tzlp9N5J@@%?;)ZV11J4W+vo=p)_1Y&JB zEP$$lr){#ezU`U?LrDH%0V>(kR=9vl&~4`}K=z)tvlie?si*Dq1<2mhmMiKOZ6|>P zz}vA4path?J8HpRd}J&@OL*E2S^!qS)3)ydnmTVAx`6Xc+u#M1;I*YJ*ar{q{5jl+ z3tZheB585_w#%`WLx07bTa5S)(kuZD*i9FJZ9GtE6y^Xc5^HEENq2bH(%qaZfNO`h z%g)`vP)%~)UB_;Q1FRO}Z<8EM0Rd_%9xNnusfkIDd^;XpcHL_@DHk*aYY@g`PI#y( z$n2py@wkrF{nph#{Z+$EDI#xOz1((S=74P->Kr-%Mb!XBF(*fhc^2(usgE|?z~{1)K12)~o? zYsPO4ey`zIiJ8tbU|>>m%5H;Fci-a|gZJFa>l-qnKmYdbPoNP)cNS{cp1Tdu{=@g- z{<+qFuFuElSAYA5vt%uO!$tgt0jLQC1C(={V)x~pF@U5S)Fq)Fuz&USF6;+(1T;mT z2T1bs?j^*u=DvWx7)VwF8FlNKr|}m+Z6Ecp@l7Yz`IPUEya~J*wlu7iZ$NTXWpVtZ zX|W)IBnu3@mrk`}b&*`)1a$$nxu2znj+&tB=+b=JeCmPU8*1eP{};di$Kdxv(eHME z-`@s)pLJSK{JuH&e>i?W{t@YeyTz>$C8Ju-XbN{(0AcXO70m)lM) zvyx~i56p@gySIBhauJR&p7CskOD;XNOpXOLT;kPqk4K3n<5k-EQQ3tI-5q$hOd=um zZ$!quQg8@F7V?OTr(`HM0A@N&T{XPO)bS}yT~n+UB>!1Ws8w%OBTQk&%Le4dHhOb$ zsz=mC@&neLtS7@3*>8PE1o__iGs!jvz4Jx;9nU*+@E*eM9JD*uMc>Csq@^U6N8d{h zBsC|kh$n9e#0Lig@mqei1?*EYw80y5O%dRdg<6iUBlBd&@4#QYRO1mgHLH}M?GdLt zyz8}hGalfPTIh%msfg1Z-W#;H(%xiKv^U)~mu8A(XRYax!8!n6V#X^Oa)=23DX53o z*A~=6unk~Th?8EmX7F+Irn;u!(~M^3)dTBSGassW92eK@6N>?dR&}WDz>ML5_N4>Z zC&<)AQ_5kV@@SVz{rzoWpEx5T?+V!@ur2C;a$^?{wOak_EpDB3o~*gjkv z!dWK!yBGUvTJ&J{(zNKo4AiuI>_VJ@}i?uIk3$90mXG{LS0=6!Zp5j>=lkP#XsP zO@?|YNAowI9^~>jn?Z7{?UcVcNz9_#{7oTC--Ex=_IWN zQQ)WDC?M1n1$LUE%uZ7j+X?j?b{D|^FC^r`t^ip7g9p%Har1&xh$`kj3G!z&g%;ziREMMF-T8}N`x)6C;0Ky9g4Oi9q93Zvg-*GfcLkB;?=Fv6=3Tc`~jyH-a_Z#>eXuceHvE}(F>U%b?aqymFt|v z3UQp5-0g%;6K4&Zz%!kI@K%hf`{z;g;*(Gk%v_bR=;JL zB<3Xc=tFF;(OlDx#P(HOrhqvc@eoj{FI#lfORBh{^%mR5`x4u8#@ngbzR;XdW9B7@ z>~)OpBKsw`^bpxUX*&owrpW$&I`kp3e`6Xk=je5PiR^E>t_yCiQKzi!C9nsx1#x|k zn|->(_4#NDWt`p(Y*K74?v)cAu{ppd7{fxSDx=-F4V%w)cLV;x4QOi~7ppNktl-0h zkVoQ}mY}mG@rkw|eh-8MDq@bnW{^MQ`aQf?2v*aA_(69FHmgME##M3hu;LZ^O&*rm z)Pi3`9Qzi;SHsU0#QT_?jm^k-px#F!R}D+K`2jeJB?-y|i8{)LDLTqp5YG!m^IeUT zp?f6=;$QQ33F0^3E!a#1@i%K)1o4wKErR$fG%bSo@qcA_RK%8FXly2Ju{5ctApZTM z69n@iL;)0c7v=_ZJ`*P%pxlQag+Y{dj~+7cI? zWl+oj34?W8Gpf+mH~Hx39>8qEr7keTc{BL3-^3I2llM|%;cAsXjzn;o!@TlZ5V_Vd z$tAeYVO}{oWIVWZjPBHGD4}gzp-VcMy252NNP})|slbcWPDnVP4&!a`Neetj#L`QD z`75>Rx4raHMrHL=AEo#&sE?iNqkMXsRN4Q^v;Sk{+3W{9kY|4ldG-rO^^|At`B!A z(cho4D|vJm{v65Bw>ntx*jWM9Y$zs83T!A#-|_BeeDLTZkf!_-v6R@9uhK z_4K-UjuR^pWZJ^%wRdy}n$}DTeDw)D=y7zRPU}wQlp>k%>$P(V-7ydP*sg>D^6zA=3|Vrr17{NTIEIa9J;G8q{}L^*kWg1D!tV*XWej zz9xdsFTxI#)S}R0)i}w<8LlYQMW`>ifx8q&ZgYb>vQRhpOq_DkFcraVocdn~o`_S| zeMg+u4X0jW67^IOph96J0jJ_E0jJ{a|394it)nnTRLLo3LNJ2*87)ACMmsv|b(E>FCM^PwQtJL+A;ny4?q>99+lcvMCY*!s6~ z*?`owMW6MncMt0+Pb6GL$FLd*SFLAcBPV{QPn9Ah^(Bty;cIOY zNc1IqGMn#IUm{+vmze+6cm7Y&ccz?k2l%ob`0~PE_r#YA4*4IBFL#egAKW#*Y&;J5 zlDjqP3+dT?hY`R!d=-}x(|O4{?ds?Eih^M3K;5);WSPM_9qsCmw14%B>ecA^qQFL_`y^#ii0A8=jNnf&g0 z%E4o4VDljll%sPvXo-6##Z*2N1E>fvx-lM z#*wEwK#L$QPA|0`+QSU&oK_PX%sTiFW1Zl(ps`4;L};C5rOu0Whn(y1kSu{3Z7pA& z#sZ{aXN7}jjD$X8;EWGgY)qFG}G>KCY z4<^s0MZ2AtvjvzwO$m>R$lCU$9GR1rPWrqjFg)mh1YlTlZ5J>s(lmR#x{$O8FgcY` zfVuf*Omowha?0yNfY}`nUd*t92WR}NPdwPlMsxR<4?Lg;9-JL!ySaF9&98dm!M^op zhpEdEl6bHx#l?ev0l7;&xaZacJm_KRd+aaU`m^;lm{!!Zo1D*k_@DOY%}9^HC)e6H z;Xqs%D!TbN!ZvyxPOk;5VmS~8!}0n+oIkX1K*S^eIS1lO(BG4m;q)Bk{)$smal%o! zM)xQj?yrL0F#^74z07CtlW;iW)%Qs_!&tQ0O9^^mY@K&TDF#W{d?>vYWw%x=piGx1 z->UH%#&NkyJh?Fn`=7ZvD{$T|*ZST&Zm~Y@md@jD1w8JSid1;qZ5iWJwhs`W2BrdJ zmSc}FHwWeE^p5)`H&ZTBK0=PWJ%|i&TTKwQ;OtX)*5;t~1tLP+EeG7nayIjHTv^~b zbVD4M-VD>3Uj#Bg!$k|Z*4NM}*siYIkG(@ePYpcBopm06n+m@UH35D+_LiPYCWpt~ zp86$W;3Qavv0jxA=B@LkxA9isBY5P^FR+7qE#yVg!q9WdPdM_H<&FK;KJo??BvcJ= zQz+!YxFT9ffPsWfI2s3coH3LWZn_qE(oJd=C*4|6Lc^Ms9^n%M>$V$ZVAbH&zN4$} z{pj5pF0-{C`0q$(Kl%&l$$jI$Rm}dU??-G=-i`xv`6&VI~VJi{?9;enYJU7E!3NT+brc$gUd;leR=hqYMaZ@lKAj^Xf)+=Z> zKi!lAWmro1Mp4~!HxI_bU>|mlE=u*zm64=sOURg)ALRfOFV8spjjV74o6wgh-r@YG0&^(n)~$nYd>R^U23p zd#!=`)2y+u*Okn85JzBCY4cFF(U?q z!hzoMN+hUeO~IYA_KtKTKhG4EMifNe;Jm5k%IjDfR97krA=SmraKX1e z7Rx##RV;{&6z^1R;mmAE!>dLb)}2h)LA(1tL$sSR7y6mpCg*a^LQyp{7ql5ahc37> zMM|i5G;w7L9r2|Vak|61OnY;Y1^TUYz3C3`YVBRCz3W_Wy2ET4{^H;v{-The!l1a( zf)j|K5IqC#?&TafZpEpn2&$RIm{Loi4_PMha?__W7UsADGZ;ZV79ch-RE4Vgy#~1~ z4IFCK4BJ7<#cN@w(19C#5ZYBSI|t=HT1b?e{8V2k_l&a=QLgXF{-9iHXBJp;(<;zW z9dc45j&N~q1n>CXO8uz818pXv$|`y}F@o6+Y!sYJFEyk<+`^9Lro9EOvl!+^5TvU& z~_z$)6UHX+AA53WXQ>>w~iBd%i+-G1y7__Xa{DgyAu|qf$9#O6k=(J+b#2Q zoD*`xQhAf9sY?+BS+fSvBucHt&2@NJ=-mjC#>_7+AzrFV#Ilw)?q@boI~t>}RpVU! zh>c|X;vz74RAt}+oJ&Mp5zCUM?{=Fln;CqKLay23OC`$lwE#2(%bz*zazjbTgjG-x zfI3Q)Fz?}R)L-?P#<|Q|9eI%8To38Mp9R~Bp!3xmgs$O$Uao0QN~%HA^0D_zcvOV( ziN?9C8MWU=jdQbDO(Fn2eyGN|?7C{!WrB0dNJlhXK)M7pCs~;_5bZ2fRSP^EYcKts zsJ_H_QXgC+6BR7KivA1qA|xpo>0pX>>gp$?eh*WRb)_!pp=p^^mox8SNqSU0or}!Z|lE(o>giO(5uud zpexmC`P(dizqpr+DD@fiS-P_(JIiI+1AX!W%`7sOOMRAZ=-xeefm{6S+b%D#WQfZP z%&bIA>u>e=i&0}OBvXJvwx_xTVaNpx`ev%=BH$EVGRU2A0hk*p67Z;@i6`l{UWc;F z3A%2^2>QlnS2A#a@L5{ABcD49C}l_bf*VnqpMlRVm?8LVn4mJs=T^M#;{RgWHa}(Zy}f{=`n?b&IZb zI^@UqIrxoCuEuYWvvuJ&nG4M-K46r?JHJMDtjvb}@y%vKy8JD`Uk9BOvo3IKgAZ-~ zkwC7!L?aXNjV?;|&Zx&sOJw3hKtU$Mga8I181ZK>WIo-2m`qR(@R3tN$bpXPHYD%N zU=9$wk{JMqr7>LsF_zTf3CO*5L;ry zO|B#IxkrGAEaVF4DY?<9yzXB}y-4Q^=S^|HP!Jod|L1&65am(FUWsmCHe|6(Gt=N= z8{u?U{1C;>%;HR+ub;|G?Vfto<_=t zC*Eg&r{Ck}F!D@Z{1xpuWZD5G!%x!M=`HXV?etB{Q5{y(rp0(fRr*OY@bs2H!DSv2 z#o-H%*1GAF){AcXFg(Oegy^PkiX$*rP|v0)DKw6!Z7OF*Pg`j{lJK-$Q;)1+6@q;a zRw2Y(d)s;SAwk@NcTiI;~)r*OV zee1am(>AnTj6)2r7vm5q_0%#qV;mS7%~*G`V>m#1?LP!a-~XQmr1=dlkS;{w6M%FP zfpj5&bP<5`BrFyj%eYnCN2ZY_u^dIH8^O7 zcUzP^l9_*7L>TfTM9Dr@w<(wKK?IP7H&>KQybT#RXMYOG(r`|R{S6Si6}e`KFGb0B zIp>u6fY^QM!VdaCLu_WPRty)2-GMq#?_49Wx{mZ@O|x#)6`GEaK3~)Fu_s^4@TiCn zTN6ad^&2$AE@HU_V!t*h0b-9juM1-TO49`_$Pmzk*s>njAlSnsexxiwKyc*uF2t7f zAk}A5mKb$rp$LK_l6pTu@NbZ!2EmS`+f#&79Z z@w*SdNAUY6eoy1~JbsJuTaI4~ey`*A4t^iv_X&QVt^3bBU(>}8jJ?8vUqyHJ$q%$j zgF5^`(r!KYfyrYy5M6%Ysg$1lKqKN~Zm||F1%XjMRQ(QN$PZlmnadAM0@*KqAW0?c z419Ds%HAhG&~1O<5(bm)k64xci8In8m=FJVf8hVz{s4hYANvCx>dYke5NCgYrnH>> zfo@6Abl!rbft4aQI{BoE7+_w2A^PdU&AwT23mv`RkoBKTY zqJDFqnPVO9^NC5A%X{&gUH74!d8soSTz{LxZ)WwA-y~}R{s{Ptj3KWzA-{rGS>jBQ ze*!Y_jhyDpD>SDmzQTI((ve=A=8t4BvyduQSmDnc2J=pv!DO+7!Th;A8Sep94_x4L z_`;oWzeIzCYeW~fU*5ZLDR$w~oWlKF?)L$(PAUb3b9hyaJ+vhRm-{Vad6G~b7wt$B zoQ=qAf((|1cdKabw-}*!$o(cDSM|hY?iUL8%O3D^xZn3U^0UuJr!*VJFs&Y3E;(P} za{VB{<&xP2m&@|ndsNo!e7J$RbxnPQ^}B28!|~5XUSx*J{3e?8Aa7`!0vWrw6BfBI zgafQ-FrKANeHcY}f^{eB*I^=O-6Kro!~YpfB)-z#jS<$@*^Mbi;djbJN<1); zjMWztx!d?2Oyt)g?cg$z8|mOMk<8E8j@b{4Vx=m@0k_^v09w`h*c9?y2jZcJnZvAQvl*J=kwPhcXC z-&sP!KpxjKp+oyfXrO98sRvujvV$At2oP>mc&E)&N=amG-_Q=-N|mG@)QN!`W%up= zmFiBMf^xqg*-lLrBMJgCS7E|hUnVzJB{$vUawKx2e>|TcxQg4(7{&6i;?z^Zn>=vY zvVPN#n2(wFOG+#%dC7)Y$%+cyn;5d&YNhqjNM}K=&wU zcYgjE-00siWYrhv?0_4U1=!|BD_Ow)ZOL4qYLKGlMhOwPB{TUv%+!5dZevEtjYjcz zmC9SnEtzrh_d0RU0bQvs7vH0V9z|d0Ul%|2WPt-uHdOSUHGwy*qq?ph5eaxxKFVY zt$lZY=JqcV__1?Y_CEQsKJfAKiSnVl#>bI8fR8&+SoI{9{2k%rx6lE820niND#6Dy zS{!_Q_(B&S|E~2X!6Q|F&=uHp z^?}T-cqUtW`1uASLfWwfkAM|XXf=RnEWCL6L|(?=B^0l0XM4h~58l)nxw6d4^}>|U z_^zpRMKp`>IZuhtBxKk^75~{=j-f z!Tmk;_&nS(RF5eRcFeRmKPg}>)886-u@&yvQOZNU);R27u=1>NgSCcEI6lsY0MRy_EDTsCuZP1jqjt*{Td^EoPn=pRa@ioH9U;GNYO7c z`z!uN8d&k3l4%H8fROok16c^NfMk3kq~F@^@Ea45Ui_{K1ZP#iS1qHHRbERcGgc#U z%j@)8E#7d`9$rjQI!3rg?Zdi&z3yhb;hL33ytRdqQ2|nA_Nr$4rp~q#oRa-E(ohXo zPsv~>*Y;C4bw(P>T*pF2dJB%rV)8M%ZJfO?F)^j4UL;rG?1MDexzr?i54?CE&~)i; zffpCziO!hDK0s}Lg!3@jJ1%f^^IP%icu5kQCOBU0J-se=WAT`WzMlqrheE>+J!)is z$!JasUUIED?De@;c{AQ53w6=jA5gKWKmrav29;hmCg-1viW&J#t{my#_Wi3xPB z<6S2EI~B|>o)=M9pRAF1t#+tU=i3gg6UtuH%&^%zhi#5&9dpj#G zv~Mf~k%3k#5xAYpe%26 z(?uoYqT5d^9gBcQd_t@3otrJqRdNU-OK;p~D6BNZFBu>O;6)zX19%SxBid4_(zFeL z-=0cJ_p#P@F45tT8uL{32&i4G^^V&^a6_3`7$oLX!5Rh5B5M-T&FukQaH0Yp^< zQ$9~<;$c|vGX2H}G;)gd8y}o)SeIrGC4Cw_bCvXEEZI9Nta)HrOmGQG`u_%&?XvZa zaj;j|geosKT?i%R8pM28bE$55f`@r^#50hpDxVE$mvY)ACnyw(d0CZ)f!GoIh zlpG#uXh!SnNvsZ(%7k~Mq1JV*q~ku~$fZh$%%|f3ov18)U!N?A$~4DBd(4cl!MoSY zxJVqcF-Pe{(>Sj^4o7^TEF3kYMa_uIIx+3v&cKpCeJPizZfZtXRQ}<^5uQT)oacEx z=xgxq{LTW+A0bAf{gl=`2T<&Gvx{iE?5Au%`E2_sk9^t#%nsk*1+%MF0esP)yV+0K zTMdM3!u^gbe*^OdKmWd-$3NNL^S++l+mKOz?sv@R_x7-lBK8sFYDX&jr%mWmWuBD2 zyuK1`rJf5r)%5OEyPASWq0{H#=z(=!YRJOHFCUl_4#TyNF@*Qz#mD?I&-x)`ZN-Ua z@61{_g{*vxoeA53I)mFle2gEi7#O?&_o97{-x~a0hqh2~o7V?V*pWF-^n|Op5b+Y8 zSwb}Oy2KUs-Gts**TYfY2Dt%IymS75cVy5MiYE_2PI<3mI3MO66&!@A3}zdVb3Cs} ziomRxU)~7ss0mGK1jflG3+41i`2~h~5j=gt*FiLe&C)dtJ_03c;zfxk$^DJr@;Q(+01qd=u{aF2^S4F2^PYjVC{^?{W-|xFY1e`4wg~!nw&&yR9*- z(h+%9UTP>l__q{dWV17 zT<7vnYs8WEP4sbs8jN_-JV8p>*v0?EZ?6--S?M)s0k3a>cgR4m55~NQjE6z*K$>^R z*fhN3bn18*^oB9-A!Ge`&&N9qdc&Cakg63?SI7Fo)^e{8WyTQW1*dY)Dm(%{QftLA-^gk9#$H8CbnG`% z-TPSAN?`FM9@o`=Jm8d9pnKRl%ZDScR>&8!)`c?H29EcX?n@0-bY5KF1(*?CTD0l> zuhCaQEP<|S5>6=%%*$DU+gV$9$?7Ra^qb_#$IH2;P(1Kmz{tDPVa5=712i@!(gwMKV^$aaUgd zOSCUjIZkTHu}8=r#37lYUjK+#z{*EYR`)zBtN70C%UrQYkc34hQEfkt%i>D4WxQ)& zhJ%Jqe;vzllW6a}H~-A@DAe9kTTYYW!Ccsg>s|gi6%z|??1celE_FNspzrRi#FPki z6h5q28lnRwP0fpob;6K7lx&!#Xsl~}d70Oyh8BH4Fc81#2M51%Z3hC&;v-(gHy%s& zo`gM*(dz>BWT>&~=fhpy`X$;kJ|V&YtH(L4485RE>hq2grq2oR$J3nv#a#g+Am#da zd<>EbM#w!wpa3Y@$d=#LN*uvcb4mkT8R z5}xN1=Ym$vF!6|4J7V9>iIt`j#jIf|7<)u5`7a;d0?(s?Jh_?g0)Jp_I?k}7?Le7f>-JhcGFwiwl6`^B=3MVQ zPoT3Acgz1W*PIdO)m4E`ShDpe=jN=L{3dI!kSQ7bPF5eL7mJ&UNKp2ex~eZSImjMOb@ zB#pWx1kH{%5Xxwmq>9zny(G6JlmzW$7ev}I7;&00(5)CpxWy1T4?5%8JYm(-c+UPM zO%G%3KPNQGS%wPJx7L=i?(`k4Z`}e`w;j#Fb174;^|E9QLxj6gYEZ=9ZIKIH z9hJQ^4@}%`89L3rs@06wAa!S8Jp|f}Jxv#Fz8wq>;XgRv7CNFF6>=sX-oo;laizV< z-)L{T!@Gm-ra*7R_OZ$&Hr?aN)8d0qOA4o#joxZ43q-$9@!ruGuPi?$8K?Hgn^i0Z zEZ^fV{s;9q9yy?_sp(U3OFiC@0iizazZbjq--FHUTg7H+vpHc^Q;;Rb69VN`|1ji?`B8-z&T3f6O|JK+Yo;q)!75%sDYurV>< z>fug;V!$0^;c*1S2e1_QOuyRyX|jq{Wx@yJ8UYmUAAa&0RT0c?uyrmE@V)v?9^iZR zn|{byGBj)%KhUg--~o-o3Ix%%6ClCMmm#Ay3R!okMn7_`lq%uvTfdfb&dmuox_Uxp zGH!Imh3-5qhGk7|bVbubnCbU*4u5KaW`2v2hWgW|!u%GHzV$SIQQSxR08Pv8&fc09 zrg%3^%ja$u8dY&yz0Lfxg)Xbp%&(s%NAA0+Ti(^oFFS;KHA~pY4WyTAx}J0c=t{$0 z0uYT_e_2eTfBP)Qsq7r?vn)jtHLPRc<30RXM!}O}O?2?^B^O@+NPN&$$V=@fe?P

4lR5&a_P8(Be7m3gXUoa>-d_A? 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 z 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 W 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