From 2cf8d6229faddda244f8f5df6a059499a04cc2d5 Mon Sep 17 00:00:00 2001 From: Adrien GIVRY Date: Thu, 3 Apr 2025 23:52:52 -0400 Subject: [PATCH 01/11] Added tracy profiler client --- Dependencies/tracy/TracyClient.cpp | 61 + Dependencies/tracy/client/TracyAlloc.cpp | 43 + .../tracy/client/TracyArmCpuTable.hpp | 419 ++ Dependencies/tracy/client/TracyCallstack.cpp | 1415 +++++ Dependencies/tracy/client/TracyCallstack.h | 35 + Dependencies/tracy/client/TracyCallstack.hpp | 153 + Dependencies/tracy/client/TracyCpuid.hpp | 12 + Dependencies/tracy/client/TracyDebug.hpp | 11 + Dependencies/tracy/client/TracyDxt1.cpp | 644 +++ Dependencies/tracy/client/TracyDxt1.hpp | 11 + Dependencies/tracy/client/TracyFastVector.hpp | 118 + Dependencies/tracy/client/TracyKCore.cpp | 121 + Dependencies/tracy/client/TracyKCore.hpp | 37 + Dependencies/tracy/client/TracyLock.hpp | 546 ++ Dependencies/tracy/client/TracyOverride.cpp | 26 + Dependencies/tracy/client/TracyProfiler.cpp | 4756 +++++++++++++++++ Dependencies/tracy/client/TracyProfiler.hpp | 1010 ++++ Dependencies/tracy/client/TracyRingBuffer.hpp | 141 + Dependencies/tracy/client/TracyScoped.hpp | 228 + .../tracy/client/TracyStringHelpers.hpp | 41 + Dependencies/tracy/client/TracySysPower.cpp | 164 + Dependencies/tracy/client/TracySysPower.hpp | 44 + Dependencies/tracy/client/TracySysTime.cpp | 108 + Dependencies/tracy/client/TracySysTime.hpp | 36 + Dependencies/tracy/client/TracySysTrace.cpp | 1611 ++++++ Dependencies/tracy/client/TracySysTrace.hpp | 28 + Dependencies/tracy/client/TracyThread.hpp | 90 + Dependencies/tracy/client/tracy_SPSCQueue.h | 148 + .../tracy/client/tracy_concurrentqueue.h | 1441 +++++ Dependencies/tracy/client/tracy_rpmalloc.cpp | 3517 ++++++++++++ Dependencies/tracy/client/tracy_rpmalloc.hpp | 363 ++ Dependencies/tracy/common/TracyAlign.hpp | 27 + Dependencies/tracy/common/TracyAlloc.hpp | 72 + Dependencies/tracy/common/TracyApi.h | 16 + Dependencies/tracy/common/TracyColor.hpp | 690 +++ .../tracy/common/TracyForceInline.hpp | 20 + Dependencies/tracy/common/TracyMutex.hpp | 24 + Dependencies/tracy/common/TracyProtocol.hpp | 169 + Dependencies/tracy/common/TracyQueue.hpp | 905 ++++ Dependencies/tracy/common/TracySocket.cpp | 752 +++ Dependencies/tracy/common/TracySocket.hpp | 155 + .../tracy/common/TracyStackFrames.cpp | 122 + .../tracy/common/TracyStackFrames.hpp | 22 + Dependencies/tracy/common/TracySystem.cpp | 347 ++ Dependencies/tracy/common/TracySystem.hpp | 43 + Dependencies/tracy/common/TracyUwp.hpp | 11 + Dependencies/tracy/common/TracyVersion.hpp | 14 + Dependencies/tracy/common/TracyYield.hpp | 28 + Dependencies/tracy/common/tracy_lz4.cpp | 2720 ++++++++++ Dependencies/tracy/common/tracy_lz4.hpp | 847 +++ Dependencies/tracy/common/tracy_lz4hc.cpp | 1636 ++++++ Dependencies/tracy/common/tracy_lz4hc.hpp | 405 ++ Dependencies/tracy/premake5.lua | 16 + Dependencies/tracy/tracy/Tracy.hpp | 300 ++ Dependencies/tracy/tracy/TracyC.h | 417 ++ Dependencies/tracy/tracy/TracyD3D11.hpp | 446 ++ Dependencies/tracy/tracy/TracyD3D12.hpp | 500 ++ Dependencies/tracy/tracy/TracyLua.hpp | 446 ++ Dependencies/tracy/tracy/TracyOpenCL.hpp | 414 ++ Dependencies/tracy/tracy/TracyOpenGL.hpp | 325 ++ Dependencies/tracy/tracy/TracyVulkan.hpp | 723 +++ Sources/Overload/OvCore/premake5.lua | 2 +- .../Rendering/PostProcessRenderPass.cpp | 4 + .../src/OvCore/Rendering/SceneRenderer.cpp | 13 + .../OvCore/Scripting/Lua/LuaScriptEngine.cpp | 16 + Sources/Overload/OvEditor/premake5.lua | 8 +- .../src/OvEditor/Core/Application.cpp | 7 +- Sources/Overload/OvGame/premake5.lua | 4 +- .../OvGame/src/OvGame/Core/Application.cpp | 3 + Sources/Overload/OvRendering/premake5.lua | 2 +- .../src/OvRendering/Core/ABaseRenderer.cpp | 12 + .../OvRendering/Core/CompositeRenderer.cpp | 8 + Sources/Overload/premake5.lua | 11 +- 73 files changed, 30069 insertions(+), 11 deletions(-) create mode 100644 Dependencies/tracy/TracyClient.cpp create mode 100644 Dependencies/tracy/client/TracyAlloc.cpp create mode 100644 Dependencies/tracy/client/TracyArmCpuTable.hpp create mode 100644 Dependencies/tracy/client/TracyCallstack.cpp create mode 100644 Dependencies/tracy/client/TracyCallstack.h create mode 100644 Dependencies/tracy/client/TracyCallstack.hpp create mode 100644 Dependencies/tracy/client/TracyCpuid.hpp create mode 100644 Dependencies/tracy/client/TracyDebug.hpp create mode 100644 Dependencies/tracy/client/TracyDxt1.cpp create mode 100644 Dependencies/tracy/client/TracyDxt1.hpp create mode 100644 Dependencies/tracy/client/TracyFastVector.hpp create mode 100644 Dependencies/tracy/client/TracyKCore.cpp create mode 100644 Dependencies/tracy/client/TracyKCore.hpp create mode 100644 Dependencies/tracy/client/TracyLock.hpp create mode 100644 Dependencies/tracy/client/TracyOverride.cpp create mode 100644 Dependencies/tracy/client/TracyProfiler.cpp create mode 100644 Dependencies/tracy/client/TracyProfiler.hpp create mode 100644 Dependencies/tracy/client/TracyRingBuffer.hpp create mode 100644 Dependencies/tracy/client/TracyScoped.hpp create mode 100644 Dependencies/tracy/client/TracyStringHelpers.hpp create mode 100644 Dependencies/tracy/client/TracySysPower.cpp create mode 100644 Dependencies/tracy/client/TracySysPower.hpp create mode 100644 Dependencies/tracy/client/TracySysTime.cpp create mode 100644 Dependencies/tracy/client/TracySysTime.hpp create mode 100644 Dependencies/tracy/client/TracySysTrace.cpp create mode 100644 Dependencies/tracy/client/TracySysTrace.hpp create mode 100644 Dependencies/tracy/client/TracyThread.hpp create mode 100644 Dependencies/tracy/client/tracy_SPSCQueue.h create mode 100644 Dependencies/tracy/client/tracy_concurrentqueue.h create mode 100644 Dependencies/tracy/client/tracy_rpmalloc.cpp create mode 100644 Dependencies/tracy/client/tracy_rpmalloc.hpp create mode 100644 Dependencies/tracy/common/TracyAlign.hpp create mode 100644 Dependencies/tracy/common/TracyAlloc.hpp create mode 100644 Dependencies/tracy/common/TracyApi.h create mode 100644 Dependencies/tracy/common/TracyColor.hpp create mode 100644 Dependencies/tracy/common/TracyForceInline.hpp create mode 100644 Dependencies/tracy/common/TracyMutex.hpp create mode 100644 Dependencies/tracy/common/TracyProtocol.hpp create mode 100644 Dependencies/tracy/common/TracyQueue.hpp create mode 100644 Dependencies/tracy/common/TracySocket.cpp create mode 100644 Dependencies/tracy/common/TracySocket.hpp create mode 100644 Dependencies/tracy/common/TracyStackFrames.cpp create mode 100644 Dependencies/tracy/common/TracyStackFrames.hpp create mode 100644 Dependencies/tracy/common/TracySystem.cpp create mode 100644 Dependencies/tracy/common/TracySystem.hpp create mode 100644 Dependencies/tracy/common/TracyUwp.hpp create mode 100644 Dependencies/tracy/common/TracyVersion.hpp create mode 100644 Dependencies/tracy/common/TracyYield.hpp create mode 100644 Dependencies/tracy/common/tracy_lz4.cpp create mode 100644 Dependencies/tracy/common/tracy_lz4.hpp create mode 100644 Dependencies/tracy/common/tracy_lz4hc.cpp create mode 100644 Dependencies/tracy/common/tracy_lz4hc.hpp create mode 100644 Dependencies/tracy/premake5.lua create mode 100644 Dependencies/tracy/tracy/Tracy.hpp create mode 100644 Dependencies/tracy/tracy/TracyC.h create mode 100644 Dependencies/tracy/tracy/TracyD3D11.hpp create mode 100644 Dependencies/tracy/tracy/TracyD3D12.hpp create mode 100644 Dependencies/tracy/tracy/TracyLua.hpp create mode 100644 Dependencies/tracy/tracy/TracyOpenCL.hpp create mode 100644 Dependencies/tracy/tracy/TracyOpenGL.hpp create mode 100644 Dependencies/tracy/tracy/TracyVulkan.hpp diff --git a/Dependencies/tracy/TracyClient.cpp b/Dependencies/tracy/TracyClient.cpp new file mode 100644 index 000000000..6224f48bf --- /dev/null +++ b/Dependencies/tracy/TracyClient.cpp @@ -0,0 +1,61 @@ +// +// Tracy profiler +// ---------------- +// +// For fast integration, compile and +// link with this source file (and none +// other) in your executable (or in the +// main DLL / shared object on multi-DLL +// projects). +// + +// Define TRACY_ENABLE to enable profiler. + +#include "common/TracySystem.cpp" + +#ifdef TRACY_ENABLE + +#ifdef _MSC_VER +# pragma warning(push, 0) +#endif + +#include "common/tracy_lz4.cpp" +#include "client/TracyProfiler.cpp" +#include "client/TracyCallstack.cpp" +#include "client/TracySysPower.cpp" +#include "client/TracySysTime.cpp" +#include "client/TracySysTrace.cpp" +#include "common/TracySocket.cpp" +#include "client/tracy_rpmalloc.cpp" +#include "client/TracyDxt1.cpp" +#include "client/TracyAlloc.cpp" +#include "client/TracyOverride.cpp" +#include "client/TracyKCore.cpp" + +#if defined(TRACY_HAS_CALLSTACK) +# if TRACY_HAS_CALLSTACK == 2 || TRACY_HAS_CALLSTACK == 3 || TRACY_HAS_CALLSTACK == 4 || TRACY_HAS_CALLSTACK == 6 +# include "libbacktrace/alloc.cpp" +# include "libbacktrace/dwarf.cpp" +# include "libbacktrace/fileline.cpp" +# include "libbacktrace/mmapio.cpp" +# include "libbacktrace/posix.cpp" +# include "libbacktrace/sort.cpp" +# include "libbacktrace/state.cpp" +# if TRACY_HAS_CALLSTACK == 4 +# include "libbacktrace/macho.cpp" +# else +# include "libbacktrace/elf.cpp" +# endif +# include "common/TracyStackFrames.cpp" +# endif +#endif + +#ifdef _MSC_VER +# pragma comment(lib, "ws2_32.lib") +# pragma comment(lib, "dbghelp.lib") +# pragma comment(lib, "advapi32.lib") +# pragma comment(lib, "user32.lib") +# pragma warning(pop) +#endif + +#endif diff --git a/Dependencies/tracy/client/TracyAlloc.cpp b/Dependencies/tracy/client/TracyAlloc.cpp new file mode 100644 index 000000000..c675b6d3f --- /dev/null +++ b/Dependencies/tracy/client/TracyAlloc.cpp @@ -0,0 +1,43 @@ +#include "../common/TracyAlloc.hpp" + +#ifdef TRACY_USE_RPMALLOC + +#include + +#include "../common/TracyForceInline.hpp" +#include "../common/TracyYield.hpp" + +namespace tracy +{ + +extern thread_local bool RpThreadInitDone; +extern std::atomic RpInitDone; +extern std::atomic RpInitLock; + +tracy_no_inline static void InitRpmallocPlumbing() +{ + const auto done = RpInitDone.load( std::memory_order_acquire ); + if( !done ) + { + int expected = 0; + while( !RpInitLock.compare_exchange_weak( expected, 1, std::memory_order_release, std::memory_order_relaxed ) ) { expected = 0; YieldThread(); } + const auto done = RpInitDone.load( std::memory_order_acquire ); + if( !done ) + { + rpmalloc_initialize(); + RpInitDone.store( 1, std::memory_order_release ); + } + RpInitLock.store( 0, std::memory_order_release ); + } + rpmalloc_thread_initialize(); + RpThreadInitDone = true; +} + +TRACY_API void InitRpmalloc() +{ + if( !RpThreadInitDone ) InitRpmallocPlumbing(); +} + +} + +#endif diff --git a/Dependencies/tracy/client/TracyArmCpuTable.hpp b/Dependencies/tracy/client/TracyArmCpuTable.hpp new file mode 100644 index 000000000..2b47c3a60 --- /dev/null +++ b/Dependencies/tracy/client/TracyArmCpuTable.hpp @@ -0,0 +1,419 @@ +namespace tracy +{ + +#if defined __linux__ && defined __ARM_ARCH + +static const char* DecodeArmImplementer( uint32_t v ) +{ + static char buf[16]; + switch( v ) + { + case 0x41: return "ARM"; + case 0x42: return "Broadcom"; + case 0x43: return "Cavium"; + case 0x44: return "DEC"; + case 0x46: return "Fujitsu"; + case 0x48: return "HiSilicon"; + case 0x49: return "Infineon"; + case 0x4d: return "Motorola"; + case 0x4e: return "Nvidia"; + case 0x50: return "Applied Micro"; + case 0x51: return "Qualcomm"; + case 0x53: return "Samsung"; + case 0x54: return "Texas Instruments"; + case 0x56: return "Marvell"; + case 0x61: return "Apple"; + case 0x66: return "Faraday"; + case 0x68: return "HXT"; + case 0x69: return "Intel"; + case 0xc0: return "Ampere Computing"; + default: break; + } + sprintf( buf, "0x%x", v ); + return buf; +} + +static const char* DecodeArmPart( uint32_t impl, uint32_t part ) +{ + static char buf[16]; + switch( impl ) + { + case 0x41: // ARM + switch( part ) + { + case 0x810: return "810"; + case 0x920: return "920"; + case 0x922: return "922"; + case 0x926: return "926"; + case 0x940: return "940"; + case 0x946: return "946"; + case 0x966: return "966"; + case 0xa20: return "1020"; + case 0xa22: return "1022"; + case 0xa26: return "1026"; + case 0xb02: return "11 MPCore"; + case 0xb36: return "1136"; + case 0xb56: return "1156"; + case 0xb76: return "1176"; + case 0xc05: return " Cortex-A5"; + case 0xc07: return " Cortex-A7"; + case 0xc08: return " Cortex-A8"; + case 0xc09: return " Cortex-A9"; + case 0xc0c: return " Cortex-A12"; + case 0xc0d: return " Rockchip RK3288"; + case 0xc0e: return " Cortex-A17"; + case 0xc0f: return " Cortex-A15"; + case 0xc14: return " Cortex-R4"; + case 0xc15: return " Cortex-R5"; + case 0xc17: return " Cortex-R7"; + case 0xc18: return " Cortex-R8"; + case 0xc20: return " Cortex-M0"; + case 0xc21: return " Cortex-M1"; + case 0xc23: return " Cortex-M3"; + case 0xc24: return " Cortex-M4"; + case 0xc27: return " Cortex-M7"; + case 0xc60: return " Cortex-M0+"; + case 0xd00: return " AArch64 simulator"; + case 0xd01: return " Cortex-A32"; + case 0xd02: return " Cortex-A34"; + case 0xd03: return " Cortex-A53"; + case 0xd04: return " Cortex-A35"; + case 0xd05: return " Cortex-A55"; + case 0xd06: return " Cortex-A65"; + case 0xd07: return " Cortex-A57"; + case 0xd08: return " Cortex-A72"; + case 0xd09: return " Cortex-A73"; + case 0xd0a: return " Cortex-A75"; + case 0xd0b: return " Cortex-A76"; + case 0xd0c: return " Neoverse N1"; + case 0xd0d: return " Cortex-A77"; + case 0xd0e: return " Cortex-A76AE"; + case 0xd0f: return " AEMv8"; + case 0xd13: return " Cortex-R52"; + case 0xd20: return " Cortex-M23"; + case 0xd21: return " Cortex-M33"; + case 0xd22: return " Cortex-M55"; + case 0xd40: return " Neoverse V1"; + case 0xd41: return " Cortex-A78"; + case 0xd42: return " Cortex-A78AE"; + case 0xd43: return " Cortex-A65AE"; + case 0xd44: return " Cortex-X1"; + case 0xd47: return " Cortex-A710"; + case 0xd48: return " Cortex-X2"; + case 0xd49: return " Neoverse N2"; + case 0xd4a: return " Neoverse E1"; + case 0xd4b: return " Cortex-A78C"; + case 0xd4c: return " Cortex-X1C"; + default: break; + } + case 0x42: // Broadcom + switch( part ) + { + case 0xf: return " Brahma B15"; + case 0x100: return " Brahma B53"; + case 0x516: return " ThunderX2"; + default: break; + } + case 0x43: // Cavium + switch( part ) + { + case 0xa0: return " ThunderX"; + case 0xa1: return " ThunderX 88XX"; + case 0xa2: return " ThunderX 81XX"; + case 0xa3: return " ThunderX 83XX"; + case 0xaf: return " ThunderX2 99xx"; + case 0xb0: return " OcteonTX2"; + case 0xb1: return " OcteonTX2 T98"; + case 0xb2: return " OcteonTX2 T96"; + case 0xb3: return " OcteonTX2 F95"; + case 0xb4: return " OcteonTX2 F95N"; + case 0xb5: return " OcteonTX2 F95MM"; + case 0xb6: return " OcteonTX2 F95O"; + case 0xb8: return " ThunderX3 T110"; + default: break; + } + case 0x44: // DEC + switch( part ) + { + case 0xa10: return " SA110"; + case 0xa11: return " SA1100"; + default: break; + } + case 0x46: // Fujitsu + switch( part ) + { + case 0x1: return " A64FX"; + default: break; + } + case 0x48: // HiSilicon + switch( part ) + { + case 0xd01: return " TSV100"; + case 0xd40: return " Kirin 980"; + default: break; + } + case 0x4e: // Nvidia + switch( part ) + { + case 0x0: return " Denver"; + case 0x3: return " Denver 2"; + case 0x4: return " Carmel"; + default: break; + } + case 0x50: // Applied Micro + switch( part ) + { + case 0x0: return " X-Gene"; + default: break; + } + case 0x51: // Qualcomm + switch( part ) + { + case 0xf: return " Scorpion"; + case 0x2d: return " Scorpion"; + case 0x4d: return " Krait"; + case 0x6f: return " Krait"; + case 0x200: return " Kryo"; + case 0x201: return " Kryo Silver (Snapdragon 821)"; + case 0x205: return " Kryo Gold"; + case 0x211: return " Kryo Silver (Snapdragon 820)"; + case 0x800: return " Kryo 260 / 280 Gold"; + case 0x801: return " Kryo 260 / 280 Silver"; + case 0x802: return " Kryo 385 Gold"; + case 0x803: return " Kryo 385 Silver"; + case 0x804: return " Kryo 485 Gold"; + case 0x805: return " Kryo 4xx/5xx Silver"; + case 0xc00: return " Falkor"; + case 0xc01: return " Saphira"; + default: break; + } + case 0x53: // Samsung + switch( part ) + { + case 0x1: return " Exynos M1/M2"; + case 0x2: return " Exynos M3"; + case 0x3: return " Exynos M4"; + case 0x4: return " Exynos M5"; + default: break; + } + case 0x54: // Texas Instruments + switch( part ) + { + case 0x925: return " TI925"; + default: break; + } + case 0x56: // Marvell + switch( part ) + { + case 0x131: return " Feroceon 88FR131"; + case 0x581: return " PJ4 / PJ4B"; + case 0x584: return " PJ4B-MP / PJ4C"; + default: break; + } + case 0x61: // Apple + switch( part ) + { + case 0x1: return " Cyclone"; + case 0x2: return " Typhoon"; + case 0x3: return " Typhoon/Capri"; + case 0x4: return " Twister"; + case 0x5: return " Twister/Elba/Malta"; + case 0x6: return " Hurricane"; + case 0x7: return " Hurricane/Myst"; + case 0x22: return " M1 Icestorm"; + case 0x23: return " M1 Firestorm"; + case 0x24: return " M1 Icestorm Pro"; + case 0x25: return " M1 Firestorm Pro"; + case 0x28: return " M1 Icestorm Max"; + case 0x29: return " M1 Firestorm Max"; + default: break; + } + case 0x66: // Faraday + switch( part ) + { + case 0x526: return " FA526"; + case 0x626: return " FA626"; + default: break; + } + case 0x68: // HXT + switch( part ) + { + case 0x0: return " Phecda"; + default: break; + } + case 0xc0: // Ampere Computing + switch( part ) + { + case 0xac3: return " Ampere1"; + default: break; + } + default: break; + } + sprintf( buf, " 0x%x", part ); + return buf; +} + +#elif defined __APPLE__ && TARGET_OS_IPHONE == 1 + +static const char* DecodeIosDevice( const char* id ) +{ + static const char* DeviceTable[] = { + "i386", "32-bit simulator", + "x86_64", "64-bit simulator", + "iPhone1,1", "iPhone", + "iPhone1,2", "iPhone 3G", + "iPhone2,1", "iPhone 3GS", + "iPhone3,1", "iPhone 4 (GSM)", + "iPhone3,2", "iPhone 4 (GSM)", + "iPhone3,3", "iPhone 4 (CDMA)", + "iPhone4,1", "iPhone 4S", + "iPhone5,1", "iPhone 5 (A1428)", + "iPhone5,2", "iPhone 5 (A1429)", + "iPhone5,3", "iPhone 5c (A1456/A1532)", + "iPhone5,4", "iPhone 5c (A1507/A1516/1526/A1529)", + "iPhone6,1", "iPhone 5s (A1433/A1533)", + "iPhone6,2", "iPhone 5s (A1457/A1518/A1528/A1530)", + "iPhone7,1", "iPhone 6 Plus", + "iPhone7,2", "iPhone 6", + "iPhone8,1", "iPhone 6S", + "iPhone8,2", "iPhone 6S Plus", + "iPhone8,4", "iPhone SE", + "iPhone9,1", "iPhone 7 (CDMA)", + "iPhone9,2", "iPhone 7 Plus (CDMA)", + "iPhone9,3", "iPhone 7 (GSM)", + "iPhone9,4", "iPhone 7 Plus (GSM)", + "iPhone10,1", "iPhone 8 (CDMA)", + "iPhone10,2", "iPhone 8 Plus (CDMA)", + "iPhone10,3", "iPhone X (CDMA)", + "iPhone10,4", "iPhone 8 (GSM)", + "iPhone10,5", "iPhone 8 Plus (GSM)", + "iPhone10,6", "iPhone X (GSM)", + "iPhone11,2", "iPhone XS", + "iPhone11,4", "iPhone XS Max", + "iPhone11,6", "iPhone XS Max China", + "iPhone11,8", "iPhone XR", + "iPhone12,1", "iPhone 11", + "iPhone12,3", "iPhone 11 Pro", + "iPhone12,5", "iPhone 11 Pro Max", + "iPhone12,8", "iPhone SE 2nd Gen", + "iPhone13,1", "iPhone 12 Mini", + "iPhone13,2", "iPhone 12", + "iPhone13,3", "iPhone 12 Pro", + "iPhone13,4", "iPhone 12 Pro Max", + "iPhone14,2", "iPhone 13 Pro", + "iPhone14,3", "iPhone 13 Pro Max", + "iPhone14,4", "iPhone 13 Mini", + "iPhone14,5", "iPhone 13", + "iPhone14,6", "iPhone SE 3rd Gen", + "iPhone14,7", "iPhone 14", + "iPhone14,8", "iPhone 14 Plus", + "iPhone15,2", "iPhone 14 Pro", + "iPhone15,3", "iPhone 14 Pro Max", + "iPhone15,4", "iPhone 15", + "iPhone15,5", "iPhone 15 Plus", + "iPhone16,1", "iPhone 15 Pro", + "iPhone16,2", "iPhone 15 Pro Max", + "iPad1,1", "iPad (A1219/A1337)", + "iPad2,1", "iPad 2 (A1395)", + "iPad2,2", "iPad 2 (A1396)", + "iPad2,3", "iPad 2 (A1397)", + "iPad2,4", "iPad 2 (A1395)", + "iPad2,5", "iPad Mini (A1432)", + "iPad2,6", "iPad Mini (A1454)", + "iPad2,7", "iPad Mini (A1455)", + "iPad3,1", "iPad 3 (A1416)", + "iPad3,2", "iPad 3 (A1403)", + "iPad3,3", "iPad 3 (A1430)", + "iPad3,4", "iPad 4 (A1458)", + "iPad3,5", "iPad 4 (A1459)", + "iPad3,6", "iPad 4 (A1460)", + "iPad4,1", "iPad Air (A1474)", + "iPad4,2", "iPad Air (A1475)", + "iPad4,3", "iPad Air (A1476)", + "iPad4,4", "iPad Mini 2 (A1489)", + "iPad4,5", "iPad Mini 2 (A1490)", + "iPad4,6", "iPad Mini 2 (A1491)", + "iPad4,7", "iPad Mini 3 (A1599)", + "iPad4,8", "iPad Mini 3 (A1600)", + "iPad4,9", "iPad Mini 3 (A1601)", + "iPad5,1", "iPad Mini 4 (A1538)", + "iPad5,2", "iPad Mini 4 (A1550)", + "iPad5,3", "iPad Air 2 (A1566)", + "iPad5,4", "iPad Air 2 (A1567)", + "iPad6,3", "iPad Pro 9.7\" (A1673)", + "iPad6,4", "iPad Pro 9.7\" (A1674)", + "iPad6,5", "iPad Pro 9.7\" (A1675)", + "iPad6,7", "iPad Pro 12.9\" (A1584)", + "iPad6,8", "iPad Pro 12.9\" (A1652)", + "iPad6,11", "iPad 5th gen (A1822)", + "iPad6,12", "iPad 5th gen (A1823)", + "iPad7,1", "iPad Pro 12.9\" 2nd gen (A1670)", + "iPad7,2", "iPad Pro 12.9\" 2nd gen (A1671/A1821)", + "iPad7,3", "iPad Pro 10.5\" (A1701)", + "iPad7,4", "iPad Pro 10.5\" (A1709)", + "iPad7,5", "iPad 6th gen (A1893)", + "iPad7,6", "iPad 6th gen (A1954)", + "iPad7,11", "iPad 7th gen 10.2\" (Wifi)", + "iPad7,12", "iPad 7th gen 10.2\" (Wifi+Cellular)", + "iPad8,1", "iPad Pro 11\" (A1980)", + "iPad8,2", "iPad Pro 11\" (A1980)", + "iPad8,3", "iPad Pro 11\" (A1934/A1979/A2013)", + "iPad8,4", "iPad Pro 11\" (A1934/A1979/A2013)", + "iPad8,5", "iPad Pro 12.9\" 3rd gen (A1876)", + "iPad8,6", "iPad Pro 12.9\" 3rd gen (A1876)", + "iPad8,7", "iPad Pro 12.9\" 3rd gen (A1895/A1983/A2014)", + "iPad8,8", "iPad Pro 12.9\" 3rd gen (A1895/A1983/A2014)", + "iPad8,9", "iPad Pro 11\" 2nd gen (Wifi)", + "iPad8,10", "iPad Pro 11\" 2nd gen (Wifi+Cellular)", + "iPad8,11", "iPad Pro 12.9\" 4th gen (Wifi)", + "iPad8,12", "iPad Pro 12.9\" 4th gen (Wifi+Cellular)", + "iPad11,1", "iPad Mini 5th gen (A2133)", + "iPad11,2", "iPad Mini 5th gen (A2124/A2125/A2126)", + "iPad11,3", "iPad Air 3rd gen (A2152)", + "iPad11,4", "iPad Air 3rd gen (A2123/A2153/A2154)", + "iPad11,6", "iPad 8th gen (WiFi)", + "iPad11,7", "iPad 8th gen (WiFi+Cellular)", + "iPad12,1", "iPad 9th Gen (WiFi)", + "iPad12,2", "iPad 9th Gen (WiFi+Cellular)", + "iPad13,1", "iPad Air 4th gen (WiFi)", + "iPad13,2", "iPad Air 4th gen (WiFi+Cellular)", + "iPad13,4", "iPad Pro 11\" 3rd gen", + "iPad13,5", "iPad Pro 11\" 3rd gen", + "iPad13,6", "iPad Pro 11\" 3rd gen", + "iPad13,7", "iPad Pro 11\" 3rd gen", + "iPad13,8", "iPad Pro 12.9\" 5th gen", + "iPad13,9", "iPad Pro 12.9\" 5th gen", + "iPad13,10", "iPad Pro 12.9\" 5th gen", + "iPad13,11", "iPad Pro 12.9\" 5th gen", + "iPad13,16", "iPad Air 5th Gen (WiFi)", + "iPad13,17", "iPad Air 5th Gen (WiFi+Cellular)", + "iPad13,18", "iPad 10th Gen", + "iPad13,19", "iPad 10th Gen", + "iPad14,1", "iPad mini 6th Gen (WiFi)", + "iPad14,2", "iPad mini 6th Gen (WiFi+Cellular)", + "iPad14,3", "iPad Pro 11\" 4th Gen", + "iPad14,4", "iPad Pro 11\" 4th Gen", + "iPad14,5", "iPad Pro 12.9\" 6th Gen", + "iPad14,6", "iPad Pro 12.9\" 6th Gen", + "iPod1,1", "iPod Touch", + "iPod2,1", "iPod Touch 2nd gen", + "iPod3,1", "iPod Touch 3rd gen", + "iPod4,1", "iPod Touch 4th gen", + "iPod5,1", "iPod Touch 5th gen", + "iPod7,1", "iPod Touch 6th gen", + "iPod9,1", "iPod Touch 7th gen", + nullptr + }; + + auto ptr = DeviceTable; + while( *ptr ) + { + if( strcmp( ptr[0], id ) == 0 ) return ptr[1]; + ptr += 2; + } + return id; +} + +#endif + +} diff --git a/Dependencies/tracy/client/TracyCallstack.cpp b/Dependencies/tracy/client/TracyCallstack.cpp new file mode 100644 index 000000000..946a19721 --- /dev/null +++ b/Dependencies/tracy/client/TracyCallstack.cpp @@ -0,0 +1,1415 @@ +#include +#include +#include +#include +#include "TracyCallstack.hpp" +#include "TracyDebug.hpp" +#include "TracyFastVector.hpp" +#include "TracyStringHelpers.hpp" +#include "../common/TracyAlloc.hpp" +#include "../common/TracySystem.hpp" + + +#ifdef TRACY_HAS_CALLSTACK + +#if TRACY_HAS_CALLSTACK == 1 +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +# include +# include +# ifdef _MSC_VER +# pragma warning( push ) +# pragma warning( disable : 4091 ) +# endif +# include +# ifdef _MSC_VER +# pragma warning( pop ) +# endif +#elif TRACY_HAS_CALLSTACK == 2 || TRACY_HAS_CALLSTACK == 3 || TRACY_HAS_CALLSTACK == 4 || TRACY_HAS_CALLSTACK == 6 +# include "../libbacktrace/backtrace.hpp" +# include +# include +# include +# include +#elif TRACY_HAS_CALLSTACK == 5 +# include +# include +#endif + +#ifdef TRACY_DBGHELP_LOCK +# include "TracyProfiler.hpp" + +# define DBGHELP_INIT TracyConcat( TRACY_DBGHELP_LOCK, Init() ) +# define DBGHELP_LOCK TracyConcat( TRACY_DBGHELP_LOCK, Lock() ); +# define DBGHELP_UNLOCK TracyConcat( TRACY_DBGHELP_LOCK, Unlock() ); + +extern "C" +{ + void DBGHELP_INIT; + void DBGHELP_LOCK; + void DBGHELP_UNLOCK; +}; +#endif + +#if TRACY_HAS_CALLSTACK == 2 || TRACY_HAS_CALLSTACK == 3 || TRACY_HAS_CALLSTACK == 4 || TRACY_HAS_CALLSTACK == 5 || TRACY_HAS_CALLSTACK == 6 +// If you want to use your own demangling functionality (e.g. for another language), +// define TRACY_DEMANGLE and provide your own implementation of the __tracy_demangle +// function. The input parameter is a function name. The demangle function must +// identify whether this name is mangled, and fail if it is not. Failure is indicated +// by returning nullptr. If demangling succeeds, a pointer to the C string containing +// demangled function must be returned. The demangling function is responsible for +// managing memory for this string. It is expected that it will be internally reused. +// When a call to ___tracy_demangle is made, previous contents of the string memory +// do not need to be preserved. Function may return string of any length, but the +// profiler can choose to truncate it. +extern "C" const char* ___tracy_demangle( const char* mangled ); + +#ifndef TRACY_DEMANGLE +constexpr size_t ___tracy_demangle_buffer_len = 1024*1024; +char* ___tracy_demangle_buffer; + +void ___tracy_init_demangle_buffer() +{ + ___tracy_demangle_buffer = (char*)tracy::tracy_malloc( ___tracy_demangle_buffer_len ); +} + +void ___tracy_free_demangle_buffer() +{ + tracy::tracy_free( ___tracy_demangle_buffer ); +} + +extern "C" const char* ___tracy_demangle( const char* mangled ) +{ + if( !mangled || mangled[0] != '_' ) return nullptr; + if( strlen( mangled ) > ___tracy_demangle_buffer_len ) return nullptr; + int status; + size_t len = ___tracy_demangle_buffer_len; + return abi::__cxa_demangle( mangled, ___tracy_demangle_buffer, &len, &status ); +} +#endif +#endif + +#if TRACY_HAS_CALLSTACK == 3 +# define TRACY_USE_IMAGE_CACHE +# include +#endif + +namespace tracy +{ + +#ifdef TRACY_USE_IMAGE_CACHE +// when we have access to dl_iterate_phdr(), we can build a cache of address ranges to image paths +// so we can quickly determine which image an address falls into. +// We refresh this cache only when we hit an address that doesn't fall into any known range. +class ImageCache +{ +public: + struct ImageEntry + { + void* m_startAddress = nullptr; + void* m_endAddress = nullptr; + char* m_name = nullptr; + }; + + ImageCache() + : m_images( 512 ) + { + Refresh(); + } + + ~ImageCache() + { + Clear(); + } + + const ImageEntry* GetImageForAddress( void* address ) + { + const ImageEntry* entry = GetImageForAddressImpl( address ); + if( !entry ) + { + Refresh(); + return GetImageForAddressImpl( address ); + } + return entry; + } + +private: + tracy::FastVector m_images; + bool m_updated = false; + bool m_haveMainImageName = false; + + static int Callback( struct dl_phdr_info* info, size_t size, void* data ) + { + ImageCache* cache = reinterpret_cast( data ); + + const auto startAddress = reinterpret_cast( info->dlpi_addr ); + if( cache->Contains( startAddress ) ) return 0; + + const uint32_t headerCount = info->dlpi_phnum; + assert( headerCount > 0); + const auto endAddress = reinterpret_cast( info->dlpi_addr + + info->dlpi_phdr[info->dlpi_phnum - 1].p_vaddr + info->dlpi_phdr[info->dlpi_phnum - 1].p_memsz); + + ImageEntry* image = cache->m_images.push_next(); + image->m_startAddress = startAddress; + image->m_endAddress = endAddress; + + // the base executable name isn't provided when iterating with dl_iterate_phdr, + // we will have to patch the executable image name outside this callback + if( info->dlpi_name && info->dlpi_name[0] != '\0' ) + { + size_t sz = strlen( info->dlpi_name ) + 1; + image->m_name = (char*)tracy_malloc( sz ); + memcpy( image->m_name, info->dlpi_name, sz ); + } + else + { + image->m_name = nullptr; + } + + cache->m_updated = true; + + return 0; + } + + bool Contains( void* startAddress ) const + { + return std::any_of( m_images.begin(), m_images.end(), [startAddress]( const ImageEntry& entry ) { return startAddress == entry.m_startAddress; } ); + } + + void Refresh() + { + m_updated = false; + dl_iterate_phdr( Callback, this ); + + if( m_updated ) + { + std::sort( m_images.begin(), m_images.end(), + []( const ImageEntry& lhs, const ImageEntry& rhs ) { return lhs.m_startAddress > rhs.m_startAddress; } ); + + // patch the main executable image name here, as calling dl_* functions inside the dl_iterate_phdr callback might cause deadlocks + UpdateMainImageName(); + } + } + + void UpdateMainImageName() + { + if( m_haveMainImageName ) + { + return; + } + + for( ImageEntry& entry : m_images ) + { + if( entry.m_name == nullptr ) + { + Dl_info dlInfo; + if( dladdr( (void *)entry.m_startAddress, &dlInfo ) ) + { + if( dlInfo.dli_fname ) + { + size_t sz = strlen( dlInfo.dli_fname ) + 1; + entry.m_name = (char*)tracy_malloc( sz ); + memcpy( entry.m_name, dlInfo.dli_fname, sz ); + } + } + + // we only expect one entry to be null for the main executable entry + break; + } + } + + m_haveMainImageName = true; + } + + const ImageEntry* GetImageForAddressImpl( void* address ) const + { + auto it = std::lower_bound( m_images.begin(), m_images.end(), address, + []( const ImageEntry& lhs, const void* rhs ) { return lhs.m_startAddress > rhs; } ); + + if( it != m_images.end() && address < it->m_endAddress ) + { + return it; + } + return nullptr; + } + + void Clear() + { + for( ImageEntry& entry : m_images ) + { + tracy_free( entry.m_name ); + } + + m_images.clear(); + m_haveMainImageName = false; + } +}; +#endif //#ifdef TRACY_USE_IMAGE_CACHE + +// when "TRACY_SYMBOL_OFFLINE_RESOLVE" is set, instead of fully resolving symbols at runtime, +// simply resolve the offset and image name (which will be enough the resolving to be done offline) +#ifdef TRACY_SYMBOL_OFFLINE_RESOLVE +constexpr bool s_shouldResolveSymbolsOffline = true; +#else +static bool s_shouldResolveSymbolsOffline = false; +bool ShouldResolveSymbolsOffline() +{ + const char* symbolOfflineResolve = GetEnvVar( "TRACY_SYMBOL_OFFLINE_RESOLVE" ); + return (symbolOfflineResolve && symbolOfflineResolve[0] == '1'); +} +#endif // #ifdef TRACY_SYMBOL_OFFLINE_RESOLVE + +#if TRACY_HAS_CALLSTACK == 1 + +enum { MaxCbTrace = 64 }; +enum { MaxNameSize = 8*1024 }; + +int cb_num; +CallstackEntry cb_data[MaxCbTrace]; + +extern "C" +{ + typedef DWORD (__stdcall *t_SymAddrIncludeInlineTrace)( HANDLE hProcess, DWORD64 Address ); + typedef BOOL (__stdcall *t_SymQueryInlineTrace)( HANDLE hProcess, DWORD64 StartAddress, DWORD StartContext, DWORD64 StartRetAddress, DWORD64 CurAddress, LPDWORD CurContext, LPDWORD CurFrameIndex ); + typedef BOOL (__stdcall *t_SymFromInlineContext)( HANDLE hProcess, DWORD64 Address, ULONG InlineContext, PDWORD64 Displacement, PSYMBOL_INFO Symbol ); + typedef BOOL (__stdcall *t_SymGetLineFromInlineContext)( HANDLE hProcess, DWORD64 qwAddr, ULONG InlineContext, DWORD64 qwModuleBaseAddress, PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line64 ); + + t_SymAddrIncludeInlineTrace _SymAddrIncludeInlineTrace = 0; + t_SymQueryInlineTrace _SymQueryInlineTrace = 0; + t_SymFromInlineContext _SymFromInlineContext = 0; + t_SymGetLineFromInlineContext _SymGetLineFromInlineContext = 0; + + TRACY_API ___tracy_t_RtlWalkFrameChain ___tracy_RtlWalkFrameChain = 0; +} + +struct ModuleCache +{ + uint64_t start; + uint64_t end; + char* name; +}; + +static FastVector* s_modCache; + + +struct KernelDriver +{ + uint64_t addr; + const char* mod; + const char* path; +}; + +KernelDriver* s_krnlCache = nullptr; +size_t s_krnlCacheCnt; + +void InitCallstackCritical() +{ + ___tracy_RtlWalkFrameChain = (___tracy_t_RtlWalkFrameChain)GetProcAddress( GetModuleHandleA( "ntdll.dll" ), "RtlWalkFrameChain" ); +} + +void DbgHelpInit() +{ + if( s_shouldResolveSymbolsOffline ) return; + + _SymAddrIncludeInlineTrace = (t_SymAddrIncludeInlineTrace)GetProcAddress(GetModuleHandleA("dbghelp.dll"), "SymAddrIncludeInlineTrace"); + _SymQueryInlineTrace = (t_SymQueryInlineTrace)GetProcAddress(GetModuleHandleA("dbghelp.dll"), "SymQueryInlineTrace"); + _SymFromInlineContext = (t_SymFromInlineContext)GetProcAddress(GetModuleHandleA("dbghelp.dll"), "SymFromInlineContext"); + _SymGetLineFromInlineContext = (t_SymGetLineFromInlineContext)GetProcAddress(GetModuleHandleA("dbghelp.dll"), "SymGetLineFromInlineContext"); + +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_INIT; + DBGHELP_LOCK; +#endif + + SymInitialize( GetCurrentProcess(), nullptr, true ); + SymSetOptions( SYMOPT_LOAD_LINES ); + +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_UNLOCK; +#endif +} + +DWORD64 DbgHelpLoadSymbolsForModule( const char* imageName, uint64_t baseOfDll, uint32_t bllSize ) +{ + if( s_shouldResolveSymbolsOffline ) return 0; + return SymLoadModuleEx( GetCurrentProcess(), nullptr, imageName, nullptr, baseOfDll, bllSize, nullptr, 0 ); +} + +ModuleCache* LoadSymbolsForModuleAndCache( const char* imageName, uint32_t imageNameLength, uint64_t baseOfDll, uint32_t dllSize ) +{ + DbgHelpLoadSymbolsForModule( imageName, baseOfDll, dllSize ); + + ModuleCache* cachedModule = s_modCache->push_next(); + cachedModule->start = baseOfDll; + cachedModule->end = baseOfDll + dllSize; + + // when doing offline symbol resolution, we must store the full path of the dll for the resolving to work + if( s_shouldResolveSymbolsOffline ) + { + cachedModule->name = (char*)tracy_malloc_fast(imageNameLength + 1); + memcpy(cachedModule->name, imageName, imageNameLength); + cachedModule->name[imageNameLength] = '\0'; + } + else + { + auto ptr = imageName + imageNameLength; + while (ptr > imageName && *ptr != '\\' && *ptr != '/') ptr--; + if (ptr > imageName) ptr++; + const auto namelen = imageName + imageNameLength - ptr; + cachedModule->name = (char*)tracy_malloc_fast(namelen + 3); + cachedModule->name[0] = '['; + memcpy(cachedModule->name + 1, ptr, namelen); + cachedModule->name[namelen + 1] = ']'; + cachedModule->name[namelen + 2] = '\0'; + } + + return cachedModule; +} + +void InitCallstack() +{ +#ifndef TRACY_SYMBOL_OFFLINE_RESOLVE + s_shouldResolveSymbolsOffline = ShouldResolveSymbolsOffline(); +#endif //#ifndef TRACY_SYMBOL_OFFLINE_RESOLVE + if( s_shouldResolveSymbolsOffline ) + { + TracyDebug("TRACY: enabling offline symbol resolving!\n"); + } + + DbgHelpInit(); + +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_LOCK; +#endif + + // use TRACY_NO_DBGHELP_INIT_LOAD=1 to disable preloading of driver + // and process module symbol loading at startup time - they will be loaded on demand later + // Sometimes this process can take a very long time and prevent resolving callstack frames + // symbols during that time. + const char* noInitLoadEnv = GetEnvVar( "TRACY_NO_DBGHELP_INIT_LOAD" ); + const bool initTimeModuleLoad = !( noInitLoadEnv && noInitLoadEnv[0] == '1' ); + if ( !initTimeModuleLoad ) + { + TracyDebug("TRACY: skipping init time dbghelper module load\n"); + } + + DWORD needed; + LPVOID dev[4096]; + if( initTimeModuleLoad && EnumDeviceDrivers( dev, sizeof(dev), &needed ) != 0 ) + { + char windir[MAX_PATH]; + if( !GetWindowsDirectoryA( windir, sizeof( windir ) ) ) memcpy( windir, "c:\\windows", 11 ); + const auto windirlen = strlen( windir ); + + const auto sz = needed / sizeof( LPVOID ); + s_krnlCache = (KernelDriver*)tracy_malloc( sizeof(KernelDriver) * sz ); + int cnt = 0; + for( size_t i=0; i", 2 ); + s_krnlCache[cnt] = KernelDriver { (uint64_t)dev[i], buf }; + + const auto len = GetDeviceDriverFileNameA( dev[i], fn, sizeof( fn ) ); + if( len != 0 ) + { + char full[MAX_PATH]; + char* path = fn; + + if( memcmp( fn, "\\SystemRoot\\", 12 ) == 0 ) + { + memcpy( full, windir, windirlen ); + strcpy( full + windirlen, fn + 11 ); + path = full; + } + + DbgHelpLoadSymbolsForModule( path, (DWORD64)dev[i], 0 ); + + const auto psz = strlen( path ); + auto pptr = (char*)tracy_malloc_fast( psz+1 ); + memcpy( pptr, path, psz ); + pptr[psz] = '\0'; + s_krnlCache[cnt].path = pptr; + } + + cnt++; + } + } + s_krnlCacheCnt = cnt; + std::sort( s_krnlCache, s_krnlCache + s_krnlCacheCnt, []( const KernelDriver& lhs, const KernelDriver& rhs ) { return lhs.addr > rhs.addr; } ); + } + + s_modCache = (FastVector*)tracy_malloc( sizeof( FastVector ) ); + new(s_modCache) FastVector( 512 ); + + HANDLE proc = GetCurrentProcess(); + HMODULE mod[1024]; + if( initTimeModuleLoad && EnumProcessModules( proc, mod, sizeof( mod ), &needed ) != 0 ) + { + const auto sz = needed / sizeof( HMODULE ); + for( size_t i=0; i 0 ) + { + // This may be a new module loaded since our call to SymInitialize. + // Just in case, force DbgHelp to load its pdb ! + LoadSymbolsForModuleAndCache( name, nameLength, (DWORD64)info.lpBaseOfDll, info.SizeOfImage ); + } + } + } + } + +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_UNLOCK; +#endif +} + +void EndCallstack() +{ +} + +const char* DecodeCallstackPtrFast( uint64_t ptr ) +{ + if( s_shouldResolveSymbolsOffline ) return "[unresolved]"; + + static char ret[MaxNameSize]; + const auto proc = GetCurrentProcess(); + + char buf[sizeof( SYMBOL_INFO ) + MaxNameSize]; + auto si = (SYMBOL_INFO*)buf; + si->SizeOfStruct = sizeof( SYMBOL_INFO ); + si->MaxNameLen = MaxNameSize; + +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_LOCK; +#endif + if( SymFromAddr( proc, ptr, nullptr, si ) == 0 ) + { + *ret = '\0'; + } + else + { + memcpy( ret, si->Name, si->NameLen ); + ret[si->NameLen] = '\0'; + } +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_UNLOCK; +#endif + return ret; +} + +const char* GetKernelModulePath( uint64_t addr ) +{ + assert( addr >> 63 != 0 ); + if( !s_krnlCache ) return nullptr; + auto it = std::lower_bound( s_krnlCache, s_krnlCache + s_krnlCacheCnt, addr, []( const KernelDriver& lhs, const uint64_t& rhs ) { return lhs.addr > rhs; } ); + if( it == s_krnlCache + s_krnlCacheCnt ) return nullptr; + return it->path; +} + +struct ModuleNameAndBaseAddress +{ + const char* name; + uint64_t baseAddr; +}; + +ModuleNameAndBaseAddress GetModuleNameAndPrepareSymbols( uint64_t addr ) +{ + if( ( addr >> 63 ) != 0 ) + { + if( s_krnlCache ) + { + auto it = std::lower_bound( s_krnlCache, s_krnlCache + s_krnlCacheCnt, addr, []( const KernelDriver& lhs, const uint64_t& rhs ) { return lhs.addr > rhs; } ); + if( it != s_krnlCache + s_krnlCacheCnt ) + { + return ModuleNameAndBaseAddress{ it->mod, it->addr }; + } + } + return ModuleNameAndBaseAddress{ "", addr }; + } + + for( auto& v : *s_modCache ) + { + if( addr >= v.start && addr < v.end ) + { + return ModuleNameAndBaseAddress{ v.name, v.start }; + } + } + + HMODULE mod[1024]; + DWORD needed; + HANDLE proc = GetCurrentProcess(); + + InitRpmalloc(); + if( EnumProcessModules( proc, mod, sizeof( mod ), &needed ) != 0 ) + { + const auto sz = needed / sizeof( HMODULE ); + for( size_t i=0; i= base && addr < base + info.SizeOfImage ) + { + char name[1024]; + const auto nameLength = GetModuleFileNameA( mod[i], name, 1021 ); + if( nameLength > 0 ) + { + // since this is the first time we encounter this module, load its symbols (needed for modules loaded after SymInitialize) + ModuleCache* cachedModule = LoadSymbolsForModuleAndCache( name, nameLength, (DWORD64)info.lpBaseOfDll, info.SizeOfImage ); + return ModuleNameAndBaseAddress{ cachedModule->name, cachedModule->start }; + } + } + } + } + } + + return ModuleNameAndBaseAddress{ "[unknown]", 0x0 }; +} + +CallstackSymbolData DecodeSymbolAddress( uint64_t ptr ) +{ + CallstackSymbolData sym; + + if( s_shouldResolveSymbolsOffline ) + { + sym.file = "[unknown]"; + sym.line = 0; + sym.needFree = false; + return sym; + } + + IMAGEHLP_LINE64 line; + DWORD displacement = 0; + line.SizeOfStruct = sizeof(IMAGEHLP_LINE64); +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_LOCK; +#endif + const auto res = SymGetLineFromAddr64( GetCurrentProcess(), ptr, &displacement, &line ); + if( res == 0 || line.LineNumber >= 0xF00000 ) + { + sym.file = "[unknown]"; + sym.line = 0; + sym.needFree = false; + } + else + { + sym.file = CopyString( line.FileName ); + sym.line = line.LineNumber; + sym.needFree = true; + } +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_UNLOCK; +#endif + return sym; +} + +CallstackEntryData DecodeCallstackPtr( uint64_t ptr ) +{ +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_LOCK; +#endif + + InitRpmalloc(); + + const ModuleNameAndBaseAddress moduleNameAndAddress = GetModuleNameAndPrepareSymbols( ptr ); + + if( s_shouldResolveSymbolsOffline ) + { +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_UNLOCK; +#endif + + cb_data[0].symAddr = ptr - moduleNameAndAddress.baseAddr; + cb_data[0].symLen = 0; + + cb_data[0].name = CopyStringFast("[unresolved]"); + cb_data[0].file = CopyStringFast("[unknown]"); + cb_data[0].line = 0; + + return { cb_data, 1, moduleNameAndAddress.name }; + } + + int write; + const auto proc = GetCurrentProcess(); + +#if !defined TRACY_NO_CALLSTACK_INLINES + BOOL doInline = FALSE; + DWORD ctx = 0; + DWORD inlineNum = 0; + if( _SymAddrIncludeInlineTrace ) + { + inlineNum = _SymAddrIncludeInlineTrace( proc, ptr ); + if( inlineNum > MaxCbTrace - 1 ) inlineNum = MaxCbTrace - 1; + DWORD idx; + if( inlineNum != 0 ) doInline = _SymQueryInlineTrace( proc, ptr, 0, ptr, ptr, &ctx, &idx ); + } + if( doInline ) + { + write = inlineNum; + cb_num = 1 + inlineNum; + } + else +#endif + { + write = 0; + cb_num = 1; + } + + char buf[sizeof( SYMBOL_INFO ) + MaxNameSize]; + auto si = (SYMBOL_INFO*)buf; + si->SizeOfStruct = sizeof( SYMBOL_INFO ); + si->MaxNameLen = MaxNameSize; + + const auto symValid = SymFromAddr( proc, ptr, nullptr, si ) != 0; + + IMAGEHLP_LINE64 line; + DWORD displacement = 0; + line.SizeOfStruct = sizeof(IMAGEHLP_LINE64); + + { + const char* filename; + const auto res = SymGetLineFromAddr64( proc, ptr, &displacement, &line ); + if( res == 0 || line.LineNumber >= 0xF00000 ) + { + filename = "[unknown]"; + cb_data[write].line = 0; + } + else + { + filename = line.FileName; + cb_data[write].line = line.LineNumber; + } + + cb_data[write].name = symValid ? CopyStringFast( si->Name, si->NameLen ) : CopyStringFast( moduleNameAndAddress.name ); + cb_data[write].file = CopyStringFast( filename ); + if( symValid ) + { + cb_data[write].symLen = si->Size; + cb_data[write].symAddr = si->Address; + } + else + { + cb_data[write].symLen = 0; + cb_data[write].symAddr = 0; + } + } + +#if !defined TRACY_NO_CALLSTACK_INLINES + if( doInline ) + { + for( DWORD i=0; iName, si->NameLen ) : CopyStringFast( moduleNameAndAddress.name ); + cb.file = CopyStringFast( filename ); + if( symInlineValid ) + { + cb.symLen = si->Size; + cb.symAddr = si->Address; + } + else + { + cb.symLen = 0; + cb.symAddr = 0; + } + + ctx++; + } + } +#endif +#ifdef TRACY_DBGHELP_LOCK + DBGHELP_UNLOCK; +#endif + + return { cb_data, uint8_t( cb_num ), moduleNameAndAddress.name }; +} + +#elif TRACY_HAS_CALLSTACK == 2 || TRACY_HAS_CALLSTACK == 3 || TRACY_HAS_CALLSTACK == 4 || TRACY_HAS_CALLSTACK == 6 + +enum { MaxCbTrace = 64 }; + +struct backtrace_state* cb_bts = nullptr; + +int cb_num; +CallstackEntry cb_data[MaxCbTrace]; +int cb_fixup; +#ifdef TRACY_USE_IMAGE_CACHE +static ImageCache* s_imageCache = nullptr; +#endif //#ifdef TRACY_USE_IMAGE_CACHE + +#ifdef TRACY_DEBUGINFOD +debuginfod_client* s_debuginfod; + +struct DebugInfo +{ + uint8_t* buildid; + size_t buildid_size; + char* filename; + int fd; +}; + +static FastVector* s_di_known; +#endif + +#ifdef __linux +struct KernelSymbol +{ + uint64_t addr; + uint32_t size; + const char* name; + const char* mod; +}; + +KernelSymbol* s_kernelSym = nullptr; +size_t s_kernelSymCnt; + +static void InitKernelSymbols() +{ + FILE* f = fopen( "/proc/kallsyms", "rb" ); + if( !f ) return; + tracy::FastVector tmpSym( 512 * 1024 ); + size_t linelen = 16 * 1024; // linelen must be big enough to prevent reallocs in getline() + auto linebuf = (char*)tracy_malloc( linelen ); + ssize_t sz; + size_t validCnt = 0; + while( ( sz = getline( &linebuf, &linelen, f ) ) != -1 ) + { + auto ptr = linebuf; + uint64_t addr = 0; + while( *ptr != ' ' ) + { + auto v = *ptr; + if( v >= '0' && v <= '9' ) + { + v -= '0'; + } + else if( v >= 'a' && v <= 'f' ) + { + v -= 'a'; + v += 10; + } + else if( v >= 'A' && v <= 'F' ) + { + v -= 'A'; + v += 10; + } + else + { + assert( false ); + } + assert( ( v & ~0xF ) == 0 ); + addr <<= 4; + addr |= v; + ptr++; + } + if( addr == 0 ) continue; + ptr++; + const bool valid = *ptr == 'T' || *ptr == 't'; + ptr += 2; + const auto namestart = ptr; + while( *ptr != '\t' && *ptr != '\n' ) ptr++; + const auto nameend = ptr; + const char* modstart = nullptr; + const char* modend; + if( *ptr == '\t' ) + { + ptr += 2; + modstart = ptr; + while( *ptr != ']' ) ptr++; + modend = ptr; + } + + char* strname = nullptr; + char* strmod = nullptr; + + if( valid ) + { + validCnt++; + + strname = (char*)tracy_malloc_fast( nameend - namestart + 1 ); + memcpy( strname, namestart, nameend - namestart ); + strname[nameend-namestart] = '\0'; + + if( modstart ) + { + strmod = (char*)tracy_malloc_fast( modend - modstart + 1 ); + memcpy( strmod, modstart, modend - modstart ); + strmod[modend-modstart] = '\0'; + } + } + + auto sym = tmpSym.push_next(); + sym->addr = addr; + sym->size = 0; + sym->name = strname; + sym->mod = strmod; + } + tracy_free_fast( linebuf ); + fclose( f ); + if( tmpSym.empty() ) return; + + std::sort( tmpSym.begin(), tmpSym.end(), []( const KernelSymbol& lhs, const KernelSymbol& rhs ) { return lhs.addr < rhs.addr; } ); + for( size_t i=0; i res && *back != '/' ) back--; + rsz = back - res; + ptr = next + 1; + continue; + } + break; + case 1: + if( *ptr == '.' ) + { + ptr = next + 1; + continue; + } + break; + case 0: + ptr = next + 1; + continue; + } + if( rsz != 1 ) res[rsz++] = '/'; + memcpy( res+rsz, ptr, lsz ); + rsz += lsz; + ptr = next + 1; + } + + if( rsz == 0 ) + { + memcpy( res, "/", 2 ); + } + else + { + res[rsz] = '\0'; + } + return res; +} + +void InitCallstackCritical() +{ +} + +void InitCallstack() +{ + InitRpmalloc(); + +#ifdef TRACY_USE_IMAGE_CACHE + s_imageCache = (ImageCache*)tracy_malloc( sizeof( ImageCache ) ); + new(s_imageCache) ImageCache(); +#endif //#ifdef TRACY_USE_IMAGE_CACHE + +#ifndef TRACY_SYMBOL_OFFLINE_RESOLVE + s_shouldResolveSymbolsOffline = ShouldResolveSymbolsOffline(); +#endif //#ifndef TRACY_SYMBOL_OFFLINE_RESOLVE + if( s_shouldResolveSymbolsOffline ) + { + cb_bts = nullptr; // disable use of libbacktrace calls + TracyDebug("TRACY: enabling offline symbol resolving!\n"); + } + else + { + cb_bts = backtrace_create_state( nullptr, 0, nullptr, nullptr ); + } + +#ifndef TRACY_DEMANGLE + ___tracy_init_demangle_buffer(); +#endif + +#ifdef __linux + InitKernelSymbols(); +#endif +#ifdef TRACY_DEBUGINFOD + s_debuginfod = debuginfod_begin(); + s_di_known = (FastVector*)tracy_malloc( sizeof( FastVector ) ); + new (s_di_known) FastVector( 16 ); +#endif +} + +#ifdef TRACY_DEBUGINFOD +void ClearDebugInfoVector( FastVector& vec ) +{ + for( auto& v : vec ) + { + tracy_free( v.buildid ); + tracy_free( v.filename ); + if( v.fd >= 0 ) close( v.fd ); + } + vec.clear(); +} + +DebugInfo* FindDebugInfo( FastVector& vec, const uint8_t* buildid_data, size_t buildid_size ) +{ + for( auto& v : vec ) + { + if( v.buildid_size == buildid_size && memcmp( v.buildid, buildid_data, buildid_size ) == 0 ) + { + return &v; + } + } + return nullptr; +} + +int GetDebugInfoDescriptor( const char* buildid_data, size_t buildid_size, const char* filename ) +{ + auto buildid = (uint8_t*)buildid_data; + auto it = FindDebugInfo( *s_di_known, buildid, buildid_size ); + if( it ) return it->fd >= 0 ? dup( it->fd ) : -1; + + int fd = debuginfod_find_debuginfo( s_debuginfod, buildid, buildid_size, nullptr ); + it = s_di_known->push_next(); + it->buildid_size = buildid_size; + it->buildid = (uint8_t*)tracy_malloc( buildid_size ); + memcpy( it->buildid, buildid, buildid_size ); + const auto fnsz = strlen( filename ) + 1; + it->filename = (char*)tracy_malloc( fnsz ); + memcpy( it->filename, filename, fnsz ); + it->fd = fd >= 0 ? fd : -1; + TracyDebug( "DebugInfo descriptor query: %i, fn: %s\n", fd, filename ); + return it->fd; +} + +const uint8_t* GetBuildIdForImage( const char* image, size_t& size ) +{ + assert( image ); + for( auto& v : *s_di_known ) + { + if( strcmp( image, v.filename ) == 0 ) + { + size = v.buildid_size; + return v.buildid; + } + } + return nullptr; +} + +debuginfod_client* GetDebuginfodClient() +{ + return s_debuginfod; +} +#endif + +void EndCallstack() +{ +#ifdef TRACY_USE_IMAGE_CACHE + if( s_imageCache ) + { + s_imageCache->~ImageCache(); + tracy_free( s_imageCache ); + } +#endif //#ifdef TRACY_USE_IMAGE_CACHE +#ifndef TRACY_DEMANGLE + ___tracy_free_demangle_buffer(); +#endif +#ifdef TRACY_DEBUGINFOD + ClearDebugInfoVector( *s_di_known ); + s_di_known->~FastVector(); + tracy_free( s_di_known ); + + debuginfod_end( s_debuginfod ); +#endif +} + +const char* DecodeCallstackPtrFast( uint64_t ptr ) +{ + static char ret[1024]; + auto vptr = (void*)ptr; + const char* symname = nullptr; + Dl_info dlinfo; + if( dladdr( vptr, &dlinfo ) && dlinfo.dli_sname ) + { + symname = dlinfo.dli_sname; + } + if( symname ) + { + strcpy( ret, symname ); + } + else + { + *ret = '\0'; + } + return ret; +} + +static int SymbolAddressDataCb( void* data, uintptr_t pc, uintptr_t lowaddr, const char* fn, int lineno, const char* function ) +{ + auto& sym = *(CallstackSymbolData*)data; + if( !fn ) + { + sym.file = "[unknown]"; + sym.line = 0; + sym.needFree = false; + } + else + { + sym.file = NormalizePath( fn ); + if( !sym.file ) sym.file = CopyString( fn ); + sym.line = lineno; + sym.needFree = true; + } + + return 1; +} + +static void SymbolAddressErrorCb( void* data, const char* /*msg*/, int /*errnum*/ ) +{ + auto& sym = *(CallstackSymbolData*)data; + sym.file = "[unknown]"; + sym.line = 0; + sym.needFree = false; +} + +CallstackSymbolData DecodeSymbolAddress( uint64_t ptr ) +{ + CallstackSymbolData sym; + if( cb_bts ) + { + backtrace_pcinfo( cb_bts, ptr, SymbolAddressDataCb, SymbolAddressErrorCb, &sym ); + } + else + { + SymbolAddressErrorCb(&sym, nullptr, 0); + } + + return sym; +} + +static int CallstackDataCb( void* /*data*/, uintptr_t pc, uintptr_t lowaddr, const char* fn, int lineno, const char* function ) +{ + cb_data[cb_num].symLen = 0; + cb_data[cb_num].symAddr = (uint64_t)lowaddr; + + if( !fn && !function ) + { + const char* symname = nullptr; + auto vptr = (void*)pc; + ptrdiff_t symoff = 0; + + Dl_info dlinfo; + if( dladdr( vptr, &dlinfo ) ) + { + symname = dlinfo.dli_sname; + symoff = (char*)pc - (char*)dlinfo.dli_saddr; + const char* demangled = ___tracy_demangle( symname ); + if( demangled ) symname = demangled; + } + + if( !symname ) symname = "[unknown]"; + + if( symoff == 0 ) + { + const auto len = std::min( strlen( symname ), std::numeric_limits::max() ); + cb_data[cb_num].name = CopyStringFast( symname, len ); + } + else + { + char buf[32]; + const auto offlen = sprintf( buf, " + %td", symoff ); + const auto namelen = std::min( strlen( symname ), std::numeric_limits::max() - offlen ); + auto name = (char*)tracy_malloc_fast( namelen + offlen + 1 ); + memcpy( name, symname, namelen ); + memcpy( name + namelen, buf, offlen ); + name[namelen + offlen] = '\0'; + cb_data[cb_num].name = name; + } + + cb_data[cb_num].file = CopyStringFast( "[unknown]" ); + cb_data[cb_num].line = 0; + } + else + { + if( !fn ) fn = "[unknown]"; + if( !function ) + { + function = "[unknown]"; + } + else + { + const char* demangled = ___tracy_demangle( function ); + if( demangled ) function = demangled; + } + + const auto len = std::min( strlen( function ), std::numeric_limits::max() ); + cb_data[cb_num].name = CopyStringFast( function, len ); + cb_data[cb_num].file = NormalizePath( fn ); + if( !cb_data[cb_num].file ) cb_data[cb_num].file = CopyStringFast( fn ); + cb_data[cb_num].line = lineno; + } + + if( ++cb_num >= MaxCbTrace ) + { + return 1; + } + else + { + return 0; + } +} + +static void CallstackErrorCb( void* /*data*/, const char* /*msg*/, int /*errnum*/ ) +{ + for( int i=0; i> 63 == 0 ) + { + const char* imageName = nullptr; + uint64_t imageBaseAddress = 0x0; + +#ifdef TRACY_USE_IMAGE_CACHE + const auto* image = s_imageCache->GetImageForAddress((void*)ptr); + if( image ) + { + imageName = image->m_name; + imageBaseAddress = uint64_t(image->m_startAddress); + } +#else + Dl_info dlinfo; + if( dladdr( (void*)ptr, &dlinfo ) ) + { + imageName = dlinfo.dli_fname; + imageBaseAddress = uint64_t( dlinfo.dli_fbase ); + } +#endif + + if( s_shouldResolveSymbolsOffline ) + { + cb_num = 1; + GetSymbolForOfflineResolve( (void*)ptr, imageBaseAddress, cb_data[0] ); + } + else + { + cb_num = 0; + backtrace_pcinfo( cb_bts, ptr, CallstackDataCb, CallstackErrorCb, nullptr ); + assert( cb_num > 0 ); + + backtrace_syminfo( cb_bts, ptr, SymInfoCallback, SymInfoError, nullptr ); + } + + return { cb_data, uint8_t( cb_num ), imageName ? imageName : "[unknown]" }; + } +#ifdef __linux + else if( s_kernelSym ) + { + auto it = std::lower_bound( s_kernelSym, s_kernelSym + s_kernelSymCnt, ptr, []( const KernelSymbol& lhs, const uint64_t& rhs ) { return lhs.addr + lhs.size < rhs; } ); + if( it != s_kernelSym + s_kernelSymCnt ) + { + cb_data[0].name = CopyStringFast( it->name ); + cb_data[0].file = CopyStringFast( "" ); + cb_data[0].line = 0; + cb_data[0].symLen = it->size; + cb_data[0].symAddr = it->addr; + return { cb_data, 1, it->mod ? it->mod : "" }; + } + } +#endif + + cb_data[0].name = CopyStringFast( "[unknown]" ); + cb_data[0].file = CopyStringFast( "" ); + cb_data[0].line = 0; + cb_data[0].symLen = 0; + cb_data[0].symAddr = 0; + return { cb_data, 1, "" }; +} + +#elif TRACY_HAS_CALLSTACK == 5 + +void InitCallstackCritical() +{ +} + +void InitCallstack() +{ + ___tracy_init_demangle_buffer(); +} + +void EndCallstack() +{ + ___tracy_free_demangle_buffer(); +} + +const char* DecodeCallstackPtrFast( uint64_t ptr ) +{ + static char ret[1024]; + auto vptr = (void*)ptr; + const char* symname = nullptr; + Dl_info dlinfo; + if( dladdr( vptr, &dlinfo ) && dlinfo.dli_sname ) + { + symname = dlinfo.dli_sname; + } + if( symname ) + { + strcpy( ret, symname ); + } + else + { + *ret = '\0'; + } + return ret; +} + +CallstackSymbolData DecodeSymbolAddress( uint64_t ptr ) +{ + const char* symloc = nullptr; + Dl_info dlinfo; + if( dladdr( (void*)ptr, &dlinfo ) ) symloc = dlinfo.dli_fname; + if( !symloc ) symloc = "[unknown]"; + return CallstackSymbolData { symloc, 0, false, 0 }; +} + +CallstackEntryData DecodeCallstackPtr( uint64_t ptr ) +{ + static CallstackEntry cb; + cb.line = 0; + + const char* symname = nullptr; + const char* symloc = nullptr; + auto vptr = (void*)ptr; + ptrdiff_t symoff = 0; + void* symaddr = nullptr; + + Dl_info dlinfo; + if( dladdr( vptr, &dlinfo ) ) + { + symloc = dlinfo.dli_fname; + symname = dlinfo.dli_sname; + symoff = (char*)ptr - (char*)dlinfo.dli_saddr; + symaddr = dlinfo.dli_saddr; + const char* demangled = ___tracy_demangle( symname ); + if( demangled ) symname = demangled; + } + + if( !symname ) symname = "[unknown]"; + if( !symloc ) symloc = "[unknown]"; + + if( symoff == 0 ) + { + const auto len = std::min( strlen( symname ), std::numeric_limits::max() ); + cb.name = CopyString( symname, len ); + } + else + { + char buf[32]; + const auto offlen = sprintf( buf, " + %td", symoff ); + const auto namelen = std::min( strlen( symname ), std::numeric_limits::max() - offlen ); + auto name = (char*)tracy_malloc( namelen + offlen + 1 ); + memcpy( name, symname, namelen ); + memcpy( name + namelen, buf, offlen ); + name[namelen + offlen] = '\0'; + cb.name = name; + } + + cb.file = CopyString( "[unknown]" ); + cb.symLen = 0; + cb.symAddr = (uint64_t)symaddr; + + return { &cb, 1, symloc }; +} + +#endif + +} + +#endif diff --git a/Dependencies/tracy/client/TracyCallstack.h b/Dependencies/tracy/client/TracyCallstack.h new file mode 100644 index 000000000..2c7ecad9f --- /dev/null +++ b/Dependencies/tracy/client/TracyCallstack.h @@ -0,0 +1,35 @@ +#ifndef __TRACYCALLSTACK_H__ +#define __TRACYCALLSTACK_H__ + +#ifndef TRACY_NO_CALLSTACK + +# if !defined _WIN32 +# include +# endif + +# if defined _WIN32 +# include "../common/TracyUwp.hpp" +# ifndef TRACY_UWP +# define TRACY_HAS_CALLSTACK 1 +# endif +# elif defined __ANDROID__ +# if !defined __arm__ || __ANDROID_API__ >= 21 +# define TRACY_HAS_CALLSTACK 2 +# else +# define TRACY_HAS_CALLSTACK 5 +# endif +# elif defined __linux +# if defined _GNU_SOURCE && defined __GLIBC__ +# define TRACY_HAS_CALLSTACK 3 +# else +# define TRACY_HAS_CALLSTACK 2 +# endif +# elif defined __APPLE__ +# define TRACY_HAS_CALLSTACK 4 +# elif defined BSD +# define TRACY_HAS_CALLSTACK 6 +# endif + +#endif + +#endif diff --git a/Dependencies/tracy/client/TracyCallstack.hpp b/Dependencies/tracy/client/TracyCallstack.hpp new file mode 100644 index 000000000..fdc9345df --- /dev/null +++ b/Dependencies/tracy/client/TracyCallstack.hpp @@ -0,0 +1,153 @@ +#ifndef __TRACYCALLSTACK_HPP__ +#define __TRACYCALLSTACK_HPP__ + +#include "../common/TracyApi.h" +#include "../common/TracyForceInline.hpp" +#include "TracyCallstack.h" + +#ifndef TRACY_HAS_CALLSTACK + +namespace tracy +{ +static tracy_force_inline void* Callstack( int /*depth*/ ) { return nullptr; } +} + +#else + +#if TRACY_HAS_CALLSTACK == 2 || TRACY_HAS_CALLSTACK == 5 +# include +#elif TRACY_HAS_CALLSTACK >= 3 +# ifdef TRACY_LIBUNWIND_BACKTRACE + // libunwind is, in general, significantly faster than execinfo based backtraces +# define UNW_LOCAL_ONLY +# include +# else +# include +# endif +#endif + +#ifdef TRACY_DEBUGINFOD +# include +#endif + +#include +#include + +#include "../common/TracyAlloc.hpp" + +namespace tracy +{ + +struct CallstackSymbolData +{ + const char* file; + uint32_t line; + bool needFree; + uint64_t symAddr; +}; + +struct CallstackEntry +{ + const char* name; + const char* file; + uint32_t line; + uint32_t symLen; + uint64_t symAddr; +}; + +struct CallstackEntryData +{ + const CallstackEntry* data; + uint8_t size; + const char* imageName; +}; + +CallstackSymbolData DecodeSymbolAddress( uint64_t ptr ); +const char* DecodeCallstackPtrFast( uint64_t ptr ); +CallstackEntryData DecodeCallstackPtr( uint64_t ptr ); +void InitCallstack(); +void InitCallstackCritical(); +void EndCallstack(); +const char* GetKernelModulePath( uint64_t addr ); + +#ifdef TRACY_DEBUGINFOD +const uint8_t* GetBuildIdForImage( const char* image, size_t& size ); +debuginfod_client* GetDebuginfodClient(); +#endif + +#if TRACY_HAS_CALLSTACK == 1 + +extern "C" +{ + typedef unsigned long (__stdcall *___tracy_t_RtlWalkFrameChain)( void**, unsigned long, unsigned long ); + TRACY_API extern ___tracy_t_RtlWalkFrameChain ___tracy_RtlWalkFrameChain; +} + +static tracy_force_inline void* Callstack( int depth ) +{ + assert( depth >= 1 && depth < 63 ); + auto trace = (uintptr_t*)tracy_malloc( ( 1 + depth ) * sizeof( uintptr_t ) ); + const auto num = ___tracy_RtlWalkFrameChain( (void**)( trace + 1 ), depth, 0 ); + *trace = num; + return trace; +} + +#elif TRACY_HAS_CALLSTACK == 2 || TRACY_HAS_CALLSTACK == 5 + +struct BacktraceState +{ + void** current; + void** end; +}; + +static _Unwind_Reason_Code tracy_unwind_callback( struct _Unwind_Context* ctx, void* arg ) +{ + auto state = (BacktraceState*)arg; + uintptr_t pc = _Unwind_GetIP( ctx ); + if( pc ) + { + if( state->current == state->end ) return _URC_END_OF_STACK; + *state->current++ = (void*)pc; + } + return _URC_NO_REASON; +} + +static tracy_force_inline void* Callstack( int depth ) +{ + assert( depth >= 1 && depth < 63 ); + + auto trace = (uintptr_t*)tracy_malloc( ( 1 + depth ) * sizeof( uintptr_t ) ); + BacktraceState state = { (void**)(trace+1), (void**)(trace+1+depth) }; + _Unwind_Backtrace( tracy_unwind_callback, &state ); + + *trace = (uintptr_t*)state.current - trace + 1; + + return trace; +} + +#elif TRACY_HAS_CALLSTACK == 3 || TRACY_HAS_CALLSTACK == 4 || TRACY_HAS_CALLSTACK == 6 + +static tracy_force_inline void* Callstack( int depth ) +{ + assert( depth >= 1 ); + + auto trace = (uintptr_t*)tracy_malloc( ( 1 + (size_t)depth ) * sizeof( uintptr_t ) ); + +#ifdef TRACY_LIBUNWIND_BACKTRACE + size_t num = unw_backtrace( (void**)(trace+1), depth ); +#else + const auto num = (size_t)backtrace( (void**)(trace+1), depth ); +#endif + + *trace = num; + + return trace; +} + +#endif + +} + +#endif + +#endif diff --git a/Dependencies/tracy/client/TracyCpuid.hpp b/Dependencies/tracy/client/TracyCpuid.hpp new file mode 100644 index 000000000..9820be00b --- /dev/null +++ b/Dependencies/tracy/client/TracyCpuid.hpp @@ -0,0 +1,12 @@ +#ifndef __TRACYCPUID_HPP__ +#define __TRACYCPUID_HPP__ + +// Prior to GCC 11 the cpuid.h header did not have any include guards and thus +// including it more than once would cause a compiler error due to symbol +// redefinitions. In order to support older GCC versions, we have to wrap this +// include between custom include guards to prevent this issue. +// See also https://github.com/wolfpld/tracy/issues/452 + +#include + +#endif diff --git a/Dependencies/tracy/client/TracyDebug.hpp b/Dependencies/tracy/client/TracyDebug.hpp new file mode 100644 index 000000000..8723356f4 --- /dev/null +++ b/Dependencies/tracy/client/TracyDebug.hpp @@ -0,0 +1,11 @@ +#ifndef __TRACYPRINT_HPP__ +#define __TRACYPRINT_HPP__ + +#ifdef TRACY_VERBOSE +# include +# define TracyDebug(...) fprintf( stderr, __VA_ARGS__ ); +#else +# define TracyDebug(...) +#endif + +#endif diff --git a/Dependencies/tracy/client/TracyDxt1.cpp b/Dependencies/tracy/client/TracyDxt1.cpp new file mode 100644 index 000000000..930d09820 --- /dev/null +++ b/Dependencies/tracy/client/TracyDxt1.cpp @@ -0,0 +1,644 @@ +#include "TracyDxt1.hpp" +#include "../common/TracyForceInline.hpp" + +#include +#include +#include + +#ifdef __ARM_NEON +# include +#endif + +#if defined __AVX__ && !defined __SSE4_1__ +# define __SSE4_1__ +#endif + +#if defined __SSE4_1__ || defined __AVX2__ +# ifdef _MSC_VER +# include +# else +# include +# ifndef _mm256_cvtsi256_si32 +# define _mm256_cvtsi256_si32( v ) ( _mm_cvtsi128_si32( _mm256_castsi256_si128( v ) ) ) +# endif +# endif +#endif + +namespace tracy +{ + +static inline uint16_t to565( uint8_t r, uint8_t g, uint8_t b ) +{ + return ( ( r & 0xF8 ) << 8 ) | ( ( g & 0xFC ) << 3 ) | ( b >> 3 ); +} + +static inline uint16_t to565( uint32_t c ) +{ + return + ( ( c & 0xF80000 ) >> 19 ) | + ( ( c & 0x00FC00 ) >> 5 ) | + ( ( c & 0x0000F8 ) << 8 ); +} + +static const uint16_t DivTable[255*3+1] = { + 0xffff, 0xffff, 0xffff, 0xffff, 0xcccc, 0xaaaa, 0x9249, 0x8000, 0x71c7, 0x6666, 0x5d17, 0x5555, 0x4ec4, 0x4924, 0x4444, 0x4000, + 0x3c3c, 0x38e3, 0x35e5, 0x3333, 0x30c3, 0x2e8b, 0x2c85, 0x2aaa, 0x28f5, 0x2762, 0x25ed, 0x2492, 0x234f, 0x2222, 0x2108, 0x2000, + 0x1f07, 0x1e1e, 0x1d41, 0x1c71, 0x1bac, 0x1af2, 0x1a41, 0x1999, 0x18f9, 0x1861, 0x17d0, 0x1745, 0x16c1, 0x1642, 0x15c9, 0x1555, + 0x14e5, 0x147a, 0x1414, 0x13b1, 0x1352, 0x12f6, 0x129e, 0x1249, 0x11f7, 0x11a7, 0x115b, 0x1111, 0x10c9, 0x1084, 0x1041, 0x1000, + 0x0fc0, 0x0f83, 0x0f48, 0x0f0f, 0x0ed7, 0x0ea0, 0x0e6c, 0x0e38, 0x0e07, 0x0dd6, 0x0da7, 0x0d79, 0x0d4c, 0x0d20, 0x0cf6, 0x0ccc, + 0x0ca4, 0x0c7c, 0x0c56, 0x0c30, 0x0c0c, 0x0be8, 0x0bc5, 0x0ba2, 0x0b81, 0x0b60, 0x0b40, 0x0b21, 0x0b02, 0x0ae4, 0x0ac7, 0x0aaa, + 0x0a8e, 0x0a72, 0x0a57, 0x0a3d, 0x0a23, 0x0a0a, 0x09f1, 0x09d8, 0x09c0, 0x09a9, 0x0991, 0x097b, 0x0964, 0x094f, 0x0939, 0x0924, + 0x090f, 0x08fb, 0x08e7, 0x08d3, 0x08c0, 0x08ad, 0x089a, 0x0888, 0x0876, 0x0864, 0x0853, 0x0842, 0x0831, 0x0820, 0x0810, 0x0800, + 0x07f0, 0x07e0, 0x07d1, 0x07c1, 0x07b3, 0x07a4, 0x0795, 0x0787, 0x0779, 0x076b, 0x075d, 0x0750, 0x0743, 0x0736, 0x0729, 0x071c, + 0x070f, 0x0703, 0x06f7, 0x06eb, 0x06df, 0x06d3, 0x06c8, 0x06bc, 0x06b1, 0x06a6, 0x069b, 0x0690, 0x0685, 0x067b, 0x0670, 0x0666, + 0x065c, 0x0652, 0x0648, 0x063e, 0x0634, 0x062b, 0x0621, 0x0618, 0x060f, 0x0606, 0x05fd, 0x05f4, 0x05eb, 0x05e2, 0x05d9, 0x05d1, + 0x05c9, 0x05c0, 0x05b8, 0x05b0, 0x05a8, 0x05a0, 0x0598, 0x0590, 0x0588, 0x0581, 0x0579, 0x0572, 0x056b, 0x0563, 0x055c, 0x0555, + 0x054e, 0x0547, 0x0540, 0x0539, 0x0532, 0x052b, 0x0525, 0x051e, 0x0518, 0x0511, 0x050b, 0x0505, 0x04fe, 0x04f8, 0x04f2, 0x04ec, + 0x04e6, 0x04e0, 0x04da, 0x04d4, 0x04ce, 0x04c8, 0x04c3, 0x04bd, 0x04b8, 0x04b2, 0x04ad, 0x04a7, 0x04a2, 0x049c, 0x0497, 0x0492, + 0x048d, 0x0487, 0x0482, 0x047d, 0x0478, 0x0473, 0x046e, 0x0469, 0x0465, 0x0460, 0x045b, 0x0456, 0x0452, 0x044d, 0x0448, 0x0444, + 0x043f, 0x043b, 0x0436, 0x0432, 0x042d, 0x0429, 0x0425, 0x0421, 0x041c, 0x0418, 0x0414, 0x0410, 0x040c, 0x0408, 0x0404, 0x0400, + 0x03fc, 0x03f8, 0x03f4, 0x03f0, 0x03ec, 0x03e8, 0x03e4, 0x03e0, 0x03dd, 0x03d9, 0x03d5, 0x03d2, 0x03ce, 0x03ca, 0x03c7, 0x03c3, + 0x03c0, 0x03bc, 0x03b9, 0x03b5, 0x03b2, 0x03ae, 0x03ab, 0x03a8, 0x03a4, 0x03a1, 0x039e, 0x039b, 0x0397, 0x0394, 0x0391, 0x038e, + 0x038b, 0x0387, 0x0384, 0x0381, 0x037e, 0x037b, 0x0378, 0x0375, 0x0372, 0x036f, 0x036c, 0x0369, 0x0366, 0x0364, 0x0361, 0x035e, + 0x035b, 0x0358, 0x0355, 0x0353, 0x0350, 0x034d, 0x034a, 0x0348, 0x0345, 0x0342, 0x0340, 0x033d, 0x033a, 0x0338, 0x0335, 0x0333, + 0x0330, 0x032e, 0x032b, 0x0329, 0x0326, 0x0324, 0x0321, 0x031f, 0x031c, 0x031a, 0x0317, 0x0315, 0x0313, 0x0310, 0x030e, 0x030c, + 0x0309, 0x0307, 0x0305, 0x0303, 0x0300, 0x02fe, 0x02fc, 0x02fa, 0x02f7, 0x02f5, 0x02f3, 0x02f1, 0x02ef, 0x02ec, 0x02ea, 0x02e8, + 0x02e6, 0x02e4, 0x02e2, 0x02e0, 0x02de, 0x02dc, 0x02da, 0x02d8, 0x02d6, 0x02d4, 0x02d2, 0x02d0, 0x02ce, 0x02cc, 0x02ca, 0x02c8, + 0x02c6, 0x02c4, 0x02c2, 0x02c0, 0x02be, 0x02bc, 0x02bb, 0x02b9, 0x02b7, 0x02b5, 0x02b3, 0x02b1, 0x02b0, 0x02ae, 0x02ac, 0x02aa, + 0x02a8, 0x02a7, 0x02a5, 0x02a3, 0x02a1, 0x02a0, 0x029e, 0x029c, 0x029b, 0x0299, 0x0297, 0x0295, 0x0294, 0x0292, 0x0291, 0x028f, + 0x028d, 0x028c, 0x028a, 0x0288, 0x0287, 0x0285, 0x0284, 0x0282, 0x0280, 0x027f, 0x027d, 0x027c, 0x027a, 0x0279, 0x0277, 0x0276, + 0x0274, 0x0273, 0x0271, 0x0270, 0x026e, 0x026d, 0x026b, 0x026a, 0x0268, 0x0267, 0x0265, 0x0264, 0x0263, 0x0261, 0x0260, 0x025e, + 0x025d, 0x025c, 0x025a, 0x0259, 0x0257, 0x0256, 0x0255, 0x0253, 0x0252, 0x0251, 0x024f, 0x024e, 0x024d, 0x024b, 0x024a, 0x0249, + 0x0247, 0x0246, 0x0245, 0x0243, 0x0242, 0x0241, 0x0240, 0x023e, 0x023d, 0x023c, 0x023b, 0x0239, 0x0238, 0x0237, 0x0236, 0x0234, + 0x0233, 0x0232, 0x0231, 0x0230, 0x022e, 0x022d, 0x022c, 0x022b, 0x022a, 0x0229, 0x0227, 0x0226, 0x0225, 0x0224, 0x0223, 0x0222, + 0x0220, 0x021f, 0x021e, 0x021d, 0x021c, 0x021b, 0x021a, 0x0219, 0x0218, 0x0216, 0x0215, 0x0214, 0x0213, 0x0212, 0x0211, 0x0210, + 0x020f, 0x020e, 0x020d, 0x020c, 0x020b, 0x020a, 0x0209, 0x0208, 0x0207, 0x0206, 0x0205, 0x0204, 0x0203, 0x0202, 0x0201, 0x0200, + 0x01ff, 0x01fe, 0x01fd, 0x01fc, 0x01fb, 0x01fa, 0x01f9, 0x01f8, 0x01f7, 0x01f6, 0x01f5, 0x01f4, 0x01f3, 0x01f2, 0x01f1, 0x01f0, + 0x01ef, 0x01ee, 0x01ed, 0x01ec, 0x01eb, 0x01ea, 0x01e9, 0x01e9, 0x01e8, 0x01e7, 0x01e6, 0x01e5, 0x01e4, 0x01e3, 0x01e2, 0x01e1, + 0x01e0, 0x01e0, 0x01df, 0x01de, 0x01dd, 0x01dc, 0x01db, 0x01da, 0x01da, 0x01d9, 0x01d8, 0x01d7, 0x01d6, 0x01d5, 0x01d4, 0x01d4, + 0x01d3, 0x01d2, 0x01d1, 0x01d0, 0x01cf, 0x01cf, 0x01ce, 0x01cd, 0x01cc, 0x01cb, 0x01cb, 0x01ca, 0x01c9, 0x01c8, 0x01c7, 0x01c7, + 0x01c6, 0x01c5, 0x01c4, 0x01c3, 0x01c3, 0x01c2, 0x01c1, 0x01c0, 0x01c0, 0x01bf, 0x01be, 0x01bd, 0x01bd, 0x01bc, 0x01bb, 0x01ba, + 0x01ba, 0x01b9, 0x01b8, 0x01b7, 0x01b7, 0x01b6, 0x01b5, 0x01b4, 0x01b4, 0x01b3, 0x01b2, 0x01b2, 0x01b1, 0x01b0, 0x01af, 0x01af, + 0x01ae, 0x01ad, 0x01ad, 0x01ac, 0x01ab, 0x01aa, 0x01aa, 0x01a9, 0x01a8, 0x01a8, 0x01a7, 0x01a6, 0x01a6, 0x01a5, 0x01a4, 0x01a4, + 0x01a3, 0x01a2, 0x01a2, 0x01a1, 0x01a0, 0x01a0, 0x019f, 0x019e, 0x019e, 0x019d, 0x019c, 0x019c, 0x019b, 0x019a, 0x019a, 0x0199, + 0x0198, 0x0198, 0x0197, 0x0197, 0x0196, 0x0195, 0x0195, 0x0194, 0x0193, 0x0193, 0x0192, 0x0192, 0x0191, 0x0190, 0x0190, 0x018f, + 0x018f, 0x018e, 0x018d, 0x018d, 0x018c, 0x018b, 0x018b, 0x018a, 0x018a, 0x0189, 0x0189, 0x0188, 0x0187, 0x0187, 0x0186, 0x0186, + 0x0185, 0x0184, 0x0184, 0x0183, 0x0183, 0x0182, 0x0182, 0x0181, 0x0180, 0x0180, 0x017f, 0x017f, 0x017e, 0x017e, 0x017d, 0x017d, + 0x017c, 0x017b, 0x017b, 0x017a, 0x017a, 0x0179, 0x0179, 0x0178, 0x0178, 0x0177, 0x0177, 0x0176, 0x0175, 0x0175, 0x0174, 0x0174, + 0x0173, 0x0173, 0x0172, 0x0172, 0x0171, 0x0171, 0x0170, 0x0170, 0x016f, 0x016f, 0x016e, 0x016e, 0x016d, 0x016d, 0x016c, 0x016c, + 0x016b, 0x016b, 0x016a, 0x016a, 0x0169, 0x0169, 0x0168, 0x0168, 0x0167, 0x0167, 0x0166, 0x0166, 0x0165, 0x0165, 0x0164, 0x0164, + 0x0163, 0x0163, 0x0162, 0x0162, 0x0161, 0x0161, 0x0160, 0x0160, 0x015f, 0x015f, 0x015e, 0x015e, 0x015d, 0x015d, 0x015d, 0x015c, + 0x015c, 0x015b, 0x015b, 0x015a, 0x015a, 0x0159, 0x0159, 0x0158, 0x0158, 0x0158, 0x0157, 0x0157, 0x0156, 0x0156 +}; + +#if defined __ARM_NEON && defined __aarch64__ +static const uint16_t DivTableNEON[255*3+1] = { + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x1c71, 0x1af2, 0x1999, 0x1861, 0x1745, 0x1642, 0x1555, 0x147a, 0x13b1, 0x12f6, 0x1249, 0x11a7, 0x1111, 0x1084, 0x1000, + 0x0f83, 0x0f0f, 0x0ea0, 0x0e38, 0x0dd6, 0x0d79, 0x0d20, 0x0ccc, 0x0c7c, 0x0c30, 0x0be8, 0x0ba2, 0x0b60, 0x0b21, 0x0ae4, 0x0aaa, + 0x0a72, 0x0a3d, 0x0a0a, 0x09d8, 0x09a9, 0x097b, 0x094f, 0x0924, 0x08fb, 0x08d3, 0x08ad, 0x0888, 0x0864, 0x0842, 0x0820, 0x0800, + 0x07e0, 0x07c1, 0x07a4, 0x0787, 0x076b, 0x0750, 0x0736, 0x071c, 0x0703, 0x06eb, 0x06d3, 0x06bc, 0x06a6, 0x0690, 0x067b, 0x0666, + 0x0652, 0x063e, 0x062b, 0x0618, 0x0606, 0x05f4, 0x05e2, 0x05d1, 0x05c0, 0x05b0, 0x05a0, 0x0590, 0x0581, 0x0572, 0x0563, 0x0555, + 0x0547, 0x0539, 0x052b, 0x051e, 0x0511, 0x0505, 0x04f8, 0x04ec, 0x04e0, 0x04d4, 0x04c8, 0x04bd, 0x04b2, 0x04a7, 0x049c, 0x0492, + 0x0487, 0x047d, 0x0473, 0x0469, 0x0460, 0x0456, 0x044d, 0x0444, 0x043b, 0x0432, 0x0429, 0x0421, 0x0418, 0x0410, 0x0408, 0x0400, + 0x03f8, 0x03f0, 0x03e8, 0x03e0, 0x03d9, 0x03d2, 0x03ca, 0x03c3, 0x03bc, 0x03b5, 0x03ae, 0x03a8, 0x03a1, 0x039b, 0x0394, 0x038e, + 0x0387, 0x0381, 0x037b, 0x0375, 0x036f, 0x0369, 0x0364, 0x035e, 0x0358, 0x0353, 0x034d, 0x0348, 0x0342, 0x033d, 0x0338, 0x0333, + 0x032e, 0x0329, 0x0324, 0x031f, 0x031a, 0x0315, 0x0310, 0x030c, 0x0307, 0x0303, 0x02fe, 0x02fa, 0x02f5, 0x02f1, 0x02ec, 0x02e8, + 0x02e4, 0x02e0, 0x02dc, 0x02d8, 0x02d4, 0x02d0, 0x02cc, 0x02c8, 0x02c4, 0x02c0, 0x02bc, 0x02b9, 0x02b5, 0x02b1, 0x02ae, 0x02aa, + 0x02a7, 0x02a3, 0x02a0, 0x029c, 0x0299, 0x0295, 0x0292, 0x028f, 0x028c, 0x0288, 0x0285, 0x0282, 0x027f, 0x027c, 0x0279, 0x0276, + 0x0273, 0x0270, 0x026d, 0x026a, 0x0267, 0x0264, 0x0261, 0x025e, 0x025c, 0x0259, 0x0256, 0x0253, 0x0251, 0x024e, 0x024b, 0x0249, + 0x0246, 0x0243, 0x0241, 0x023e, 0x023c, 0x0239, 0x0237, 0x0234, 0x0232, 0x0230, 0x022d, 0x022b, 0x0229, 0x0226, 0x0224, 0x0222, + 0x021f, 0x021d, 0x021b, 0x0219, 0x0216, 0x0214, 0x0212, 0x0210, 0x020e, 0x020c, 0x020a, 0x0208, 0x0206, 0x0204, 0x0202, 0x0200, + 0x01fe, 0x01fc, 0x01fa, 0x01f8, 0x01f6, 0x01f4, 0x01f2, 0x01f0, 0x01ee, 0x01ec, 0x01ea, 0x01e9, 0x01e7, 0x01e5, 0x01e3, 0x01e1, + 0x01e0, 0x01de, 0x01dc, 0x01da, 0x01d9, 0x01d7, 0x01d5, 0x01d4, 0x01d2, 0x01d0, 0x01cf, 0x01cd, 0x01cb, 0x01ca, 0x01c8, 0x01c7, + 0x01c5, 0x01c3, 0x01c2, 0x01c0, 0x01bf, 0x01bd, 0x01bc, 0x01ba, 0x01b9, 0x01b7, 0x01b6, 0x01b4, 0x01b3, 0x01b2, 0x01b0, 0x01af, + 0x01ad, 0x01ac, 0x01aa, 0x01a9, 0x01a8, 0x01a6, 0x01a5, 0x01a4, 0x01a2, 0x01a1, 0x01a0, 0x019e, 0x019d, 0x019c, 0x019a, 0x0199, + 0x0198, 0x0197, 0x0195, 0x0194, 0x0193, 0x0192, 0x0190, 0x018f, 0x018e, 0x018d, 0x018b, 0x018a, 0x0189, 0x0188, 0x0187, 0x0186, + 0x0184, 0x0183, 0x0182, 0x0181, 0x0180, 0x017f, 0x017e, 0x017d, 0x017b, 0x017a, 0x0179, 0x0178, 0x0177, 0x0176, 0x0175, 0x0174, + 0x0173, 0x0172, 0x0171, 0x0170, 0x016f, 0x016e, 0x016d, 0x016c, 0x016b, 0x016a, 0x0169, 0x0168, 0x0167, 0x0166, 0x0165, 0x0164, + 0x0163, 0x0162, 0x0161, 0x0160, 0x015f, 0x015e, 0x015d, 0x015c, 0x015b, 0x015a, 0x0159, 0x0158, 0x0158, 0x0157, 0x0156, 0x0155, + 0x0154, 0x0153, 0x0152, 0x0151, 0x0150, 0x0150, 0x014f, 0x014e, 0x014d, 0x014c, 0x014b, 0x014a, 0x014a, 0x0149, 0x0148, 0x0147, + 0x0146, 0x0146, 0x0145, 0x0144, 0x0143, 0x0142, 0x0142, 0x0141, 0x0140, 0x013f, 0x013e, 0x013e, 0x013d, 0x013c, 0x013b, 0x013b, + 0x013a, 0x0139, 0x0138, 0x0138, 0x0137, 0x0136, 0x0135, 0x0135, 0x0134, 0x0133, 0x0132, 0x0132, 0x0131, 0x0130, 0x0130, 0x012f, + 0x012e, 0x012e, 0x012d, 0x012c, 0x012b, 0x012b, 0x012a, 0x0129, 0x0129, 0x0128, 0x0127, 0x0127, 0x0126, 0x0125, 0x0125, 0x0124, + 0x0123, 0x0123, 0x0122, 0x0121, 0x0121, 0x0120, 0x0120, 0x011f, 0x011e, 0x011e, 0x011d, 0x011c, 0x011c, 0x011b, 0x011b, 0x011a, + 0x0119, 0x0119, 0x0118, 0x0118, 0x0117, 0x0116, 0x0116, 0x0115, 0x0115, 0x0114, 0x0113, 0x0113, 0x0112, 0x0112, 0x0111, 0x0111, + 0x0110, 0x010f, 0x010f, 0x010e, 0x010e, 0x010d, 0x010d, 0x010c, 0x010c, 0x010b, 0x010a, 0x010a, 0x0109, 0x0109, 0x0108, 0x0108, + 0x0107, 0x0107, 0x0106, 0x0106, 0x0105, 0x0105, 0x0104, 0x0104, 0x0103, 0x0103, 0x0102, 0x0102, 0x0101, 0x0101, 0x0100, 0x0100, + 0x00ff, 0x00ff, 0x00fe, 0x00fe, 0x00fd, 0x00fd, 0x00fc, 0x00fc, 0x00fb, 0x00fb, 0x00fa, 0x00fa, 0x00f9, 0x00f9, 0x00f8, 0x00f8, + 0x00f7, 0x00f7, 0x00f6, 0x00f6, 0x00f5, 0x00f5, 0x00f4, 0x00f4, 0x00f4, 0x00f3, 0x00f3, 0x00f2, 0x00f2, 0x00f1, 0x00f1, 0x00f0, + 0x00f0, 0x00f0, 0x00ef, 0x00ef, 0x00ee, 0x00ee, 0x00ed, 0x00ed, 0x00ed, 0x00ec, 0x00ec, 0x00eb, 0x00eb, 0x00ea, 0x00ea, 0x00ea, + 0x00e9, 0x00e9, 0x00e8, 0x00e8, 0x00e7, 0x00e7, 0x00e7, 0x00e6, 0x00e6, 0x00e5, 0x00e5, 0x00e5, 0x00e4, 0x00e4, 0x00e3, 0x00e3, + 0x00e3, 0x00e2, 0x00e2, 0x00e1, 0x00e1, 0x00e1, 0x00e0, 0x00e0, 0x00e0, 0x00df, 0x00df, 0x00de, 0x00de, 0x00de, 0x00dd, 0x00dd, + 0x00dd, 0x00dc, 0x00dc, 0x00db, 0x00db, 0x00db, 0x00da, 0x00da, 0x00da, 0x00d9, 0x00d9, 0x00d9, 0x00d8, 0x00d8, 0x00d7, 0x00d7, + 0x00d7, 0x00d6, 0x00d6, 0x00d6, 0x00d5, 0x00d5, 0x00d5, 0x00d4, 0x00d4, 0x00d4, 0x00d3, 0x00d3, 0x00d3, 0x00d2, 0x00d2, 0x00d2, + 0x00d1, 0x00d1, 0x00d1, 0x00d0, 0x00d0, 0x00d0, 0x00cf, 0x00cf, 0x00cf, 0x00ce, 0x00ce, 0x00ce, 0x00cd, 0x00cd, 0x00cd, 0x00cc, + 0x00cc, 0x00cc, 0x00cb, 0x00cb, 0x00cb, 0x00ca, 0x00ca, 0x00ca, 0x00c9, 0x00c9, 0x00c9, 0x00c9, 0x00c8, 0x00c8, 0x00c8, 0x00c7, + 0x00c7, 0x00c7, 0x00c6, 0x00c6, 0x00c6, 0x00c5, 0x00c5, 0x00c5, 0x00c5, 0x00c4, 0x00c4, 0x00c4, 0x00c3, 0x00c3, 0x00c3, 0x00c3, + 0x00c2, 0x00c2, 0x00c2, 0x00c1, 0x00c1, 0x00c1, 0x00c1, 0x00c0, 0x00c0, 0x00c0, 0x00bf, 0x00bf, 0x00bf, 0x00bf, 0x00be, 0x00be, + 0x00be, 0x00bd, 0x00bd, 0x00bd, 0x00bd, 0x00bc, 0x00bc, 0x00bc, 0x00bc, 0x00bb, 0x00bb, 0x00bb, 0x00ba, 0x00ba, 0x00ba, 0x00ba, + 0x00b9, 0x00b9, 0x00b9, 0x00b9, 0x00b8, 0x00b8, 0x00b8, 0x00b8, 0x00b7, 0x00b7, 0x00b7, 0x00b7, 0x00b6, 0x00b6, 0x00b6, 0x00b6, + 0x00b5, 0x00b5, 0x00b5, 0x00b5, 0x00b4, 0x00b4, 0x00b4, 0x00b4, 0x00b3, 0x00b3, 0x00b3, 0x00b3, 0x00b2, 0x00b2, 0x00b2, 0x00b2, + 0x00b1, 0x00b1, 0x00b1, 0x00b1, 0x00b0, 0x00b0, 0x00b0, 0x00b0, 0x00af, 0x00af, 0x00af, 0x00af, 0x00ae, 0x00ae, 0x00ae, 0x00ae, + 0x00ae, 0x00ad, 0x00ad, 0x00ad, 0x00ad, 0x00ac, 0x00ac, 0x00ac, 0x00ac, 0x00ac, 0x00ab, 0x00ab, 0x00ab, 0x00ab, +}; +#endif + + +static tracy_force_inline uint64_t ProcessRGB( const uint8_t* src ) +{ +#ifdef __SSE4_1__ + __m128i px0 = _mm_loadu_si128(((__m128i*)src) + 0); + __m128i px1 = _mm_loadu_si128(((__m128i*)src) + 1); + __m128i px2 = _mm_loadu_si128(((__m128i*)src) + 2); + __m128i px3 = _mm_loadu_si128(((__m128i*)src) + 3); + + __m128i smask = _mm_set1_epi32( 0xF8FCF8 ); + __m128i sd0 = _mm_and_si128( px0, smask ); + __m128i sd1 = _mm_and_si128( px1, smask ); + __m128i sd2 = _mm_and_si128( px2, smask ); + __m128i sd3 = _mm_and_si128( px3, smask ); + + __m128i sc = _mm_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m128i sc0 = _mm_cmpeq_epi8(sd0, sc); + __m128i sc1 = _mm_cmpeq_epi8(sd1, sc); + __m128i sc2 = _mm_cmpeq_epi8(sd2, sc); + __m128i sc3 = _mm_cmpeq_epi8(sd3, sc); + + __m128i sm0 = _mm_and_si128(sc0, sc1); + __m128i sm1 = _mm_and_si128(sc2, sc3); + __m128i sm = _mm_and_si128(sm0, sm1); + + if( _mm_testc_si128(sm, _mm_set1_epi32(-1)) ) + { + return uint64_t( to565( src[0], src[1], src[2] ) ) << 16; + } + + __m128i amask = _mm_set1_epi32( 0xFFFFFF ); + px0 = _mm_and_si128( px0, amask ); + px1 = _mm_and_si128( px1, amask ); + px2 = _mm_and_si128( px2, amask ); + px3 = _mm_and_si128( px3, amask ); + + __m128i min0 = _mm_min_epu8( px0, px1 ); + __m128i min1 = _mm_min_epu8( px2, px3 ); + __m128i min2 = _mm_min_epu8( min0, min1 ); + + __m128i max0 = _mm_max_epu8( px0, px1 ); + __m128i max1 = _mm_max_epu8( px2, px3 ); + __m128i max2 = _mm_max_epu8( max0, max1 ); + + __m128i min3 = _mm_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i max3 = _mm_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m128i min4 = _mm_min_epu8( min2, min3 ); + __m128i max4 = _mm_max_epu8( max2, max3 ); + + __m128i min5 = _mm_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i max5 = _mm_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m128i rmin = _mm_min_epu8( min4, min5 ); + __m128i rmax = _mm_max_epu8( max4, max5 ); + + __m128i range1 = _mm_subs_epu8( rmax, rmin ); + __m128i range2 = _mm_sad_epu8( rmax, rmin ); + + uint32_t vrange = _mm_cvtsi128_si32( range2 ) >> 1; + __m128i range = _mm_set1_epi16( DivTable[vrange] ); + + __m128i inset1 = _mm_srli_epi16( range1, 4 ); + __m128i inset = _mm_and_si128( inset1, _mm_set1_epi8( 0xF ) ); + __m128i min = _mm_adds_epu8( rmin, inset ); + __m128i max = _mm_subs_epu8( rmax, inset ); + + __m128i c0 = _mm_subs_epu8( px0, rmin ); + __m128i c1 = _mm_subs_epu8( px1, rmin ); + __m128i c2 = _mm_subs_epu8( px2, rmin ); + __m128i c3 = _mm_subs_epu8( px3, rmin ); + + __m128i is0 = _mm_maddubs_epi16( c0, _mm_set1_epi8( 1 ) ); + __m128i is1 = _mm_maddubs_epi16( c1, _mm_set1_epi8( 1 ) ); + __m128i is2 = _mm_maddubs_epi16( c2, _mm_set1_epi8( 1 ) ); + __m128i is3 = _mm_maddubs_epi16( c3, _mm_set1_epi8( 1 ) ); + + __m128i s0 = _mm_hadd_epi16( is0, is1 ); + __m128i s1 = _mm_hadd_epi16( is2, is3 ); + + __m128i m0 = _mm_mulhi_epu16( s0, range ); + __m128i m1 = _mm_mulhi_epu16( s1, range ); + + __m128i p0 = _mm_packus_epi16( m0, m1 ); + + __m128i p1 = _mm_or_si128( _mm_srai_epi32( p0, 6 ), _mm_srai_epi32( p0, 12 ) ); + __m128i p2 = _mm_or_si128( _mm_srai_epi32( p0, 18 ), p0 ); + __m128i p3 = _mm_or_si128( p1, p2 ); + __m128i p =_mm_shuffle_epi8( p3, _mm_set1_epi32( 0x0C080400 ) ); + + uint32_t vmin = _mm_cvtsi128_si32( min ); + uint32_t vmax = _mm_cvtsi128_si32( max ); + uint32_t vp = _mm_cvtsi128_si32( p ); + + return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); +#elif defined __ARM_NEON +# ifdef __aarch64__ + uint8x16x4_t px = vld4q_u8( src ); + + uint8x16_t lr = px.val[0]; + uint8x16_t lg = px.val[1]; + uint8x16_t lb = px.val[2]; + + uint8_t rmaxr = vmaxvq_u8( lr ); + uint8_t rmaxg = vmaxvq_u8( lg ); + uint8_t rmaxb = vmaxvq_u8( lb ); + + uint8_t rminr = vminvq_u8( lr ); + uint8_t rming = vminvq_u8( lg ); + uint8_t rminb = vminvq_u8( lb ); + + int rr = rmaxr - rminr; + int rg = rmaxg - rming; + int rb = rmaxb - rminb; + + int vrange1 = rr + rg + rb; + uint16_t vrange2 = DivTableNEON[vrange1]; + + uint8_t insetr = rr >> 4; + uint8_t insetg = rg >> 4; + uint8_t insetb = rb >> 4; + + uint8_t minr = rminr + insetr; + uint8_t ming = rming + insetg; + uint8_t minb = rminb + insetb; + + uint8_t maxr = rmaxr - insetr; + uint8_t maxg = rmaxg - insetg; + uint8_t maxb = rmaxb - insetb; + + uint8x16_t cr = vsubq_u8( lr, vdupq_n_u8( rminr ) ); + uint8x16_t cg = vsubq_u8( lg, vdupq_n_u8( rming ) ); + uint8x16_t cb = vsubq_u8( lb, vdupq_n_u8( rminb ) ); + + uint16x8_t is0l = vaddl_u8( vget_low_u8( cr ), vget_low_u8( cg ) ); + uint16x8_t is0h = vaddl_u8( vget_high_u8( cr ), vget_high_u8( cg ) ); + uint16x8_t is1l = vaddw_u8( is0l, vget_low_u8( cb ) ); + uint16x8_t is1h = vaddw_u8( is0h, vget_high_u8( cb ) ); + + int16x8_t range = vdupq_n_s16( vrange2 ); + uint16x8_t m0 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( is1l ), range ) ); + uint16x8_t m1 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( is1h ), range ) ); + + uint8x8_t p00 = vmovn_u16( m0 ); + uint8x8_t p01 = vmovn_u16( m1 ); + uint8x16_t p0 = vcombine_u8( p00, p01 ); + + uint32x4_t p1 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 6 ), vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 12 ) ); + uint32x4_t p2 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 18 ), vreinterpretq_u32_u8( p0 ) ); + uint32x4_t p3 = vaddq_u32( p1, p2 ); + + uint16x4x2_t p4 = vuzp_u16( vget_low_u16( vreinterpretq_u16_u32( p3 ) ), vget_high_u16( vreinterpretq_u16_u32( p3 ) ) ); + uint8x8x2_t p = vuzp_u8( vreinterpret_u8_u16( p4.val[0] ), vreinterpret_u8_u16( p4.val[0] ) ); + + uint32_t vp; + vst1_lane_u32( &vp, vreinterpret_u32_u8( p.val[0] ), 0 ); + + return uint64_t( ( uint64_t( to565( minr, ming, minb ) ) << 16 ) | to565( maxr, maxg, maxb ) | ( uint64_t( vp ) << 32 ) ); +# else + uint32x4_t px0 = vld1q_u32( (uint32_t*)src ); + uint32x4_t px1 = vld1q_u32( (uint32_t*)src + 4 ); + uint32x4_t px2 = vld1q_u32( (uint32_t*)src + 8 ); + uint32x4_t px3 = vld1q_u32( (uint32_t*)src + 12 ); + + uint32x4_t smask = vdupq_n_u32( 0xF8FCF8 ); + uint32x4_t sd0 = vandq_u32( smask, px0 ); + uint32x4_t sd1 = vandq_u32( smask, px1 ); + uint32x4_t sd2 = vandq_u32( smask, px2 ); + uint32x4_t sd3 = vandq_u32( smask, px3 ); + + uint32x4_t sc = vdupq_n_u32( sd0[0] ); + + uint32x4_t sc0 = vceqq_u32( sd0, sc ); + uint32x4_t sc1 = vceqq_u32( sd1, sc ); + uint32x4_t sc2 = vceqq_u32( sd2, sc ); + uint32x4_t sc3 = vceqq_u32( sd3, sc ); + + uint32x4_t sm0 = vandq_u32( sc0, sc1 ); + uint32x4_t sm1 = vandq_u32( sc2, sc3 ); + int64x2_t sm = vreinterpretq_s64_u32( vandq_u32( sm0, sm1 ) ); + + if( sm[0] == -1 && sm[1] == -1 ) + { + return uint64_t( to565( src[0], src[1], src[2] ) ) << 16; + } + + uint32x4_t mask = vdupq_n_u32( 0xFFFFFF ); + uint8x16_t l0 = vreinterpretq_u8_u32( vandq_u32( mask, px0 ) ); + uint8x16_t l1 = vreinterpretq_u8_u32( vandq_u32( mask, px1 ) ); + uint8x16_t l2 = vreinterpretq_u8_u32( vandq_u32( mask, px2 ) ); + uint8x16_t l3 = vreinterpretq_u8_u32( vandq_u32( mask, px3 ) ); + + uint8x16_t min0 = vminq_u8( l0, l1 ); + uint8x16_t min1 = vminq_u8( l2, l3 ); + uint8x16_t min2 = vminq_u8( min0, min1 ); + + uint8x16_t max0 = vmaxq_u8( l0, l1 ); + uint8x16_t max1 = vmaxq_u8( l2, l3 ); + uint8x16_t max2 = vmaxq_u8( max0, max1 ); + + uint8x16_t min3 = vreinterpretq_u8_u32( vrev64q_u32( vreinterpretq_u32_u8( min2 ) ) ); + uint8x16_t max3 = vreinterpretq_u8_u32( vrev64q_u32( vreinterpretq_u32_u8( max2 ) ) ); + + uint8x16_t min4 = vminq_u8( min2, min3 ); + uint8x16_t max4 = vmaxq_u8( max2, max3 ); + + uint8x16_t min5 = vcombine_u8( vget_high_u8( min4 ), vget_low_u8( min4 ) ); + uint8x16_t max5 = vcombine_u8( vget_high_u8( max4 ), vget_low_u8( max4 ) ); + + uint8x16_t rmin = vminq_u8( min4, min5 ); + uint8x16_t rmax = vmaxq_u8( max4, max5 ); + + uint8x16_t range1 = vsubq_u8( rmax, rmin ); + uint8x8_t range2 = vget_low_u8( range1 ); + uint8x8x2_t range3 = vzip_u8( range2, vdup_n_u8( 0 ) ); + uint16x4_t range4 = vreinterpret_u16_u8( range3.val[0] ); + + uint16_t vrange1; + uint16x4_t range5 = vpadd_u16( range4, range4 ); + uint16x4_t range6 = vpadd_u16( range5, range5 ); + vst1_lane_u16( &vrange1, range6, 0 ); + + uint32_t vrange2 = ( 2 << 16 ) / uint32_t( vrange1 + 1 ); + uint16x8_t range = vdupq_n_u16( vrange2 ); + + uint8x16_t inset = vshrq_n_u8( range1, 4 ); + uint8x16_t min = vaddq_u8( rmin, inset ); + uint8x16_t max = vsubq_u8( rmax, inset ); + + uint8x16_t c0 = vsubq_u8( l0, rmin ); + uint8x16_t c1 = vsubq_u8( l1, rmin ); + uint8x16_t c2 = vsubq_u8( l2, rmin ); + uint8x16_t c3 = vsubq_u8( l3, rmin ); + + uint16x8_t is0 = vpaddlq_u8( c0 ); + uint16x8_t is1 = vpaddlq_u8( c1 ); + uint16x8_t is2 = vpaddlq_u8( c2 ); + uint16x8_t is3 = vpaddlq_u8( c3 ); + + uint16x4_t is4 = vpadd_u16( vget_low_u16( is0 ), vget_high_u16( is0 ) ); + uint16x4_t is5 = vpadd_u16( vget_low_u16( is1 ), vget_high_u16( is1 ) ); + uint16x4_t is6 = vpadd_u16( vget_low_u16( is2 ), vget_high_u16( is2 ) ); + uint16x4_t is7 = vpadd_u16( vget_low_u16( is3 ), vget_high_u16( is3 ) ); + + uint16x8_t s0 = vcombine_u16( is4, is5 ); + uint16x8_t s1 = vcombine_u16( is6, is7 ); + + uint16x8_t m0 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( s0 ), vreinterpretq_s16_u16( range ) ) ); + uint16x8_t m1 = vreinterpretq_u16_s16( vqdmulhq_s16( vreinterpretq_s16_u16( s1 ), vreinterpretq_s16_u16( range ) ) ); + + uint8x8_t p00 = vmovn_u16( m0 ); + uint8x8_t p01 = vmovn_u16( m1 ); + uint8x16_t p0 = vcombine_u8( p00, p01 ); + + uint32x4_t p1 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 6 ), vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 12 ) ); + uint32x4_t p2 = vaddq_u32( vshrq_n_u32( vreinterpretq_u32_u8( p0 ), 18 ), vreinterpretq_u32_u8( p0 ) ); + uint32x4_t p3 = vaddq_u32( p1, p2 ); + + uint16x4x2_t p4 = vuzp_u16( vget_low_u16( vreinterpretq_u16_u32( p3 ) ), vget_high_u16( vreinterpretq_u16_u32( p3 ) ) ); + uint8x8x2_t p = vuzp_u8( vreinterpret_u8_u16( p4.val[0] ), vreinterpret_u8_u16( p4.val[0] ) ); + + uint32_t vmin, vmax, vp; + vst1q_lane_u32( &vmin, vreinterpretq_u32_u8( min ), 0 ); + vst1q_lane_u32( &vmax, vreinterpretq_u32_u8( max ), 0 ); + vst1_lane_u32( &vp, vreinterpret_u32_u8( p.val[0] ), 0 ); + + return uint64_t( ( uint64_t( to565( vmin ) ) << 16 ) | to565( vmax ) | ( uint64_t( vp ) << 32 ) ); +# endif +#else + uint32_t ref; + memcpy( &ref, src, 4 ); + uint32_t refMask = ref & 0xF8FCF8; + auto stmp = src + 4; + for( int i=1; i<16; i++ ) + { + uint32_t px; + memcpy( &px, stmp, 4 ); + if( ( px & 0xF8FCF8 ) != refMask ) break; + stmp += 4; + } + if( stmp == src + 64 ) + { + return uint64_t( to565( ref ) ) << 16; + } + + uint8_t min[3] = { src[0], src[1], src[2] }; + uint8_t max[3] = { src[0], src[1], src[2] }; + auto tmp = src + 4; + for( int i=1; i<16; i++ ) + { + for( int j=0; j<3; j++ ) + { + if( tmp[j] < min[j] ) min[j] = tmp[j]; + else if( tmp[j] > max[j] ) max[j] = tmp[j]; + } + tmp += 4; + } + + const uint32_t range = DivTable[max[0] - min[0] + max[1] - min[1] + max[2] - min[2]]; + const uint32_t rmin = min[0] + min[1] + min[2]; + for( int i=0; i<3; i++ ) + { + const uint8_t inset = ( max[i] - min[i] ) >> 4; + min[i] += inset; + max[i] -= inset; + } + + uint32_t data = 0; + for( int i=0; i<16; i++ ) + { + const uint32_t c = src[0] + src[1] + src[2] - rmin; + const uint8_t idx = ( c * range ) >> 16; + data |= idx << (i*2); + src += 4; + } + + return uint64_t( ( uint64_t( to565( min[0], min[1], min[2] ) ) << 16 ) | to565( max[0], max[1], max[2] ) | ( uint64_t( data ) << 32 ) ); +#endif +} + +#ifdef __AVX2__ +static tracy_force_inline void ProcessRGB_AVX( const uint8_t* src, char*& dst ) +{ + __m256i px0 = _mm256_loadu_si256(((__m256i*)src) + 0); + __m256i px1 = _mm256_loadu_si256(((__m256i*)src) + 1); + __m256i px2 = _mm256_loadu_si256(((__m256i*)src) + 2); + __m256i px3 = _mm256_loadu_si256(((__m256i*)src) + 3); + + __m256i smask = _mm256_set1_epi32( 0xF8FCF8 ); + __m256i sd0 = _mm256_and_si256( px0, smask ); + __m256i sd1 = _mm256_and_si256( px1, smask ); + __m256i sd2 = _mm256_and_si256( px2, smask ); + __m256i sd3 = _mm256_and_si256( px3, smask ); + + __m256i sc = _mm256_shuffle_epi32(sd0, _MM_SHUFFLE(0, 0, 0, 0)); + + __m256i sc0 = _mm256_cmpeq_epi8( sd0, sc ); + __m256i sc1 = _mm256_cmpeq_epi8( sd1, sc ); + __m256i sc2 = _mm256_cmpeq_epi8( sd2, sc ); + __m256i sc3 = _mm256_cmpeq_epi8( sd3, sc ); + + __m256i sm0 = _mm256_and_si256( sc0, sc1 ); + __m256i sm1 = _mm256_and_si256( sc2, sc3 ); + __m256i sm = _mm256_and_si256( sm0, sm1 ); + + const int64_t solid0 = 1 - _mm_testc_si128( _mm256_castsi256_si128( sm ), _mm_set1_epi32( -1 ) ); + const int64_t solid1 = 1 - _mm_testc_si128( _mm256_extracti128_si256( sm, 1 ), _mm_set1_epi32( -1 ) ); + + if( solid0 + solid1 == 0 ) + { + const auto c0 = uint64_t( to565( src[0], src[1], src[2] ) ) << 16; + const auto c1 = uint64_t( to565( src[16], src[17], src[18] ) ) << 16; + memcpy( dst, &c0, 8 ); + memcpy( dst+8, &c1, 8 ); + dst += 16; + return; + } + + __m256i amask = _mm256_set1_epi32( 0xFFFFFF ); + px0 = _mm256_and_si256( px0, amask ); + px1 = _mm256_and_si256( px1, amask ); + px2 = _mm256_and_si256( px2, amask ); + px3 = _mm256_and_si256( px3, amask ); + + __m256i min0 = _mm256_min_epu8( px0, px1 ); + __m256i min1 = _mm256_min_epu8( px2, px3 ); + __m256i min2 = _mm256_min_epu8( min0, min1 ); + + __m256i max0 = _mm256_max_epu8( px0, px1 ); + __m256i max1 = _mm256_max_epu8( px2, px3 ); + __m256i max2 = _mm256_max_epu8( max0, max1 ); + + __m256i min3 = _mm256_shuffle_epi32( min2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m256i max3 = _mm256_shuffle_epi32( max2, _MM_SHUFFLE( 2, 3, 0, 1 ) ); + __m256i min4 = _mm256_min_epu8( min2, min3 ); + __m256i max4 = _mm256_max_epu8( max2, max3 ); + + __m256i min5 = _mm256_shuffle_epi32( min4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m256i max5 = _mm256_shuffle_epi32( max4, _MM_SHUFFLE( 0, 0, 2, 2 ) ); + __m256i rmin = _mm256_min_epu8( min4, min5 ); + __m256i rmax = _mm256_max_epu8( max4, max5 ); + + __m256i range1 = _mm256_subs_epu8( rmax, rmin ); + __m256i range2 = _mm256_sad_epu8( rmax, rmin ); + + uint16_t vrange0 = DivTable[_mm256_cvtsi256_si32( range2 ) >> 1]; + uint16_t vrange1 = DivTable[_mm256_extract_epi16( range2, 8 ) >> 1]; + __m256i range00 = _mm256_set1_epi16( vrange0 ); + __m256i range = _mm256_inserti128_si256( range00, _mm_set1_epi16( vrange1 ), 1 ); + + __m256i inset1 = _mm256_srli_epi16( range1, 4 ); + __m256i inset = _mm256_and_si256( inset1, _mm256_set1_epi8( 0xF ) ); + __m256i min = _mm256_adds_epu8( rmin, inset ); + __m256i max = _mm256_subs_epu8( rmax, inset ); + + __m256i c0 = _mm256_subs_epu8( px0, rmin ); + __m256i c1 = _mm256_subs_epu8( px1, rmin ); + __m256i c2 = _mm256_subs_epu8( px2, rmin ); + __m256i c3 = _mm256_subs_epu8( px3, rmin ); + + __m256i is0 = _mm256_maddubs_epi16( c0, _mm256_set1_epi8( 1 ) ); + __m256i is1 = _mm256_maddubs_epi16( c1, _mm256_set1_epi8( 1 ) ); + __m256i is2 = _mm256_maddubs_epi16( c2, _mm256_set1_epi8( 1 ) ); + __m256i is3 = _mm256_maddubs_epi16( c3, _mm256_set1_epi8( 1 ) ); + + __m256i s0 = _mm256_hadd_epi16( is0, is1 ); + __m256i s1 = _mm256_hadd_epi16( is2, is3 ); + + __m256i m0 = _mm256_mulhi_epu16( s0, range ); + __m256i m1 = _mm256_mulhi_epu16( s1, range ); + + __m256i p0 = _mm256_packus_epi16( m0, m1 ); + + __m256i p1 = _mm256_or_si256( _mm256_srai_epi32( p0, 6 ), _mm256_srai_epi32( p0, 12 ) ); + __m256i p2 = _mm256_or_si256( _mm256_srai_epi32( p0, 18 ), p0 ); + __m256i p3 = _mm256_or_si256( p1, p2 ); + __m256i p =_mm256_shuffle_epi8( p3, _mm256_set1_epi32( 0x0C080400 ) ); + + __m256i mm0 = _mm256_unpacklo_epi8( _mm256_setzero_si256(), min ); + __m256i mm1 = _mm256_unpacklo_epi8( _mm256_setzero_si256(), max ); + __m256i mm2 = _mm256_unpacklo_epi64( mm1, mm0 ); + __m256i mmr = _mm256_slli_epi64( _mm256_srli_epi64( mm2, 11 ), 11 ); + __m256i mmg = _mm256_slli_epi64( _mm256_srli_epi64( mm2, 26 ), 5 ); + __m256i mmb = _mm256_srli_epi64( _mm256_slli_epi64( mm2, 16 ), 59 ); + __m256i mm3 = _mm256_or_si256( mmr, mmg ); + __m256i mm4 = _mm256_or_si256( mm3, mmb ); + __m256i mm5 = _mm256_shuffle_epi8( mm4, _mm256_set1_epi32( 0x09080100 ) ); + + __m256i d0 = _mm256_unpacklo_epi32( mm5, p ); + __m256i d1 = _mm256_permute4x64_epi64( d0, _MM_SHUFFLE( 3, 2, 2, 0 ) ); + __m128i d2 = _mm256_castsi256_si128( d1 ); + + __m128i mask = _mm_set_epi64x( 0xFFFF0000 | -solid1, 0xFFFF0000 | -solid0 ); + __m128i d3 = _mm_and_si128( d2, mask ); + _mm_storeu_si128( (__m128i*)dst, d3 ); + dst += 16; +} +#endif + +void CompressImageDxt1( const char* src, char* dst, int w, int h ) +{ + assert( (w % 4) == 0 && (h % 4) == 0 ); + +#ifdef __AVX2__ + if( w%8 == 0 ) + { + uint32_t buf[8*4]; + int i = 0; + + auto blocks = w * h / 32; + do + { + auto tmp = (char*)buf; + memcpy( tmp, src, 8*4 ); + memcpy( tmp + 8*4, src + w * 4, 8*4 ); + memcpy( tmp + 16*4, src + w * 8, 8*4 ); + memcpy( tmp + 24*4, src + w * 12, 8*4 ); + src += 8*4; + if( ++i == w/8 ) + { + src += w * 3 * 4; + i = 0; + } + + ProcessRGB_AVX( (uint8_t*)buf, dst ); + } + while( --blocks ); + } + else +#endif + { + uint32_t buf[4*4]; + int i = 0; + + auto ptr = dst; + auto blocks = w * h / 16; + do + { + auto tmp = (char*)buf; + memcpy( tmp, src, 4*4 ); + memcpy( tmp + 4*4, src + w * 4, 4*4 ); + memcpy( tmp + 8*4, src + w * 8, 4*4 ); + memcpy( tmp + 12*4, src + w * 12, 4*4 ); + src += 4*4; + if( ++i == w/4 ) + { + src += w * 3 * 4; + i = 0; + } + + const auto c = ProcessRGB( (uint8_t*)buf ); + memcpy( ptr, &c, sizeof( uint64_t ) ); + ptr += sizeof( uint64_t ); + } + while( --blocks ); + } +} + +} diff --git a/Dependencies/tracy/client/TracyDxt1.hpp b/Dependencies/tracy/client/TracyDxt1.hpp new file mode 100644 index 000000000..c23135427 --- /dev/null +++ b/Dependencies/tracy/client/TracyDxt1.hpp @@ -0,0 +1,11 @@ +#ifndef __TRACYDXT1_HPP__ +#define __TRACYDXT1_HPP__ + +namespace tracy +{ + +void CompressImageDxt1( const char* src, char* dst, int w, int h ); + +} + +#endif diff --git a/Dependencies/tracy/client/TracyFastVector.hpp b/Dependencies/tracy/client/TracyFastVector.hpp new file mode 100644 index 000000000..38accc926 --- /dev/null +++ b/Dependencies/tracy/client/TracyFastVector.hpp @@ -0,0 +1,118 @@ +#ifndef __TRACYFASTVECTOR_HPP__ +#define __TRACYFASTVECTOR_HPP__ + +#include +#include + +#include "../common/TracyAlloc.hpp" +#include "../common/TracyForceInline.hpp" + +namespace tracy +{ + +template +class FastVector +{ +public: + using iterator = T*; + using const_iterator = const T*; + + FastVector( size_t capacity ) + : m_ptr( (T*)tracy_malloc( sizeof( T ) * capacity ) ) + , m_write( m_ptr ) + , m_end( m_ptr + capacity ) + { + assert( capacity != 0 ); + } + + FastVector( const FastVector& ) = delete; + FastVector( FastVector&& ) = delete; + + ~FastVector() + { + tracy_free( m_ptr ); + } + + FastVector& operator=( const FastVector& ) = delete; + FastVector& operator=( FastVector&& ) = delete; + + bool empty() const { return m_ptr == m_write; } + size_t size() const { return m_write - m_ptr; } + + T* data() { return m_ptr; } + const T* data() const { return m_ptr; }; + + T* begin() { return m_ptr; } + const T* begin() const { return m_ptr; } + T* end() { return m_write; } + const T* end() const { return m_write; } + + T& front() { assert( !empty() ); return m_ptr[0]; } + const T& front() const { assert( !empty() ); return m_ptr[0]; } + + T& back() { assert( !empty() ); return m_write[-1]; } + const T& back() const { assert( !empty() ); return m_write[-1]; } + + T& operator[]( size_t idx ) { return m_ptr[idx]; } + const T& operator[]( size_t idx ) const { return m_ptr[idx]; } + + T* push_next() + { + if( m_write == m_end ) AllocMore(); + return m_write++; + } + + T* prepare_next() + { + if( m_write == m_end ) AllocMore(); + return m_write; + } + + void commit_next() + { + m_write++; + } + + void clear() + { + m_write = m_ptr; + } + + void swap( FastVector& vec ) + { + const auto ptr1 = m_ptr; + const auto ptr2 = vec.m_ptr; + const auto write1 = m_write; + const auto write2 = vec.m_write; + const auto end1 = m_end; + const auto end2 = vec.m_end; + + m_ptr = ptr2; + vec.m_ptr = ptr1; + m_write = write2; + vec.m_write = write1; + m_end = end2; + vec.m_end = end1; + } + +private: + tracy_no_inline void AllocMore() + { + const auto cap = size_t( m_end - m_ptr ) * 2; + const auto size = size_t( m_write - m_ptr ); + T* ptr = (T*)tracy_malloc( sizeof( T ) * cap ); + memcpy( ptr, m_ptr, size * sizeof( T ) ); + tracy_free_fast( m_ptr ); + m_ptr = ptr; + m_write = m_ptr + size; + m_end = m_ptr + cap; + } + + T* m_ptr; + T* m_write; + T* m_end; +}; + +} + +#endif diff --git a/Dependencies/tracy/client/TracyKCore.cpp b/Dependencies/tracy/client/TracyKCore.cpp new file mode 100644 index 000000000..09d51d117 --- /dev/null +++ b/Dependencies/tracy/client/TracyKCore.cpp @@ -0,0 +1,121 @@ +#ifdef __linux__ + +#include +#include +#include +#include +#include + +#include "TracyDebug.hpp" +#include "TracyKCore.hpp" +#include "../common/TracyAlloc.hpp" + +#if !defined(__GLIBC__) && !defined(__WORDSIZE) +// include __WORDSIZE headers for musl +# include +#endif + +namespace tracy +{ + +using elf_half = uint16_t; +using elf_word = uint32_t; +using elf_sword = int32_t; + +#if __WORDSIZE == 32 + using elf_addr = uint32_t; + using elf_off = uint32_t; + using elf_xword = uint32_t; +#else + using elf_addr = uint64_t; + using elf_off = uint64_t; + using elf_xword = uint64_t; +#endif + +struct elf_ehdr +{ + unsigned char e_ident[16]; + elf_half e_type; + elf_half e_machine; + elf_word e_version; + elf_addr e_entry; + elf_off e_phoff; + elf_off e_shoff; + elf_word e_flags; + elf_half e_ehsize; + elf_half e_phentsize; + elf_half e_phnum; + elf_half e_shentsize; + elf_half e_shnum; + elf_half e_shstrndx; +}; + +struct elf_phdr +{ + elf_word p_type; + elf_word p_flags; + elf_off p_offset; + elf_addr p_vaddr; + elf_addr p_paddr; + elf_xword p_filesz; + elf_xword p_memsz; + uint64_t p_align; // include 32-bit-only flags field for 32-bit compatibility +}; + +KCore::KCore() + : m_offsets( 16 ) +{ + m_fd = open( "/proc/kcore", O_RDONLY ); + if( m_fd == -1 ) return; + + elf_ehdr ehdr; + if( read( m_fd, &ehdr, sizeof( ehdr ) ) != sizeof( ehdr ) ) goto err; + + assert( ehdr.e_phentsize == sizeof( elf_phdr ) ); + + for( elf_half i=0; istart = phdr.p_vaddr; + ptr->size = phdr.p_memsz; + ptr->offset = phdr.p_offset; + } + + std::sort( m_offsets.begin(), m_offsets.end(), []( const Offset& lhs, const Offset& rhs ) { return lhs.start < rhs.start; } ); + TracyDebug( "KCore: %zu segments found\n", m_offsets.size() ); + return; + +err: + close( m_fd ); + m_fd = -1; +} + +KCore::~KCore() +{ + if( m_fd != -1 ) close( m_fd ); +} + +void* KCore::Retrieve( uint64_t addr, uint64_t size ) const +{ + if( m_fd == -1 ) return nullptr; + auto it = std::lower_bound( m_offsets.begin(), m_offsets.end(), addr, []( const Offset& lhs, uint64_t rhs ) { return lhs.start + lhs.size < rhs; } ); + if( it == m_offsets.end() ) return nullptr; + if( addr + size > it->start + it->size ) return nullptr; + if( lseek( m_fd, it->offset + addr - it->start, SEEK_SET ) == -1 ) return nullptr; + auto ptr = tracy_malloc( size ); + if( read( m_fd, ptr, size ) != ssize_t( size ) ) + { + tracy_free( ptr ); + return nullptr; + } + return ptr; +} + +} + +#endif \ No newline at end of file diff --git a/Dependencies/tracy/client/TracyKCore.hpp b/Dependencies/tracy/client/TracyKCore.hpp new file mode 100644 index 000000000..437e172c2 --- /dev/null +++ b/Dependencies/tracy/client/TracyKCore.hpp @@ -0,0 +1,37 @@ +#ifndef __TRACYKCORE_HPP__ +#define __TRACYKCORE_HPP__ + +#ifdef __linux__ + +#include + +#include "TracyFastVector.hpp" + +namespace tracy +{ + +class KCore +{ + struct Offset + { + uint64_t start; + uint64_t size; + uint64_t offset; + }; + +public: + KCore(); + ~KCore(); + + void* Retrieve( uint64_t addr, uint64_t size ) const; + +private: + int m_fd; + FastVector m_offsets; +}; + +} + +#endif + +#endif diff --git a/Dependencies/tracy/client/TracyLock.hpp b/Dependencies/tracy/client/TracyLock.hpp new file mode 100644 index 000000000..d12a3c16d --- /dev/null +++ b/Dependencies/tracy/client/TracyLock.hpp @@ -0,0 +1,546 @@ +#ifndef __TRACYLOCK_HPP__ +#define __TRACYLOCK_HPP__ + +#include +#include + +#include "../common/TracySystem.hpp" +#include "../common/TracyAlign.hpp" +#include "TracyProfiler.hpp" + +namespace tracy +{ + +class LockableCtx +{ +public: + tracy_force_inline LockableCtx( const SourceLocationData* srcloc ) + : m_id( GetLockCounter().fetch_add( 1, std::memory_order_relaxed ) ) +#ifdef TRACY_ON_DEMAND + , m_lockCount( 0 ) + , m_active( false ) +#endif + { + assert( m_id != (std::numeric_limits::max)() ); + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockAnnounce ); + MemWrite( &item->lockAnnounce.id, m_id ); + MemWrite( &item->lockAnnounce.time, Profiler::GetTime() ); + MemWrite( &item->lockAnnounce.lckloc, (uint64_t)srcloc ); + MemWrite( &item->lockAnnounce.type, LockType::Lockable ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + + LockableCtx( const LockableCtx& ) = delete; + LockableCtx& operator=( const LockableCtx& ) = delete; + + tracy_force_inline ~LockableCtx() + { + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockTerminate ); + MemWrite( &item->lockTerminate.id, m_id ); + MemWrite( &item->lockTerminate.time, Profiler::GetTime() ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + + tracy_force_inline bool BeforeLock() + { +#ifdef TRACY_ON_DEMAND + bool queue = false; + const auto locks = m_lockCount.fetch_add( 1, std::memory_order_relaxed ); + const auto active = m_active.load( std::memory_order_relaxed ); + if( locks == 0 || active ) + { + const bool connected = GetProfiler().IsConnected(); + if( active != connected ) m_active.store( connected, std::memory_order_relaxed ); + if( connected ) queue = true; + } + if( !queue ) return false; +#endif + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockWait ); + MemWrite( &item->lockWait.thread, GetThreadHandle() ); + MemWrite( &item->lockWait.id, m_id ); + MemWrite( &item->lockWait.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + return true; + } + + tracy_force_inline void AfterLock() + { + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockObtain ); + MemWrite( &item->lockObtain.thread, GetThreadHandle() ); + MemWrite( &item->lockObtain.id, m_id ); + MemWrite( &item->lockObtain.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void AfterUnlock() + { +#ifdef TRACY_ON_DEMAND + m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); + if( !m_active.load( std::memory_order_relaxed ) ) return; + if( !GetProfiler().IsConnected() ) + { + m_active.store( false, std::memory_order_relaxed ); + return; + } +#endif + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockRelease ); + MemWrite( &item->lockRelease.id, m_id ); + MemWrite( &item->lockRelease.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void AfterTryLock( bool acquired ) + { +#ifdef TRACY_ON_DEMAND + if( !acquired ) return; + + bool queue = false; + const auto locks = m_lockCount.fetch_add( 1, std::memory_order_relaxed ); + const auto active = m_active.load( std::memory_order_relaxed ); + if( locks == 0 || active ) + { + const bool connected = GetProfiler().IsConnected(); + if( active != connected ) m_active.store( connected, std::memory_order_relaxed ); + if( connected ) queue = true; + } + if( !queue ) return; +#endif + + if( acquired ) + { + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockObtain ); + MemWrite( &item->lockObtain.thread, GetThreadHandle() ); + MemWrite( &item->lockObtain.id, m_id ); + MemWrite( &item->lockObtain.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + } + + tracy_force_inline void Mark( const SourceLocationData* srcloc ) + { +#ifdef TRACY_ON_DEMAND + const auto active = m_active.load( std::memory_order_relaxed ); + if( !active ) return; + const auto connected = GetProfiler().IsConnected(); + if( !connected ) + { + if( active ) m_active.store( false, std::memory_order_relaxed ); + return; + } +#endif + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockMark ); + MemWrite( &item->lockMark.thread, GetThreadHandle() ); + MemWrite( &item->lockMark.id, m_id ); + MemWrite( &item->lockMark.srcloc, (uint64_t)srcloc ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void CustomName( const char* name, size_t size ) + { + assert( size < (std::numeric_limits::max)() ); + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, name, size ); + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockName ); + MemWrite( &item->lockNameFat.id, m_id ); + MemWrite( &item->lockNameFat.name, (uint64_t)ptr ); + MemWrite( &item->lockNameFat.size, (uint16_t)size ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + +private: + uint32_t m_id; + +#ifdef TRACY_ON_DEMAND + std::atomic m_lockCount; + std::atomic m_active; +#endif +}; + +template +class Lockable +{ +public: + tracy_force_inline Lockable( const SourceLocationData* srcloc ) + : m_ctx( srcloc ) + { + } + + Lockable( const Lockable& ) = delete; + Lockable& operator=( const Lockable& ) = delete; + + tracy_force_inline void lock() + { + const auto runAfter = m_ctx.BeforeLock(); + m_lockable.lock(); + if( runAfter ) m_ctx.AfterLock(); + } + + tracy_force_inline void unlock() + { + m_lockable.unlock(); + m_ctx.AfterUnlock(); + } + + tracy_force_inline bool try_lock() + { + const auto acquired = m_lockable.try_lock(); + m_ctx.AfterTryLock( acquired ); + return acquired; + } + + tracy_force_inline void Mark( const SourceLocationData* srcloc ) + { + m_ctx.Mark( srcloc ); + } + + tracy_force_inline void CustomName( const char* name, size_t size ) + { + m_ctx.CustomName( name, size ); + } + +private: + T m_lockable; + LockableCtx m_ctx; +}; + + +class SharedLockableCtx +{ +public: + tracy_force_inline SharedLockableCtx( const SourceLocationData* srcloc ) + : m_id( GetLockCounter().fetch_add( 1, std::memory_order_relaxed ) ) +#ifdef TRACY_ON_DEMAND + , m_lockCount( 0 ) + , m_active( false ) +#endif + { + assert( m_id != (std::numeric_limits::max)() ); + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockAnnounce ); + MemWrite( &item->lockAnnounce.id, m_id ); + MemWrite( &item->lockAnnounce.time, Profiler::GetTime() ); + MemWrite( &item->lockAnnounce.lckloc, (uint64_t)srcloc ); + MemWrite( &item->lockAnnounce.type, LockType::SharedLockable ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + + SharedLockableCtx( const SharedLockableCtx& ) = delete; + SharedLockableCtx& operator=( const SharedLockableCtx& ) = delete; + + tracy_force_inline ~SharedLockableCtx() + { + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockTerminate ); + MemWrite( &item->lockTerminate.id, m_id ); + MemWrite( &item->lockTerminate.time, Profiler::GetTime() ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + + tracy_force_inline bool BeforeLock() + { +#ifdef TRACY_ON_DEMAND + bool queue = false; + const auto locks = m_lockCount.fetch_add( 1, std::memory_order_relaxed ); + const auto active = m_active.load( std::memory_order_relaxed ); + if( locks == 0 || active ) + { + const bool connected = GetProfiler().IsConnected(); + if( active != connected ) m_active.store( connected, std::memory_order_relaxed ); + if( connected ) queue = true; + } + if( !queue ) return false; +#endif + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockWait ); + MemWrite( &item->lockWait.thread, GetThreadHandle() ); + MemWrite( &item->lockWait.id, m_id ); + MemWrite( &item->lockWait.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + return true; + } + + tracy_force_inline void AfterLock() + { + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockObtain ); + MemWrite( &item->lockObtain.thread, GetThreadHandle() ); + MemWrite( &item->lockObtain.id, m_id ); + MemWrite( &item->lockObtain.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void AfterUnlock() + { +#ifdef TRACY_ON_DEMAND + m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); + if( !m_active.load( std::memory_order_relaxed ) ) return; + if( !GetProfiler().IsConnected() ) + { + m_active.store( false, std::memory_order_relaxed ); + return; + } +#endif + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockRelease ); + MemWrite( &item->lockRelease.id, m_id ); + MemWrite( &item->lockRelease.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void AfterTryLock( bool acquired ) + { +#ifdef TRACY_ON_DEMAND + if( !acquired ) return; + + bool queue = false; + const auto locks = m_lockCount.fetch_add( 1, std::memory_order_relaxed ); + const auto active = m_active.load( std::memory_order_relaxed ); + if( locks == 0 || active ) + { + const bool connected = GetProfiler().IsConnected(); + if( active != connected ) m_active.store( connected, std::memory_order_relaxed ); + if( connected ) queue = true; + } + if( !queue ) return; +#endif + + if( acquired ) + { + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockObtain ); + MemWrite( &item->lockObtain.thread, GetThreadHandle() ); + MemWrite( &item->lockObtain.id, m_id ); + MemWrite( &item->lockObtain.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + } + + tracy_force_inline bool BeforeLockShared() + { +#ifdef TRACY_ON_DEMAND + bool queue = false; + const auto locks = m_lockCount.fetch_add( 1, std::memory_order_relaxed ); + const auto active = m_active.load( std::memory_order_relaxed ); + if( locks == 0 || active ) + { + const bool connected = GetProfiler().IsConnected(); + if( active != connected ) m_active.store( connected, std::memory_order_relaxed ); + if( connected ) queue = true; + } + if( !queue ) return false; +#endif + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockSharedWait ); + MemWrite( &item->lockWait.thread, GetThreadHandle() ); + MemWrite( &item->lockWait.id, m_id ); + MemWrite( &item->lockWait.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + return true; + } + + tracy_force_inline void AfterLockShared() + { + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockSharedObtain ); + MemWrite( &item->lockObtain.thread, GetThreadHandle() ); + MemWrite( &item->lockObtain.id, m_id ); + MemWrite( &item->lockObtain.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void AfterUnlockShared() + { +#ifdef TRACY_ON_DEMAND + m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); + if( !m_active.load( std::memory_order_relaxed ) ) return; + if( !GetProfiler().IsConnected() ) + { + m_active.store( false, std::memory_order_relaxed ); + return; + } +#endif + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockSharedRelease ); + MemWrite( &item->lockReleaseShared.thread, GetThreadHandle() ); + MemWrite( &item->lockReleaseShared.id, m_id ); + MemWrite( &item->lockReleaseShared.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void AfterTryLockShared( bool acquired ) + { +#ifdef TRACY_ON_DEMAND + if( !acquired ) return; + + bool queue = false; + const auto locks = m_lockCount.fetch_add( 1, std::memory_order_relaxed ); + const auto active = m_active.load( std::memory_order_relaxed ); + if( locks == 0 || active ) + { + const bool connected = GetProfiler().IsConnected(); + if( active != connected ) m_active.store( connected, std::memory_order_relaxed ); + if( connected ) queue = true; + } + if( !queue ) return; +#endif + + if( acquired ) + { + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockSharedObtain ); + MemWrite( &item->lockObtain.thread, GetThreadHandle() ); + MemWrite( &item->lockObtain.id, m_id ); + MemWrite( &item->lockObtain.time, Profiler::GetTime() ); + Profiler::QueueSerialFinish(); + } + } + + tracy_force_inline void Mark( const SourceLocationData* srcloc ) + { +#ifdef TRACY_ON_DEMAND + const auto active = m_active.load( std::memory_order_relaxed ); + if( !active ) return; + const auto connected = GetProfiler().IsConnected(); + if( !connected ) + { + if( active ) m_active.store( false, std::memory_order_relaxed ); + return; + } +#endif + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockMark ); + MemWrite( &item->lockMark.thread, GetThreadHandle() ); + MemWrite( &item->lockMark.id, m_id ); + MemWrite( &item->lockMark.srcloc, (uint64_t)srcloc ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void CustomName( const char* name, size_t size ) + { + assert( size < (std::numeric_limits::max)() ); + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, name, size ); + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::LockName ); + MemWrite( &item->lockNameFat.id, m_id ); + MemWrite( &item->lockNameFat.name, (uint64_t)ptr ); + MemWrite( &item->lockNameFat.size, (uint16_t)size ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + +private: + uint32_t m_id; + +#ifdef TRACY_ON_DEMAND + std::atomic m_lockCount; + std::atomic m_active; +#endif +}; + +template +class SharedLockable +{ +public: + tracy_force_inline SharedLockable( const SourceLocationData* srcloc ) + : m_ctx( srcloc ) + { + } + + SharedLockable( const SharedLockable& ) = delete; + SharedLockable& operator=( const SharedLockable& ) = delete; + + tracy_force_inline void lock() + { + const auto runAfter = m_ctx.BeforeLock(); + m_lockable.lock(); + if( runAfter ) m_ctx.AfterLock(); + } + + tracy_force_inline void unlock() + { + m_lockable.unlock(); + m_ctx.AfterUnlock(); + } + + tracy_force_inline bool try_lock() + { + const auto acquired = m_lockable.try_lock(); + m_ctx.AfterTryLock( acquired ); + return acquired; + } + + tracy_force_inline void lock_shared() + { + const auto runAfter = m_ctx.BeforeLockShared(); + m_lockable.lock_shared(); + if( runAfter ) m_ctx.AfterLockShared(); + } + + tracy_force_inline void unlock_shared() + { + m_lockable.unlock_shared(); + m_ctx.AfterUnlockShared(); + } + + tracy_force_inline bool try_lock_shared() + { + const auto acquired = m_lockable.try_lock_shared(); + m_ctx.AfterTryLockShared( acquired ); + return acquired; + } + + tracy_force_inline void Mark( const SourceLocationData* srcloc ) + { + m_ctx.Mark( srcloc ); + } + + tracy_force_inline void CustomName( const char* name, size_t size ) + { + m_ctx.CustomName( name, size ); + } + +private: + T m_lockable; + SharedLockableCtx m_ctx; +}; + + +} + +#endif diff --git a/Dependencies/tracy/client/TracyOverride.cpp b/Dependencies/tracy/client/TracyOverride.cpp new file mode 100644 index 000000000..591508a7f --- /dev/null +++ b/Dependencies/tracy/client/TracyOverride.cpp @@ -0,0 +1,26 @@ +#ifdef TRACY_ENABLE +# ifdef __linux__ +# include "TracyDebug.hpp" +# ifdef TRACY_VERBOSE +# include +# include +# endif + +extern "C" int dlclose( void* hnd ) +{ +#ifdef TRACY_VERBOSE + struct link_map* lm; + if( dlinfo( hnd, RTLD_DI_LINKMAP, &lm ) == 0 ) + { + TracyDebug( "Overriding dlclose for %s\n", lm->l_name ); + } + else + { + TracyDebug( "Overriding dlclose for unknown object (%s)\n", dlerror() ); + } +#endif + return 0; +} + +# endif +#endif diff --git a/Dependencies/tracy/client/TracyProfiler.cpp b/Dependencies/tracy/client/TracyProfiler.cpp new file mode 100644 index 000000000..fa930432f --- /dev/null +++ b/Dependencies/tracy/client/TracyProfiler.cpp @@ -0,0 +1,4756 @@ +#ifdef TRACY_ENABLE + +#ifdef _WIN32 +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +# include +# include +# include +# include +# include "../common/TracyUwp.hpp" +#else +# include +# include +#endif + +#ifdef _GNU_SOURCE +# include +#endif + +#ifdef __linux__ +# include +# include +# include +# include +#endif + +#if defined __APPLE__ || defined BSD +# include +# include +#endif + +#if defined __APPLE__ +# include "TargetConditionals.h" +# include +#endif + +#ifdef __ANDROID__ +# include +# include +# include +# include +# include +# include +#endif + +#ifdef __QNX__ +# include +# include +# include +# include +# include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../common/TracyAlign.hpp" +#include "../common/TracyAlloc.hpp" +#include "../common/TracySocket.hpp" +#include "../common/TracySystem.hpp" +#include "../common/TracyYield.hpp" +#include "../common/tracy_lz4.hpp" +#include "tracy_rpmalloc.hpp" +#include "TracyCallstack.hpp" +#include "TracyDebug.hpp" +#include "TracyDxt1.hpp" +#include "TracyScoped.hpp" +#include "TracyProfiler.hpp" +#include "TracyThread.hpp" +#include "TracyArmCpuTable.hpp" +#include "TracySysTrace.hpp" +#include "../tracy/TracyC.h" + +#ifdef TRACY_PORT +# ifndef TRACY_DATA_PORT +# define TRACY_DATA_PORT TRACY_PORT +# endif +# ifndef TRACY_BROADCAST_PORT +# define TRACY_BROADCAST_PORT TRACY_PORT +# endif +#endif + +#ifdef __APPLE__ +# ifndef TRACY_DELAYED_INIT +# define TRACY_DELAYED_INIT +# endif +#else +# ifdef __GNUC__ +# define init_order( val ) __attribute__ ((init_priority(val))) +# else +# define init_order(x) +# endif +#endif + +#if defined _WIN32 +# include +extern "C" typedef LONG (WINAPI *t_RtlGetVersion)( PRTL_OSVERSIONINFOW ); +extern "C" typedef BOOL (WINAPI *t_GetLogicalProcessorInformationEx)( LOGICAL_PROCESSOR_RELATIONSHIP, PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PDWORD ); +#else +# include +# include +#endif +#if defined __linux__ +# include +# include +#endif + +#if !defined _WIN32 && ( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 ) +# include "TracyCpuid.hpp" +#endif + +#if !( ( defined _WIN32 && _WIN32_WINNT >= _WIN32_WINNT_VISTA ) || defined __linux__ ) +# include +#endif + +#ifdef __QNX__ +extern char* __progname; +#endif + +namespace tracy +{ + +#ifdef __ANDROID__ +// Implementation helpers of EnsureReadable(address). +// This is so far only needed on Android, where it is common for libraries to be mapped +// with only executable, not readable, permissions. Typical example (line from /proc/self/maps): +/* +746b63b000-746b6dc000 --xp 00042000 07:48 35 /apex/com.android.runtime/lib64/bionic/libc.so +*/ +// See https://github.com/wolfpld/tracy/issues/125 . +// To work around this, we parse /proc/self/maps and we use mprotect to set read permissions +// on any mappings that contain symbols addresses hit by HandleSymbolCodeQuery. + +namespace { +// Holds some information about a single memory mapping. +struct MappingInfo { + // Start of address range. Inclusive. + uintptr_t start_address; + // End of address range. Exclusive, so the mapping is the half-open interval + // [start, end) and its length in bytes is `end - start`. As in /proc/self/maps. + uintptr_t end_address; + // Read/Write/Executable permissions. + bool perm_r, perm_w, perm_x; +}; +} // anonymous namespace + + // Internal implementation helper for LookUpMapping(address). + // + // Parses /proc/self/maps returning a vector. + // /proc/self/maps is assumed to be sorted by ascending address, so the resulting + // vector is sorted by ascending address too. +static std::vector ParseMappings() +{ + std::vector result; + FILE* file = fopen( "/proc/self/maps", "r" ); + if( !file ) return result; + char line[1024]; + while( fgets( line, sizeof( line ), file ) ) + { + uintptr_t start_addr; + uintptr_t end_addr; +#if defined(__LP64__) + if( sscanf( line, "%lx-%lx", &start_addr, &end_addr ) != 2 ) continue; +#else + if (sscanf( line, "%dx-%dx", &start_addr, &end_addr ) != 2 ) continue; +#endif + char* first_space = strchr( line, ' ' ); + if( !first_space ) continue; + char* perm = first_space + 1; + char* second_space = strchr( perm, ' ' ); + if( !second_space || second_space - perm != 4 ) continue; + result.emplace_back(); + auto& mapping = result.back(); + mapping.start_address = start_addr; + mapping.end_address = end_addr; + mapping.perm_r = perm[0] == 'r'; + mapping.perm_w = perm[1] == 'w'; + mapping.perm_x = perm[2] == 'x'; + } + fclose( file ); + return result; +} + +// Internal implementation helper for LookUpMapping(address). +// +// Takes as input an `address` and a known vector `mappings`, assumed to be +// sorted by increasing addresses, as /proc/self/maps seems to be. +// Returns a pointer to the MappingInfo describing the mapping that this +// address belongs to, or nullptr if the address isn't in `mappings`. +static MappingInfo* LookUpMapping(std::vector& mappings, uintptr_t address) +{ + // Comparison function for std::lower_bound. Returns true if all addresses in `m1` + // are lower than `addr`. + auto Compare = []( const MappingInfo& m1, uintptr_t addr ) { + // '<=' because the address ranges are half-open intervals, [start, end). + return m1.end_address <= addr; + }; + auto iter = std::lower_bound( mappings.begin(), mappings.end(), address, Compare ); + if( iter == mappings.end() || iter->start_address > address) { + return nullptr; + } + return &*iter; +} + +// Internal implementation helper for EnsureReadable(address). +// +// Takes as input an `address` and returns a pointer to a MappingInfo +// describing the mapping that this address belongs to, or nullptr if +// the address isn't in any known mapping. +// +// This function is stateful and not reentrant (assumes to be called from +// only one thread). It holds a vector of mappings parsed from /proc/self/maps. +// +// Attempts to react to mappings changes by re-parsing /proc/self/maps. +static MappingInfo* LookUpMapping(uintptr_t address) +{ + // Static state managed by this function. Not constant, we mutate that state as + // we turn some mappings readable. Initially parsed once here, updated as needed below. + static std::vector s_mappings = ParseMappings(); + MappingInfo* mapping = LookUpMapping( s_mappings, address ); + if( mapping ) return mapping; + + // This address isn't in any known mapping. Try parsing again, maybe + // mappings changed. + s_mappings = ParseMappings(); + return LookUpMapping( s_mappings, address ); +} + +// Internal implementation helper for EnsureReadable(address). +// +// Attempts to make the specified `mapping` readable if it isn't already. +// Returns true if and only if the mapping is readable. +static bool EnsureReadable( MappingInfo& mapping ) +{ + if( mapping.perm_r ) + { + // The mapping is already readable. + return true; + } + int prot = PROT_READ; + if( mapping.perm_w ) prot |= PROT_WRITE; + if( mapping.perm_x ) prot |= PROT_EXEC; + if( mprotect( reinterpret_cast( mapping.start_address ), + mapping.end_address - mapping.start_address, prot ) == -1 ) + { + // Failed to make the mapping readable. Shouldn't happen, hasn't + // been observed yet. If it happened in practice, we should consider + // adding a bool to MappingInfo to track this to avoid retrying mprotect + // everytime on such mappings. + return false; + } + // The mapping is now readable. Update `mapping` so the next call will be fast. + mapping.perm_r = true; + return true; +} + +// Attempts to set the read permission on the entire mapping containing the +// specified address. Returns true if and only if the mapping is now readable. +static bool EnsureReadable( uintptr_t address ) +{ + MappingInfo* mapping = LookUpMapping(address); + return mapping && EnsureReadable( *mapping ); +} +#elif defined WIN32 +static bool EnsureReadable( uintptr_t address ) +{ + MEMORY_BASIC_INFORMATION memInfo; + VirtualQuery( reinterpret_cast( address ), &memInfo, sizeof( memInfo ) ); + return memInfo.Protect != PAGE_NOACCESS; +} +#else +static bool EnsureReadable( uintptr_t address ) +{ + return true; +} +#endif + +#ifndef TRACY_DELAYED_INIT + +struct InitTimeWrapper +{ + int64_t val; +}; + +struct ProducerWrapper +{ + tracy::moodycamel::ConcurrentQueue::ExplicitProducer* ptr; +}; + +struct ThreadHandleWrapper +{ + uint32_t val; +}; +#endif + + +#if defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 +static inline void CpuId( uint32_t* regs, uint32_t leaf ) +{ + memset(regs, 0, sizeof(uint32_t) * 4); +#if defined _MSC_VER + __cpuidex( (int*)regs, leaf, 0 ); +#else + __get_cpuid( leaf, regs, regs+1, regs+2, regs+3 ); +#endif +} + +static void InitFailure( const char* msg ) +{ +#if defined _WIN32 + bool hasConsole = false; + bool reopen = false; + const auto attached = AttachConsole( ATTACH_PARENT_PROCESS ); + if( attached ) + { + hasConsole = true; + reopen = true; + } + else + { + const auto err = GetLastError(); + if( err == ERROR_ACCESS_DENIED ) + { + hasConsole = true; + } + } + if( hasConsole ) + { + fprintf( stderr, "Tracy Profiler initialization failure: %s\n", msg ); + if( reopen ) + { + freopen( "CONOUT$", "w", stderr ); + fprintf( stderr, "Tracy Profiler initialization failure: %s\n", msg ); + } + } + else + { +# ifndef TRACY_UWP + MessageBoxA( nullptr, msg, "Tracy Profiler initialization failure", MB_ICONSTOP ); +# endif + } +#else + fprintf( stderr, "Tracy Profiler initialization failure: %s\n", msg ); +#endif + exit( 1 ); +} + +static bool CheckHardwareSupportsInvariantTSC() +{ + const char* noCheck = GetEnvVar( "TRACY_NO_INVARIANT_CHECK" ); + if( noCheck && noCheck[0] == '1' ) return true; + + uint32_t regs[4]; + CpuId( regs, 1 ); + if( !( regs[3] & ( 1 << 4 ) ) ) + { +#if !defined TRACY_TIMER_QPC && !defined TRACY_TIMER_FALLBACK + InitFailure( "CPU doesn't support RDTSC instruction." ); +#else + return false; +#endif + } + CpuId( regs, 0x80000007 ); + if( regs[3] & ( 1 << 8 ) ) return true; + + return false; +} + +#if defined TRACY_TIMER_FALLBACK && defined TRACY_HW_TIMER +bool HardwareSupportsInvariantTSC() +{ + static bool cachedResult = CheckHardwareSupportsInvariantTSC(); + return cachedResult; +} +#endif + +static int64_t SetupHwTimer() +{ +#if !defined TRACY_TIMER_QPC && !defined TRACY_TIMER_FALLBACK + if( !CheckHardwareSupportsInvariantTSC() ) + { +#if defined _WIN32 + InitFailure( "CPU doesn't support invariant TSC.\nDefine TRACY_NO_INVARIANT_CHECK=1 to ignore this error, *if you know what you are doing*.\nAlternatively you may rebuild the application with the TRACY_TIMER_QPC or TRACY_TIMER_FALLBACK define to use lower resolution timer." ); +#else + InitFailure( "CPU doesn't support invariant TSC.\nDefine TRACY_NO_INVARIANT_CHECK=1 to ignore this error, *if you know what you are doing*.\nAlternatively you may rebuild the application with the TRACY_TIMER_FALLBACK define to use lower resolution timer." ); +#endif + } +#endif + + return Profiler::GetTime(); +} +#else +static int64_t SetupHwTimer() +{ + return Profiler::GetTime(); +} +#endif + +static const char* GetProcessName() +{ + const char* processName = "unknown"; +#ifdef _WIN32 + static char buf[_MAX_PATH]; + GetModuleFileNameA( nullptr, buf, _MAX_PATH ); + const char* ptr = buf; + while( *ptr != '\0' ) ptr++; + while( ptr > buf && *ptr != '\\' && *ptr != '/' ) ptr--; + if( ptr > buf ) ptr++; + processName = ptr; +#elif defined __ANDROID__ +# if __ANDROID_API__ >= 21 + auto buf = getprogname(); + if( buf ) processName = buf; +# endif +#elif defined __linux__ && defined _GNU_SOURCE + if( program_invocation_short_name ) processName = program_invocation_short_name; +#elif defined __APPLE__ || defined BSD + auto buf = getprogname(); + if( buf ) processName = buf; +#elif defined __QNX__ + processName = __progname; +#endif + return processName; +} + +static const char* GetProcessExecutablePath() +{ +#ifdef _WIN32 + static char buf[_MAX_PATH]; + GetModuleFileNameA( nullptr, buf, _MAX_PATH ); + return buf; +#elif defined __ANDROID__ + return nullptr; +#elif defined __linux__ && defined _GNU_SOURCE + return program_invocation_name; +#elif defined __APPLE__ + static char buf[1024]; + uint32_t size = 1024; + _NSGetExecutablePath( buf, &size ); + return buf; +#elif defined __DragonFly__ + static char buf[1024]; + readlink( "/proc/curproc/file", buf, 1024 ); + return buf; +#elif defined __FreeBSD__ + static char buf[1024]; + int mib[4]; + mib[0] = CTL_KERN; + mib[1] = KERN_PROC; + mib[2] = KERN_PROC_PATHNAME; + mib[3] = -1; + size_t cb = 1024; + sysctl( mib, 4, buf, &cb, nullptr, 0 ); + return buf; +#elif defined __NetBSD__ + static char buf[1024]; + readlink( "/proc/curproc/exe", buf, 1024 ); + return buf; +#elif defined __QNX__ + static char buf[_PC_PATH_MAX + 1]; + _cmdname(buf); + return buf; +#else + return nullptr; +#endif +} + +#if defined __linux__ && defined __ARM_ARCH +static uint32_t GetHex( char*& ptr, int skip ) +{ + uint32_t ret; + ptr += skip; + char* end; + if( ptr[0] == '0' && ptr[1] == 'x' ) + { + ptr += 2; + ret = strtol( ptr, &end, 16 ); + } + else + { + ret = strtol( ptr, &end, 10 ); + } + ptr = end; + return ret; +} +#endif + +static const char* GetHostInfo() +{ + static char buf[1024]; + auto ptr = buf; +#if defined _WIN32 +# ifdef TRACY_UWP + auto GetVersion = &::GetVersionEx; +# else + auto GetVersion = (t_RtlGetVersion)GetProcAddress( GetModuleHandleA( "ntdll.dll" ), "RtlGetVersion" ); +# endif + if( !GetVersion ) + { +# ifdef __MINGW32__ + ptr += sprintf( ptr, "OS: Windows (MingW)\n" ); +# else + ptr += sprintf( ptr, "OS: Windows\n" ); +# endif + } + else + { + RTL_OSVERSIONINFOW ver = { sizeof( RTL_OSVERSIONINFOW ) }; + GetVersion( &ver ); + +# ifdef __MINGW32__ + ptr += sprintf( ptr, "OS: Windows %i.%i.%i (MingW)\n", (int)ver.dwMajorVersion, (int)ver.dwMinorVersion, (int)ver.dwBuildNumber ); +# else + ptr += sprintf( ptr, "OS: Windows %lu.%lu.%lu\n", ver.dwMajorVersion, ver.dwMinorVersion, ver.dwBuildNumber ); +# endif + } +#elif defined __linux__ + struct utsname utsName; + uname( &utsName ); +# if defined __ANDROID__ + ptr += sprintf( ptr, "OS: Linux %s (Android)\n", utsName.release ); +# else + ptr += sprintf( ptr, "OS: Linux %s\n", utsName.release ); +# endif +#elif defined __APPLE__ +# if TARGET_OS_IPHONE == 1 + ptr += sprintf( ptr, "OS: Darwin (iOS)\n" ); +# elif TARGET_OS_MAC == 1 + ptr += sprintf( ptr, "OS: Darwin (OSX)\n" ); +# else + ptr += sprintf( ptr, "OS: Darwin (unknown)\n" ); +# endif +#elif defined __DragonFly__ + ptr += sprintf( ptr, "OS: BSD (DragonFly)\n" ); +#elif defined __FreeBSD__ + ptr += sprintf( ptr, "OS: BSD (FreeBSD)\n" ); +#elif defined __NetBSD__ + ptr += sprintf( ptr, "OS: BSD (NetBSD)\n" ); +#elif defined __OpenBSD__ + ptr += sprintf( ptr, "OS: BSD (OpenBSD)\n" ); +#elif defined __QNX__ + ptr += sprintf( ptr, "OS: QNX\n" ); +#else + ptr += sprintf( ptr, "OS: unknown\n" ); +#endif + +#if defined _MSC_VER +# if defined __clang__ + ptr += sprintf( ptr, "Compiler: MSVC clang-cl %i.%i.%i\n", __clang_major__, __clang_minor__, __clang_patchlevel__ ); +# else + ptr += sprintf( ptr, "Compiler: MSVC %i\n", _MSC_VER ); +# endif +#elif defined __clang__ + ptr += sprintf( ptr, "Compiler: clang %i.%i.%i\n", __clang_major__, __clang_minor__, __clang_patchlevel__ ); +#elif defined __GNUC__ + ptr += sprintf( ptr, "Compiler: gcc %i.%i.%i\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ ); +#else + ptr += sprintf( ptr, "Compiler: unknown\n" ); +#endif + +#if defined _WIN32 + InitWinSock(); + + char hostname[512]; + gethostname( hostname, 512 ); + +# ifdef TRACY_UWP + const char* user = ""; +# else + DWORD userSz = UNLEN+1; + char user[UNLEN+1]; + GetUserNameA( user, &userSz ); +# endif + + ptr += sprintf( ptr, "User: %s@%s\n", user, hostname ); +#else + char hostname[_POSIX_HOST_NAME_MAX]{}; + char user[_POSIX_LOGIN_NAME_MAX]{}; + + gethostname( hostname, _POSIX_HOST_NAME_MAX ); +# if defined __ANDROID__ + const auto login = getlogin(); + if( login ) + { + strcpy( user, login ); + } + else + { + memcpy( user, "(?)", 4 ); + } +# else + getlogin_r( user, _POSIX_LOGIN_NAME_MAX ); +# endif + + ptr += sprintf( ptr, "User: %s@%s\n", user, hostname ); +#endif + +#if defined __i386 || defined _M_IX86 + ptr += sprintf( ptr, "Arch: x86\n" ); +#elif defined __x86_64__ || defined _M_X64 + ptr += sprintf( ptr, "Arch: x64\n" ); +#elif defined __aarch64__ + ptr += sprintf( ptr, "Arch: ARM64\n" ); +#elif defined __ARM_ARCH + ptr += sprintf( ptr, "Arch: ARM\n" ); +#else + ptr += sprintf( ptr, "Arch: unknown\n" ); +#endif + +#if defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 + uint32_t regs[4]; + char cpuModel[4*4*3+1] = {}; + auto modelPtr = cpuModel; + for( uint32_t i=0x80000002; i<0x80000005; ++i ) + { + CpuId( regs, i ); + memcpy( modelPtr, regs, sizeof( regs ) ); modelPtr += sizeof( regs ); + } + + ptr += sprintf( ptr, "CPU: %s\n", cpuModel ); +#elif defined __linux__ && defined __ARM_ARCH + bool cpuFound = false; + FILE* fcpuinfo = fopen( "/proc/cpuinfo", "rb" ); + if( fcpuinfo ) + { + enum { BufSize = 4*1024 }; + char buf[BufSize]; + const auto sz = fread( buf, 1, BufSize, fcpuinfo ); + fclose( fcpuinfo ); + const auto end = buf + sz; + auto cptr = buf; + + uint32_t impl = 0; + uint32_t var = 0; + uint32_t part = 0; + uint32_t rev = 0; + + while( end - cptr > 20 ) + { + while( end - cptr > 20 && memcmp( cptr, "CPU ", 4 ) != 0 ) + { + cptr += 4; + while( end - cptr > 20 && *cptr != '\n' ) cptr++; + cptr++; + } + if( end - cptr <= 20 ) break; + cptr += 4; + if( memcmp( cptr, "implementer\t: ", 14 ) == 0 ) + { + if( impl != 0 ) break; + impl = GetHex( cptr, 14 ); + } + else if( memcmp( cptr, "variant\t: ", 10 ) == 0 ) var = GetHex( cptr, 10 ); + else if( memcmp( cptr, "part\t: ", 7 ) == 0 ) part = GetHex( cptr, 7 ); + else if( memcmp( cptr, "revision\t: ", 11 ) == 0 ) rev = GetHex( cptr, 11 ); + while( *cptr != '\n' && *cptr != '\0' ) cptr++; + cptr++; + } + + if( impl != 0 || var != 0 || part != 0 || rev != 0 ) + { + cpuFound = true; + ptr += sprintf( ptr, "CPU: %s%s r%ip%i\n", DecodeArmImplementer( impl ), DecodeArmPart( impl, part ), var, rev ); + } + } + if( !cpuFound ) + { + ptr += sprintf( ptr, "CPU: unknown\n" ); + } +#elif defined __APPLE__ && TARGET_OS_IPHONE == 1 + { + size_t sz; + sysctlbyname( "hw.machine", nullptr, &sz, nullptr, 0 ); + auto str = (char*)tracy_malloc( sz ); + sysctlbyname( "hw.machine", str, &sz, nullptr, 0 ); + ptr += sprintf( ptr, "Device: %s\n", DecodeIosDevice( str ) ); + tracy_free( str ); + } +#else + ptr += sprintf( ptr, "CPU: unknown\n" ); +#endif +#ifdef __ANDROID__ + char deviceModel[PROP_VALUE_MAX+1]; + char deviceManufacturer[PROP_VALUE_MAX+1]; + __system_property_get( "ro.product.model", deviceModel ); + __system_property_get( "ro.product.manufacturer", deviceManufacturer ); + ptr += sprintf( ptr, "Device: %s %s\n", deviceManufacturer, deviceModel ); +#endif + + ptr += sprintf( ptr, "CPU cores: %i\n", std::thread::hardware_concurrency() ); + +#if defined _WIN32 + MEMORYSTATUSEX statex; + statex.dwLength = sizeof( statex ); + GlobalMemoryStatusEx( &statex ); +# ifdef _MSC_VER + ptr += sprintf( ptr, "RAM: %I64u MB\n", statex.ullTotalPhys / 1024 / 1024 ); +# else + ptr += sprintf( ptr, "RAM: %llu MB\n", statex.ullTotalPhys / 1024 / 1024 ); +# endif +#elif defined __linux__ + struct sysinfo sysInfo; + sysinfo( &sysInfo ); + ptr += sprintf( ptr, "RAM: %lu MB\n", sysInfo.totalram / 1024 / 1024 ); +#elif defined __APPLE__ + size_t memSize; + size_t sz = sizeof( memSize ); + sysctlbyname( "hw.memsize", &memSize, &sz, nullptr, 0 ); + ptr += sprintf( ptr, "RAM: %zu MB\n", memSize / 1024 / 1024 ); +#elif defined BSD + size_t memSize; + size_t sz = sizeof( memSize ); + sysctlbyname( "hw.physmem", &memSize, &sz, nullptr, 0 ); + ptr += sprintf( ptr, "RAM: %zu MB\n", memSize / 1024 / 1024 ); +#elif defined __QNX__ + struct asinfo_entry *entries = SYSPAGE_ENTRY(asinfo); + size_t count = SYSPAGE_ENTRY_SIZE(asinfo) / sizeof(struct asinfo_entry); + char *strings = SYSPAGE_ENTRY(strings)->data; + + uint64_t memSize = 0; + size_t i; + for (i = 0; i < count; i++) { + struct asinfo_entry *entry = &entries[i]; + if (strcmp(strings + entry->name, "ram") == 0) { + memSize += entry->end - entry->start + 1; + } + } + memSize = memSize / 1024 / 1024; + ptr += sprintf( ptr, "RAM: %llu MB\n", memSize); +#else + ptr += sprintf( ptr, "RAM: unknown\n" ); +#endif + + return buf; +} + +static uint64_t GetPid() +{ +#if defined _WIN32 + return uint64_t( GetCurrentProcessId() ); +#else + return uint64_t( getpid() ); +#endif +} + +void Profiler::AckServerQuery() +{ + QueueItem item; + MemWrite( &item.hdr.type, QueueType::AckServerQueryNoop ); + NeedDataSize( QueueDataSize[(int)QueueType::AckServerQueryNoop] ); + AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::AckServerQueryNoop] ); +} + +void Profiler::AckSymbolCodeNotAvailable() +{ + QueueItem item; + MemWrite( &item.hdr.type, QueueType::AckSymbolCodeNotAvailable ); + NeedDataSize( QueueDataSize[(int)QueueType::AckSymbolCodeNotAvailable] ); + AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::AckSymbolCodeNotAvailable] ); +} + +static BroadcastMessage& GetBroadcastMessage( const char* procname, size_t pnsz, int& len, int port ) +{ + static BroadcastMessage msg; + + msg.broadcastVersion = BroadcastVersion; + msg.protocolVersion = ProtocolVersion; + msg.listenPort = port; + msg.pid = GetPid(); + + memcpy( msg.programName, procname, pnsz ); + memset( msg.programName + pnsz, 0, WelcomeMessageProgramNameSize - pnsz ); + + len = int( offsetof( BroadcastMessage, programName ) + pnsz + 1 ); + return msg; +} + +#if defined _WIN32 && !defined TRACY_UWP && !defined TRACY_NO_CRASH_HANDLER +static DWORD s_profilerThreadId = 0; +static DWORD s_symbolThreadId = 0; +static char s_crashText[1024]; + +LONG WINAPI CrashFilter( PEXCEPTION_POINTERS pExp ) +{ + if( !GetProfiler().IsConnected() ) return EXCEPTION_CONTINUE_SEARCH; + + const unsigned ec = pExp->ExceptionRecord->ExceptionCode; + auto msgPtr = s_crashText; + switch( ec ) + { + case EXCEPTION_ACCESS_VIOLATION: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_ACCESS_VIOLATION (0x%x). ", ec ); + switch( pExp->ExceptionRecord->ExceptionInformation[0] ) + { + case 0: + msgPtr += sprintf( msgPtr, "Read violation at address 0x%" PRIxPTR ".", pExp->ExceptionRecord->ExceptionInformation[1] ); + break; + case 1: + msgPtr += sprintf( msgPtr, "Write violation at address 0x%" PRIxPTR ".", pExp->ExceptionRecord->ExceptionInformation[1] ); + break; + case 8: + msgPtr += sprintf( msgPtr, "DEP violation at address 0x%" PRIxPTR ".", pExp->ExceptionRecord->ExceptionInformation[1] ); + break; + default: + break; + } + break; + case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_ARRAY_BOUNDS_EXCEEDED (0x%x). ", ec ); + break; + case EXCEPTION_DATATYPE_MISALIGNMENT: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_DATATYPE_MISALIGNMENT (0x%x). ", ec ); + break; + case EXCEPTION_FLT_DIVIDE_BY_ZERO: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_FLT_DIVIDE_BY_ZERO (0x%x). ", ec ); + break; + case EXCEPTION_ILLEGAL_INSTRUCTION: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_ILLEGAL_INSTRUCTION (0x%x). ", ec ); + break; + case EXCEPTION_IN_PAGE_ERROR: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_IN_PAGE_ERROR (0x%x). ", ec ); + break; + case EXCEPTION_INT_DIVIDE_BY_ZERO: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_INT_DIVIDE_BY_ZERO (0x%x). ", ec ); + break; + case EXCEPTION_PRIV_INSTRUCTION: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_PRIV_INSTRUCTION (0x%x). ", ec ); + break; + case EXCEPTION_STACK_OVERFLOW: + msgPtr += sprintf( msgPtr, "Exception EXCEPTION_STACK_OVERFLOW (0x%x). ", ec ); + break; + default: + return EXCEPTION_CONTINUE_SEARCH; + } + + { + GetProfiler().SendCallstack( 60, "KiUserExceptionDispatcher" ); + + TracyQueuePrepare( QueueType::CrashReport ); + item->crashReport.time = Profiler::GetTime(); + item->crashReport.text = (uint64_t)s_crashText; + TracyQueueCommit( crashReportThread ); + } + + HANDLE h = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 ); + if( h == INVALID_HANDLE_VALUE ) return EXCEPTION_CONTINUE_SEARCH; + + THREADENTRY32 te = { sizeof( te ) }; + if( !Thread32First( h, &te ) ) + { + CloseHandle( h ); + return EXCEPTION_CONTINUE_SEARCH; + } + + const auto pid = GetCurrentProcessId(); + const auto tid = GetCurrentThreadId(); + + do + { + if( te.th32OwnerProcessID == pid && te.th32ThreadID != tid && te.th32ThreadID != s_profilerThreadId && te.th32ThreadID != s_symbolThreadId ) + { + HANDLE th = OpenThread( THREAD_SUSPEND_RESUME, FALSE, te.th32ThreadID ); + if( th != INVALID_HANDLE_VALUE ) + { + SuspendThread( th ); + CloseHandle( th ); + } + } + } + while( Thread32Next( h, &te ) ); + CloseHandle( h ); + + { + TracyLfqPrepare( QueueType::Crash ); + TracyLfqCommit; + } + + std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) ); + GetProfiler().RequestShutdown(); + while( !GetProfiler().HasShutdownFinished() ) { std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); }; + + return EXCEPTION_CONTINUE_SEARCH; +} +#endif + +static Profiler* s_instance = nullptr; +static Thread* s_thread; +#ifndef TRACY_NO_FRAME_IMAGE +static Thread* s_compressThread; +#endif +#ifdef TRACY_HAS_CALLSTACK +static Thread* s_symbolThread; +std::atomic s_symbolThreadGone { false }; +#endif +#ifdef TRACY_HAS_SYSTEM_TRACING +static Thread* s_sysTraceThread = nullptr; +#endif + +#if defined __linux__ && !defined TRACY_NO_CRASH_HANDLER +# ifndef TRACY_CRASH_SIGNAL +# define TRACY_CRASH_SIGNAL SIGPWR +# endif + +static long s_profilerTid = 0; +static long s_symbolTid = 0; +static char s_crashText[1024]; +static std::atomic s_alreadyCrashed( false ); + +static void ThreadFreezer( int /*signal*/ ) +{ + for(;;) sleep( 1000 ); +} + +static inline void HexPrint( char*& ptr, uint64_t val ) +{ + if( val == 0 ) + { + *ptr++ = '0'; + return; + } + + static const char HexTable[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; + char buf[16]; + auto bptr = buf; + + do + { + *bptr++ = HexTable[val%16]; + val /= 16; + } + while( val > 0 ); + + do + { + *ptr++ = *--bptr; + } + while( bptr != buf ); +} + +static void CrashHandler( int signal, siginfo_t* info, void* /*ucontext*/ ) +{ + bool expected = false; + if( !s_alreadyCrashed.compare_exchange_strong( expected, true ) ) ThreadFreezer( signal ); + + struct sigaction act = {}; + act.sa_handler = SIG_DFL; + sigaction( SIGABRT, &act, nullptr ); + + auto msgPtr = s_crashText; + switch( signal ) + { + case SIGILL: + strcpy( msgPtr, "Illegal Instruction.\n" ); + while( *msgPtr ) msgPtr++; + switch( info->si_code ) + { + case ILL_ILLOPC: + strcpy( msgPtr, "Illegal opcode.\n" ); + break; + case ILL_ILLOPN: + strcpy( msgPtr, "Illegal operand.\n" ); + break; + case ILL_ILLADR: + strcpy( msgPtr, "Illegal addressing mode.\n" ); + break; + case ILL_ILLTRP: + strcpy( msgPtr, "Illegal trap.\n" ); + break; + case ILL_PRVOPC: + strcpy( msgPtr, "Privileged opcode.\n" ); + break; + case ILL_PRVREG: + strcpy( msgPtr, "Privileged register.\n" ); + break; + case ILL_COPROC: + strcpy( msgPtr, "Coprocessor error.\n" ); + break; + case ILL_BADSTK: + strcpy( msgPtr, "Internal stack error.\n" ); + break; + default: + break; + } + break; + case SIGFPE: + strcpy( msgPtr, "Floating-point exception.\n" ); + while( *msgPtr ) msgPtr++; + switch( info->si_code ) + { + case FPE_INTDIV: + strcpy( msgPtr, "Integer divide by zero.\n" ); + break; + case FPE_INTOVF: + strcpy( msgPtr, "Integer overflow.\n" ); + break; + case FPE_FLTDIV: + strcpy( msgPtr, "Floating-point divide by zero.\n" ); + break; + case FPE_FLTOVF: + strcpy( msgPtr, "Floating-point overflow.\n" ); + break; + case FPE_FLTUND: + strcpy( msgPtr, "Floating-point underflow.\n" ); + break; + case FPE_FLTRES: + strcpy( msgPtr, "Floating-point inexact result.\n" ); + break; + case FPE_FLTINV: + strcpy( msgPtr, "Floating-point invalid operation.\n" ); + break; + case FPE_FLTSUB: + strcpy( msgPtr, "Subscript out of range.\n" ); + break; + default: + break; + } + break; + case SIGSEGV: + strcpy( msgPtr, "Invalid memory reference.\n" ); + while( *msgPtr ) msgPtr++; + switch( info->si_code ) + { + case SEGV_MAPERR: + strcpy( msgPtr, "Address not mapped to object.\n" ); + break; + case SEGV_ACCERR: + strcpy( msgPtr, "Invalid permissions for mapped object.\n" ); + break; +# ifdef SEGV_BNDERR + case SEGV_BNDERR: + strcpy( msgPtr, "Failed address bound checks.\n" ); + break; +# endif +# ifdef SEGV_PKUERR + case SEGV_PKUERR: + strcpy( msgPtr, "Access was denied by memory protection keys.\n" ); + break; +# endif + default: + break; + } + break; + case SIGPIPE: + strcpy( msgPtr, "Broken pipe.\n" ); + while( *msgPtr ) msgPtr++; + break; + case SIGBUS: + strcpy( msgPtr, "Bus error.\n" ); + while( *msgPtr ) msgPtr++; + switch( info->si_code ) + { + case BUS_ADRALN: + strcpy( msgPtr, "Invalid address alignment.\n" ); + break; + case BUS_ADRERR: + strcpy( msgPtr, "Nonexistent physical address.\n" ); + break; + case BUS_OBJERR: + strcpy( msgPtr, "Object-specific hardware error.\n" ); + break; +# ifdef BUS_MCEERR_AR + case BUS_MCEERR_AR: + strcpy( msgPtr, "Hardware memory error consumed on a machine check; action required.\n" ); + break; +# endif +# ifdef BUS_MCEERR_AO + case BUS_MCEERR_AO: + strcpy( msgPtr, "Hardware memory error detected in process but not consumed; action optional.\n" ); + break; +# endif + default: + break; + } + break; + case SIGABRT: + strcpy( msgPtr, "Abort signal from abort().\n" ); + break; + default: + abort(); + } + while( *msgPtr ) msgPtr++; + + if( signal != SIGPIPE ) + { + strcpy( msgPtr, "Fault address: 0x" ); + while( *msgPtr ) msgPtr++; + HexPrint( msgPtr, uint64_t( info->si_addr ) ); + *msgPtr++ = '\n'; + } + + { + GetProfiler().SendCallstack( 60, "__kernel_rt_sigreturn" ); + + TracyQueuePrepare( QueueType::CrashReport ); + item->crashReport.time = Profiler::GetTime(); + item->crashReport.text = (uint64_t)s_crashText; + TracyQueueCommit( crashReportThread ); + } + + DIR* dp = opendir( "/proc/self/task" ); + if( !dp ) abort(); + + const auto selfTid = syscall( SYS_gettid ); + + struct dirent* ep; + while( ( ep = readdir( dp ) ) != nullptr ) + { + if( ep->d_name[0] == '.' ) continue; + int tid = atoi( ep->d_name ); + if( tid != selfTid && tid != s_profilerTid && tid != s_symbolTid ) + { + syscall( SYS_tkill, tid, TRACY_CRASH_SIGNAL ); + } + } + closedir( dp ); + +#ifdef TRACY_HAS_CALLSTACK + if( selfTid == s_symbolTid ) s_symbolThreadGone.store( true, std::memory_order_release ); +#endif + + TracyLfqPrepare( QueueType::Crash ); + TracyLfqCommit; + + std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) ); + GetProfiler().RequestShutdown(); + while( !GetProfiler().HasShutdownFinished() ) { std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); }; + + abort(); +} +#endif + + +enum { QueuePrealloc = 256 * 1024 }; + +TRACY_API int64_t GetFrequencyQpc() +{ +#if defined _WIN32 + LARGE_INTEGER t; + QueryPerformanceFrequency( &t ); + return t.QuadPart; +#else + return 0; +#endif +} + +#ifdef TRACY_DELAYED_INIT +struct ThreadNameData; +TRACY_API moodycamel::ConcurrentQueue& GetQueue(); + +struct ProfilerData +{ + int64_t initTime = SetupHwTimer(); + moodycamel::ConcurrentQueue queue; + Profiler profiler; + std::atomic lockCounter { 0 }; + std::atomic gpuCtxCounter { 0 }; + std::atomic threadNameData { nullptr }; +}; + +struct ProducerWrapper +{ + ProducerWrapper( ProfilerData& data ) : detail( data.queue ), ptr( data.queue.get_explicit_producer( detail ) ) {} + moodycamel::ProducerToken detail; + tracy::moodycamel::ConcurrentQueue::ExplicitProducer* ptr; +}; + +struct ProfilerThreadData +{ + ProfilerThreadData( ProfilerData& data ) : token( data ), gpuCtx( { nullptr } ) {} + ProducerWrapper token; + GpuCtxWrapper gpuCtx; +# ifdef TRACY_ON_DEMAND + LuaZoneState luaZoneState; +# endif +}; + +std::atomic RpInitDone { 0 }; +std::atomic RpInitLock { 0 }; +thread_local bool RpThreadInitDone = false; +thread_local bool RpThreadShutdown = false; + +# ifdef TRACY_MANUAL_LIFETIME +ProfilerData* s_profilerData = nullptr; +static ProfilerThreadData& GetProfilerThreadData(); +static std::atomic s_isProfilerStarted { false }; +TRACY_API void StartupProfiler() +{ + s_profilerData = (ProfilerData*)tracy_malloc( sizeof( ProfilerData ) ); + new (s_profilerData) ProfilerData(); + s_profilerData->profiler.SpawnWorkerThreads(); + GetProfilerThreadData().token = ProducerWrapper( *s_profilerData ); + s_isProfilerStarted.store( true, std::memory_order_seq_cst ); +} +static ProfilerData& GetProfilerData() +{ + assert( s_profilerData ); + return *s_profilerData; +} +TRACY_API void ShutdownProfiler() +{ + s_isProfilerStarted.store( false, std::memory_order_seq_cst ); + s_profilerData->~ProfilerData(); + tracy_free( s_profilerData ); + s_profilerData = nullptr; + rpmalloc_finalize(); + RpThreadInitDone = false; + RpInitDone.store( 0, std::memory_order_release ); +} +TRACY_API bool IsProfilerStarted() +{ + return s_isProfilerStarted.load( std::memory_order_seq_cst ); +} +# else +static std::atomic profilerDataLock { 0 }; +static std::atomic profilerData { nullptr }; + +static ProfilerData& GetProfilerData() +{ + auto ptr = profilerData.load( std::memory_order_acquire ); + if( !ptr ) + { + int expected = 0; + while( !profilerDataLock.compare_exchange_weak( expected, 1, std::memory_order_release, std::memory_order_relaxed ) ) { expected = 0; YieldThread(); } + ptr = profilerData.load( std::memory_order_acquire ); + if( !ptr ) + { + ptr = (ProfilerData*)tracy_malloc( sizeof( ProfilerData ) ); + new (ptr) ProfilerData(); + profilerData.store( ptr, std::memory_order_release ); + } + profilerDataLock.store( 0, std::memory_order_release ); + } + return *ptr; +} +# endif + +// GCC prior to 8.4 had a bug with function-inline thread_local variables. Versions of glibc beginning with +// 2.18 may attempt to work around this issue, which manifests as a crash while running static destructors +// if this function is compiled into a shared object. Unfortunately, centos7 ships with glibc 2.17. If running +// on old GCC, use the old-fashioned way as a workaround +// See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85400 +#if !defined(__clang__) && defined(__GNUC__) && ((__GNUC__ < 8) || ((__GNUC__ == 8) && (__GNUC_MINOR__ < 4))) +struct ProfilerThreadDataKey +{ +public: + ProfilerThreadDataKey() + { + int val = pthread_key_create(&m_key, sDestructor); + static_cast(val); // unused + assert(val == 0); + } + ~ProfilerThreadDataKey() + { + int val = pthread_key_delete(m_key); + static_cast(val); // unused + assert(val == 0); + } + ProfilerThreadData& get() + { + void* p = pthread_getspecific(m_key); + if (!p) + { + p = (ProfilerThreadData*)tracy_malloc( sizeof( ProfilerThreadData ) ); + new (p) ProfilerThreadData(GetProfilerData()); + pthread_setspecific(m_key, p); + } + return *static_cast(p); + } +private: + pthread_key_t m_key; + + static void sDestructor(void* p) + { + ((ProfilerThreadData*)p)->~ProfilerThreadData(); + tracy_free(p); + } +}; + +static ProfilerThreadData& GetProfilerThreadData() +{ + static ProfilerThreadDataKey key; + return key.get(); +} +#else +static ProfilerThreadData& GetProfilerThreadData() +{ + thread_local ProfilerThreadData data( GetProfilerData() ); + return data; +} +#endif + +TRACY_API moodycamel::ConcurrentQueue::ExplicitProducer* GetToken() { return GetProfilerThreadData().token.ptr; } +TRACY_API Profiler& GetProfiler() { return GetProfilerData().profiler; } +TRACY_API moodycamel::ConcurrentQueue& GetQueue() { return GetProfilerData().queue; } +TRACY_API int64_t GetInitTime() { return GetProfilerData().initTime; } +TRACY_API std::atomic& GetLockCounter() { return GetProfilerData().lockCounter; } +TRACY_API std::atomic& GetGpuCtxCounter() { return GetProfilerData().gpuCtxCounter; } +TRACY_API GpuCtxWrapper& GetGpuCtx() { return GetProfilerThreadData().gpuCtx; } +TRACY_API uint32_t GetThreadHandle() { return detail::GetThreadHandleImpl(); } +std::atomic& GetThreadNameData() { return GetProfilerData().threadNameData; } + +# ifdef TRACY_ON_DEMAND +TRACY_API LuaZoneState& GetLuaZoneState() { return GetProfilerThreadData().luaZoneState; } +# endif + +# ifndef TRACY_MANUAL_LIFETIME +namespace +{ + const auto& __profiler_init = GetProfiler(); +} +# endif + +#else + +// MSVC static initialization order solution. gcc/clang uses init_order() to avoid all this. + +// 1a. But s_queue is needed for initialization of variables in point 2. +extern moodycamel::ConcurrentQueue s_queue; + +// 2. If these variables would be in the .CRT$XCB section, they would be initialized only in main thread. +thread_local moodycamel::ProducerToken init_order(107) s_token_detail( s_queue ); +thread_local ProducerWrapper init_order(108) s_token { s_queue.get_explicit_producer( s_token_detail ) }; +thread_local ThreadHandleWrapper init_order(104) s_threadHandle { detail::GetThreadHandleImpl() }; + +# ifdef _MSC_VER +// 1. Initialize these static variables before all other variables. +# pragma warning( disable : 4075 ) +# pragma init_seg( ".CRT$XCB" ) +# endif + +static InitTimeWrapper init_order(101) s_initTime { SetupHwTimer() }; +std::atomic init_order(102) RpInitDone( 0 ); +std::atomic init_order(102) RpInitLock( 0 ); +thread_local bool RpThreadInitDone = false; +thread_local bool RpThreadShutdown = false; +moodycamel::ConcurrentQueue init_order(103) s_queue( QueuePrealloc ); +std::atomic init_order(104) s_lockCounter( 0 ); +std::atomic init_order(104) s_gpuCtxCounter( 0 ); + +thread_local GpuCtxWrapper init_order(104) s_gpuCtx { nullptr }; + +struct ThreadNameData; +static std::atomic init_order(104) s_threadNameDataInstance( nullptr ); +std::atomic& s_threadNameData = s_threadNameDataInstance; + +# ifdef TRACY_ON_DEMAND +thread_local LuaZoneState init_order(104) s_luaZoneState { 0, false }; +# endif + +static Profiler init_order(105) s_profiler; + +TRACY_API moodycamel::ConcurrentQueue::ExplicitProducer* GetToken() { return s_token.ptr; } +TRACY_API Profiler& GetProfiler() { return s_profiler; } +TRACY_API moodycamel::ConcurrentQueue& GetQueue() { return s_queue; } +TRACY_API int64_t GetInitTime() { return s_initTime.val; } +TRACY_API std::atomic& GetLockCounter() { return s_lockCounter; } +TRACY_API std::atomic& GetGpuCtxCounter() { return s_gpuCtxCounter; } +TRACY_API GpuCtxWrapper& GetGpuCtx() { return s_gpuCtx; } +TRACY_API uint32_t GetThreadHandle() { return s_threadHandle.val; } + +std::atomic& GetThreadNameData() { return s_threadNameData; } + +# ifdef TRACY_ON_DEMAND +TRACY_API LuaZoneState& GetLuaZoneState() { return s_luaZoneState; } +# endif +#endif + +TRACY_API bool ProfilerAvailable() { return s_instance != nullptr; } +TRACY_API bool ProfilerAllocatorAvailable() { return !RpThreadShutdown; } + +Profiler::Profiler() + : m_timeBegin( 0 ) + , m_mainThread( detail::GetThreadHandleImpl() ) + , m_epoch( std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch() ).count() ) + , m_shutdown( false ) + , m_shutdownManual( false ) + , m_shutdownFinished( false ) + , m_sock( nullptr ) + , m_broadcast( nullptr ) + , m_noExit( false ) + , m_userPort( 0 ) + , m_zoneId( 1 ) + , m_samplingPeriod( 0 ) + , m_stream( LZ4_createStream() ) + , m_buffer( (char*)tracy_malloc( TargetFrameSize*3 ) ) + , m_bufferOffset( 0 ) + , m_bufferStart( 0 ) + , m_lz4Buf( (char*)tracy_malloc( LZ4Size + sizeof( lz4sz_t ) ) ) + , m_serialQueue( 1024*1024 ) + , m_serialDequeue( 1024*1024 ) +#ifndef TRACY_NO_FRAME_IMAGE + , m_fiQueue( 16 ) + , m_fiDequeue( 16 ) +#endif + , m_symbolQueue( 8*1024 ) + , m_frameCount( 0 ) + , m_isConnected( false ) +#ifdef TRACY_ON_DEMAND + , m_connectionId( 0 ) + , m_deferredQueue( 64*1024 ) +#endif + , m_paramCallback( nullptr ) + , m_sourceCallback( nullptr ) + , m_queryImage( nullptr ) + , m_queryData( nullptr ) + , m_crashHandlerInstalled( false ) + , m_programName( nullptr ) +{ + assert( !s_instance ); + s_instance = this; + +#ifndef TRACY_DELAYED_INIT +# ifdef _MSC_VER + // 3. But these variables need to be initialized in main thread within the .CRT$XCB section. Do it here. + s_token_detail = moodycamel::ProducerToken( s_queue ); + s_token = ProducerWrapper { s_queue.get_explicit_producer( s_token_detail ) }; + s_threadHandle = ThreadHandleWrapper { m_mainThread }; +# endif +#endif + + CalibrateTimer(); + CalibrateDelay(); + ReportTopology(); + +#ifdef __linux__ + m_kcore = (KCore*)tracy_malloc( sizeof( KCore ) ); + new(m_kcore) KCore(); +#endif + +#ifndef TRACY_NO_EXIT + const char* noExitEnv = GetEnvVar( "TRACY_NO_EXIT" ); + if( noExitEnv && noExitEnv[0] == '1' ) + { + m_noExit = true; + } +#endif + + const char* userPort = GetEnvVar( "TRACY_PORT" ); + if( userPort ) + { + m_userPort = atoi( userPort ); + } + +#if !defined(TRACY_DELAYED_INIT) || !defined(TRACY_MANUAL_LIFETIME) + SpawnWorkerThreads(); +#endif +} + +void Profiler::InstallCrashHandler() +{ + +#if defined __linux__ && !defined TRACY_NO_CRASH_HANDLER + struct sigaction threadFreezer = {}; + threadFreezer.sa_handler = ThreadFreezer; + sigaction( TRACY_CRASH_SIGNAL, &threadFreezer, &m_prevSignal.pwr ); + + struct sigaction crashHandler = {}; + crashHandler.sa_sigaction = CrashHandler; + crashHandler.sa_flags = SA_SIGINFO; + sigaction( SIGILL, &crashHandler, &m_prevSignal.ill ); + sigaction( SIGFPE, &crashHandler, &m_prevSignal.fpe ); + sigaction( SIGSEGV, &crashHandler, &m_prevSignal.segv ); + sigaction( SIGPIPE, &crashHandler, &m_prevSignal.pipe ); + sigaction( SIGBUS, &crashHandler, &m_prevSignal.bus ); + sigaction( SIGABRT, &crashHandler, &m_prevSignal.abrt ); +#endif + +#if defined _WIN32 && !defined TRACY_UWP && !defined TRACY_NO_CRASH_HANDLER + m_exceptionHandler = AddVectoredExceptionHandler( 1, CrashFilter ); +#endif + +#ifndef TRACY_NO_CRASH_HANDLER + m_crashHandlerInstalled = true; +#endif + +} + +void Profiler::RemoveCrashHandler() +{ +#if defined _WIN32 && !defined TRACY_UWP + if( m_crashHandlerInstalled ) RemoveVectoredExceptionHandler( m_exceptionHandler ); +#endif + +#if defined __linux__ && !defined TRACY_NO_CRASH_HANDLER + if( m_crashHandlerInstalled ) + { + sigaction( TRACY_CRASH_SIGNAL, &m_prevSignal.pwr, nullptr ); + sigaction( SIGILL, &m_prevSignal.ill, nullptr ); + sigaction( SIGFPE, &m_prevSignal.fpe, nullptr ); + sigaction( SIGSEGV, &m_prevSignal.segv, nullptr ); + sigaction( SIGPIPE, &m_prevSignal.pipe, nullptr ); + sigaction( SIGBUS, &m_prevSignal.bus, nullptr ); + sigaction( SIGABRT, &m_prevSignal.abrt, nullptr ); + } +#endif + m_crashHandlerInstalled = false; +} + +void Profiler::SpawnWorkerThreads() +{ +#ifdef TRACY_HAS_SYSTEM_TRACING + // use TRACY_NO_SYS_TRACE=1 to force disabling sys tracing (even if available in the underlying system) + // as it can have significant impact on the size of the traces + const char* noSysTrace = GetEnvVar( "TRACY_NO_SYS_TRACE" ); + const bool disableSystrace = (noSysTrace && noSysTrace[0] == '1'); + if( disableSystrace ) + { + TracyDebug("TRACY: Sys Trace was disabled by 'TRACY_NO_SYS_TRACE=1'\n"); + } + else if( SysTraceStart( m_samplingPeriod ) ) + { + s_sysTraceThread = (Thread*)tracy_malloc( sizeof( Thread ) ); + new(s_sysTraceThread) Thread( SysTraceWorker, nullptr ); + std::this_thread::sleep_for( std::chrono::milliseconds( 1 ) ); + } +#endif + + s_thread = (Thread*)tracy_malloc( sizeof( Thread ) ); + new(s_thread) Thread( LaunchWorker, this ); + +#ifndef TRACY_NO_FRAME_IMAGE + s_compressThread = (Thread*)tracy_malloc( sizeof( Thread ) ); + new(s_compressThread) Thread( LaunchCompressWorker, this ); +#endif + +#ifdef TRACY_HAS_CALLSTACK + s_symbolThread = (Thread*)tracy_malloc( sizeof( Thread ) ); + new(s_symbolThread) Thread( LaunchSymbolWorker, this ); +#endif + +#if defined _WIN32 && !defined TRACY_UWP && !defined TRACY_NO_CRASH_HANDLER + s_profilerThreadId = GetThreadId( s_thread->Handle() ); +# ifdef TRACY_HAS_CALLSTACK + s_symbolThreadId = GetThreadId( s_symbolThread->Handle() ); +# endif +#endif + +#ifdef TRACY_HAS_CALLSTACK + InitCallstackCritical(); +#endif + + m_timeBegin.store( GetTime(), std::memory_order_relaxed ); +} + +Profiler::~Profiler() +{ + m_shutdown.store( true, std::memory_order_relaxed ); + + RemoveCrashHandler(); + +#ifdef TRACY_HAS_SYSTEM_TRACING + if( s_sysTraceThread ) + { + SysTraceStop(); + s_sysTraceThread->~Thread(); + tracy_free( s_sysTraceThread ); + } +#endif + +#ifdef TRACY_HAS_CALLSTACK + s_symbolThread->~Thread(); + tracy_free( s_symbolThread ); +#endif + +#ifndef TRACY_NO_FRAME_IMAGE + s_compressThread->~Thread(); + tracy_free( s_compressThread ); +#endif + + s_thread->~Thread(); + tracy_free( s_thread ); + +#ifdef TRACY_HAS_CALLSTACK + EndCallstack(); +#endif + +#ifdef __linux__ + m_kcore->~KCore(); + tracy_free( m_kcore ); +#endif + + tracy_free( m_lz4Buf ); + tracy_free( m_buffer ); + LZ4_freeStream( (LZ4_stream_t*)m_stream ); + + if( m_sock ) + { + m_sock->~Socket(); + tracy_free( m_sock ); + } + + if( m_broadcast ) + { + m_broadcast->~UdpBroadcast(); + tracy_free( m_broadcast ); + } + + assert( s_instance ); + s_instance = nullptr; +} + +bool Profiler::ShouldExit() +{ + return s_instance->m_shutdown.load( std::memory_order_relaxed ); +} + +void Profiler::Worker() +{ +#if defined __linux__ && !defined TRACY_NO_CRASH_HANDLER + s_profilerTid = syscall( SYS_gettid ); +#endif + + ThreadExitHandler threadExitHandler; + + SetThreadName( "Tracy Profiler" ); + +#ifdef TRACY_DATA_PORT + const bool dataPortSearch = false; + auto dataPort = m_userPort != 0 ? m_userPort : TRACY_DATA_PORT; +#else + const bool dataPortSearch = m_userPort == 0; + auto dataPort = m_userPort != 0 ? m_userPort : 8086; +#endif +#ifdef TRACY_BROADCAST_PORT + const auto broadcastPort = TRACY_BROADCAST_PORT; +#else + const auto broadcastPort = 8086; +#endif + + while( m_timeBegin.load( std::memory_order_relaxed ) == 0 ) std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); + +#ifdef TRACY_USE_RPMALLOC + rpmalloc_thread_initialize(); +#endif + + m_exectime = 0; + const auto execname = GetProcessExecutablePath(); + if( execname ) + { + struct stat st; + if( stat( execname, &st ) == 0 ) + { + m_exectime = (uint64_t)st.st_mtime; + } + } + + const auto procname = GetProcessName(); + const auto pnsz = std::min( strlen( procname ), WelcomeMessageProgramNameSize - 1 ); + + const auto hostinfo = GetHostInfo(); + const auto hisz = std::min( strlen( hostinfo ), WelcomeMessageHostInfoSize - 1 ); + + const uint64_t pid = GetPid(); + + uint8_t flags = 0; + +#ifdef TRACY_ON_DEMAND + flags |= WelcomeFlag::OnDemand; +#endif +#ifdef __APPLE__ + flags |= WelcomeFlag::IsApple; +#endif +#ifndef TRACY_NO_CODE_TRANSFER + flags |= WelcomeFlag::CodeTransfer; +#endif +#ifdef _WIN32 + flags |= WelcomeFlag::CombineSamples; +# ifndef TRACY_NO_CONTEXT_SWITCH + flags |= WelcomeFlag::IdentifySamples; +# endif +#endif + +#if defined __i386 || defined _M_IX86 + uint8_t cpuArch = CpuArchX86; +#elif defined __x86_64__ || defined _M_X64 + uint8_t cpuArch = CpuArchX64; +#elif defined __aarch64__ + uint8_t cpuArch = CpuArchArm64; +#elif defined __ARM_ARCH + uint8_t cpuArch = CpuArchArm32; +#else + uint8_t cpuArch = CpuArchUnknown; +#endif + +#if defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 + uint32_t regs[4]; + char manufacturer[12]; + CpuId( regs, 0 ); + memcpy( manufacturer, regs+1, 4 ); + memcpy( manufacturer+4, regs+3, 4 ); + memcpy( manufacturer+8, regs+2, 4 ); + + CpuId( regs, 1 ); + uint32_t cpuId = ( regs[0] & 0xFFF ) | ( ( regs[0] & 0xFFF0000 ) >> 4 ); +#else + const char manufacturer[12] = {}; + uint32_t cpuId = 0; +#endif + + WelcomeMessage welcome; + MemWrite( &welcome.timerMul, m_timerMul ); + MemWrite( &welcome.initBegin, GetInitTime() ); + MemWrite( &welcome.initEnd, m_timeBegin.load( std::memory_order_relaxed ) ); + MemWrite( &welcome.delay, m_delay ); + MemWrite( &welcome.resolution, m_resolution ); + MemWrite( &welcome.epoch, m_epoch ); + MemWrite( &welcome.exectime, m_exectime ); + MemWrite( &welcome.pid, pid ); + MemWrite( &welcome.samplingPeriod, m_samplingPeriod ); + MemWrite( &welcome.flags, flags ); + MemWrite( &welcome.cpuArch, cpuArch ); + memcpy( welcome.cpuManufacturer, manufacturer, 12 ); + MemWrite( &welcome.cpuId, cpuId ); + memcpy( welcome.programName, procname, pnsz ); + memset( welcome.programName + pnsz, 0, WelcomeMessageProgramNameSize - pnsz ); + memcpy( welcome.hostInfo, hostinfo, hisz ); + memset( welcome.hostInfo + hisz, 0, WelcomeMessageHostInfoSize - hisz ); + + moodycamel::ConsumerToken token( GetQueue() ); + + ListenSocket listen; + bool isListening = false; + if( !dataPortSearch ) + { + isListening = listen.Listen( dataPort, 4 ); + } + else + { + for( uint32_t i=0; i<20; i++ ) + { + if( listen.Listen( dataPort+i, 4 ) ) + { + dataPort += i; + isListening = true; + break; + } + } + } + if( !isListening ) + { + for(;;) + { + if( ShouldExit() ) + { + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } + + ClearQueues( token ); + std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); + } + } + +#ifndef TRACY_NO_BROADCAST + m_broadcast = (UdpBroadcast*)tracy_malloc( sizeof( UdpBroadcast ) ); + new(m_broadcast) UdpBroadcast(); +# ifdef TRACY_ONLY_LOCALHOST + const char* addr = "127.255.255.255"; +# elif defined TRACY_CLIENT_ADDRESS + const char* addr = TRACY_CLIENT_ADDRESS; +# elif defined __QNX__ + // global broadcast address of 255.255.255.255 is not well-supported by QNX, + // use the interface broadcast address instead, e.g. "const char* addr = 192.168.1.255;" +# error Need to specify TRACY_CLIENT_ADDRESS for a QNX target. +# else + const char* addr = "255.255.255.255"; +# endif + if( !m_broadcast->Open( addr, broadcastPort ) ) + { + m_broadcast->~UdpBroadcast(); + tracy_free( m_broadcast ); + m_broadcast = nullptr; + } +#endif + + int broadcastLen = 0; + auto& broadcastMsg = GetBroadcastMessage( procname, pnsz, broadcastLen, dataPort ); + uint64_t lastBroadcast = 0; + + // Connections loop. + // Each iteration of the loop handles whole connection. Multiple iterations will only + // happen in the on-demand mode or when handshake fails. + for(;;) + { + // Wait for incoming connection + for(;;) + { +#ifndef TRACY_NO_EXIT + if( !m_noExit && ShouldExit() ) + { + if( m_broadcast ) + { + broadcastMsg.activeTime = -1; + m_broadcast->Send( broadcastPort, &broadcastMsg, broadcastLen ); + } + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } +#endif + m_sock = listen.Accept(); + if( m_sock ) break; +#ifndef TRACY_ON_DEMAND + ProcessSysTime(); +# ifdef TRACY_HAS_SYSPOWER + m_sysPower.Tick(); +# endif +#endif + + if( m_broadcast ) + { + const auto t = std::chrono::high_resolution_clock::now().time_since_epoch().count(); + if( t - lastBroadcast > 3000000000 ) // 3s + { + m_programNameLock.lock(); + if( m_programName ) + { + broadcastMsg = GetBroadcastMessage( m_programName, strlen( m_programName ), broadcastLen, dataPort ); + m_programName = nullptr; + } + m_programNameLock.unlock(); + + lastBroadcast = t; + const auto ts = std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch() ).count(); + broadcastMsg.activeTime = int32_t( ts - m_epoch ); + assert( broadcastMsg.activeTime >= 0 ); + m_broadcast->Send( broadcastPort, &broadcastMsg, broadcastLen ); + } + } + } + + if( m_broadcast ) + { + lastBroadcast = 0; + broadcastMsg.activeTime = -1; + m_broadcast->Send( broadcastPort, &broadcastMsg, broadcastLen ); + } + + // Handshake + { + char shibboleth[HandshakeShibbolethSize]; + auto res = m_sock->ReadRaw( shibboleth, HandshakeShibbolethSize, 2000 ); + if( !res || memcmp( shibboleth, HandshakeShibboleth, HandshakeShibbolethSize ) != 0 ) + { + m_sock->~Socket(); + tracy_free( m_sock ); + m_sock = nullptr; + continue; + } + + uint32_t protocolVersion; + res = m_sock->ReadRaw( &protocolVersion, sizeof( protocolVersion ), 2000 ); + if( !res ) + { + m_sock->~Socket(); + tracy_free( m_sock ); + m_sock = nullptr; + continue; + } + + if( protocolVersion != ProtocolVersion ) + { + HandshakeStatus status = HandshakeProtocolMismatch; + m_sock->Send( &status, sizeof( status ) ); + m_sock->~Socket(); + tracy_free( m_sock ); + m_sock = nullptr; + continue; + } + } + +#ifdef TRACY_ON_DEMAND + const auto currentTime = GetTime(); + ClearQueues( token ); + m_connectionId.fetch_add( 1, std::memory_order_release ); +#endif + m_isConnected.store( true, std::memory_order_release ); + InstallCrashHandler(); + + HandshakeStatus handshake = HandshakeWelcome; + m_sock->Send( &handshake, sizeof( handshake ) ); + + LZ4_resetStream( (LZ4_stream_t*)m_stream ); + m_sock->Send( &welcome, sizeof( welcome ) ); + + m_threadCtx = 0; + m_refTimeSerial = 0; + m_refTimeCtx = 0; + m_refTimeGpu = 0; + +#ifdef TRACY_ON_DEMAND + OnDemandPayloadMessage onDemand; + onDemand.frames = m_frameCount.load( std::memory_order_relaxed ); + onDemand.currentTime = currentTime; + + m_sock->Send( &onDemand, sizeof( onDemand ) ); + + m_deferredLock.lock(); + for( auto& item : m_deferredQueue ) + { + uint64_t ptr; + uint16_t size; + const auto idx = MemRead( &item.hdr.idx ); + switch( (QueueType)idx ) + { + case QueueType::MessageAppInfo: + ptr = MemRead( &item.messageFat.text ); + size = MemRead( &item.messageFat.size ); + SendSingleString( (const char*)ptr, size ); + break; + case QueueType::LockName: + ptr = MemRead( &item.lockNameFat.name ); + size = MemRead( &item.lockNameFat.size ); + SendSingleString( (const char*)ptr, size ); + break; + case QueueType::GpuContextName: + ptr = MemRead( &item.gpuContextNameFat.ptr ); + size = MemRead( &item.gpuContextNameFat.size ); + SendSingleString( (const char*)ptr, size ); + break; + default: + break; + } + AppendData( &item, QueueDataSize[idx] ); + } + m_deferredLock.unlock(); +#endif + + // Main communications loop + int keepAlive = 0; + for(;;) + { + ProcessSysTime(); +#ifdef TRACY_HAS_SYSPOWER + m_sysPower.Tick(); +#endif + const auto status = Dequeue( token ); + const auto serialStatus = DequeueSerial(); + if( status == DequeueStatus::ConnectionLost || serialStatus == DequeueStatus::ConnectionLost ) + { + break; + } + else if( status == DequeueStatus::QueueEmpty && serialStatus == DequeueStatus::QueueEmpty ) + { + if( ShouldExit() ) break; + if( m_bufferOffset != m_bufferStart ) + { + if( !CommitData() ) break; + } + if( keepAlive == 500 ) + { + QueueItem ka; + ka.hdr.type = QueueType::KeepAlive; + AppendData( &ka, QueueDataSize[ka.hdr.idx] ); + if( !CommitData() ) break; + + keepAlive = 0; + } + else if( !m_sock->HasData() ) + { + keepAlive++; + std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); + } + } + else + { + keepAlive = 0; + } + + bool connActive = true; + while( m_sock->HasData() ) + { + connActive = HandleServerQuery(); + if( !connActive ) break; + } + if( !connActive ) break; + } + if( ShouldExit() ) break; + + m_isConnected.store( false, std::memory_order_release ); + RemoveCrashHandler(); + +#ifdef TRACY_ON_DEMAND + m_bufferOffset = 0; + m_bufferStart = 0; +#endif + + m_sock->~Socket(); + tracy_free( m_sock ); + m_sock = nullptr; + +#ifndef TRACY_ON_DEMAND + // Client is no longer available here. Accept incoming connections, but reject handshake. + for(;;) + { + if( ShouldExit() ) + { + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } + + ClearQueues( token ); + + m_sock = listen.Accept(); + if( m_sock ) + { + char shibboleth[HandshakeShibbolethSize]; + auto res = m_sock->ReadRaw( shibboleth, HandshakeShibbolethSize, 1000 ); + if( !res || memcmp( shibboleth, HandshakeShibboleth, HandshakeShibbolethSize ) != 0 ) + { + m_sock->~Socket(); + tracy_free( m_sock ); + m_sock = nullptr; + continue; + } + + uint32_t protocolVersion; + res = m_sock->ReadRaw( &protocolVersion, sizeof( protocolVersion ), 1000 ); + if( !res ) + { + m_sock->~Socket(); + tracy_free( m_sock ); + m_sock = nullptr; + continue; + } + + HandshakeStatus status = HandshakeNotAvailable; + m_sock->Send( &status, sizeof( status ) ); + m_sock->~Socket(); + tracy_free( m_sock ); + } + } +#endif + } + // End of connections loop + + // Wait for symbols thread to terminate. Symbol resolution will continue in this thread. +#ifdef TRACY_HAS_CALLSTACK + while( s_symbolThreadGone.load() == false ) { YieldThread(); } +#endif + + // Client is exiting. Send items remaining in queues. + for(;;) + { + const auto status = Dequeue( token ); + const auto serialStatus = DequeueSerial(); + if( status == DequeueStatus::ConnectionLost || serialStatus == DequeueStatus::ConnectionLost ) + { + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } + else if( status == DequeueStatus::QueueEmpty && serialStatus == DequeueStatus::QueueEmpty ) + { + if( m_bufferOffset != m_bufferStart ) CommitData(); + break; + } + + while( m_sock->HasData() ) + { + if( !HandleServerQuery() ) + { + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } + } + +#ifdef TRACY_HAS_CALLSTACK + for(;;) + { + auto si = m_symbolQueue.front(); + if( !si ) break; + HandleSymbolQueueItem( *si ); + m_symbolQueue.pop(); + } +#endif + } + + // Send client termination notice to the server + QueueItem terminate; + MemWrite( &terminate.hdr.type, QueueType::Terminate ); + if( !SendData( (const char*)&terminate, 1 ) ) + { + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } + // Handle remaining server queries + for(;;) + { + while( m_sock->HasData() ) + { + if( !HandleServerQuery() ) + { + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } + } +#ifdef TRACY_HAS_CALLSTACK + for(;;) + { + auto si = m_symbolQueue.front(); + if( !si ) break; + HandleSymbolQueueItem( *si ); + m_symbolQueue.pop(); + } +#endif + const auto status = Dequeue( token ); + const auto serialStatus = DequeueSerial(); + if( status == DequeueStatus::ConnectionLost || serialStatus == DequeueStatus::ConnectionLost ) + { + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } + if( m_bufferOffset != m_bufferStart ) + { + if( !CommitData() ) + { + m_shutdownFinished.store( true, std::memory_order_relaxed ); + return; + } + } + } +} + +#ifndef TRACY_NO_FRAME_IMAGE +void Profiler::CompressWorker() +{ + ThreadExitHandler threadExitHandler; + SetThreadName( "Tracy DXT1" ); + while( m_timeBegin.load( std::memory_order_relaxed ) == 0 ) std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); + +#ifdef TRACY_USE_RPMALLOC + rpmalloc_thread_initialize(); +#endif + + for(;;) + { + const auto shouldExit = ShouldExit(); + + { + bool lockHeld = true; + while( !m_fiLock.try_lock() ) + { + if( m_shutdownManual.load( std::memory_order_relaxed ) ) + { + lockHeld = false; + break; + } + } + if( !m_fiQueue.empty() ) m_fiQueue.swap( m_fiDequeue ); + if( lockHeld ) + { + m_fiLock.unlock(); + } + } + + const auto sz = m_fiDequeue.size(); + if( sz > 0 ) + { + auto fi = m_fiDequeue.data(); + auto end = fi + sz; + while( fi != end ) + { + const auto w = fi->w; + const auto h = fi->h; + const auto csz = size_t( w * h / 2 ); + auto etc1buf = (char*)tracy_malloc( csz ); + CompressImageDxt1( (const char*)fi->image, etc1buf, w, h ); + tracy_free( fi->image ); + + TracyLfqPrepare( QueueType::FrameImage ); + MemWrite( &item->frameImageFat.image, (uint64_t)etc1buf ); + MemWrite( &item->frameImageFat.frame, fi->frame ); + MemWrite( &item->frameImageFat.w, w ); + MemWrite( &item->frameImageFat.h, h ); + uint8_t flip = fi->flip; + MemWrite( &item->frameImageFat.flip, flip ); + TracyLfqCommit; + + fi++; + } + m_fiDequeue.clear(); + } + else + { + std::this_thread::sleep_for( std::chrono::milliseconds( 20 ) ); + } + + if( shouldExit ) + { + return; + } + } +} +#endif + +static void FreeAssociatedMemory( const QueueItem& item ) +{ + if( item.hdr.idx >= (int)QueueType::Terminate ) return; + + uint64_t ptr; + switch( item.hdr.type ) + { + case QueueType::ZoneText: + case QueueType::ZoneName: + ptr = MemRead( &item.zoneTextFat.text ); + tracy_free( (void*)ptr ); + break; + case QueueType::MessageColor: + case QueueType::MessageColorCallstack: + ptr = MemRead( &item.messageColorFat.text ); + tracy_free( (void*)ptr ); + break; + case QueueType::Message: + case QueueType::MessageCallstack: +#ifndef TRACY_ON_DEMAND + case QueueType::MessageAppInfo: +#endif + ptr = MemRead( &item.messageFat.text ); + tracy_free( (void*)ptr ); + break; + case QueueType::ZoneBeginAllocSrcLoc: + case QueueType::ZoneBeginAllocSrcLocCallstack: + ptr = MemRead( &item.zoneBegin.srcloc ); + tracy_free( (void*)ptr ); + break; + case QueueType::GpuZoneBeginAllocSrcLoc: + case QueueType::GpuZoneBeginAllocSrcLocCallstack: + case QueueType::GpuZoneBeginAllocSrcLocSerial: + case QueueType::GpuZoneBeginAllocSrcLocCallstackSerial: + ptr = MemRead( &item.gpuZoneBegin.srcloc ); + tracy_free( (void*)ptr ); + break; + case QueueType::CallstackSerial: + case QueueType::Callstack: + ptr = MemRead( &item.callstackFat.ptr ); + tracy_free( (void*)ptr ); + break; + case QueueType::CallstackAlloc: + ptr = MemRead( &item.callstackAllocFat.nativePtr ); + tracy_free( (void*)ptr ); + ptr = MemRead( &item.callstackAllocFat.ptr ); + tracy_free( (void*)ptr ); + break; + case QueueType::CallstackSample: + case QueueType::CallstackSampleContextSwitch: + ptr = MemRead( &item.callstackSampleFat.ptr ); + tracy_free( (void*)ptr ); + break; + case QueueType::FrameImage: + ptr = MemRead( &item.frameImageFat.image ); + tracy_free( (void*)ptr ); + break; +#ifdef TRACY_HAS_CALLSTACK + case QueueType::CallstackFrameSize: + { + InitRpmalloc(); + auto size = MemRead( &item.callstackFrameSizeFat.size ); + auto data = (const CallstackEntry*)MemRead( &item.callstackFrameSizeFat.data ); + for( uint8_t i=0; i( &item.symbolInformationFat.needFree ); + if( needFree ) + { + ptr = MemRead( &item.symbolInformationFat.fileString ); + tracy_free( (void*)ptr ); + } + break; + } + case QueueType::SymbolCodeMetadata: + ptr = MemRead( &item.symbolCodeMetadata.ptr ); + tracy_free( (void*)ptr ); + break; +#endif +#ifndef TRACY_ON_DEMAND + case QueueType::LockName: + ptr = MemRead( &item.lockNameFat.name ); + tracy_free( (void*)ptr ); + break; + case QueueType::GpuContextName: + ptr = MemRead( &item.gpuContextNameFat.ptr ); + tracy_free( (void*)ptr ); + break; +#endif +#ifdef TRACY_ON_DEMAND + case QueueType::MessageAppInfo: + case QueueType::GpuContextName: + // Don't free memory associated with deferred messages. + break; +#endif +#ifdef TRACY_HAS_SYSTEM_TRACING + case QueueType::ExternalNameMetadata: + ptr = MemRead( &item.externalNameMetadata.name ); + tracy_free( (void*)ptr ); + ptr = MemRead( &item.externalNameMetadata.threadName ); + tracy_free_fast( (void*)ptr ); + break; +#endif + case QueueType::SourceCodeMetadata: + ptr = MemRead( &item.sourceCodeMetadata.ptr ); + tracy_free( (void*)ptr ); + break; + default: + break; + } +} + +void Profiler::ClearQueues( moodycamel::ConsumerToken& token ) +{ + for(;;) + { + const auto sz = GetQueue().try_dequeue_bulk_single( token, [](const uint64_t&){}, []( QueueItem* item, size_t sz ) { assert( sz > 0 ); while( sz-- > 0 ) FreeAssociatedMemory( *item++ ); } ); + if( sz == 0 ) break; + } + + ClearSerial(); +} + +void Profiler::ClearSerial() +{ + bool lockHeld = true; + while( !m_serialLock.try_lock() ) + { + if( m_shutdownManual.load( std::memory_order_relaxed ) ) + { + lockHeld = false; + break; + } + } + for( auto& v : m_serialQueue ) FreeAssociatedMemory( v ); + m_serialQueue.clear(); + if( lockHeld ) + { + m_serialLock.unlock(); + } + + for( auto& v : m_serialDequeue ) FreeAssociatedMemory( v ); + m_serialDequeue.clear(); +} + +Profiler::DequeueStatus Profiler::Dequeue( moodycamel::ConsumerToken& token ) +{ + bool connectionLost = false; + const auto sz = GetQueue().try_dequeue_bulk_single( token, + [this, &connectionLost] ( const uint32_t& threadId ) + { + if( ThreadCtxCheck( threadId ) == ThreadCtxStatus::ConnectionLost ) connectionLost = true; + }, + [this, &connectionLost] ( QueueItem* item, size_t sz ) + { + if( connectionLost ) return; + InitRpmalloc(); + assert( sz > 0 ); + int64_t refThread = m_refTimeThread; + int64_t refCtx = m_refTimeCtx; + int64_t refGpu = m_refTimeGpu; + while( sz-- > 0 ) + { + uint64_t ptr; + uint16_t size; + auto idx = MemRead( &item->hdr.idx ); + if( idx < (int)QueueType::Terminate ) + { + switch( (QueueType)idx ) + { + case QueueType::ZoneText: + case QueueType::ZoneName: + ptr = MemRead( &item->zoneTextFat.text ); + size = MemRead( &item->zoneTextFat.size ); + SendSingleString( (const char*)ptr, size ); + tracy_free_fast( (void*)ptr ); + break; + case QueueType::Message: + case QueueType::MessageCallstack: + ptr = MemRead( &item->messageFat.text ); + size = MemRead( &item->messageFat.size ); + SendSingleString( (const char*)ptr, size ); + tracy_free_fast( (void*)ptr ); + break; + case QueueType::MessageColor: + case QueueType::MessageColorCallstack: + ptr = MemRead( &item->messageColorFat.text ); + size = MemRead( &item->messageColorFat.size ); + SendSingleString( (const char*)ptr, size ); + tracy_free_fast( (void*)ptr ); + break; + case QueueType::MessageAppInfo: + ptr = MemRead( &item->messageFat.text ); + size = MemRead( &item->messageFat.size ); + SendSingleString( (const char*)ptr, size ); +#ifndef TRACY_ON_DEMAND + tracy_free_fast( (void*)ptr ); +#endif + break; + case QueueType::ZoneBeginAllocSrcLoc: + case QueueType::ZoneBeginAllocSrcLocCallstack: + { + int64_t t = MemRead( &item->zoneBegin.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->zoneBegin.time, dt ); + ptr = MemRead( &item->zoneBegin.srcloc ); + SendSourceLocationPayload( ptr ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::Callstack: + ptr = MemRead( &item->callstackFat.ptr ); + SendCallstackPayload( ptr ); + tracy_free_fast( (void*)ptr ); + break; + case QueueType::CallstackAlloc: + ptr = MemRead( &item->callstackAllocFat.nativePtr ); + if( ptr != 0 ) + { + CutCallstack( (void*)ptr, "lua_pcall" ); + SendCallstackPayload( ptr ); + tracy_free_fast( (void*)ptr ); + } + ptr = MemRead( &item->callstackAllocFat.ptr ); + SendCallstackAlloc( ptr ); + tracy_free_fast( (void*)ptr ); + break; + case QueueType::CallstackSample: + case QueueType::CallstackSampleContextSwitch: + { + ptr = MemRead( &item->callstackSampleFat.ptr ); + SendCallstackPayload64( ptr ); + tracy_free_fast( (void*)ptr ); + int64_t t = MemRead( &item->callstackSampleFat.time ); + int64_t dt = t - refCtx; + refCtx = t; + MemWrite( &item->callstackSampleFat.time, dt ); + break; + } + case QueueType::FrameImage: + { + ptr = MemRead( &item->frameImageFat.image ); + const auto w = MemRead( &item->frameImageFat.w ); + const auto h = MemRead( &item->frameImageFat.h ); + const auto csz = size_t( w * h / 2 ); + SendLongString( ptr, (const char*)ptr, csz, QueueType::FrameImageData ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::ZoneBegin: + case QueueType::ZoneBeginCallstack: + { + int64_t t = MemRead( &item->zoneBegin.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->zoneBegin.time, dt ); + break; + } + case QueueType::ZoneEnd: + { + int64_t t = MemRead( &item->zoneEnd.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->zoneEnd.time, dt ); + break; + } + case QueueType::GpuZoneBegin: + case QueueType::GpuZoneBeginCallstack: + { + int64_t t = MemRead( &item->gpuZoneBegin.cpuTime ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->gpuZoneBegin.cpuTime, dt ); + break; + } + case QueueType::GpuZoneBeginAllocSrcLoc: + case QueueType::GpuZoneBeginAllocSrcLocCallstack: + { + int64_t t = MemRead( &item->gpuZoneBegin.cpuTime ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->gpuZoneBegin.cpuTime, dt ); + ptr = MemRead( &item->gpuZoneBegin.srcloc ); + SendSourceLocationPayload( ptr ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::GpuZoneEnd: + { + int64_t t = MemRead( &item->gpuZoneEnd.cpuTime ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->gpuZoneEnd.cpuTime, dt ); + break; + } + case QueueType::GpuContextName: + ptr = MemRead( &item->gpuContextNameFat.ptr ); + size = MemRead( &item->gpuContextNameFat.size ); + SendSingleString( (const char*)ptr, size ); +#ifndef TRACY_ON_DEMAND + tracy_free_fast( (void*)ptr ); +#endif + break; + case QueueType::PlotDataInt: + case QueueType::PlotDataFloat: + case QueueType::PlotDataDouble: + { + int64_t t = MemRead( &item->plotDataInt.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->plotDataInt.time, dt ); + break; + } + case QueueType::ContextSwitch: + { + int64_t t = MemRead( &item->contextSwitch.time ); + int64_t dt = t - refCtx; + refCtx = t; + MemWrite( &item->contextSwitch.time, dt ); + break; + } + case QueueType::ThreadWakeup: + { + int64_t t = MemRead( &item->threadWakeup.time ); + int64_t dt = t - refCtx; + refCtx = t; + MemWrite( &item->threadWakeup.time, dt ); + break; + } + case QueueType::GpuTime: + { + int64_t t = MemRead( &item->gpuTime.gpuTime ); + int64_t dt = t - refGpu; + refGpu = t; + MemWrite( &item->gpuTime.gpuTime, dt ); + break; + } +#ifdef TRACY_HAS_CALLSTACK + case QueueType::CallstackFrameSize: + { + auto data = (const CallstackEntry*)MemRead( &item->callstackFrameSizeFat.data ); + auto datasz = MemRead( &item->callstackFrameSizeFat.size ); + auto imageName = (const char*)MemRead( &item->callstackFrameSizeFat.imageName ); + SendSingleString( imageName ); + AppendData( item++, QueueDataSize[idx] ); + + for( uint8_t i=0; i( &item->symbolInformationFat.fileString ); + auto needFree = MemRead( &item->symbolInformationFat.needFree ); + SendSingleString( fileString ); + if( needFree ) tracy_free_fast( (void*)fileString ); + break; + } + case QueueType::SymbolCodeMetadata: + { + auto symbol = MemRead( &item->symbolCodeMetadata.symbol ); + auto ptr = (const char*)MemRead( &item->symbolCodeMetadata.ptr ); + auto size = MemRead( &item->symbolCodeMetadata.size ); + SendLongString( symbol, ptr, size, QueueType::SymbolCode ); + tracy_free_fast( (void*)ptr ); + ++item; + continue; + } +#endif +#ifdef TRACY_HAS_SYSTEM_TRACING + case QueueType::ExternalNameMetadata: + { + auto thread = MemRead( &item->externalNameMetadata.thread ); + auto name = (const char*)MemRead( &item->externalNameMetadata.name ); + auto threadName = (const char*)MemRead( &item->externalNameMetadata.threadName ); + SendString( thread, threadName, QueueType::ExternalThreadName ); + SendString( thread, name, QueueType::ExternalName ); + tracy_free_fast( (void*)threadName ); + tracy_free_fast( (void*)name ); + ++item; + continue; + } +#endif + case QueueType::SourceCodeMetadata: + { + auto ptr = (const char*)MemRead( &item->sourceCodeMetadata.ptr ); + auto size = MemRead( &item->sourceCodeMetadata.size ); + auto id = MemRead( &item->sourceCodeMetadata.id ); + SendLongString( (uint64_t)id, ptr, size, QueueType::SourceCode ); + tracy_free_fast( (void*)ptr ); + ++item; + continue; + } + default: + assert( false ); + break; + } + } + if( !AppendData( item++, QueueDataSize[idx] ) ) + { + connectionLost = true; + m_refTimeThread = refThread; + m_refTimeCtx = refCtx; + m_refTimeGpu = refGpu; + return; + } + } + m_refTimeThread = refThread; + m_refTimeCtx = refCtx; + m_refTimeGpu = refGpu; + } + ); + if( connectionLost ) return DequeueStatus::ConnectionLost; + return sz > 0 ? DequeueStatus::DataDequeued : DequeueStatus::QueueEmpty; +} + +Profiler::DequeueStatus Profiler::DequeueContextSwitches( tracy::moodycamel::ConsumerToken& token, int64_t& timeStop ) +{ + const auto sz = GetQueue().try_dequeue_bulk_single( token, [] ( const uint64_t& ) {}, + [this, &timeStop] ( QueueItem* item, size_t sz ) + { + assert( sz > 0 ); + int64_t refCtx = m_refTimeCtx; + while( sz-- > 0 ) + { + FreeAssociatedMemory( *item ); + if( timeStop < 0 ) return; + const auto idx = MemRead( &item->hdr.idx ); + if( idx == (uint8_t)QueueType::ContextSwitch ) + { + const auto csTime = MemRead( &item->contextSwitch.time ); + if( csTime > timeStop ) + { + timeStop = -1; + m_refTimeCtx = refCtx; + return; + } + int64_t dt = csTime - refCtx; + refCtx = csTime; + MemWrite( &item->contextSwitch.time, dt ); + if( !AppendData( item, QueueDataSize[(int)QueueType::ContextSwitch] ) ) + { + timeStop = -2; + m_refTimeCtx = refCtx; + return; + } + } + else if( idx == (uint8_t)QueueType::ThreadWakeup ) + { + const auto csTime = MemRead( &item->threadWakeup.time ); + if( csTime > timeStop ) + { + timeStop = -1; + m_refTimeCtx = refCtx; + return; + } + int64_t dt = csTime - refCtx; + refCtx = csTime; + MemWrite( &item->threadWakeup.time, dt ); + if( !AppendData( item, QueueDataSize[(int)QueueType::ThreadWakeup] ) ) + { + timeStop = -2; + m_refTimeCtx = refCtx; + return; + } + } + item++; + } + m_refTimeCtx = refCtx; + } + ); + + if( timeStop == -2 ) return DequeueStatus::ConnectionLost; + return ( timeStop == -1 || sz > 0 ) ? DequeueStatus::DataDequeued : DequeueStatus::QueueEmpty; +} + +#define ThreadCtxCheckSerial( _name ) \ + uint32_t thread = MemRead( &item->_name.thread ); \ + switch( ThreadCtxCheck( thread ) ) \ + { \ + case ThreadCtxStatus::Same: break; \ + case ThreadCtxStatus::Changed: assert( m_refTimeThread == 0 ); refThread = 0; break; \ + case ThreadCtxStatus::ConnectionLost: return DequeueStatus::ConnectionLost; \ + default: assert( false ); break; \ + } + +Profiler::DequeueStatus Profiler::DequeueSerial() +{ + { + bool lockHeld = true; + while( !m_serialLock.try_lock() ) + { + if( m_shutdownManual.load( std::memory_order_relaxed ) ) + { + lockHeld = false; + break; + } + } + if( !m_serialQueue.empty() ) m_serialQueue.swap( m_serialDequeue ); + if( lockHeld ) + { + m_serialLock.unlock(); + } + } + + const auto sz = m_serialDequeue.size(); + if( sz > 0 ) + { + InitRpmalloc(); + int64_t refSerial = m_refTimeSerial; + int64_t refGpu = m_refTimeGpu; +#ifdef TRACY_FIBERS + int64_t refThread = m_refTimeThread; +#endif + auto item = m_serialDequeue.data(); + auto end = item + sz; + while( item != end ) + { + uint64_t ptr; + auto idx = MemRead( &item->hdr.idx ); + if( idx < (int)QueueType::Terminate ) + { + switch( (QueueType)idx ) + { + case QueueType::CallstackSerial: + ptr = MemRead( &item->callstackFat.ptr ); + SendCallstackPayload( ptr ); + tracy_free_fast( (void*)ptr ); + break; + case QueueType::LockWait: + case QueueType::LockSharedWait: + { + int64_t t = MemRead( &item->lockWait.time ); + int64_t dt = t - refSerial; + refSerial = t; + MemWrite( &item->lockWait.time, dt ); + break; + } + case QueueType::LockObtain: + case QueueType::LockSharedObtain: + { + int64_t t = MemRead( &item->lockObtain.time ); + int64_t dt = t - refSerial; + refSerial = t; + MemWrite( &item->lockObtain.time, dt ); + break; + } + case QueueType::LockRelease: + case QueueType::LockSharedRelease: + { + int64_t t = MemRead( &item->lockRelease.time ); + int64_t dt = t - refSerial; + refSerial = t; + MemWrite( &item->lockRelease.time, dt ); + break; + } + case QueueType::LockName: + { + ptr = MemRead( &item->lockNameFat.name ); + uint16_t size = MemRead( &item->lockNameFat.size ); + SendSingleString( (const char*)ptr, size ); +#ifndef TRACY_ON_DEMAND + tracy_free_fast( (void*)ptr ); +#endif + break; + } + case QueueType::MemAlloc: + case QueueType::MemAllocNamed: + case QueueType::MemAllocCallstack: + case QueueType::MemAllocCallstackNamed: + { + int64_t t = MemRead( &item->memAlloc.time ); + int64_t dt = t - refSerial; + refSerial = t; + MemWrite( &item->memAlloc.time, dt ); + break; + } + case QueueType::MemFree: + case QueueType::MemFreeNamed: + case QueueType::MemFreeCallstack: + case QueueType::MemFreeCallstackNamed: + { + int64_t t = MemRead( &item->memFree.time ); + int64_t dt = t - refSerial; + refSerial = t; + MemWrite( &item->memFree.time, dt ); + break; + } + case QueueType::GpuZoneBeginSerial: + case QueueType::GpuZoneBeginCallstackSerial: + { + int64_t t = MemRead( &item->gpuZoneBegin.cpuTime ); + int64_t dt = t - refSerial; + refSerial = t; + MemWrite( &item->gpuZoneBegin.cpuTime, dt ); + break; + } + case QueueType::GpuZoneBeginAllocSrcLocSerial: + case QueueType::GpuZoneBeginAllocSrcLocCallstackSerial: + { + int64_t t = MemRead( &item->gpuZoneBegin.cpuTime ); + int64_t dt = t - refSerial; + refSerial = t; + MemWrite( &item->gpuZoneBegin.cpuTime, dt ); + ptr = MemRead( &item->gpuZoneBegin.srcloc ); + SendSourceLocationPayload( ptr ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::GpuZoneEndSerial: + { + int64_t t = MemRead( &item->gpuZoneEnd.cpuTime ); + int64_t dt = t - refSerial; + refSerial = t; + MemWrite( &item->gpuZoneEnd.cpuTime, dt ); + break; + } + case QueueType::GpuTime: + { + int64_t t = MemRead( &item->gpuTime.gpuTime ); + int64_t dt = t - refGpu; + refGpu = t; + MemWrite( &item->gpuTime.gpuTime, dt ); + break; + } + case QueueType::GpuContextName: + { + ptr = MemRead( &item->gpuContextNameFat.ptr ); + uint16_t size = MemRead( &item->gpuContextNameFat.size ); + SendSingleString( (const char*)ptr, size ); +#ifndef TRACY_ON_DEMAND + tracy_free_fast( (void*)ptr ); +#endif + break; + } +#ifdef TRACY_FIBERS + case QueueType::ZoneBegin: + case QueueType::ZoneBeginCallstack: + { + ThreadCtxCheckSerial( zoneBeginThread ); + int64_t t = MemRead( &item->zoneBegin.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->zoneBegin.time, dt ); + break; + } + case QueueType::ZoneBeginAllocSrcLoc: + case QueueType::ZoneBeginAllocSrcLocCallstack: + { + ThreadCtxCheckSerial( zoneBeginThread ); + int64_t t = MemRead( &item->zoneBegin.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->zoneBegin.time, dt ); + ptr = MemRead( &item->zoneBegin.srcloc ); + SendSourceLocationPayload( ptr ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::ZoneEnd: + { + ThreadCtxCheckSerial( zoneEndThread ); + int64_t t = MemRead( &item->zoneEnd.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->zoneEnd.time, dt ); + break; + } + case QueueType::ZoneText: + case QueueType::ZoneName: + { + ThreadCtxCheckSerial( zoneTextFatThread ); + ptr = MemRead( &item->zoneTextFat.text ); + uint16_t size = MemRead( &item->zoneTextFat.size ); + SendSingleString( (const char*)ptr, size ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::Message: + case QueueType::MessageCallstack: + { + ThreadCtxCheckSerial( messageFatThread ); + ptr = MemRead( &item->messageFat.text ); + uint16_t size = MemRead( &item->messageFat.size ); + SendSingleString( (const char*)ptr, size ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::MessageColor: + case QueueType::MessageColorCallstack: + { + ThreadCtxCheckSerial( messageColorFatThread ); + ptr = MemRead( &item->messageColorFat.text ); + uint16_t size = MemRead( &item->messageColorFat.size ); + SendSingleString( (const char*)ptr, size ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::Callstack: + { + ThreadCtxCheckSerial( callstackFatThread ); + ptr = MemRead( &item->callstackFat.ptr ); + SendCallstackPayload( ptr ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::CallstackAlloc: + { + ThreadCtxCheckSerial( callstackAllocFatThread ); + ptr = MemRead( &item->callstackAllocFat.nativePtr ); + if( ptr != 0 ) + { + CutCallstack( (void*)ptr, "lua_pcall" ); + SendCallstackPayload( ptr ); + tracy_free_fast( (void*)ptr ); + } + ptr = MemRead( &item->callstackAllocFat.ptr ); + SendCallstackAlloc( ptr ); + tracy_free_fast( (void*)ptr ); + break; + } + case QueueType::FiberEnter: + { + ThreadCtxCheckSerial( fiberEnter ); + int64_t t = MemRead( &item->fiberEnter.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->fiberEnter.time, dt ); + break; + } + case QueueType::FiberLeave: + { + ThreadCtxCheckSerial( fiberLeave ); + int64_t t = MemRead( &item->fiberLeave.time ); + int64_t dt = t - refThread; + refThread = t; + MemWrite( &item->fiberLeave.time, dt ); + break; + } +#endif + default: + assert( false ); + break; + } + } +#ifdef TRACY_FIBERS + else + { + switch( (QueueType)idx ) + { + case QueueType::ZoneColor: + { + ThreadCtxCheckSerial( zoneColorThread ); + break; + } + case QueueType::ZoneValue: + { + ThreadCtxCheckSerial( zoneValueThread ); + break; + } + case QueueType::ZoneValidation: + { + ThreadCtxCheckSerial( zoneValidationThread ); + break; + } + case QueueType::MessageLiteral: + case QueueType::MessageLiteralCallstack: + { + ThreadCtxCheckSerial( messageLiteralThread ); + break; + } + case QueueType::MessageLiteralColor: + case QueueType::MessageLiteralColorCallstack: + { + ThreadCtxCheckSerial( messageColorLiteralThread ); + break; + } + case QueueType::CrashReport: + { + ThreadCtxCheckSerial( crashReportThread ); + break; + } + default: + break; + } + } +#endif + if( !AppendData( item, QueueDataSize[idx] ) ) return DequeueStatus::ConnectionLost; + item++; + } + m_refTimeSerial = refSerial; + m_refTimeGpu = refGpu; +#ifdef TRACY_FIBERS + m_refTimeThread = refThread; +#endif + m_serialDequeue.clear(); + } + else + { + return DequeueStatus::QueueEmpty; + } + return DequeueStatus::DataDequeued; +} + +Profiler::ThreadCtxStatus Profiler::ThreadCtxCheck( uint32_t threadId ) +{ + if( m_threadCtx == threadId ) return ThreadCtxStatus::Same; + QueueItem item; + MemWrite( &item.hdr.type, QueueType::ThreadContext ); + MemWrite( &item.threadCtx.thread, threadId ); + if( !AppendData( &item, QueueDataSize[(int)QueueType::ThreadContext] ) ) return ThreadCtxStatus::ConnectionLost; + m_threadCtx = threadId; + m_refTimeThread = 0; + return ThreadCtxStatus::Changed; +} + +bool Profiler::CommitData() +{ + bool ret = SendData( m_buffer + m_bufferStart, m_bufferOffset - m_bufferStart ); + if( m_bufferOffset > TargetFrameSize * 2 ) m_bufferOffset = 0; + m_bufferStart = m_bufferOffset; + return ret; +} + +bool Profiler::SendData( const char* data, size_t len ) +{ + const lz4sz_t lz4sz = LZ4_compress_fast_continue( (LZ4_stream_t*)m_stream, data, m_lz4Buf + sizeof( lz4sz_t ), (int)len, LZ4Size, 1 ); + memcpy( m_lz4Buf, &lz4sz, sizeof( lz4sz ) ); + return m_sock->Send( m_lz4Buf, lz4sz + sizeof( lz4sz_t ) ) != -1; +} + +void Profiler::SendString( uint64_t str, const char* ptr, size_t len, QueueType type ) +{ + assert( type == QueueType::StringData || + type == QueueType::ThreadName || + type == QueueType::PlotName || + type == QueueType::FrameName || + type == QueueType::ExternalName || + type == QueueType::ExternalThreadName || + type == QueueType::FiberName ); + + QueueItem item; + MemWrite( &item.hdr.type, type ); + MemWrite( &item.stringTransfer.ptr, str ); + + assert( len <= std::numeric_limits::max() ); + auto l16 = uint16_t( len ); + + NeedDataSize( QueueDataSize[(int)type] + sizeof( l16 ) + l16 ); + + AppendDataUnsafe( &item, QueueDataSize[(int)type] ); + AppendDataUnsafe( &l16, sizeof( l16 ) ); + AppendDataUnsafe( ptr, l16 ); +} + +void Profiler::SendSingleString( const char* ptr, size_t len ) +{ + QueueItem item; + MemWrite( &item.hdr.type, QueueType::SingleStringData ); + + assert( len <= std::numeric_limits::max() ); + auto l16 = uint16_t( len ); + + NeedDataSize( QueueDataSize[(int)QueueType::SingleStringData] + sizeof( l16 ) + l16 ); + + AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::SingleStringData] ); + AppendDataUnsafe( &l16, sizeof( l16 ) ); + AppendDataUnsafe( ptr, l16 ); +} + +void Profiler::SendSecondString( const char* ptr, size_t len ) +{ + QueueItem item; + MemWrite( &item.hdr.type, QueueType::SecondStringData ); + + assert( len <= std::numeric_limits::max() ); + auto l16 = uint16_t( len ); + + NeedDataSize( QueueDataSize[(int)QueueType::SecondStringData] + sizeof( l16 ) + l16 ); + + AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::SecondStringData] ); + AppendDataUnsafe( &l16, sizeof( l16 ) ); + AppendDataUnsafe( ptr, l16 ); +} + +void Profiler::SendLongString( uint64_t str, const char* ptr, size_t len, QueueType type ) +{ + assert( type == QueueType::FrameImageData || + type == QueueType::SymbolCode || + type == QueueType::SourceCode ); + + QueueItem item; + MemWrite( &item.hdr.type, type ); + MemWrite( &item.stringTransfer.ptr, str ); + + assert( len <= std::numeric_limits::max() ); + assert( QueueDataSize[(int)type] + sizeof( uint32_t ) + len <= TargetFrameSize ); + auto l32 = uint32_t( len ); + + NeedDataSize( QueueDataSize[(int)type] + sizeof( l32 ) + l32 ); + + AppendDataUnsafe( &item, QueueDataSize[(int)type] ); + AppendDataUnsafe( &l32, sizeof( l32 ) ); + AppendDataUnsafe( ptr, l32 ); +} + +void Profiler::SendSourceLocation( uint64_t ptr ) +{ + auto srcloc = (const SourceLocationData*)ptr; + QueueItem item; + MemWrite( &item.hdr.type, QueueType::SourceLocation ); + MemWrite( &item.srcloc.name, (uint64_t)srcloc->name ); + MemWrite( &item.srcloc.file, (uint64_t)srcloc->file ); + MemWrite( &item.srcloc.function, (uint64_t)srcloc->function ); + MemWrite( &item.srcloc.line, srcloc->line ); + MemWrite( &item.srcloc.b, uint8_t( ( srcloc->color ) & 0xFF ) ); + MemWrite( &item.srcloc.g, uint8_t( ( srcloc->color >> 8 ) & 0xFF ) ); + MemWrite( &item.srcloc.r, uint8_t( ( srcloc->color >> 16 ) & 0xFF ) ); + AppendData( &item, QueueDataSize[(int)QueueType::SourceLocation] ); +} + +void Profiler::SendSourceLocationPayload( uint64_t _ptr ) +{ + auto ptr = (const char*)_ptr; + + QueueItem item; + MemWrite( &item.hdr.type, QueueType::SourceLocationPayload ); + MemWrite( &item.stringTransfer.ptr, _ptr ); + + uint16_t len; + memcpy( &len, ptr, sizeof( len ) ); + assert( len > 2 ); + len -= 2; + ptr += 2; + + NeedDataSize( QueueDataSize[(int)QueueType::SourceLocationPayload] + sizeof( len ) + len ); + + AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::SourceLocationPayload] ); + AppendDataUnsafe( &len, sizeof( len ) ); + AppendDataUnsafe( ptr, len ); +} + +void Profiler::SendCallstackPayload( uint64_t _ptr ) +{ + auto ptr = (uintptr_t*)_ptr; + + QueueItem item; + MemWrite( &item.hdr.type, QueueType::CallstackPayload ); + MemWrite( &item.stringTransfer.ptr, _ptr ); + + const auto sz = *ptr++; + const auto len = sz * sizeof( uint64_t ); + const auto l16 = uint16_t( len ); + + NeedDataSize( QueueDataSize[(int)QueueType::CallstackPayload] + sizeof( l16 ) + l16 ); + + AppendDataUnsafe( &item, QueueDataSize[(int)QueueType::CallstackPayload] ); + AppendDataUnsafe( &l16, sizeof( l16 ) ); + + if( compile_time_condition::value ) + { + AppendDataUnsafe( ptr, sizeof( uint64_t ) * sz ); + } + else + { + for( uintptr_t i=0; i> 63 != 0 ) + { + SendSingleString( "" ); + QueueItem item; + MemWrite( &item.hdr.type, QueueType::SymbolInformation ); + MemWrite( &item.symbolInformation.line, 0 ); + MemWrite( &item.symbolInformation.symAddr, symbol ); + AppendData( &item, QueueDataSize[(int)QueueType::SymbolInformation] ); + } + else + { + m_symbolQueue.emplace( SymbolQueueItem { SymbolQueueItemType::SymbolQuery, symbol } ); + } +#else + AckServerQuery(); +#endif +} + +void Profiler::QueueExternalName( uint64_t ptr ) +{ +#ifdef TRACY_HAS_SYSTEM_TRACING + m_symbolQueue.emplace( SymbolQueueItem { SymbolQueueItemType::ExternalName, ptr } ); +#endif +} + +void Profiler::QueueKernelCode( uint64_t symbol, uint32_t size ) +{ + assert( symbol >> 63 != 0 ); +#ifdef TRACY_HAS_CALLSTACK + m_symbolQueue.emplace( SymbolQueueItem { SymbolQueueItemType::KernelCode, symbol, size } ); +#else + AckSymbolCodeNotAvailable(); +#endif +} + +void Profiler::QueueSourceCodeQuery( uint32_t id ) +{ + assert( m_exectime != 0 ); + assert( m_queryData ); + m_symbolQueue.emplace( SymbolQueueItem { SymbolQueueItemType::SourceCode, uint64_t( m_queryData ), uint64_t( m_queryImage ), id } ); + m_queryData = nullptr; + m_queryImage = nullptr; +} + +#ifdef TRACY_HAS_CALLSTACK +void Profiler::HandleSymbolQueueItem( const SymbolQueueItem& si ) +{ + switch( si.type ) + { + case SymbolQueueItemType::CallstackFrame: + { + const auto frameData = DecodeCallstackPtr( si.ptr ); + auto data = tracy_malloc_fast( sizeof( CallstackEntry ) * frameData.size ); + memcpy( data, frameData.data, sizeof( CallstackEntry ) * frameData.size ); + TracyLfqPrepare( QueueType::CallstackFrameSize ); + MemWrite( &item->callstackFrameSizeFat.ptr, si.ptr ); + MemWrite( &item->callstackFrameSizeFat.size, frameData.size ); + MemWrite( &item->callstackFrameSizeFat.data, (uint64_t)data ); + MemWrite( &item->callstackFrameSizeFat.imageName, (uint64_t)frameData.imageName ); + TracyLfqCommit; + break; + } + case SymbolQueueItemType::SymbolQuery: + { +#ifdef __ANDROID__ + // On Android it's common for code to be in mappings that are only executable + // but not readable. + if( !EnsureReadable( si.ptr ) ) + { + TracyLfqPrepare( QueueType::AckServerQueryNoop ); + TracyLfqCommit; + break; + } +#endif + const auto sym = DecodeSymbolAddress( si.ptr ); + TracyLfqPrepare( QueueType::SymbolInformation ); + MemWrite( &item->symbolInformationFat.line, sym.line ); + MemWrite( &item->symbolInformationFat.symAddr, si.ptr ); + MemWrite( &item->symbolInformationFat.fileString, (uint64_t)sym.file ); + MemWrite( &item->symbolInformationFat.needFree, (uint8_t)sym.needFree ); + TracyLfqCommit; + break; + } +#ifdef TRACY_HAS_SYSTEM_TRACING + case SymbolQueueItemType::ExternalName: + { + const char* threadName; + const char* name; + SysTraceGetExternalName( si.ptr, threadName, name ); + TracyLfqPrepare( QueueType::ExternalNameMetadata ); + MemWrite( &item->externalNameMetadata.thread, si.ptr ); + MemWrite( &item->externalNameMetadata.name, (uint64_t)name ); + MemWrite( &item->externalNameMetadata.threadName, (uint64_t)threadName ); + TracyLfqCommit; + break; + } +#endif + case SymbolQueueItemType::KernelCode: + { +#ifdef _WIN32 + auto mod = GetKernelModulePath( si.ptr ); + if( mod ) + { + auto fn = DecodeCallstackPtrFast( si.ptr ); + if( *fn ) + { + auto hnd = LoadLibraryExA( mod, nullptr, DONT_RESOLVE_DLL_REFERENCES ); + if( hnd ) + { + auto ptr = (const void*)GetProcAddress( hnd, fn ); + if( ptr ) + { + auto buf = (char*)tracy_malloc( si.extra ); + memcpy( buf, ptr, si.extra ); + FreeLibrary( hnd ); + TracyLfqPrepare( QueueType::SymbolCodeMetadata ); + MemWrite( &item->symbolCodeMetadata.symbol, si.ptr ); + MemWrite( &item->symbolCodeMetadata.ptr, (uint64_t)buf ); + MemWrite( &item->symbolCodeMetadata.size, (uint32_t)si.extra ); + TracyLfqCommit; + break; + } + FreeLibrary( hnd ); + } + } + } +#elif defined __linux__ + void* data = m_kcore->Retrieve( si.ptr, si.extra ); + if( data ) + { + TracyLfqPrepare( QueueType::SymbolCodeMetadata ); + MemWrite( &item->symbolCodeMetadata.symbol, si.ptr ); + MemWrite( &item->symbolCodeMetadata.ptr, (uint64_t)data ); + MemWrite( &item->symbolCodeMetadata.size, (uint32_t)si.extra ); + TracyLfqCommit; + break; + } +#endif + TracyLfqPrepare( QueueType::AckSymbolCodeNotAvailable ); + TracyLfqCommit; + break; + } + case SymbolQueueItemType::SourceCode: + HandleSourceCodeQuery( (char*)si.ptr, (char*)si.extra, si.id ); + break; + default: + assert( false ); + break; + } +} + +void Profiler::SymbolWorker() +{ +#if defined __linux__ && !defined TRACY_NO_CRASH_HANDLER + s_symbolTid = syscall( SYS_gettid ); +#endif + + ThreadExitHandler threadExitHandler; + SetThreadName( "Tracy Symbol Worker" ); +#ifdef TRACY_USE_RPMALLOC + InitRpmalloc(); +#endif + InitCallstack(); + while( m_timeBegin.load( std::memory_order_relaxed ) == 0 ) std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); + + for(;;) + { + const auto shouldExit = ShouldExit(); +#ifdef TRACY_ON_DEMAND + if( !IsConnected() ) + { + if( shouldExit ) + { + s_symbolThreadGone.store( true, std::memory_order_release ); + return; + } + while( m_symbolQueue.front() ) m_symbolQueue.pop(); + std::this_thread::sleep_for( std::chrono::milliseconds( 20 ) ); + continue; + } +#endif + auto si = m_symbolQueue.front(); + if( si ) + { + HandleSymbolQueueItem( *si ); + m_symbolQueue.pop(); + } + else + { + if( shouldExit ) + { + s_symbolThreadGone.store( true, std::memory_order_release ); + return; + } + std::this_thread::sleep_for( std::chrono::milliseconds( 20 ) ); + } + } +} +#endif + +bool Profiler::HandleServerQuery() +{ + ServerQueryPacket payload; + if( !m_sock->Read( &payload, sizeof( payload ), 10 ) ) return false; + + uint8_t type; + uint64_t ptr; + memcpy( &type, &payload.type, sizeof( payload.type ) ); + memcpy( &ptr, &payload.ptr, sizeof( payload.ptr ) ); + + switch( type ) + { + case ServerQueryString: + SendString( ptr, (const char*)ptr, QueueType::StringData ); + break; + case ServerQueryThreadString: + if( ptr == m_mainThread ) + { + SendString( ptr, "Main thread", 11, QueueType::ThreadName ); + } + else + { + auto t = GetThreadNameData( (uint32_t)ptr ); + if( t ) + { + SendString( ptr, t->name, QueueType::ThreadName ); + if( t->groupHint != 0 ) + { + TracyLfqPrepare( QueueType::ThreadGroupHint ); + MemWrite( &item->threadGroupHint.thread, (uint32_t)ptr ); + MemWrite( &item->threadGroupHint.groupHint, t->groupHint ); + TracyLfqCommit; + } + } + else + { + SendString( ptr, GetThreadName( (uint32_t)ptr ), QueueType::ThreadName ); + } + } + break; + case ServerQuerySourceLocation: + SendSourceLocation( ptr ); + break; + case ServerQueryPlotName: + SendString( ptr, (const char*)ptr, QueueType::PlotName ); + break; + case ServerQueryTerminate: + return false; + case ServerQueryCallstackFrame: + QueueCallstackFrame( ptr ); + break; + case ServerQueryFrameName: + SendString( ptr, (const char*)ptr, QueueType::FrameName ); + break; + case ServerQueryDisconnect: + HandleDisconnect(); + return false; +#ifdef TRACY_HAS_SYSTEM_TRACING + case ServerQueryExternalName: + QueueExternalName( ptr ); + break; +#endif + case ServerQueryParameter: + HandleParameter( ptr ); + break; + case ServerQuerySymbol: + QueueSymbolQuery( ptr ); + break; +#ifndef TRACY_NO_CODE_TRANSFER + case ServerQuerySymbolCode: + HandleSymbolCodeQuery( ptr, payload.extra ); + break; +#endif + case ServerQuerySourceCode: + QueueSourceCodeQuery( uint32_t( ptr ) ); + break; + case ServerQueryDataTransfer: + if( m_queryData ) + { + assert( !m_queryImage ); + m_queryImage = m_queryData; + } + m_queryDataPtr = m_queryData = (char*)tracy_malloc( ptr + 11 ); + AckServerQuery(); + break; + case ServerQueryDataTransferPart: + memcpy( m_queryDataPtr, &ptr, 8 ); + memcpy( m_queryDataPtr+8, &payload.extra, 4 ); + m_queryDataPtr += 12; + AckServerQuery(); + break; +#ifdef TRACY_FIBERS + case ServerQueryFiberName: + SendString( ptr, (const char*)ptr, QueueType::FiberName ); + break; +#endif + default: + assert( false ); + break; + } + + return true; +} + +void Profiler::HandleDisconnect() +{ + moodycamel::ConsumerToken token( GetQueue() ); + +#ifdef TRACY_HAS_SYSTEM_TRACING + if( s_sysTraceThread ) + { + auto timestamp = GetTime(); + for(;;) + { + const auto status = DequeueContextSwitches( token, timestamp ); + if( status == DequeueStatus::ConnectionLost ) + { + return; + } + else if( status == DequeueStatus::QueueEmpty ) + { + if( m_bufferOffset != m_bufferStart ) + { + if( !CommitData() ) return; + } + } + if( timestamp < 0 ) + { + if( m_bufferOffset != m_bufferStart ) + { + if( !CommitData() ) return; + } + break; + } + ClearSerial(); + if( m_sock->HasData() ) + { + while( m_sock->HasData() ) + { + if( !HandleServerQuery() ) return; + } + if( m_bufferOffset != m_bufferStart ) + { + if( !CommitData() ) return; + } + } + else + { + if( m_bufferOffset != m_bufferStart ) + { + if( !CommitData() ) return; + } + std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); + } + } + } +#endif + + QueueItem terminate; + MemWrite( &terminate.hdr.type, QueueType::Terminate ); + if( !SendData( (const char*)&terminate, 1 ) ) return; + for(;;) + { + ClearQueues( token ); + if( m_sock->HasData() ) + { + while( m_sock->HasData() ) + { + if( !HandleServerQuery() ) return; + } + if( m_bufferOffset != m_bufferStart ) + { + if( !CommitData() ) return; + } + } + else + { + if( m_bufferOffset != m_bufferStart ) + { + if( !CommitData() ) return; + } + std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) ); + } + } +} + +void Profiler::CalibrateTimer() +{ + m_timerMul = 1.; + +#ifdef TRACY_HW_TIMER + +# if !defined TRACY_TIMER_QPC && defined TRACY_TIMER_FALLBACK + const bool needCalibration = HardwareSupportsInvariantTSC(); +# else + const bool needCalibration = true; +# endif + if( needCalibration ) + { + std::atomic_signal_fence( std::memory_order_acq_rel ); + const auto t0 = std::chrono::high_resolution_clock::now(); + const auto r0 = GetTime(); + std::atomic_signal_fence( std::memory_order_acq_rel ); + std::this_thread::sleep_for( std::chrono::milliseconds( 200 ) ); + std::atomic_signal_fence( std::memory_order_acq_rel ); + const auto t1 = std::chrono::high_resolution_clock::now(); + const auto r1 = GetTime(); + std::atomic_signal_fence( std::memory_order_acq_rel ); + + const auto dt = std::chrono::duration_cast( t1 - t0 ).count(); + const auto dr = r1 - r0; + + m_timerMul = double( dt ) / double( dr ); + } +#endif +} + +void Profiler::CalibrateDelay() +{ + constexpr int Iterations = 50000; + + auto mindiff = std::numeric_limits::max(); + for( int i=0; i 0 && dti < mindiff ) mindiff = dti; + } + m_resolution = mindiff; + +#ifdef TRACY_DELAYED_INIT + m_delay = m_resolution; +#else + constexpr int Events = Iterations * 2; // start + end + static_assert( Events < QueuePrealloc, "Delay calibration loop will allocate memory in queue" ); + + static const tracy::SourceLocationData __tracy_source_location { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; + const auto t0 = GetTime(); + for( int i=0; izoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, (uint64_t)&__tracy_source_location ); + TracyLfqCommit; + } + { + TracyLfqPrepare( QueueType::ZoneEnd ); + MemWrite( &item->zoneEnd.time, GetTime() ); + TracyLfqCommit; + } + } + const auto t1 = GetTime(); + const auto dt = t1 - t0; + m_delay = dt / Events; + + moodycamel::ConsumerToken token( GetQueue() ); + int left = Events; + while( left != 0 ) + { + const auto sz = GetQueue().try_dequeue_bulk_single( token, [](const uint64_t&){}, [](QueueItem* item, size_t sz){} ); + assert( sz > 0 ); + left -= (int)sz; + } + assert( GetQueue().size_approx() == 0 ); +#endif +} + +void Profiler::ReportTopology() +{ +#ifndef TRACY_DELAYED_INIT + struct CpuData + { + uint32_t package; + uint32_t die; + uint32_t core; + uint32_t thread; + }; + +#if defined _WIN32 +# ifdef TRACY_UWP + t_GetLogicalProcessorInformationEx _GetLogicalProcessorInformationEx = &::GetLogicalProcessorInformationEx; +# else + t_GetLogicalProcessorInformationEx _GetLogicalProcessorInformationEx = (t_GetLogicalProcessorInformationEx)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "GetLogicalProcessorInformationEx" ); +# endif + if( !_GetLogicalProcessorInformationEx ) return; + + DWORD psz = 0; + _GetLogicalProcessorInformationEx( RelationProcessorPackage, nullptr, &psz ); + auto packageInfo = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)tracy_malloc( psz ); + auto res = _GetLogicalProcessorInformationEx( RelationProcessorPackage, packageInfo, &psz ); + assert( res ); + + DWORD csz = 0; + _GetLogicalProcessorInformationEx( RelationProcessorCore, nullptr, &csz ); + auto coreInfo = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)tracy_malloc( csz ); + res = _GetLogicalProcessorInformationEx( RelationProcessorCore, coreInfo, &csz ); + assert( res ); + + SYSTEM_INFO sysinfo; + GetSystemInfo( &sysinfo ); + const uint32_t numcpus = sysinfo.dwNumberOfProcessors; + + auto cpuData = (CpuData*)tracy_malloc( sizeof( CpuData ) * numcpus ); + memset( cpuData, 0, sizeof( CpuData ) * numcpus ); + for( uint32_t i=0; iRelationship == RelationProcessorPackage ); + // FIXME account for GroupCount + auto mask = ptr->Processor.GroupMask[0].Mask; + int core = 0; + while( mask != 0 ) + { + if( mask & 1 ) cpuData[core].package = idx; + core++; + mask >>= 1; + } + ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size); + idx++; + } + + idx = 0; + ptr = coreInfo; + while( (char*)ptr < ((char*)coreInfo) + csz ) + { + assert( ptr->Relationship == RelationProcessorCore ); + // FIXME account for GroupCount + auto mask = ptr->Processor.GroupMask[0].Mask; + int core = 0; + while( mask != 0 ) + { + if( mask & 1 ) cpuData[core].core = idx; + core++; + mask >>= 1; + } + ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size); + idx++; + } + + for( uint32_t i=0; icpuTopology.package, data.package ); + MemWrite( &item->cpuTopology.die, data.die ); + MemWrite( &item->cpuTopology.core, data.core ); + MemWrite( &item->cpuTopology.thread, data.thread ); + +#ifdef TRACY_ON_DEMAND + DeferItem( *item ); +#endif + + TracyLfqCommit; + } + + tracy_free( cpuData ); + tracy_free( coreInfo ); + tracy_free( packageInfo ); +#elif defined __linux__ + const int numcpus = std::thread::hardware_concurrency(); + auto cpuData = (CpuData*)tracy_malloc( sizeof( CpuData ) * numcpus ); + memset( cpuData, 0, sizeof( CpuData ) * numcpus ); + + const char* basePath = "/sys/devices/system/cpu/cpu"; + for( int i=0; icpuTopology.package, data.package ); + MemWrite( &item->cpuTopology.die, data.die ); + MemWrite( &item->cpuTopology.core, data.core ); + MemWrite( &item->cpuTopology.thread, data.thread ); + +#ifdef TRACY_ON_DEMAND + DeferItem( *item ); +#endif + + TracyLfqCommit; + } + + tracy_free( cpuData ); +#endif +#endif +} + +void Profiler::SendCallstack( int depth, const char* skipBefore ) +{ +#ifdef TRACY_HAS_CALLSTACK + auto ptr = Callstack( depth ); + CutCallstack( ptr, skipBefore ); + + TracyQueuePrepare( QueueType::Callstack ); + MemWrite( &item->callstackFat.ptr, (uint64_t)ptr ); + TracyQueueCommit( callstackFatThread ); +#endif +} + +void Profiler::CutCallstack( void* callstack, const char* skipBefore ) +{ +#ifdef TRACY_HAS_CALLSTACK + auto data = (uintptr_t*)callstack; + const auto sz = *data++; + uintptr_t i; + for( i=0; i 100000000 ) // 100 ms + { + auto sysTime = m_sysTime.Get(); + if( sysTime >= 0 ) + { + m_sysTimeLast = t; + + TracyLfqPrepare( QueueType::SysTimeReport ); + MemWrite( &item->sysTime.time, GetTime() ); + MemWrite( &item->sysTime.sysTime, sysTime ); + TracyLfqCommit; + } + } +} +#endif + +void Profiler::HandleParameter( uint64_t payload ) +{ + assert( m_paramCallback ); + const auto idx = uint32_t( payload >> 32 ); + const auto val = int32_t( payload & 0xFFFFFFFF ); + m_paramCallback( m_paramCallbackData, idx, val ); + AckServerQuery(); +} + +void Profiler::HandleSymbolCodeQuery( uint64_t symbol, uint32_t size ) +{ + if( symbol >> 63 != 0 ) + { + QueueKernelCode( symbol, size ); + } + else + { + if( !EnsureReadable( symbol ) ) + { + AckSymbolCodeNotAvailable(); + return; + } + + SendLongString( symbol, (const char*)symbol, size, QueueType::SymbolCode ); + } +} + +void Profiler::HandleSourceCodeQuery( char* data, char* image, uint32_t id ) +{ + bool ok = false; + FILE* f = fopen( data, "rb" ); + if( f ) + { + struct stat st; + if( fstat( fileno( f ), &st ) == 0 && (uint64_t)st.st_mtime < m_exectime && st.st_size < ( TargetFrameSize - 16 ) ) + { + auto ptr = (char*)tracy_malloc_fast( st.st_size ); + auto rd = fread( ptr, 1, st.st_size, f ); + if( rd == (size_t)st.st_size ) + { + TracyLfqPrepare( QueueType::SourceCodeMetadata ); + MemWrite( &item->sourceCodeMetadata.ptr, (uint64_t)ptr ); + MemWrite( &item->sourceCodeMetadata.size, (uint32_t)rd ); + MemWrite( &item->sourceCodeMetadata.id, id ); + TracyLfqCommit; + ok = true; + } + else + { + tracy_free_fast( ptr ); + } + } + fclose( f ); + } + +#ifdef TRACY_DEBUGINFOD + else if( image && data[0] == '/' ) + { + size_t size; + auto buildid = GetBuildIdForImage( image, size ); + if( buildid ) + { + auto d = debuginfod_find_source( GetDebuginfodClient(), buildid, size, data, nullptr ); + TracyDebug( "DebugInfo source query: %s, fn: %s, image: %s\n", d >= 0 ? " ok " : "fail", data, image ); + if( d >= 0 ) + { + struct stat st; + fstat( d, &st ); + if( st.st_size < ( TargetFrameSize - 16 ) ) + { + lseek( d, 0, SEEK_SET ); + auto ptr = (char*)tracy_malloc_fast( st.st_size ); + auto rd = read( d, ptr, st.st_size ); + if( rd == (size_t)st.st_size ) + { + TracyLfqPrepare( QueueType::SourceCodeMetadata ); + MemWrite( &item->sourceCodeMetadata.ptr, (uint64_t)ptr ); + MemWrite( &item->sourceCodeMetadata.size, (uint32_t)rd ); + MemWrite( &item->sourceCodeMetadata.id, id ); + TracyLfqCommit; + ok = true; + } + else + { + tracy_free_fast( ptr ); + } + } + close( d ); + } + } + } + else + { + TracyDebug( "DebugInfo invalid query fn: %s, image: %s\n", data, image ); + } +#endif + + if( !ok && m_sourceCallback ) + { + size_t sz; + char* ptr = m_sourceCallback( m_sourceCallbackData, data, sz ); + if( ptr ) + { + if( sz < ( TargetFrameSize - 16 ) ) + { + TracyLfqPrepare( QueueType::SourceCodeMetadata ); + MemWrite( &item->sourceCodeMetadata.ptr, (uint64_t)ptr ); + MemWrite( &item->sourceCodeMetadata.size, (uint32_t)sz ); + MemWrite( &item->sourceCodeMetadata.id, id ); + TracyLfqCommit; + ok = true; + } + else + { + tracy_free_fast( ptr ); + } + } + } + + if( !ok ) + { + TracyLfqPrepare( QueueType::AckSourceCodeNotAvailable ); + MemWrite( &item->sourceCodeNotAvailable, id ); + TracyLfqCommit; + } + + tracy_free_fast( data ); + tracy_free_fast( image ); +} + +#if defined _WIN32 && defined TRACY_TIMER_QPC +int64_t Profiler::GetTimeQpc() +{ + LARGE_INTEGER t; + QueryPerformanceCounter( &t ); + return t.QuadPart; +} +#endif + +} + +#ifdef __cplusplus +extern "C" { +#endif + +TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin( const struct ___tracy_source_location_data* srcloc, int active ) +{ + ___tracy_c_zone_context ctx; +#ifdef TRACY_ON_DEMAND + ctx.active = active && tracy::GetProfiler().IsConnected(); +#else + ctx.active = active; +#endif + if( !ctx.active ) return ctx; + const auto id = tracy::GetProfiler().GetNextZoneId(); + ctx.id = id; + +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + { + TracyQueuePrepareC( tracy::QueueType::ZoneBegin ); + tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc ); + TracyQueueCommitC( zoneBeginThread ); + } + return ctx; +} + +TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_callstack( const struct ___tracy_source_location_data* srcloc, int depth, int active ) +{ + ___tracy_c_zone_context ctx; +#ifdef TRACY_ON_DEMAND + ctx.active = active && tracy::GetProfiler().IsConnected(); +#else + ctx.active = active; +#endif + if( !ctx.active ) return ctx; + const auto id = tracy::GetProfiler().GetNextZoneId(); + ctx.id = id; + +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + tracy::GetProfiler().SendCallstack( depth ); + { + TracyQueuePrepareC( tracy::QueueType::ZoneBeginCallstack ); + tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc ); + TracyQueueCommitC( zoneBeginThread ); + } + return ctx; +} + +TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_alloc( uint64_t srcloc, int active ) +{ + ___tracy_c_zone_context ctx; +#ifdef TRACY_ON_DEMAND + ctx.active = active && tracy::GetProfiler().IsConnected(); +#else + ctx.active = active; +#endif + if( !ctx.active ) + { + tracy::tracy_free( (void*)srcloc ); + return ctx; + } + const auto id = tracy::GetProfiler().GetNextZoneId(); + ctx.id = id; + +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + { + TracyQueuePrepareC( tracy::QueueType::ZoneBeginAllocSrcLoc ); + tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->zoneBegin.srcloc, srcloc ); + TracyQueueCommitC( zoneBeginThread ); + } + return ctx; +} + +TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_alloc_callstack( uint64_t srcloc, int depth, int active ) +{ + ___tracy_c_zone_context ctx; +#ifdef TRACY_ON_DEMAND + ctx.active = active && tracy::GetProfiler().IsConnected(); +#else + ctx.active = active; +#endif + if( !ctx.active ) + { + tracy::tracy_free( (void*)srcloc ); + return ctx; + } + const auto id = tracy::GetProfiler().GetNextZoneId(); + ctx.id = id; + +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + tracy::GetProfiler().SendCallstack( depth ); + { + TracyQueuePrepareC( tracy::QueueType::ZoneBeginAllocSrcLocCallstack ); + tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->zoneBegin.srcloc, srcloc ); + TracyQueueCommitC( zoneBeginThread ); + } + return ctx; +} + +TRACY_API void ___tracy_emit_zone_end( TracyCZoneCtx ctx ) +{ + if( !ctx.active ) return; +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, ctx.id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + { + TracyQueuePrepareC( tracy::QueueType::ZoneEnd ); + tracy::MemWrite( &item->zoneEnd.time, tracy::Profiler::GetTime() ); + TracyQueueCommitC( zoneEndThread ); + } +} + +TRACY_API void ___tracy_emit_zone_text( TracyCZoneCtx ctx, const char* txt, size_t size ) +{ + assert( size < std::numeric_limits::max() ); + if( !ctx.active ) return; + auto ptr = (char*)tracy::tracy_malloc( size ); + memcpy( ptr, txt, size ); +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, ctx.id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + { + TracyQueuePrepareC( tracy::QueueType::ZoneText ); + tracy::MemWrite( &item->zoneTextFat.text, (uint64_t)ptr ); + tracy::MemWrite( &item->zoneTextFat.size, (uint16_t)size ); + TracyQueueCommitC( zoneTextFatThread ); + } +} + +TRACY_API void ___tracy_emit_zone_name( TracyCZoneCtx ctx, const char* txt, size_t size ) +{ + assert( size < std::numeric_limits::max() ); + if( !ctx.active ) return; + auto ptr = (char*)tracy::tracy_malloc( size ); + memcpy( ptr, txt, size ); +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, ctx.id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + { + TracyQueuePrepareC( tracy::QueueType::ZoneName ); + tracy::MemWrite( &item->zoneTextFat.text, (uint64_t)ptr ); + tracy::MemWrite( &item->zoneTextFat.size, (uint16_t)size ); + TracyQueueCommitC( zoneTextFatThread ); + } +} + +TRACY_API void ___tracy_emit_zone_color( TracyCZoneCtx ctx, uint32_t color ) { + if( !ctx.active ) return; +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, ctx.id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + { + TracyQueuePrepareC( tracy::QueueType::ZoneColor ); + tracy::MemWrite( &item->zoneColor.b, uint8_t( ( color ) & 0xFF ) ); + tracy::MemWrite( &item->zoneColor.g, uint8_t( ( color >> 8 ) & 0xFF ) ); + tracy::MemWrite( &item->zoneColor.r, uint8_t( ( color >> 16 ) & 0xFF ) ); + TracyQueueCommitC( zoneColorThread ); + } +} + +TRACY_API void ___tracy_emit_zone_value( TracyCZoneCtx ctx, uint64_t value ) +{ + if( !ctx.active ) return; +#ifndef TRACY_NO_VERIFY + { + TracyQueuePrepareC( tracy::QueueType::ZoneValidation ); + tracy::MemWrite( &item->zoneValidation.id, ctx.id ); + TracyQueueCommitC( zoneValidationThread ); + } +#endif + { + TracyQueuePrepareC( tracy::QueueType::ZoneValue ); + tracy::MemWrite( &item->zoneValue.value, value ); + TracyQueueCommitC( zoneValueThread ); + } +} + +TRACY_API void ___tracy_emit_memory_alloc( const void* ptr, size_t size, int secure ) { tracy::Profiler::MemAlloc( ptr, size, secure != 0 ); } +TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int depth, int secure ) { tracy::Profiler::MemAllocCallstack( ptr, size, depth, secure != 0 ); } +TRACY_API void ___tracy_emit_memory_free( const void* ptr, int secure ) { tracy::Profiler::MemFree( ptr, secure != 0 ); } +TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int depth, int secure ) { tracy::Profiler::MemFreeCallstack( ptr, depth, secure != 0 ); } +TRACY_API void ___tracy_emit_memory_alloc_named( const void* ptr, size_t size, int secure, const char* name ) { tracy::Profiler::MemAllocNamed( ptr, size, secure != 0, name ); } +TRACY_API void ___tracy_emit_memory_alloc_callstack_named( const void* ptr, size_t size, int depth, int secure, const char* name ) { tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, secure != 0, name ); } +TRACY_API void ___tracy_emit_memory_free_named( const void* ptr, int secure, const char* name ) { tracy::Profiler::MemFreeNamed( ptr, secure != 0, name ); } +TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int depth, int secure, const char* name ) { tracy::Profiler::MemFreeCallstackNamed( ptr, depth, secure != 0, name ); } +TRACY_API void ___tracy_emit_frame_mark( const char* name ) { tracy::Profiler::SendFrameMark( name ); } +TRACY_API void ___tracy_emit_frame_mark_start( const char* name ) { tracy::Profiler::SendFrameMark( name, tracy::QueueType::FrameMarkMsgStart ); } +TRACY_API void ___tracy_emit_frame_mark_end( const char* name ) { tracy::Profiler::SendFrameMark( name, tracy::QueueType::FrameMarkMsgEnd ); } +TRACY_API void ___tracy_emit_frame_image( const void* image, uint16_t w, uint16_t h, uint8_t offset, int flip ) { tracy::Profiler::SendFrameImage( image, w, h, offset, flip ); } +TRACY_API void ___tracy_emit_plot( const char* name, double val ) { tracy::Profiler::PlotData( name, val ); } +TRACY_API void ___tracy_emit_plot_float( const char* name, float val ) { tracy::Profiler::PlotData( name, val ); } +TRACY_API void ___tracy_emit_plot_int( const char* name, int64_t val ) { tracy::Profiler::PlotData( name, val ); } +TRACY_API void ___tracy_emit_plot_config( const char* name, int type, int step, int fill, uint32_t color ) { tracy::Profiler::ConfigurePlot( name, tracy::PlotFormatType(type), step, fill, color ); } +TRACY_API void ___tracy_emit_message( const char* txt, size_t size, int callstack ) { tracy::Profiler::Message( txt, size, callstack ); } +TRACY_API void ___tracy_emit_messageL( const char* txt, int callstack ) { tracy::Profiler::Message( txt, callstack ); } +TRACY_API void ___tracy_emit_messageC( const char* txt, size_t size, uint32_t color, int callstack ) { tracy::Profiler::MessageColor( txt, size, color, callstack ); } +TRACY_API void ___tracy_emit_messageLC( const char* txt, uint32_t color, int callstack ) { tracy::Profiler::MessageColor( txt, color, callstack ); } +TRACY_API void ___tracy_emit_message_appinfo( const char* txt, size_t size ) { tracy::Profiler::MessageAppInfo( txt, size ); } + +TRACY_API uint64_t ___tracy_alloc_srcloc( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, uint32_t color ) { + return tracy::Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, color ); +} + +TRACY_API uint64_t ___tracy_alloc_srcloc_name( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, uint32_t color ) { + return tracy::Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz, color ); +} + +TRACY_API void ___tracy_emit_gpu_zone_begin( const struct ___tracy_gpu_zone_begin_data data ) +{ + TracyLfqPrepareC( tracy::QueueType::GpuZoneBegin ); + tracy::MemWrite( &item->gpuZoneBegin.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuZoneBegin.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuZoneBegin.srcloc, data.srcloc ); + tracy::MemWrite( &item->gpuZoneBegin.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneBegin.context, data.context ); + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_zone_begin_callstack( const struct ___tracy_gpu_zone_begin_callstack_data data ) +{ + tracy::GetProfiler().SendCallstack( data.depth ); + TracyLfqPrepareC( tracy::QueueType::GpuZoneBeginCallstack ); + tracy::MemWrite( &item->gpuZoneBegin.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuZoneBegin.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuZoneBegin.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneBegin.context, data.context ); + tracy::MemWrite( &item->gpuZoneBegin.srcloc, data.srcloc ); + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_zone_begin_alloc( const struct ___tracy_gpu_zone_begin_data data ) +{ + TracyLfqPrepareC( tracy::QueueType::GpuZoneBeginAllocSrcLoc ); + tracy::MemWrite( &item->gpuZoneBegin.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuZoneBegin.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuZoneBegin.srcloc, data.srcloc ); + tracy::MemWrite( &item->gpuZoneBegin.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneBegin.context, data.context ); + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_zone_begin_alloc_callstack( const struct ___tracy_gpu_zone_begin_callstack_data data ) +{ + tracy::GetProfiler().SendCallstack( data.depth ); + TracyLfqPrepareC( tracy::QueueType::GpuZoneBeginAllocSrcLocCallstack ); + tracy::MemWrite( &item->gpuZoneBegin.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuZoneBegin.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuZoneBegin.srcloc, data.srcloc ); + tracy::MemWrite( &item->gpuZoneBegin.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneBegin.context, data.context ); + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_time( const struct ___tracy_gpu_time_data data ) +{ + TracyLfqPrepareC( tracy::QueueType::GpuTime ); + tracy::MemWrite( &item->gpuTime.gpuTime, data.gpuTime ); + tracy::MemWrite( &item->gpuTime.queryId, data.queryId ); + tracy::MemWrite( &item->gpuTime.context, data.context ); + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_zone_end( const struct ___tracy_gpu_zone_end_data data ) +{ + TracyLfqPrepareC( tracy::QueueType::GpuZoneEnd ); + tracy::MemWrite( &item->gpuZoneEnd.cpuTime, tracy::Profiler::GetTime() ); + memset( &item->gpuZoneEnd.thread, 0, sizeof( item->gpuZoneEnd.thread ) ); + tracy::MemWrite( &item->gpuZoneEnd.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneEnd.context, data.context ); + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_new_context( ___tracy_gpu_new_context_data data ) +{ + TracyLfqPrepareC( tracy::QueueType::GpuNewContext ); + tracy::MemWrite( &item->gpuNewContext.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuNewContext.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuNewContext.gpuTime, data.gpuTime ); + tracy::MemWrite( &item->gpuNewContext.period, data.period ); + tracy::MemWrite( &item->gpuNewContext.context, data.context ); + tracy::MemWrite( &item->gpuNewContext.flags, data.flags ); + tracy::MemWrite( &item->gpuNewContext.type, data.type ); + +#ifdef TRACY_ON_DEMAND + tracy::GetProfiler().DeferItem( *item ); +#endif + + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_context_name( const struct ___tracy_gpu_context_name_data data ) +{ + auto ptr = (char*)tracy::tracy_malloc( data.len ); + memcpy( ptr, data.name, data.len ); + + TracyLfqPrepareC( tracy::QueueType::GpuContextName ); + tracy::MemWrite( &item->gpuContextNameFat.context, data.context ); + tracy::MemWrite( &item->gpuContextNameFat.ptr, (uint64_t)ptr ); + tracy::MemWrite( &item->gpuContextNameFat.size, data.len ); + +#ifdef TRACY_ON_DEMAND + tracy::GetProfiler().DeferItem( *item ); +#endif + + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_calibration( const struct ___tracy_gpu_calibration_data data ) +{ + TracyLfqPrepareC( tracy::QueueType::GpuCalibration ); + tracy::MemWrite( &item->gpuCalibration.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuCalibration.gpuTime, data.gpuTime ); + tracy::MemWrite( &item->gpuCalibration.cpuDelta, data.cpuDelta ); + tracy::MemWrite( &item->gpuCalibration.context, data.context ); + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_time_sync( const struct ___tracy_gpu_time_sync_data data ) +{ + TracyLfqPrepareC( tracy::QueueType::GpuTimeSync ); + tracy::MemWrite( &item->gpuTimeSync.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuTimeSync.gpuTime, data.gpuTime ); + tracy::MemWrite( &item->gpuTimeSync.context, data.context ); + TracyLfqCommitC; +} + +TRACY_API void ___tracy_emit_gpu_zone_begin_serial( const struct ___tracy_gpu_zone_begin_data data ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuZoneBeginSerial ); + tracy::MemWrite( &item->gpuZoneBegin.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuZoneBegin.srcloc, data.srcloc ); + tracy::MemWrite( &item->gpuZoneBegin.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuZoneBegin.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneBegin.context, data.context ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_zone_begin_callstack_serial( const struct ___tracy_gpu_zone_begin_callstack_data data ) +{ + auto item = tracy::Profiler::QueueSerialCallstack( tracy::Callstack( data.depth ) ); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuZoneBeginCallstackSerial ); + tracy::MemWrite( &item->gpuZoneBegin.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuZoneBegin.srcloc, data.srcloc ); + tracy::MemWrite( &item->gpuZoneBegin.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuZoneBegin.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneBegin.context, data.context ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_zone_begin_alloc_serial( const struct ___tracy_gpu_zone_begin_data data ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuZoneBeginAllocSrcLocSerial ); + tracy::MemWrite( &item->gpuZoneBegin.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuZoneBegin.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuZoneBegin.srcloc, data.srcloc ); + tracy::MemWrite( &item->gpuZoneBegin.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneBegin.context, data.context ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_zone_begin_alloc_callstack_serial( const struct ___tracy_gpu_zone_begin_callstack_data data ) +{ + auto item = tracy::Profiler::QueueSerialCallstack( tracy::Callstack( data.depth ) ); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuZoneBeginAllocSrcLocCallstackSerial ); + tracy::MemWrite( &item->gpuZoneBegin.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuZoneBegin.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuZoneBegin.srcloc, data.srcloc ); + tracy::MemWrite( &item->gpuZoneBegin.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneBegin.context, data.context ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_time_serial( const struct ___tracy_gpu_time_data data ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuTime ); + tracy::MemWrite( &item->gpuTime.gpuTime, data.gpuTime ); + tracy::MemWrite( &item->gpuTime.queryId, data.queryId ); + tracy::MemWrite( &item->gpuTime.context, data.context ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_zone_end_serial( const struct ___tracy_gpu_zone_end_data data ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuZoneEndSerial ); + tracy::MemWrite( &item->gpuZoneEnd.cpuTime, tracy::Profiler::GetTime() ); + memset( &item->gpuZoneEnd.thread, 0, sizeof( item->gpuZoneEnd.thread ) ); + tracy::MemWrite( &item->gpuZoneEnd.queryId, data.queryId ); + tracy::MemWrite( &item->gpuZoneEnd.context, data.context ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_new_context_serial( ___tracy_gpu_new_context_data data ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuNewContext ); + tracy::MemWrite( &item->gpuNewContext.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuNewContext.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->gpuNewContext.gpuTime, data.gpuTime ); + tracy::MemWrite( &item->gpuNewContext.period, data.period ); + tracy::MemWrite( &item->gpuNewContext.context, data.context ); + tracy::MemWrite( &item->gpuNewContext.flags, data.flags ); + tracy::MemWrite( &item->gpuNewContext.type, data.type ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_context_name_serial( const struct ___tracy_gpu_context_name_data data ) +{ + auto ptr = (char*)tracy::tracy_malloc( data.len ); + memcpy( ptr, data.name, data.len ); + + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuContextName ); + tracy::MemWrite( &item->gpuContextNameFat.context, data.context ); + tracy::MemWrite( &item->gpuContextNameFat.ptr, (uint64_t)ptr ); + tracy::MemWrite( &item->gpuContextNameFat.size, data.len ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_calibration_serial( const struct ___tracy_gpu_calibration_data data ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuCalibration ); + tracy::MemWrite( &item->gpuCalibration.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuCalibration.gpuTime, data.gpuTime ); + tracy::MemWrite( &item->gpuCalibration.cpuDelta, data.cpuDelta ); + tracy::MemWrite( &item->gpuCalibration.context, data.context ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_emit_gpu_time_sync_serial( const struct ___tracy_gpu_time_sync_data data ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::GpuTimeSync ); + tracy::MemWrite( &item->gpuTimeSync.cpuTime, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->gpuTimeSync.gpuTime, data.gpuTime ); + tracy::MemWrite( &item->gpuTimeSync.context, data.context ); + tracy::Profiler::QueueSerialFinish(); +} + +struct __tracy_lockable_context_data +{ + uint32_t m_id; +#ifdef TRACY_ON_DEMAND + std::atomic m_lockCount; + std::atomic m_active; +#endif +}; + +TRACY_API struct __tracy_lockable_context_data* ___tracy_announce_lockable_ctx( const struct ___tracy_source_location_data* srcloc ) +{ + struct __tracy_lockable_context_data *lockdata = (__tracy_lockable_context_data*)tracy::tracy_malloc( sizeof( __tracy_lockable_context_data ) ); + lockdata->m_id =tracy:: GetLockCounter().fetch_add( 1, std::memory_order_relaxed ); +#ifdef TRACY_ON_DEMAND + new(&lockdata->m_lockCount) std::atomic( 0 ); + new(&lockdata->m_active) std::atomic( false ); +#endif + assert( lockdata->m_id != (std::numeric_limits::max)() ); + + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::LockAnnounce ); + tracy::MemWrite( &item->lockAnnounce.id, lockdata->m_id ); + tracy::MemWrite( &item->lockAnnounce.time, tracy::Profiler::GetTime() ); + tracy::MemWrite( &item->lockAnnounce.lckloc, (uint64_t)srcloc ); + tracy::MemWrite( &item->lockAnnounce.type, tracy::LockType::Lockable ); +#ifdef TRACY_ON_DEMAND + tracy::GetProfiler().DeferItem( *item ); +#endif + tracy::Profiler::QueueSerialFinish(); + + return lockdata; +} + +TRACY_API void ___tracy_terminate_lockable_ctx( struct __tracy_lockable_context_data* lockdata ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::LockTerminate ); + tracy::MemWrite( &item->lockTerminate.id, lockdata->m_id ); + tracy::MemWrite( &item->lockTerminate.time, tracy::Profiler::GetTime() ); +#ifdef TRACY_ON_DEMAND + tracy::GetProfiler().DeferItem( *item ); +#endif + tracy::Profiler::QueueSerialFinish(); + +#ifdef TRACY_ON_DEMAND + lockdata->m_lockCount.~atomic(); + lockdata->m_active.~atomic(); +#endif + tracy::tracy_free((void*)lockdata); +} + +TRACY_API int ___tracy_before_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ) +{ +#ifdef TRACY_ON_DEMAND + bool queue = false; + const auto locks = lockdata->m_lockCount.fetch_add( 1, std::memory_order_relaxed ); + const auto active = lockdata->m_active.load( std::memory_order_relaxed ); + if( locks == 0 || active ) + { + const bool connected = tracy::GetProfiler().IsConnected(); + if( active != connected ) lockdata->m_active.store( connected, std::memory_order_relaxed ); + if( connected ) queue = true; + } + if( !queue ) return false; +#endif + + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::LockWait ); + tracy::MemWrite( &item->lockWait.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->lockWait.id, lockdata->m_id ); + tracy::MemWrite( &item->lockWait.time, tracy::Profiler::GetTime() ); + tracy::Profiler::QueueSerialFinish(); + return true; +} + +TRACY_API void ___tracy_after_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ) +{ + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::LockObtain ); + tracy::MemWrite( &item->lockObtain.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->lockObtain.id, lockdata->m_id ); + tracy::MemWrite( &item->lockObtain.time, tracy::Profiler::GetTime() ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_after_unlock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ) +{ +#ifdef TRACY_ON_DEMAND + lockdata->m_lockCount.fetch_sub( 1, std::memory_order_relaxed ); + if( !lockdata->m_active.load( std::memory_order_relaxed ) ) return; + if( !tracy::GetProfiler().IsConnected() ) + { + lockdata->m_active.store( false, std::memory_order_relaxed ); + return; + } +#endif + + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::LockRelease ); + tracy::MemWrite( &item->lockRelease.id, lockdata->m_id ); + tracy::MemWrite( &item->lockRelease.time, tracy::Profiler::GetTime() ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_after_try_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata, int acquired ) +{ +#ifdef TRACY_ON_DEMAND + if( !acquired ) return; + + bool queue = false; + const auto locks = lockdata->m_lockCount.fetch_add( 1, std::memory_order_relaxed ); + const auto active = lockdata->m_active.load( std::memory_order_relaxed ); + if( locks == 0 || active ) + { + const bool connected = tracy::GetProfiler().IsConnected(); + if( active != connected ) lockdata->m_active.store( connected, std::memory_order_relaxed ); + if( connected ) queue = true; + } + if( !queue ) return; +#endif + + if( acquired ) + { + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::LockObtain ); + tracy::MemWrite( &item->lockObtain.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->lockObtain.id, lockdata->m_id ); + tracy::MemWrite( &item->lockObtain.time, tracy::Profiler::GetTime() ); + tracy::Profiler::QueueSerialFinish(); + } +} + +TRACY_API void ___tracy_mark_lockable_ctx( struct __tracy_lockable_context_data* lockdata, const struct ___tracy_source_location_data* srcloc ) +{ +#ifdef TRACY_ON_DEMAND + const auto active = lockdata->m_active.load( std::memory_order_relaxed ); + if( !active ) return; + const auto connected = tracy::GetProfiler().IsConnected(); + if( !connected ) + { + if( active ) lockdata->m_active.store( false, std::memory_order_relaxed ); + return; + } +#endif + + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::LockMark ); + tracy::MemWrite( &item->lockMark.thread, tracy::GetThreadHandle() ); + tracy::MemWrite( &item->lockMark.id, lockdata->m_id ); + tracy::MemWrite( &item->lockMark.srcloc, (uint64_t)srcloc ); + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API void ___tracy_custom_name_lockable_ctx( struct __tracy_lockable_context_data* lockdata, const char* name, size_t nameSz ) +{ + assert( nameSz < (std::numeric_limits::max)() ); + auto ptr = (char*)tracy::tracy_malloc( nameSz ); + memcpy( ptr, name, nameSz ); + auto item = tracy::Profiler::QueueSerial(); + tracy::MemWrite( &item->hdr.type, tracy::QueueType::LockName ); + tracy::MemWrite( &item->lockNameFat.id, lockdata->m_id ); + tracy::MemWrite( &item->lockNameFat.name, (uint64_t)ptr ); + tracy::MemWrite( &item->lockNameFat.size, (uint16_t)nameSz ); +#ifdef TRACY_ON_DEMAND + tracy::GetProfiler().DeferItem( *item ); +#endif + tracy::Profiler::QueueSerialFinish(); +} + +TRACY_API int ___tracy_connected( void ) +{ + return tracy::GetProfiler().IsConnected(); +} + +#ifdef TRACY_FIBERS +TRACY_API void ___tracy_fiber_enter( const char* fiber ){ tracy::Profiler::EnterFiber( fiber, 0 ); } +TRACY_API void ___tracy_fiber_leave( void ){ tracy::Profiler::LeaveFiber(); } +#endif + +# ifdef TRACY_MANUAL_LIFETIME +TRACY_API void ___tracy_startup_profiler( void ) +{ + tracy::StartupProfiler(); +} + +TRACY_API void ___tracy_shutdown_profiler( void ) +{ + tracy::ShutdownProfiler(); +} + +TRACY_API int ___tracy_profiler_started( void ) +{ + return tracy::s_isProfilerStarted.load( std::memory_order_seq_cst ); +} +# endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Dependencies/tracy/client/TracyProfiler.hpp b/Dependencies/tracy/client/TracyProfiler.hpp new file mode 100644 index 000000000..46f11f3d0 --- /dev/null +++ b/Dependencies/tracy/client/TracyProfiler.hpp @@ -0,0 +1,1010 @@ +#ifndef __TRACYPROFILER_HPP__ +#define __TRACYPROFILER_HPP__ + +#include +#include +#include +#include +#include + +#include "tracy_concurrentqueue.h" +#include "tracy_SPSCQueue.h" +#include "TracyCallstack.hpp" +#include "TracyKCore.hpp" +#include "TracySysPower.hpp" +#include "TracySysTime.hpp" +#include "TracyFastVector.hpp" +#include "../common/TracyQueue.hpp" +#include "../common/TracyAlign.hpp" +#include "../common/TracyAlloc.hpp" +#include "../common/TracyMutex.hpp" +#include "../common/TracyProtocol.hpp" + +#if defined _WIN32 +# include +#endif +#ifdef __APPLE__ +# include +# include +#endif + +#if ( (defined _WIN32 && !(defined _M_ARM64 || defined _M_ARM)) || ( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 ) || ( defined TARGET_OS_IOS && TARGET_OS_IOS == 1 ) ) +# define TRACY_HW_TIMER +#endif + +#ifdef __linux__ +# include +#endif + +#if defined TRACY_TIMER_FALLBACK || !defined TRACY_HW_TIMER +# include +#endif + +#ifndef TracyConcat +# define TracyConcat(x,y) TracyConcatIndirect(x,y) +#endif +#ifndef TracyConcatIndirect +# define TracyConcatIndirect(x,y) x##y +#endif + +namespace tracy +{ +#if defined(TRACY_DELAYED_INIT) && defined(TRACY_MANUAL_LIFETIME) +TRACY_API void StartupProfiler(); +TRACY_API void ShutdownProfiler(); +TRACY_API bool IsProfilerStarted(); +# define TracyIsStarted tracy::IsProfilerStarted() +#else +# define TracyIsStarted true +#endif + +class GpuCtx; +class Profiler; +class Socket; +class UdpBroadcast; + +struct GpuCtxWrapper +{ + GpuCtx* ptr; +}; + +TRACY_API moodycamel::ConcurrentQueue::ExplicitProducer* GetToken(); +TRACY_API Profiler& GetProfiler(); +TRACY_API std::atomic& GetLockCounter(); +TRACY_API std::atomic& GetGpuCtxCounter(); +TRACY_API GpuCtxWrapper& GetGpuCtx(); +TRACY_API uint32_t GetThreadHandle(); +TRACY_API bool ProfilerAvailable(); +TRACY_API bool ProfilerAllocatorAvailable(); +TRACY_API int64_t GetFrequencyQpc(); + +#if defined TRACY_TIMER_FALLBACK && defined TRACY_HW_TIMER && ( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 ) +TRACY_API bool HardwareSupportsInvariantTSC(); // check, if we need fallback scenario +#else +# if defined TRACY_HW_TIMER +tracy_force_inline bool HardwareSupportsInvariantTSC() +{ + return true; // this is checked at startup +} +# else +tracy_force_inline bool HardwareSupportsInvariantTSC() +{ + return false; +} +# endif +#endif + + +struct SourceLocationData +{ + const char* name; + const char* function; + const char* file; + uint32_t line; + uint32_t color; +}; + +#ifdef TRACY_ON_DEMAND +struct LuaZoneState +{ + uint32_t counter; + bool active; +}; +#endif + + +#define TracyLfqPrepare( _type ) \ + moodycamel::ConcurrentQueueDefaultTraits::index_t __magic; \ + auto __token = GetToken(); \ + auto& __tail = __token->get_tail_index(); \ + auto item = __token->enqueue_begin( __magic ); \ + MemWrite( &item->hdr.type, _type ); + +#define TracyLfqCommit \ + __tail.store( __magic + 1, std::memory_order_release ); + +#define TracyLfqPrepareC( _type ) \ + tracy::moodycamel::ConcurrentQueueDefaultTraits::index_t __magic; \ + auto __token = tracy::GetToken(); \ + auto& __tail = __token->get_tail_index(); \ + auto item = __token->enqueue_begin( __magic ); \ + tracy::MemWrite( &item->hdr.type, _type ); + +#define TracyLfqCommitC \ + __tail.store( __magic + 1, std::memory_order_release ); + + +#ifdef TRACY_FIBERS +# define TracyQueuePrepare( _type ) \ + auto item = Profiler::QueueSerial(); \ + MemWrite( &item->hdr.type, _type ); +# define TracyQueueCommit( _name ) \ + MemWrite( &item->_name.thread, GetThreadHandle() ); \ + Profiler::QueueSerialFinish(); +# define TracyQueuePrepareC( _type ) \ + auto item = tracy::Profiler::QueueSerial(); \ + tracy::MemWrite( &item->hdr.type, _type ); +# define TracyQueueCommitC( _name ) \ + tracy::MemWrite( &item->_name.thread, tracy::GetThreadHandle() ); \ + tracy::Profiler::QueueSerialFinish(); +#else +# define TracyQueuePrepare( _type ) TracyLfqPrepare( _type ) +# define TracyQueueCommit( _name ) TracyLfqCommit +# define TracyQueuePrepareC( _type ) TracyLfqPrepareC( _type ) +# define TracyQueueCommitC( _name ) TracyLfqCommitC +#endif + + +typedef void(*ParameterCallback)( void* data, uint32_t idx, int32_t val ); +typedef char*(*SourceContentsCallback)( void* data, const char* filename, size_t& size ); + +class Profiler +{ + struct FrameImageQueueItem + { + void* image; + uint32_t frame; + uint16_t w; + uint16_t h; + bool flip; + }; + + enum class SymbolQueueItemType + { + CallstackFrame, + SymbolQuery, + ExternalName, + KernelCode, + SourceCode + }; + + struct SymbolQueueItem + { + SymbolQueueItemType type; + uint64_t ptr; + uint64_t extra; + uint32_t id; + }; + +public: + Profiler(); + ~Profiler(); + + void SpawnWorkerThreads(); + + static tracy_force_inline int64_t GetTime() + { +#ifdef TRACY_HW_TIMER +# if defined TARGET_OS_IOS && TARGET_OS_IOS == 1 + if( HardwareSupportsInvariantTSC() ) return mach_absolute_time(); +# elif defined _WIN32 +# ifdef TRACY_TIMER_QPC + return GetTimeQpc(); +# else + if( HardwareSupportsInvariantTSC() ) return int64_t( __rdtsc() ); +# endif +# elif defined __i386 || defined _M_IX86 + if( HardwareSupportsInvariantTSC() ) + { + uint32_t eax, edx; + asm volatile ( "rdtsc" : "=a" (eax), "=d" (edx) ); + return ( uint64_t( edx ) << 32 ) + uint64_t( eax ); + } +# elif defined __x86_64__ || defined _M_X64 + if( HardwareSupportsInvariantTSC() ) + { + uint64_t rax, rdx; +#ifdef TRACY_PATCHABLE_NOPSLEDS + // Some external tooling (such as rr) wants to patch our rdtsc and replace it by a + // branch to control the external input seen by a program. This kind of patching is + // not generally possible depending on the surrounding code and can lead to significant + // slowdowns if the compiler generated unlucky code and rr and tracy are used together. + // To avoid this, use the rr-safe `nopl 0(%rax, %rax, 1); rdtsc` instruction sequence, + // which rr promises will be patchable independent of the surrounding code. + asm volatile ( + // This is nopl 0(%rax, %rax, 1), but assemblers are inconsistent about whether + // they emit that as a 4 or 5 byte sequence and we need to be guaranteed to use + // the 5 byte one. + ".byte 0x0f, 0x1f, 0x44, 0x00, 0x00\n\t" + "rdtsc" : "=a" (rax), "=d" (rdx) ); +#else + asm volatile ( "rdtsc" : "=a" (rax), "=d" (rdx) ); +#endif + return (int64_t)(( rdx << 32 ) + rax); + } +# else +# error "TRACY_HW_TIMER detection logic needs fixing" +# endif +#endif + +#if !defined TRACY_HW_TIMER || defined TRACY_TIMER_FALLBACK +# if defined __linux__ && defined CLOCK_MONOTONIC_RAW + struct timespec ts; + clock_gettime( CLOCK_MONOTONIC_RAW, &ts ); + return int64_t( ts.tv_sec ) * 1000000000ll + int64_t( ts.tv_nsec ); +# else + return std::chrono::duration_cast( std::chrono::high_resolution_clock::now().time_since_epoch() ).count(); +# endif +#endif + +#if !defined TRACY_TIMER_FALLBACK + return 0; // unreachable branch +#endif + } + + tracy_force_inline uint32_t GetNextZoneId() + { + return m_zoneId.fetch_add( 1, std::memory_order_relaxed ); + } + + static tracy_force_inline QueueItem* QueueSerial() + { + auto& p = GetProfiler(); + p.m_serialLock.lock(); + return p.m_serialQueue.prepare_next(); + } + + static tracy_force_inline QueueItem* QueueSerialCallstack( void* ptr ) + { + auto& p = GetProfiler(); + p.m_serialLock.lock(); + p.SendCallstackSerial( ptr ); + return p.m_serialQueue.prepare_next(); + } + + static tracy_force_inline void QueueSerialFinish() + { + auto& p = GetProfiler(); + p.m_serialQueue.commit_next(); + p.m_serialLock.unlock(); + } + + static tracy_force_inline void SendFrameMark( const char* name ) + { + if( !name ) GetProfiler().m_frameCount.fetch_add( 1, std::memory_order_relaxed ); +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + auto item = QueueSerial(); + MemWrite( &item->hdr.type, QueueType::FrameMarkMsg ); + MemWrite( &item->frameMark.time, GetTime() ); + MemWrite( &item->frameMark.name, uint64_t( name ) ); + QueueSerialFinish(); + } + + static tracy_force_inline void SendFrameMark( const char* name, QueueType type ) + { + assert( type == QueueType::FrameMarkMsgStart || type == QueueType::FrameMarkMsgEnd ); +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + auto item = QueueSerial(); + MemWrite( &item->hdr.type, type ); + MemWrite( &item->frameMark.time, GetTime() ); + MemWrite( &item->frameMark.name, uint64_t( name ) ); + QueueSerialFinish(); + } + + static tracy_force_inline void SendFrameImage( const void* image, uint16_t w, uint16_t h, uint8_t offset, bool flip ) + { +#ifndef TRACY_NO_FRAME_IMAGE + auto& profiler = GetProfiler(); + assert( profiler.m_frameCount.load( std::memory_order_relaxed ) < (std::numeric_limits::max)() ); +# ifdef TRACY_ON_DEMAND + if( !profiler.IsConnected() ) return; +# endif + const auto sz = size_t( w ) * size_t( h ) * 4; + auto ptr = (char*)tracy_malloc( sz ); + memcpy( ptr, image, sz ); + + profiler.m_fiLock.lock(); + auto fi = profiler.m_fiQueue.prepare_next(); + fi->image = ptr; + fi->frame = uint32_t( profiler.m_frameCount.load( std::memory_order_relaxed ) - offset ); + fi->w = w; + fi->h = h; + fi->flip = flip; + profiler.m_fiQueue.commit_next(); + profiler.m_fiLock.unlock(); +#else + static_cast(image); // unused + static_cast(w); // unused + static_cast(h); // unused + static_cast(offset); // unused + static_cast(flip); // unused +#endif + } + + static tracy_force_inline void PlotData( const char* name, int64_t val ) + { +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + TracyLfqPrepare( QueueType::PlotDataInt ); + MemWrite( &item->plotDataInt.name, (uint64_t)name ); + MemWrite( &item->plotDataInt.time, GetTime() ); + MemWrite( &item->plotDataInt.val, val ); + TracyLfqCommit; + } + + static tracy_force_inline void PlotData( const char* name, float val ) + { +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + TracyLfqPrepare( QueueType::PlotDataFloat ); + MemWrite( &item->plotDataFloat.name, (uint64_t)name ); + MemWrite( &item->plotDataFloat.time, GetTime() ); + MemWrite( &item->plotDataFloat.val, val ); + TracyLfqCommit; + } + + static tracy_force_inline void PlotData( const char* name, double val ) + { +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + TracyLfqPrepare( QueueType::PlotDataDouble ); + MemWrite( &item->plotDataDouble.name, (uint64_t)name ); + MemWrite( &item->plotDataDouble.time, GetTime() ); + MemWrite( &item->plotDataDouble.val, val ); + TracyLfqCommit; + } + + static tracy_force_inline void ConfigurePlot( const char* name, PlotFormatType type, bool step, bool fill, uint32_t color ) + { + TracyLfqPrepare( QueueType::PlotConfig ); + MemWrite( &item->plotConfig.name, (uint64_t)name ); + MemWrite( &item->plotConfig.type, (uint8_t)type ); + MemWrite( &item->plotConfig.step, (uint8_t)step ); + MemWrite( &item->plotConfig.fill, (uint8_t)fill ); + MemWrite( &item->plotConfig.color, color ); + +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + + TracyLfqCommit; + } + + static tracy_force_inline void Message( const char* txt, size_t size, int callstack ) + { + assert( size < (std::numeric_limits::max)() ); +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + if( callstack != 0 ) + { + tracy::GetProfiler().SendCallstack( callstack ); + } + + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, txt, size ); + + TracyQueuePrepare( callstack == 0 ? QueueType::Message : QueueType::MessageCallstack ); + MemWrite( &item->messageFat.time, GetTime() ); + MemWrite( &item->messageFat.text, (uint64_t)ptr ); + MemWrite( &item->messageFat.size, (uint16_t)size ); + TracyQueueCommit( messageFatThread ); + } + + static tracy_force_inline void Message( const char* txt, int callstack ) + { +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + if( callstack != 0 ) + { + tracy::GetProfiler().SendCallstack( callstack ); + } + + TracyQueuePrepare( callstack == 0 ? QueueType::MessageLiteral : QueueType::MessageLiteralCallstack ); + MemWrite( &item->messageLiteral.time, GetTime() ); + MemWrite( &item->messageLiteral.text, (uint64_t)txt ); + TracyQueueCommit( messageLiteralThread ); + } + + static tracy_force_inline void MessageColor( const char* txt, size_t size, uint32_t color, int callstack ) + { + assert( size < (std::numeric_limits::max)() ); +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + if( callstack != 0 ) + { + tracy::GetProfiler().SendCallstack( callstack ); + } + + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, txt, size ); + + TracyQueuePrepare( callstack == 0 ? QueueType::MessageColor : QueueType::MessageColorCallstack ); + MemWrite( &item->messageColorFat.time, GetTime() ); + MemWrite( &item->messageColorFat.text, (uint64_t)ptr ); + MemWrite( &item->messageColorFat.b, uint8_t( ( color ) & 0xFF ) ); + MemWrite( &item->messageColorFat.g, uint8_t( ( color >> 8 ) & 0xFF ) ); + MemWrite( &item->messageColorFat.r, uint8_t( ( color >> 16 ) & 0xFF ) ); + MemWrite( &item->messageColorFat.size, (uint16_t)size ); + TracyQueueCommit( messageColorFatThread ); + } + + static tracy_force_inline void MessageColor( const char* txt, uint32_t color, int callstack ) + { +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + if( callstack != 0 ) + { + tracy::GetProfiler().SendCallstack( callstack ); + } + + TracyQueuePrepare( callstack == 0 ? QueueType::MessageLiteralColor : QueueType::MessageLiteralColorCallstack ); + MemWrite( &item->messageColorLiteral.time, GetTime() ); + MemWrite( &item->messageColorLiteral.text, (uint64_t)txt ); + MemWrite( &item->messageColorLiteral.b, uint8_t( ( color ) & 0xFF ) ); + MemWrite( &item->messageColorLiteral.g, uint8_t( ( color >> 8 ) & 0xFF ) ); + MemWrite( &item->messageColorLiteral.r, uint8_t( ( color >> 16 ) & 0xFF ) ); + TracyQueueCommit( messageColorLiteralThread ); + } + + static tracy_force_inline void MessageAppInfo( const char* txt, size_t size ) + { + assert( size < (std::numeric_limits::max)() ); + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, txt, size ); + TracyLfqPrepare( QueueType::MessageAppInfo ); + MemWrite( &item->messageFat.time, GetTime() ); + MemWrite( &item->messageFat.text, (uint64_t)ptr ); + MemWrite( &item->messageFat.size, (uint16_t)size ); + +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + + TracyLfqCommit; + } + + static tracy_force_inline void MemAlloc( const void* ptr, size_t size, bool secure ) + { + if( secure && !ProfilerAvailable() ) return; +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + const auto thread = GetThreadHandle(); + + GetProfiler().m_serialLock.lock(); + SendMemAlloc( QueueType::MemAlloc, thread, ptr, size ); + GetProfiler().m_serialLock.unlock(); + } + + static tracy_force_inline void MemFree( const void* ptr, bool secure ) + { + if( secure && !ProfilerAvailable() ) return; +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + const auto thread = GetThreadHandle(); + + GetProfiler().m_serialLock.lock(); + SendMemFree( QueueType::MemFree, thread, ptr ); + GetProfiler().m_serialLock.unlock(); + } + + static tracy_force_inline void MemAllocCallstack( const void* ptr, size_t size, int depth, bool secure ) + { + if( secure && !ProfilerAvailable() ) return; +#ifdef TRACY_HAS_CALLSTACK + auto& profiler = GetProfiler(); +# ifdef TRACY_ON_DEMAND + if( !profiler.IsConnected() ) return; +# endif + const auto thread = GetThreadHandle(); + + auto callstack = Callstack( depth ); + + profiler.m_serialLock.lock(); + SendCallstackSerial( callstack ); + SendMemAlloc( QueueType::MemAllocCallstack, thread, ptr, size ); + profiler.m_serialLock.unlock(); +#else + static_cast(depth); // unused + MemAlloc( ptr, size, secure ); +#endif + } + + static tracy_force_inline void MemFreeCallstack( const void* ptr, int depth, bool secure ) + { + if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAllocatorAvailable() ) + { + MemFree( ptr, secure ); + return; + } +#ifdef TRACY_HAS_CALLSTACK + auto& profiler = GetProfiler(); +# ifdef TRACY_ON_DEMAND + if( !profiler.IsConnected() ) return; +# endif + const auto thread = GetThreadHandle(); + + auto callstack = Callstack( depth ); + + profiler.m_serialLock.lock(); + SendCallstackSerial( callstack ); + SendMemFree( QueueType::MemFreeCallstack, thread, ptr ); + profiler.m_serialLock.unlock(); +#else + static_cast(depth); // unused + MemFree( ptr, secure ); +#endif + } + + static tracy_force_inline void MemAllocNamed( const void* ptr, size_t size, bool secure, const char* name ) + { + if( secure && !ProfilerAvailable() ) return; +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + const auto thread = GetThreadHandle(); + + GetProfiler().m_serialLock.lock(); + SendMemName( name ); + SendMemAlloc( QueueType::MemAllocNamed, thread, ptr, size ); + GetProfiler().m_serialLock.unlock(); + } + + static tracy_force_inline void MemFreeNamed( const void* ptr, bool secure, const char* name ) + { + if( secure && !ProfilerAvailable() ) return; +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + const auto thread = GetThreadHandle(); + + GetProfiler().m_serialLock.lock(); + SendMemName( name ); + SendMemFree( QueueType::MemFreeNamed, thread, ptr ); + GetProfiler().m_serialLock.unlock(); + } + + static tracy_force_inline void MemAllocCallstackNamed( const void* ptr, size_t size, int depth, bool secure, const char* name ) + { + if( secure && !ProfilerAvailable() ) return; +#ifdef TRACY_HAS_CALLSTACK + auto& profiler = GetProfiler(); +# ifdef TRACY_ON_DEMAND + if( !profiler.IsConnected() ) return; +# endif + const auto thread = GetThreadHandle(); + + auto callstack = Callstack( depth ); + + profiler.m_serialLock.lock(); + SendCallstackSerial( callstack ); + SendMemName( name ); + SendMemAlloc( QueueType::MemAllocCallstackNamed, thread, ptr, size ); + profiler.m_serialLock.unlock(); +#else + static_cast(depth); // unused + MemAllocNamed( ptr, size, secure, name ); +#endif + } + + static tracy_force_inline void MemFreeCallstackNamed( const void* ptr, int depth, bool secure, const char* name ) + { + if( secure && !ProfilerAvailable() ) return; +#ifdef TRACY_HAS_CALLSTACK + auto& profiler = GetProfiler(); +# ifdef TRACY_ON_DEMAND + if( !profiler.IsConnected() ) return; +# endif + const auto thread = GetThreadHandle(); + + auto callstack = Callstack( depth ); + + profiler.m_serialLock.lock(); + SendCallstackSerial( callstack ); + SendMemName( name ); + SendMemFree( QueueType::MemFreeCallstackNamed, thread, ptr ); + profiler.m_serialLock.unlock(); +#else + static_cast(depth); // unused + MemFreeNamed( ptr, secure, name ); +#endif + } + + static tracy_force_inline void SendCallstack( int depth ) + { +#ifdef TRACY_HAS_CALLSTACK + auto ptr = Callstack( depth ); + TracyQueuePrepare( QueueType::Callstack ); + MemWrite( &item->callstackFat.ptr, (uint64_t)ptr ); + TracyQueueCommit( callstackFatThread ); +#else + static_cast(depth); // unused +#endif + } + + static tracy_force_inline void ParameterRegister( ParameterCallback cb, void* data ) + { + auto& profiler = GetProfiler(); + profiler.m_paramCallback = cb; + profiler.m_paramCallbackData = data; + } + + static tracy_force_inline void ParameterSetup( uint32_t idx, const char* name, bool isBool, int32_t val ) + { + TracyLfqPrepare( QueueType::ParamSetup ); + tracy::MemWrite( &item->paramSetup.idx, idx ); + tracy::MemWrite( &item->paramSetup.name, (uint64_t)name ); + tracy::MemWrite( &item->paramSetup.isBool, (uint8_t)isBool ); + tracy::MemWrite( &item->paramSetup.val, val ); + +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + + TracyLfqCommit; + } + + static tracy_force_inline void SourceCallbackRegister( SourceContentsCallback cb, void* data ) + { + auto& profiler = GetProfiler(); + profiler.m_sourceCallback = cb; + profiler.m_sourceCallbackData = data; + } + +#ifdef TRACY_FIBERS + static tracy_force_inline void EnterFiber( const char* fiber, int32_t groupHint ) + { + TracyQueuePrepare( QueueType::FiberEnter ); + MemWrite( &item->fiberEnter.time, GetTime() ); + MemWrite( &item->fiberEnter.fiber, (uint64_t)fiber ); + MemWrite( &item->fiberEnter.groupHint, groupHint ); + TracyQueueCommit( fiberEnter ); + } + + static tracy_force_inline void LeaveFiber() + { + TracyQueuePrepare( QueueType::FiberLeave ); + MemWrite( &item->fiberLeave.time, GetTime() ); + TracyQueueCommit( fiberLeave ); + } +#endif + + void SendCallstack( int depth, const char* skipBefore ); + static void CutCallstack( void* callstack, const char* skipBefore ); + + static bool ShouldExit(); + + tracy_force_inline bool IsConnected() const + { + return m_isConnected.load( std::memory_order_acquire ); + } + + tracy_force_inline void SetProgramName( const char* name ) + { + m_programNameLock.lock(); + m_programName = name; + m_programNameLock.unlock(); + } + +#ifdef TRACY_ON_DEMAND + tracy_force_inline uint64_t ConnectionId() const + { + return m_connectionId.load( std::memory_order_acquire ); + } + + tracy_force_inline void DeferItem( const QueueItem& item ) + { + m_deferredLock.lock(); + auto dst = m_deferredQueue.push_next(); + memcpy( dst, &item, sizeof( item ) ); + m_deferredLock.unlock(); + } +#endif + + void RequestShutdown() { m_shutdown.store( true, std::memory_order_relaxed ); m_shutdownManual.store( true, std::memory_order_relaxed ); } + bool HasShutdownFinished() const { return m_shutdownFinished.load( std::memory_order_relaxed ); } + + void SendString( uint64_t str, const char* ptr, QueueType type ) { SendString( str, ptr, strlen( ptr ), type ); } + void SendString( uint64_t str, const char* ptr, size_t len, QueueType type ); + void SendSingleString( const char* ptr ) { SendSingleString( ptr, strlen( ptr ) ); } + void SendSingleString( const char* ptr, size_t len ); + void SendSecondString( const char* ptr ) { SendSecondString( ptr, strlen( ptr ) ); } + void SendSecondString( const char* ptr, size_t len ); + + + // Allocated source location data layout: + // 2b payload size + // 4b color + // 4b source line + // fsz function name + // 1b null terminator + // ssz source file name + // 1b null terminator + // nsz zone name (optional) + + static tracy_force_inline uint64_t AllocSourceLocation( uint32_t line, const char* source, const char* function, uint32_t color = 0 ) + { + return AllocSourceLocation( line, source, function, nullptr, 0, color ); + } + + static tracy_force_inline uint64_t AllocSourceLocation( uint32_t line, const char* source, const char* function, const char* name, size_t nameSz, uint32_t color = 0 ) + { + return AllocSourceLocation( line, source, strlen(source), function, strlen(function), name, nameSz, color ); + } + + static tracy_force_inline uint64_t AllocSourceLocation( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, uint32_t color = 0 ) + { + return AllocSourceLocation( line, source, sourceSz, function, functionSz, nullptr, 0, color ); + } + + static tracy_force_inline uint64_t AllocSourceLocation( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, uint32_t color = 0 ) + { + const auto sz32 = uint32_t( 2 + 4 + 4 + functionSz + 1 + sourceSz + 1 + nameSz ); + assert( sz32 <= (std::numeric_limits::max)() ); + const auto sz = uint16_t( sz32 ); + auto ptr = (char*)tracy_malloc( sz ); + memcpy( ptr, &sz, 2 ); + memcpy( ptr + 2, &color, 4 ); + memcpy( ptr + 6, &line, 4 ); + memcpy( ptr + 10, function, functionSz ); + ptr[10 + functionSz] = '\0'; + memcpy( ptr + 10 + functionSz + 1, source, sourceSz ); + ptr[10 + functionSz + 1 + sourceSz] = '\0'; + if( nameSz != 0 ) + { + memcpy( ptr + 10 + functionSz + 1 + sourceSz + 1, name, nameSz ); + } + return uint64_t( ptr ); + } + +private: + enum class DequeueStatus { DataDequeued, ConnectionLost, QueueEmpty }; + enum class ThreadCtxStatus { Same, Changed, ConnectionLost }; + + static void LaunchWorker( void* ptr ) { ((Profiler*)ptr)->Worker(); } + void Worker(); + +#ifndef TRACY_NO_FRAME_IMAGE + static void LaunchCompressWorker( void* ptr ) { ((Profiler*)ptr)->CompressWorker(); } + void CompressWorker(); +#endif + +#ifdef TRACY_HAS_CALLSTACK + static void LaunchSymbolWorker( void* ptr ) { ((Profiler*)ptr)->SymbolWorker(); } + void SymbolWorker(); + void HandleSymbolQueueItem( const SymbolQueueItem& si ); +#endif + + void InstallCrashHandler(); + void RemoveCrashHandler(); + + void ClearQueues( tracy::moodycamel::ConsumerToken& token ); + void ClearSerial(); + DequeueStatus Dequeue( tracy::moodycamel::ConsumerToken& token ); + DequeueStatus DequeueContextSwitches( tracy::moodycamel::ConsumerToken& token, int64_t& timeStop ); + DequeueStatus DequeueSerial(); + ThreadCtxStatus ThreadCtxCheck( uint32_t threadId ); + bool CommitData(); + + tracy_force_inline bool AppendData( const void* data, size_t len ) + { + const auto ret = NeedDataSize( len ); + AppendDataUnsafe( data, len ); + return ret; + } + + tracy_force_inline bool NeedDataSize( size_t len ) + { + assert( len <= TargetFrameSize ); + bool ret = true; + if( m_bufferOffset - m_bufferStart + (int)len > TargetFrameSize ) + { + ret = CommitData(); + } + return ret; + } + + tracy_force_inline void AppendDataUnsafe( const void* data, size_t len ) + { + memcpy( m_buffer + m_bufferOffset, data, len ); + m_bufferOffset += int( len ); + } + + bool SendData( const char* data, size_t len ); + void SendLongString( uint64_t ptr, const char* str, size_t len, QueueType type ); + void SendSourceLocation( uint64_t ptr ); + void SendSourceLocationPayload( uint64_t ptr ); + void SendCallstackPayload( uint64_t ptr ); + void SendCallstackPayload64( uint64_t ptr ); + void SendCallstackAlloc( uint64_t ptr ); + + void QueueCallstackFrame( uint64_t ptr ); + void QueueSymbolQuery( uint64_t symbol ); + void QueueExternalName( uint64_t ptr ); + void QueueKernelCode( uint64_t symbol, uint32_t size ); + void QueueSourceCodeQuery( uint32_t id ); + + bool HandleServerQuery(); + void HandleDisconnect(); + void HandleParameter( uint64_t payload ); + void HandleSymbolCodeQuery( uint64_t symbol, uint32_t size ); + void HandleSourceCodeQuery( char* data, char* image, uint32_t id ); + + void AckServerQuery(); + void AckSymbolCodeNotAvailable(); + + void CalibrateTimer(); + void CalibrateDelay(); + void ReportTopology(); + + static tracy_force_inline void SendCallstackSerial( void* ptr ) + { +#ifdef TRACY_HAS_CALLSTACK + auto item = GetProfiler().m_serialQueue.prepare_next(); + MemWrite( &item->hdr.type, QueueType::CallstackSerial ); + MemWrite( &item->callstackFat.ptr, (uint64_t)ptr ); + GetProfiler().m_serialQueue.commit_next(); +#else + static_cast(ptr); // unused +#endif + } + + static tracy_force_inline void SendMemAlloc( QueueType type, const uint32_t thread, const void* ptr, size_t size ) + { + assert( type == QueueType::MemAlloc || type == QueueType::MemAllocCallstack || type == QueueType::MemAllocNamed || type == QueueType::MemAllocCallstackNamed ); + + auto item = GetProfiler().m_serialQueue.prepare_next(); + MemWrite( &item->hdr.type, type ); + MemWrite( &item->memAlloc.time, GetTime() ); + MemWrite( &item->memAlloc.thread, thread ); + MemWrite( &item->memAlloc.ptr, (uint64_t)ptr ); + if( compile_time_condition::value ) + { + memcpy( &item->memAlloc.size, &size, 4 ); + memset( &item->memAlloc.size + 4, 0, 2 ); + } + else + { + assert( sizeof( size ) == 8 ); + memcpy( &item->memAlloc.size, &size, 4 ); + memcpy( ((char*)&item->memAlloc.size)+4, ((char*)&size)+4, 2 ); + } + GetProfiler().m_serialQueue.commit_next(); + } + + static tracy_force_inline void SendMemFree( QueueType type, const uint32_t thread, const void* ptr ) + { + assert( type == QueueType::MemFree || type == QueueType::MemFreeCallstack || type == QueueType::MemFreeNamed || type == QueueType::MemFreeCallstackNamed ); + + auto item = GetProfiler().m_serialQueue.prepare_next(); + MemWrite( &item->hdr.type, type ); + MemWrite( &item->memFree.time, GetTime() ); + MemWrite( &item->memFree.thread, thread ); + MemWrite( &item->memFree.ptr, (uint64_t)ptr ); + GetProfiler().m_serialQueue.commit_next(); + } + + static tracy_force_inline void SendMemName( const char* name ) + { + assert( name ); + auto item = GetProfiler().m_serialQueue.prepare_next(); + MemWrite( &item->hdr.type, QueueType::MemNamePayload ); + MemWrite( &item->memName.name, (uint64_t)name ); + GetProfiler().m_serialQueue.commit_next(); + } + +#if defined _WIN32 && defined TRACY_TIMER_QPC + static int64_t GetTimeQpc(); +#endif + + double m_timerMul; + uint64_t m_resolution; + uint64_t m_delay; + std::atomic m_timeBegin; + uint32_t m_mainThread; + uint64_t m_epoch, m_exectime; + std::atomic m_shutdown; + std::atomic m_shutdownManual; + std::atomic m_shutdownFinished; + Socket* m_sock; + UdpBroadcast* m_broadcast; + bool m_noExit; + uint32_t m_userPort; + std::atomic m_zoneId; + int64_t m_samplingPeriod; + + uint32_t m_threadCtx; + int64_t m_refTimeThread; + int64_t m_refTimeSerial; + int64_t m_refTimeCtx; + int64_t m_refTimeGpu; + + void* m_stream; // LZ4_stream_t* + char* m_buffer; + int m_bufferOffset; + int m_bufferStart; + + char* m_lz4Buf; + + FastVector m_serialQueue, m_serialDequeue; + TracyMutex m_serialLock; + +#ifndef TRACY_NO_FRAME_IMAGE + FastVector m_fiQueue, m_fiDequeue; + TracyMutex m_fiLock; +#endif + + SPSCQueue m_symbolQueue; + + std::atomic m_frameCount; + std::atomic m_isConnected; +#ifdef TRACY_ON_DEMAND + std::atomic m_connectionId; + + TracyMutex m_deferredLock; + FastVector m_deferredQueue; +#endif + +#ifdef TRACY_HAS_SYSTIME + void ProcessSysTime(); + + SysTime m_sysTime; + uint64_t m_sysTimeLast = 0; +#else + void ProcessSysTime() {} +#endif + +#ifdef TRACY_HAS_SYSPOWER + SysPower m_sysPower; +#endif + + ParameterCallback m_paramCallback; + void* m_paramCallbackData; + SourceContentsCallback m_sourceCallback; + void* m_sourceCallbackData; + + char* m_queryImage; + char* m_queryData; + char* m_queryDataPtr; + +#if defined _WIN32 + void* m_exceptionHandler; +#endif +#ifdef __linux__ + struct { + struct sigaction pwr, ill, fpe, segv, pipe, bus, abrt; + } m_prevSignal; + KCore* m_kcore; +#endif + bool m_crashHandlerInstalled; + + const char* m_programName; + TracyMutex m_programNameLock; +}; + +} + +#endif diff --git a/Dependencies/tracy/client/TracyRingBuffer.hpp b/Dependencies/tracy/client/TracyRingBuffer.hpp new file mode 100644 index 000000000..e9100e2d8 --- /dev/null +++ b/Dependencies/tracy/client/TracyRingBuffer.hpp @@ -0,0 +1,141 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "TracyDebug.hpp" + +namespace tracy +{ + +class RingBuffer +{ +public: + RingBuffer( unsigned int size, int fd, int id, int cpu = -1 ) + : m_size( size ) + , m_id( id ) + , m_cpu( cpu ) + , m_fd( fd ) + { + const auto pageSize = uint32_t( getpagesize() ); + assert( size >= pageSize ); + assert( __builtin_popcount( size ) == 1 ); + m_mapSize = size + pageSize; + auto mapAddr = mmap( nullptr, m_mapSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 ); + if( mapAddr == MAP_FAILED ) + { + TracyDebug( "mmap failed: errno %i (%s)\n", errno, strerror( errno ) ); + m_fd = 0; + m_metadata = nullptr; + close( fd ); + return; + } + m_metadata = (perf_event_mmap_page*)mapAddr; + assert( m_metadata->data_offset == pageSize ); + m_buffer = ((char*)mapAddr) + pageSize; + m_tail = m_metadata->data_tail; + } + + ~RingBuffer() + { + if( m_metadata ) munmap( m_metadata, m_mapSize ); + if( m_fd ) close( m_fd ); + } + + RingBuffer( const RingBuffer& ) = delete; + RingBuffer& operator=( const RingBuffer& ) = delete; + + RingBuffer( RingBuffer&& other ) + { + memcpy( (char*)&other, (char*)this, sizeof( RingBuffer ) ); + m_metadata = nullptr; + m_fd = 0; + } + + RingBuffer& operator=( RingBuffer&& other ) + { + memcpy( (char*)&other, (char*)this, sizeof( RingBuffer ) ); + m_metadata = nullptr; + m_fd = 0; + return *this; + } + + bool IsValid() const { return m_metadata != nullptr; } + int GetId() const { return m_id; } + int GetCpu() const { return m_cpu; } + + void Enable() + { + ioctl( m_fd, PERF_EVENT_IOC_ENABLE, 0 ); + } + + void Read( void* dst, uint64_t offset, uint64_t cnt ) + { + const auto size = m_size; + auto src = ( m_tail + offset ) % size; + if( src + cnt <= size ) + { + memcpy( dst, m_buffer + src, cnt ); + } + else + { + const auto s0 = size - src; + const auto buf = m_buffer; + memcpy( dst, buf + src, s0 ); + memcpy( (char*)dst + s0, buf, cnt - s0 ); + } + } + + void Advance( uint64_t cnt ) + { + m_tail += cnt; + StoreTail(); + } + + bool CheckTscCaps() const + { + return m_metadata->cap_user_time_zero; + } + + int64_t ConvertTimeToTsc( int64_t timestamp ) const + { + if( !m_metadata->cap_user_time_zero ) return 0; + const auto time = timestamp - m_metadata->time_zero; + const auto quot = time / m_metadata->time_mult; + const auto rem = time % m_metadata->time_mult; + return ( quot << m_metadata->time_shift ) + ( rem << m_metadata->time_shift ) / m_metadata->time_mult; + } + + uint64_t LoadHead() const + { + return std::atomic_load_explicit( (const volatile std::atomic*)&m_metadata->data_head, std::memory_order_acquire ); + } + + uint64_t GetTail() const + { + return m_tail; + } + +private: + void StoreTail() + { + std::atomic_store_explicit( (volatile std::atomic*)&m_metadata->data_tail, m_tail, std::memory_order_release ); + } + + unsigned int m_size; + uint64_t m_tail; + char* m_buffer; + int m_id; + int m_cpu; + perf_event_mmap_page* m_metadata; + + size_t m_mapSize; + int m_fd; +}; + +} diff --git a/Dependencies/tracy/client/TracyScoped.hpp b/Dependencies/tracy/client/TracyScoped.hpp new file mode 100644 index 000000000..8e81c998f --- /dev/null +++ b/Dependencies/tracy/client/TracyScoped.hpp @@ -0,0 +1,228 @@ +#ifndef __TRACYSCOPED_HPP__ +#define __TRACYSCOPED_HPP__ + +#include +#include +#include +#include + +#include "../common/TracySystem.hpp" +#include "../common/TracyAlign.hpp" +#include "../common/TracyAlloc.hpp" +#include "TracyProfiler.hpp" + +namespace tracy +{ + +class ScopedZone +{ +public: + ScopedZone( const ScopedZone& ) = delete; + ScopedZone( ScopedZone&& ) = delete; + ScopedZone& operator=( const ScopedZone& ) = delete; + ScopedZone& operator=( ScopedZone&& ) = delete; + + tracy_force_inline ScopedZone( const SourceLocationData* srcloc, bool is_active = true ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + m_connectionId = GetProfiler().ConnectionId(); +#endif + TracyQueuePrepare( QueueType::ZoneBegin ); + MemWrite( &item->zoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc ); + TracyQueueCommit( zoneBeginThread ); + } + + tracy_force_inline ScopedZone( const SourceLocationData* srcloc, int depth, bool is_active = true ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + m_connectionId = GetProfiler().ConnectionId(); +#endif + GetProfiler().SendCallstack( depth ); + + TracyQueuePrepare( QueueType::ZoneBeginCallstack ); + MemWrite( &item->zoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc ); + TracyQueueCommit( zoneBeginThread ); + } + + tracy_force_inline ScopedZone( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, uint32_t color, bool is_active = true ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + m_connectionId = GetProfiler().ConnectionId(); +#endif + TracyQueuePrepare( QueueType::ZoneBeginAllocSrcLoc ); + const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz, color ); + MemWrite( &item->zoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, srcloc ); + TracyQueueCommit( zoneBeginThread ); + } + + tracy_force_inline ScopedZone( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, bool is_active = true ) : ScopedZone( line, source, sourceSz, function, functionSz, name, nameSz, static_cast(0), is_active ) {} + + tracy_force_inline ScopedZone( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, uint32_t color, int depth, bool is_active = true ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + m_connectionId = GetProfiler().ConnectionId(); +#endif + GetProfiler().SendCallstack( depth ); + + TracyQueuePrepare( QueueType::ZoneBeginAllocSrcLocCallstack ); + const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz, color ); + MemWrite( &item->zoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, srcloc ); + TracyQueueCommit( zoneBeginThread ); + } + + tracy_force_inline ScopedZone( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, int depth, bool is_active = true ) : ScopedZone( line, source, sourceSz, function, functionSz, name, nameSz, 0, depth, is_active ) {} + + tracy_force_inline ~ScopedZone() + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + if( GetProfiler().ConnectionId() != m_connectionId ) return; +#endif + TracyQueuePrepare( QueueType::ZoneEnd ); + MemWrite( &item->zoneEnd.time, Profiler::GetTime() ); + TracyQueueCommit( zoneEndThread ); + } + + tracy_force_inline void Text( const char* txt, size_t size ) + { + assert( size < (std::numeric_limits::max)() ); + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + if( GetProfiler().ConnectionId() != m_connectionId ) return; +#endif + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, txt, size ); + TracyQueuePrepare( QueueType::ZoneText ); + MemWrite( &item->zoneTextFat.text, (uint64_t)ptr ); + MemWrite( &item->zoneTextFat.size, (uint16_t)size ); + TracyQueueCommit( zoneTextFatThread ); + } + + void TextFmt( const char* fmt, ... ) + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + if( GetProfiler().ConnectionId() != m_connectionId ) return; +#endif + va_list args; + va_start( args, fmt ); + auto size = vsnprintf( nullptr, 0, fmt, args ); + va_end( args ); + if( size < 0 ) return; + assert( size < (std::numeric_limits::max)() ); + + char* ptr = (char*)tracy_malloc( size_t( size ) + 1 ); + va_start( args, fmt ); + vsnprintf( ptr, size_t( size ) + 1, fmt, args ); + va_end( args ); + + TracyQueuePrepare( QueueType::ZoneText ); + MemWrite( &item->zoneTextFat.text, (uint64_t)ptr ); + MemWrite( &item->zoneTextFat.size, (uint16_t)size ); + TracyQueueCommit( zoneTextFatThread ); + } + + tracy_force_inline void Name( const char* txt, size_t size ) + { + assert( size < (std::numeric_limits::max)() ); + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + if( GetProfiler().ConnectionId() != m_connectionId ) return; +#endif + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, txt, size ); + TracyQueuePrepare( QueueType::ZoneName ); + MemWrite( &item->zoneTextFat.text, (uint64_t)ptr ); + MemWrite( &item->zoneTextFat.size, (uint16_t)size ); + TracyQueueCommit( zoneTextFatThread ); + } + + void NameFmt( const char* fmt, ... ) + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + if( GetProfiler().ConnectionId() != m_connectionId ) return; +#endif + va_list args; + va_start( args, fmt ); + auto size = vsnprintf( nullptr, 0, fmt, args ); + va_end( args ); + if( size < 0 ) return; + assert( size < (std::numeric_limits::max)() ); + + char* ptr = (char*)tracy_malloc( size_t( size ) + 1 ); + va_start( args, fmt ); + vsnprintf( ptr, size_t( size ) + 1, fmt, args ); + va_end( args ); + + TracyQueuePrepare( QueueType::ZoneName ); + MemWrite( &item->zoneTextFat.text, (uint64_t)ptr ); + MemWrite( &item->zoneTextFat.size, (uint16_t)size ); + TracyQueueCommit( zoneTextFatThread ); + } + + tracy_force_inline void Color( uint32_t color ) + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + if( GetProfiler().ConnectionId() != m_connectionId ) return; +#endif + TracyQueuePrepare( QueueType::ZoneColor ); + MemWrite( &item->zoneColor.b, uint8_t( ( color ) & 0xFF ) ); + MemWrite( &item->zoneColor.g, uint8_t( ( color >> 8 ) & 0xFF ) ); + MemWrite( &item->zoneColor.r, uint8_t( ( color >> 16 ) & 0xFF ) ); + TracyQueueCommit( zoneColorThread ); + } + + tracy_force_inline void Value( uint64_t value ) + { + if( !m_active ) return; +#ifdef TRACY_ON_DEMAND + if( GetProfiler().ConnectionId() != m_connectionId ) return; +#endif + TracyQueuePrepare( QueueType::ZoneValue ); + MemWrite( &item->zoneValue.value, value ); + TracyQueueCommit( zoneValueThread ); + } + + tracy_force_inline bool IsActive() const { return m_active; } + +private: + const bool m_active; + +#ifdef TRACY_ON_DEMAND + uint64_t m_connectionId = 0; +#endif +}; + +} + +#endif diff --git a/Dependencies/tracy/client/TracyStringHelpers.hpp b/Dependencies/tracy/client/TracyStringHelpers.hpp new file mode 100644 index 000000000..977be6a3e --- /dev/null +++ b/Dependencies/tracy/client/TracyStringHelpers.hpp @@ -0,0 +1,41 @@ +#ifndef __TRACYSTRINGHELPERS_HPP__ +#define __TRACYSTRINGHELPERS_HPP__ + +#include +#include + +#include "../common/TracyAlloc.hpp" +#include "../common/TracyForceInline.hpp" + +namespace tracy +{ + +static tracy_force_inline char* CopyString( const char* src, size_t sz ) +{ + auto dst = (char*)tracy_malloc( sz + 1 ); + memcpy( dst, src, sz ); + dst[sz] = '\0'; + return dst; +} + +static tracy_force_inline char* CopyString( const char* src ) +{ + return CopyString( src, strlen( src ) ); +} + +static tracy_force_inline char* CopyStringFast( const char* src, size_t sz ) +{ + auto dst = (char*)tracy_malloc_fast( sz + 1 ); + memcpy( dst, src, sz ); + dst[sz] = '\0'; + return dst; +} + +static tracy_force_inline char* CopyStringFast( const char* src ) +{ + return CopyStringFast( src, strlen( src ) ); +} + +} + +#endif diff --git a/Dependencies/tracy/client/TracySysPower.cpp b/Dependencies/tracy/client/TracySysPower.cpp new file mode 100644 index 000000000..bd5939da2 --- /dev/null +++ b/Dependencies/tracy/client/TracySysPower.cpp @@ -0,0 +1,164 @@ +#include "TracySysPower.hpp" + +#ifdef TRACY_HAS_SYSPOWER + +#include +#include +#include +#include +#include +#include + +#include "TracyDebug.hpp" +#include "TracyProfiler.hpp" +#include "../common/TracyAlloc.hpp" + +namespace tracy +{ + +SysPower::SysPower() + : m_domains( 4 ) + , m_lastTime( 0 ) +{ + ScanDirectory( "/sys/devices/virtual/powercap/intel-rapl", -1 ); +} + +SysPower::~SysPower() +{ + for( auto& v : m_domains ) + { + fclose( v.handle ); + // Do not release v.name, as it may be still needed + } +} + +void SysPower::Tick() +{ + auto t = std::chrono::high_resolution_clock::now().time_since_epoch().count(); + if( t - m_lastTime > 10000000 ) // 10 ms + { + m_lastTime = t; + for( auto& v : m_domains ) + { + char tmp[32]; + if( fread( tmp, 1, 32, v.handle ) > 0 ) + { + rewind( v.handle ); + auto p = (uint64_t)atoll( tmp ); + uint64_t delta; + if( p >= v.value ) + { + delta = p - v.value; + } + else + { + delta = v.overflow - v.value + p; + } + v.value = p; + + TracyLfqPrepare( QueueType::SysPowerReport ); + MemWrite( &item->sysPower.time, Profiler::GetTime() ); + MemWrite( &item->sysPower.delta, delta ); + MemWrite( &item->sysPower.name, (uint64_t)v.name ); + TracyLfqCommit; + } + } + } +} + +void SysPower::ScanDirectory( const char* path, int parent ) +{ + DIR* dir = opendir( path ); + if( !dir ) return; + struct dirent* ent; + uint64_t maxRange = 0; + char* name = nullptr; + FILE* handle = nullptr; + while( ( ent = readdir( dir ) ) ) + { + if( ent->d_type == DT_REG ) + { + if( strcmp( ent->d_name, "max_energy_range_uj" ) == 0 ) + { + char tmp[PATH_MAX]; + snprintf( tmp, PATH_MAX, "%s/max_energy_range_uj", path ); + FILE* f = fopen( tmp, "r" ); + if( f ) + { + fscanf( f, "%" PRIu64, &maxRange ); + fclose( f ); + } + } + else if( strcmp( ent->d_name, "name" ) == 0 ) + { + char tmp[PATH_MAX]; + snprintf( tmp, PATH_MAX, "%s/name", path ); + FILE* f = fopen( tmp, "r" ); + if( f ) + { + char ntmp[128]; + if( fgets( ntmp, 128, f ) ) + { + // Last character is newline, skip it + const auto sz = strlen( ntmp ) - 1; + if( parent < 0 ) + { + name = (char*)tracy_malloc( sz + 1 ); + memcpy( name, ntmp, sz ); + name[sz] = '\0'; + } + else + { + const auto p = m_domains[parent]; + const auto psz = strlen( p.name ); + name = (char*)tracy_malloc( psz + sz + 2 ); + memcpy( name, p.name, psz ); + name[psz] = ':'; + memcpy( name+psz+1, ntmp, sz ); + name[psz+sz+1] = '\0'; + } + } + fclose( f ); + } + } + else if( strcmp( ent->d_name, "energy_uj" ) == 0 ) + { + char tmp[PATH_MAX]; + snprintf( tmp, PATH_MAX, "%s/energy_uj", path ); + handle = fopen( tmp, "r" ); + } + } + if( name && handle && maxRange > 0 ) break; + } + if( name && handle && maxRange > 0 ) + { + parent = (int)m_domains.size(); + Domain* domain = m_domains.push_next(); + domain->value = 0; + domain->overflow = maxRange; + domain->handle = handle; + domain->name = name; + TracyDebug( "Power domain id %i, %s found at %s\n", parent, name, path ); + } + else + { + if( name ) tracy_free( name ); + if( handle ) fclose( handle ); + } + + rewinddir( dir ); + while( ( ent = readdir( dir ) ) ) + { + if( ent->d_type == DT_DIR && strncmp( ent->d_name, "intel-rapl:", 11 ) == 0 ) + { + char tmp[PATH_MAX]; + snprintf( tmp, PATH_MAX, "%s/%s", path, ent->d_name ); + ScanDirectory( tmp, parent ); + } + } + closedir( dir ); +} + +} + +#endif diff --git a/Dependencies/tracy/client/TracySysPower.hpp b/Dependencies/tracy/client/TracySysPower.hpp new file mode 100644 index 000000000..210123bce --- /dev/null +++ b/Dependencies/tracy/client/TracySysPower.hpp @@ -0,0 +1,44 @@ +#ifndef __TRACYSYSPOWER_HPP__ +#define __TRACYSYSPOWER_HPP__ + +#if defined __linux__ +# define TRACY_HAS_SYSPOWER +#endif + +#ifdef TRACY_HAS_SYSPOWER + +#include +#include + +#include "TracyFastVector.hpp" + +namespace tracy +{ + +class SysPower +{ + struct Domain + { + uint64_t value; + uint64_t overflow; + FILE* handle; + const char* name; + }; + +public: + SysPower(); + ~SysPower(); + + void Tick(); + +private: + void ScanDirectory( const char* path, int parent ); + + FastVector m_domains; + uint64_t m_lastTime; +}; + +} +#endif + +#endif diff --git a/Dependencies/tracy/client/TracySysTime.cpp b/Dependencies/tracy/client/TracySysTime.cpp new file mode 100644 index 000000000..b690a9114 --- /dev/null +++ b/Dependencies/tracy/client/TracySysTime.cpp @@ -0,0 +1,108 @@ +#include "TracySysTime.hpp" + +#ifdef TRACY_HAS_SYSTIME + +# if defined _WIN32 +# include +# elif defined __linux__ +# include +# include +# elif defined __APPLE__ +# include +# include +# elif defined BSD +# include +# include +# endif + +namespace tracy +{ + +# if defined _WIN32 + +static inline uint64_t ConvertTime( const FILETIME& t ) +{ + return ( uint64_t( t.dwHighDateTime ) << 32 ) | uint64_t( t.dwLowDateTime ); +} + +void SysTime::ReadTimes() +{ + FILETIME idleTime; + FILETIME kernelTime; + FILETIME userTime; + + GetSystemTimes( &idleTime, &kernelTime, &userTime ); + + idle = ConvertTime( idleTime ); + const auto kernel = ConvertTime( kernelTime ); + const auto user = ConvertTime( userTime ); + used = kernel + user; +} + +# elif defined __linux__ + +void SysTime::ReadTimes() +{ + uint64_t user, nice, system; + FILE* f = fopen( "/proc/stat", "r" ); + if( f ) + { + int read = fscanf( f, "cpu %" PRIu64 " %" PRIu64 " %" PRIu64" %" PRIu64, &user, &nice, &system, &idle ); + fclose( f ); + if (read == 4) + { + used = user + nice + system; + } + } +} + +# elif defined __APPLE__ + +void SysTime::ReadTimes() +{ + host_cpu_load_info_data_t info; + mach_msg_type_number_t cnt = HOST_CPU_LOAD_INFO_COUNT; + host_statistics( mach_host_self(), HOST_CPU_LOAD_INFO, reinterpret_cast( &info ), &cnt ); + used = info.cpu_ticks[CPU_STATE_USER] + info.cpu_ticks[CPU_STATE_NICE] + info.cpu_ticks[CPU_STATE_SYSTEM]; + idle = info.cpu_ticks[CPU_STATE_IDLE]; +} + +# elif defined BSD + +void SysTime::ReadTimes() +{ + u_long data[5]; + size_t sz = sizeof( data ); + sysctlbyname( "kern.cp_time", &data, &sz, nullptr, 0 ); + used = data[0] + data[1] + data[2] + data[3]; + idle = data[4]; +} + +#endif + +SysTime::SysTime() +{ + ReadTimes(); +} + +float SysTime::Get() +{ + const auto oldUsed = used; + const auto oldIdle = idle; + + ReadTimes(); + + const auto diffIdle = idle - oldIdle; + const auto diffUsed = used - oldUsed; + +#if defined _WIN32 + return diffUsed == 0 ? -1 : ( diffUsed - diffIdle ) * 100.f / diffUsed; +#elif defined __linux__ || defined __APPLE__ || defined BSD + const auto total = diffUsed + diffIdle; + return total == 0 ? -1 : diffUsed * 100.f / total; +#endif +} + +} + +#endif diff --git a/Dependencies/tracy/client/TracySysTime.hpp b/Dependencies/tracy/client/TracySysTime.hpp new file mode 100644 index 000000000..cb5ebe736 --- /dev/null +++ b/Dependencies/tracy/client/TracySysTime.hpp @@ -0,0 +1,36 @@ +#ifndef __TRACYSYSTIME_HPP__ +#define __TRACYSYSTIME_HPP__ + +#if defined _WIN32 || defined __linux__ || defined __APPLE__ +# define TRACY_HAS_SYSTIME +#else +# include +#endif + +#ifdef BSD +# define TRACY_HAS_SYSTIME +#endif + +#ifdef TRACY_HAS_SYSTIME + +#include + +namespace tracy +{ + +class SysTime +{ +public: + SysTime(); + float Get(); + + void ReadTimes(); + +private: + uint64_t idle, used; +}; + +} +#endif + +#endif diff --git a/Dependencies/tracy/client/TracySysTrace.cpp b/Dependencies/tracy/client/TracySysTrace.cpp new file mode 100644 index 000000000..0fd1d0ac5 --- /dev/null +++ b/Dependencies/tracy/client/TracySysTrace.cpp @@ -0,0 +1,1611 @@ +#include "TracyDebug.hpp" +#include "TracyStringHelpers.hpp" +#include "TracySysTrace.hpp" +#include "../common/TracySystem.hpp" + +#ifdef TRACY_HAS_SYSTEM_TRACING + +#ifndef TRACY_SAMPLING_HZ +# if defined _WIN32 +# define TRACY_SAMPLING_HZ 8000 +# elif defined __linux__ +# define TRACY_SAMPLING_HZ 10000 +# endif +#endif + +namespace tracy +{ + +static int GetSamplingFrequency() +{ + int samplingHz = TRACY_SAMPLING_HZ; + + auto env = GetEnvVar( "TRACY_SAMPLING_HZ" ); + if( env ) + { + int val = atoi( env ); + if( val > 0 ) samplingHz = val; + } + +#if defined _WIN32 + return samplingHz > 8000 ? 8000 : ( samplingHz < 1 ? 1 : samplingHz ); +#else + return samplingHz > 1000000 ? 1000000 : ( samplingHz < 1 ? 1 : samplingHz ); +#endif +} + +static int GetSamplingPeriod() +{ + return 1000000000 / GetSamplingFrequency(); +} + +} + +# if defined _WIN32 + +# ifndef NOMINMAX +# define NOMINMAX +# endif + +# define INITGUID +# include +# include +# include +# include +# include +# include +# include +# include + +# include "../common/TracyAlloc.hpp" +# include "../common/TracySystem.hpp" +# include "TracyProfiler.hpp" +# include "TracyThread.hpp" + +namespace tracy +{ + +static const GUID PerfInfoGuid = { 0xce1dbfb4, 0x137e, 0x4da6, { 0x87, 0xb0, 0x3f, 0x59, 0xaa, 0x10, 0x2c, 0xbc } }; +static const GUID DxgKrnlGuid = { 0x802ec45a, 0x1e99, 0x4b83, { 0x99, 0x20, 0x87, 0xc9, 0x82, 0x77, 0xba, 0x9d } }; +static const GUID ThreadV2Guid = { 0x3d6fa8d1, 0xfe05, 0x11d0, { 0x9d, 0xda, 0x00, 0xc0, 0x4f, 0xd7, 0xba, 0x7c } }; + + +static TRACEHANDLE s_traceHandle; +static TRACEHANDLE s_traceHandle2; +static EVENT_TRACE_PROPERTIES* s_prop; +static DWORD s_pid; + +static EVENT_TRACE_PROPERTIES* s_propVsync; +static TRACEHANDLE s_traceHandleVsync; +static TRACEHANDLE s_traceHandleVsync2; +Thread* s_threadVsync = nullptr; + +struct CSwitch +{ + uint32_t newThreadId; + uint32_t oldThreadId; + int8_t newThreadPriority; + int8_t oldThreadPriority; + uint8_t previousCState; + int8_t spareByte; + int8_t oldThreadWaitReason; + int8_t oldThreadWaitMode; + int8_t oldThreadState; + int8_t oldThreadWaitIdealProcessor; + uint32_t newThreadWaitTime; + uint32_t reserved; +}; + +struct ReadyThread +{ + uint32_t threadId; + int8_t adjustReason; + int8_t adjustIncrement; + int8_t flag; + int8_t reserverd; +}; + +struct ThreadTrace +{ + uint32_t processId; + uint32_t threadId; + uint32_t stackBase; + uint32_t stackLimit; + uint32_t userStackBase; + uint32_t userStackLimit; + uint32_t startAddr; + uint32_t win32StartAddr; + uint32_t tebBase; + uint32_t subProcessTag; +}; + +struct StackWalkEvent +{ + uint64_t eventTimeStamp; + uint32_t stackProcess; + uint32_t stackThread; + uint64_t stack[192]; +}; + +struct VSyncInfo +{ + void* dxgAdapter; + uint32_t vidPnTargetId; + uint64_t scannedPhysicalAddress; + uint32_t vidPnSourceId; + uint32_t frameNumber; + int64_t frameQpcTime; + void* hFlipDevice; + uint32_t flipType; + uint64_t flipFenceId; +}; + +extern "C" typedef NTSTATUS (WINAPI *t_NtQueryInformationThread)( HANDLE, THREADINFOCLASS, PVOID, ULONG, PULONG ); +extern "C" typedef BOOL (WINAPI *t_EnumProcessModules)( HANDLE, HMODULE*, DWORD, LPDWORD ); +extern "C" typedef BOOL (WINAPI *t_GetModuleInformation)( HANDLE, HMODULE, LPMODULEINFO, DWORD ); +extern "C" typedef DWORD (WINAPI *t_GetModuleBaseNameA)( HANDLE, HMODULE, LPSTR, DWORD ); +extern "C" typedef HRESULT (WINAPI *t_GetThreadDescription)( HANDLE, PWSTR* ); + +t_NtQueryInformationThread NtQueryInformationThread = (t_NtQueryInformationThread)GetProcAddress( GetModuleHandleA( "ntdll.dll" ), "NtQueryInformationThread" ); +t_EnumProcessModules _EnumProcessModules = (t_EnumProcessModules)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "K32EnumProcessModules" ); +t_GetModuleInformation _GetModuleInformation = (t_GetModuleInformation)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "K32GetModuleInformation" ); +t_GetModuleBaseNameA _GetModuleBaseNameA = (t_GetModuleBaseNameA)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "K32GetModuleBaseNameA" ); + +static t_GetThreadDescription _GetThreadDescription = 0; + + +void WINAPI EventRecordCallback( PEVENT_RECORD record ) +{ +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + + const auto& hdr = record->EventHeader; + switch( hdr.ProviderId.Data1 ) + { + case 0x3d6fa8d1: // Thread Guid + if( hdr.EventDescriptor.Opcode == 36 ) + { + const auto cswitch = (const CSwitch*)record->UserData; + + TracyLfqPrepare( QueueType::ContextSwitch ); + MemWrite( &item->contextSwitch.time, hdr.TimeStamp.QuadPart ); + MemWrite( &item->contextSwitch.oldThread, cswitch->oldThreadId ); + MemWrite( &item->contextSwitch.newThread, cswitch->newThreadId ); + MemWrite( &item->contextSwitch.cpu, record->BufferContext.ProcessorNumber ); + MemWrite( &item->contextSwitch.reason, cswitch->oldThreadWaitReason ); + MemWrite( &item->contextSwitch.state, cswitch->oldThreadState ); + TracyLfqCommit; + } + else if( hdr.EventDescriptor.Opcode == 50 ) + { + const auto rt = (const ReadyThread*)record->UserData; + + TracyLfqPrepare( QueueType::ThreadWakeup ); + MemWrite( &item->threadWakeup.time, hdr.TimeStamp.QuadPart ); + MemWrite( &item->threadWakeup.thread, rt->threadId ); + TracyLfqCommit; + } + else if( hdr.EventDescriptor.Opcode == 1 || hdr.EventDescriptor.Opcode == 3 ) + { + const auto tt = (const ThreadTrace*)record->UserData; + + uint64_t tid = tt->threadId; + if( tid == 0 ) return; + uint64_t pid = tt->processId; + TracyLfqPrepare( QueueType::TidToPid ); + MemWrite( &item->tidToPid.tid, tid ); + MemWrite( &item->tidToPid.pid, pid ); + TracyLfqCommit; + } + break; + case 0xdef2fe46: // StackWalk Guid + if( hdr.EventDescriptor.Opcode == 32 ) + { + const auto sw = (const StackWalkEvent*)record->UserData; + if( sw->stackProcess == s_pid ) + { + const uint64_t sz = ( record->UserDataLength - 16 ) / 8; + if( sz > 0 ) + { + auto trace = (uint64_t*)tracy_malloc( ( 1 + sz ) * sizeof( uint64_t ) ); + memcpy( trace, &sz, sizeof( uint64_t ) ); + memcpy( trace+1, sw->stack, sizeof( uint64_t ) * sz ); + TracyLfqPrepare( QueueType::CallstackSample ); + MemWrite( &item->callstackSampleFat.time, sw->eventTimeStamp ); + MemWrite( &item->callstackSampleFat.thread, sw->stackThread ); + MemWrite( &item->callstackSampleFat.ptr, (uint64_t)trace ); + TracyLfqCommit; + } + } + } + break; + default: + break; + } +} + +void WINAPI EventRecordCallbackVsync( PEVENT_RECORD record ) +{ +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return; +#endif + + const auto& hdr = record->EventHeader; + assert( hdr.ProviderId.Data1 == 0x802EC45A ); + assert( hdr.EventDescriptor.Id == 0x0011 ); + + const auto vs = (const VSyncInfo*)record->UserData; + + TracyLfqPrepare( QueueType::FrameVsync ); + MemWrite( &item->frameVsync.time, hdr.TimeStamp.QuadPart ); + MemWrite( &item->frameVsync.id, vs->vidPnTargetId ); + TracyLfqCommit; +} + +static void SetupVsync() +{ +#if _WIN32_WINNT >= _WIN32_WINNT_WINBLUE && !defined(__MINGW32__) + const auto psz = sizeof( EVENT_TRACE_PROPERTIES ) + MAX_PATH; + s_propVsync = (EVENT_TRACE_PROPERTIES*)tracy_malloc( psz ); + memset( s_propVsync, 0, sizeof( EVENT_TRACE_PROPERTIES ) ); + s_propVsync->LogFileMode = EVENT_TRACE_REAL_TIME_MODE; + s_propVsync->Wnode.BufferSize = psz; +#ifdef TRACY_TIMER_QPC + s_propVsync->Wnode.ClientContext = 1; +#else + s_propVsync->Wnode.ClientContext = 3; +#endif + s_propVsync->LoggerNameOffset = sizeof( EVENT_TRACE_PROPERTIES ); + strcpy( ((char*)s_propVsync) + sizeof( EVENT_TRACE_PROPERTIES ), "TracyVsync" ); + + auto backup = tracy_malloc( psz ); + memcpy( backup, s_propVsync, psz ); + + const auto controlStatus = ControlTraceA( 0, "TracyVsync", s_propVsync, EVENT_TRACE_CONTROL_STOP ); + if( controlStatus != ERROR_SUCCESS && controlStatus != ERROR_WMI_INSTANCE_NOT_FOUND ) + { + tracy_free( backup ); + tracy_free( s_propVsync ); + return; + } + + memcpy( s_propVsync, backup, psz ); + tracy_free( backup ); + + const auto startStatus = StartTraceA( &s_traceHandleVsync, "TracyVsync", s_propVsync ); + if( startStatus != ERROR_SUCCESS ) + { + tracy_free( s_propVsync ); + return; + } + + EVENT_FILTER_EVENT_ID fe = {}; + fe.FilterIn = TRUE; + fe.Count = 1; + fe.Events[0] = 0x0011; // VSyncDPC_Info + + EVENT_FILTER_DESCRIPTOR desc = {}; + desc.Ptr = (ULONGLONG)&fe; + desc.Size = sizeof( fe ); + desc.Type = EVENT_FILTER_TYPE_EVENT_ID; + + ENABLE_TRACE_PARAMETERS params = {}; + params.Version = ENABLE_TRACE_PARAMETERS_VERSION_2; + params.EnableProperty = EVENT_ENABLE_PROPERTY_IGNORE_KEYWORD_0; + params.SourceId = s_propVsync->Wnode.Guid; + params.EnableFilterDesc = &desc; + params.FilterDescCount = 1; + + uint64_t mask = 0x4000000000000001; // Microsoft_Windows_DxgKrnl_Performance | Base + if( EnableTraceEx2( s_traceHandleVsync, &DxgKrnlGuid, EVENT_CONTROL_CODE_ENABLE_PROVIDER, TRACE_LEVEL_INFORMATION, mask, mask, 0, ¶ms ) != ERROR_SUCCESS ) + { + tracy_free( s_propVsync ); + return; + } + + char loggerName[MAX_PATH]; + strcpy( loggerName, "TracyVsync" ); + + EVENT_TRACE_LOGFILEA log = {}; + log.LoggerName = loggerName; + log.ProcessTraceMode = PROCESS_TRACE_MODE_REAL_TIME | PROCESS_TRACE_MODE_EVENT_RECORD | PROCESS_TRACE_MODE_RAW_TIMESTAMP; + log.EventRecordCallback = EventRecordCallbackVsync; + + s_traceHandleVsync2 = OpenTraceA( &log ); + if( s_traceHandleVsync2 == (TRACEHANDLE)INVALID_HANDLE_VALUE ) + { + CloseTrace( s_traceHandleVsync ); + tracy_free( s_propVsync ); + return; + } + + s_threadVsync = (Thread*)tracy_malloc( sizeof( Thread ) ); + new(s_threadVsync) Thread( [] (void*) { + ThreadExitHandler threadExitHandler; + SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL ); + SetThreadName( "Tracy Vsync" ); + ProcessTrace( &s_traceHandleVsync2, 1, nullptr, nullptr ); + }, nullptr ); +#endif +} + +static int GetSamplingInterval() +{ + return GetSamplingPeriod() / 100; +} + +bool SysTraceStart( int64_t& samplingPeriod ) +{ + if( !_GetThreadDescription ) _GetThreadDescription = (t_GetThreadDescription)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "GetThreadDescription" ); + + s_pid = GetCurrentProcessId(); + +#if defined _WIN64 + constexpr bool isOs64Bit = true; +#else + BOOL _iswow64; + IsWow64Process( GetCurrentProcess(), &_iswow64 ); + const bool isOs64Bit = _iswow64; +#endif + + TOKEN_PRIVILEGES priv = {}; + priv.PrivilegeCount = 1; + priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; + if( LookupPrivilegeValue( nullptr, SE_SYSTEM_PROFILE_NAME, &priv.Privileges[0].Luid ) == 0 ) return false; + + HANDLE pt; + if( OpenProcessToken( GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &pt ) == 0 ) return false; + const auto adjust = AdjustTokenPrivileges( pt, FALSE, &priv, 0, nullptr, nullptr ); + CloseHandle( pt ); + if( adjust == 0 ) return false; + const auto status = GetLastError(); + if( status != ERROR_SUCCESS ) return false; + + if( isOs64Bit ) + { + TRACE_PROFILE_INTERVAL interval = {}; + interval.Interval = GetSamplingInterval(); + const auto intervalStatus = TraceSetInformation( 0, TraceSampledProfileIntervalInfo, &interval, sizeof( interval ) ); + if( intervalStatus != ERROR_SUCCESS ) return false; + samplingPeriod = GetSamplingPeriod(); + } + + const auto psz = sizeof( EVENT_TRACE_PROPERTIES ) + sizeof( KERNEL_LOGGER_NAME ); + s_prop = (EVENT_TRACE_PROPERTIES*)tracy_malloc( psz ); + memset( s_prop, 0, sizeof( EVENT_TRACE_PROPERTIES ) ); + ULONG flags = 0; +#ifndef TRACY_NO_CONTEXT_SWITCH + flags = EVENT_TRACE_FLAG_CSWITCH | EVENT_TRACE_FLAG_DISPATCHER | EVENT_TRACE_FLAG_THREAD; +#endif +#ifndef TRACY_NO_SAMPLING + if( isOs64Bit ) flags |= EVENT_TRACE_FLAG_PROFILE; +#endif + s_prop->EnableFlags = flags; + s_prop->LogFileMode = EVENT_TRACE_REAL_TIME_MODE; + s_prop->Wnode.BufferSize = psz; + s_prop->Wnode.Flags = WNODE_FLAG_TRACED_GUID; +#ifdef TRACY_TIMER_QPC + s_prop->Wnode.ClientContext = 1; +#else + s_prop->Wnode.ClientContext = 3; +#endif + s_prop->Wnode.Guid = SystemTraceControlGuid; + s_prop->BufferSize = 1024; + s_prop->MinimumBuffers = std::thread::hardware_concurrency() * 4; + s_prop->MaximumBuffers = std::thread::hardware_concurrency() * 6; + s_prop->LoggerNameOffset = sizeof( EVENT_TRACE_PROPERTIES ); + memcpy( ((char*)s_prop) + sizeof( EVENT_TRACE_PROPERTIES ), KERNEL_LOGGER_NAME, sizeof( KERNEL_LOGGER_NAME ) ); + + auto backup = tracy_malloc( psz ); + memcpy( backup, s_prop, psz ); + + const auto controlStatus = ControlTrace( 0, KERNEL_LOGGER_NAME, s_prop, EVENT_TRACE_CONTROL_STOP ); + if( controlStatus != ERROR_SUCCESS && controlStatus != ERROR_WMI_INSTANCE_NOT_FOUND ) + { + tracy_free( backup ); + tracy_free( s_prop ); + return false; + } + + memcpy( s_prop, backup, psz ); + tracy_free( backup ); + + const auto startStatus = StartTrace( &s_traceHandle, KERNEL_LOGGER_NAME, s_prop ); + if( startStatus != ERROR_SUCCESS ) + { + tracy_free( s_prop ); + return false; + } + +#ifndef TRACY_NO_SAMPLING + if( isOs64Bit ) + { + CLASSIC_EVENT_ID stackId[2] = {}; + stackId[0].EventGuid = PerfInfoGuid; + stackId[0].Type = 46; + stackId[1].EventGuid = ThreadV2Guid; + stackId[1].Type = 36; + const auto stackStatus = TraceSetInformation( s_traceHandle, TraceStackTracingInfo, &stackId, sizeof( stackId ) ); + if( stackStatus != ERROR_SUCCESS ) + { + tracy_free( s_prop ); + return false; + } + } +#endif + +#ifdef UNICODE + WCHAR KernelLoggerName[sizeof( KERNEL_LOGGER_NAME )]; +#else + char KernelLoggerName[sizeof( KERNEL_LOGGER_NAME )]; +#endif + memcpy( KernelLoggerName, KERNEL_LOGGER_NAME, sizeof( KERNEL_LOGGER_NAME ) ); + EVENT_TRACE_LOGFILE log = {}; + log.LoggerName = KernelLoggerName; + log.ProcessTraceMode = PROCESS_TRACE_MODE_REAL_TIME | PROCESS_TRACE_MODE_EVENT_RECORD | PROCESS_TRACE_MODE_RAW_TIMESTAMP; + log.EventRecordCallback = EventRecordCallback; + + s_traceHandle2 = OpenTrace( &log ); + if( s_traceHandle2 == (TRACEHANDLE)INVALID_HANDLE_VALUE ) + { + CloseTrace( s_traceHandle ); + tracy_free( s_prop ); + return false; + } + +#ifndef TRACY_NO_VSYNC_CAPTURE + SetupVsync(); +#endif + + return true; +} + +void SysTraceStop() +{ + if( s_threadVsync ) + { + CloseTrace( s_traceHandleVsync2 ); + CloseTrace( s_traceHandleVsync ); + s_threadVsync->~Thread(); + tracy_free( s_threadVsync ); + } + + CloseTrace( s_traceHandle2 ); + CloseTrace( s_traceHandle ); +} + +void SysTraceWorker( void* ptr ) +{ + ThreadExitHandler threadExitHandler; + SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL ); + SetThreadName( "Tracy SysTrace" ); + ProcessTrace( &s_traceHandle2, 1, 0, 0 ); + ControlTrace( 0, KERNEL_LOGGER_NAME, s_prop, EVENT_TRACE_CONTROL_STOP ); + tracy_free( s_prop ); +} + +void SysTraceGetExternalName( uint64_t thread, const char*& threadName, const char*& name ) +{ + bool threadSent = false; + auto hnd = OpenThread( THREAD_QUERY_INFORMATION, FALSE, DWORD( thread ) ); + if( hnd == 0 ) + { + hnd = OpenThread( THREAD_QUERY_LIMITED_INFORMATION, FALSE, DWORD( thread ) ); + } + if( hnd != 0 ) + { + if( _GetThreadDescription ) + { + PWSTR tmp; + _GetThreadDescription( hnd, &tmp ); + char buf[256]; + if( tmp ) + { + auto ret = wcstombs( buf, tmp, 256 ); + if( ret != 0 ) + { + threadName = CopyString( buf, ret ); + threadSent = true; + } + } + } + const auto pid = GetProcessIdOfThread( hnd ); + if( !threadSent && NtQueryInformationThread && _EnumProcessModules && _GetModuleInformation && _GetModuleBaseNameA ) + { + void* ptr; + ULONG retlen; + auto status = NtQueryInformationThread( hnd, (THREADINFOCLASS)9 /*ThreadQuerySetWin32StartAddress*/, &ptr, sizeof( &ptr ), &retlen ); + if( status == 0 ) + { + const auto phnd = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid ); + if( phnd != INVALID_HANDLE_VALUE ) + { + HMODULE modules[1024]; + DWORD needed; + if( _EnumProcessModules( phnd, modules, 1024 * sizeof( HMODULE ), &needed ) != 0 ) + { + const auto sz = std::min( DWORD( needed / sizeof( HMODULE ) ), DWORD( 1024 ) ); + for( DWORD i=0; i= (uint64_t)info.lpBaseOfDll && (uint64_t)ptr <= (uint64_t)info.lpBaseOfDll + (uint64_t)info.SizeOfImage ) + { + char buf2[1024]; + const auto modlen = _GetModuleBaseNameA( phnd, modules[i], buf2, 1024 ); + if( modlen != 0 ) + { + threadName = CopyString( buf2, modlen ); + threadSent = true; + } + } + } + } + } + CloseHandle( phnd ); + } + } + } + CloseHandle( hnd ); + if( !threadSent ) + { + threadName = CopyString( "???", 3 ); + threadSent = true; + } + if( pid != 0 ) + { + { + uint64_t _pid = pid; + TracyLfqPrepare( QueueType::TidToPid ); + MemWrite( &item->tidToPid.tid, thread ); + MemWrite( &item->tidToPid.pid, _pid ); + TracyLfqCommit; + } + if( pid == 4 ) + { + name = CopyStringFast( "System", 6 ); + return; + } + else + { + const auto phnd = OpenProcess( PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid ); + if( phnd != INVALID_HANDLE_VALUE ) + { + char buf2[1024]; + const auto sz = GetProcessImageFileNameA( phnd, buf2, 1024 ); + CloseHandle( phnd ); + if( sz != 0 ) + { + auto ptr = buf2 + sz - 1; + while( ptr > buf2 && *ptr != '\\' ) ptr--; + if( *ptr == '\\' ) ptr++; + name = CopyStringFast( ptr ); + return; + } + } + } + } + } + + if( !threadSent ) + { + threadName = CopyString( "???", 3 ); + } + name = CopyStringFast( "???", 3 ); +} + +} + +# elif defined __linux__ + +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# if defined __i386 || defined __x86_64__ +# include "TracyCpuid.hpp" +# endif + +# include "TracyProfiler.hpp" +# include "TracyRingBuffer.hpp" +# include "TracyThread.hpp" + +namespace tracy +{ + +static std::atomic traceActive { false }; +static int s_numCpus = 0; +static int s_numBuffers = 0; +static int s_ctxBufferIdx = 0; + +static RingBuffer* s_ring = nullptr; + +static const int ThreadHashSize = 4 * 1024; +static uint32_t s_threadHash[ThreadHashSize] = {}; + +static bool CurrentProcOwnsThread( uint32_t tid ) +{ + const auto hash = tid & ( ThreadHashSize-1 ); + const auto hv = s_threadHash[hash]; + if( hv == tid ) return true; + if( hv == -tid ) return false; + + char path[256]; + sprintf( path, "/proc/self/task/%d", tid ); + struct stat st; + if( stat( path, &st ) == 0 ) + { + s_threadHash[hash] = tid; + return true; + } + else + { + s_threadHash[hash] = -tid; + return false; + } +} + +static int perf_event_open( struct perf_event_attr* hw_event, pid_t pid, int cpu, int group_fd, unsigned long flags ) +{ + return syscall( __NR_perf_event_open, hw_event, pid, cpu, group_fd, flags ); +} + +enum TraceEventId +{ + EventCallstack, + EventCpuCycles, + EventInstructionsRetired, + EventCacheReference, + EventCacheMiss, + EventBranchRetired, + EventBranchMiss, + EventVsync, + EventContextSwitch, + EventWakeup, +}; + +static void ProbePreciseIp( perf_event_attr& pe, unsigned long long config0, unsigned long long config1, pid_t pid ) +{ + pe.config = config1; + pe.precise_ip = 3; + while( pe.precise_ip != 0 ) + { + const int fd = perf_event_open( &pe, pid, 0, -1, PERF_FLAG_FD_CLOEXEC ); + if( fd != -1 ) + { + close( fd ); + break; + } + pe.precise_ip--; + } + pe.config = config0; + while( pe.precise_ip != 0 ) + { + const int fd = perf_event_open( &pe, pid, 0, -1, PERF_FLAG_FD_CLOEXEC ); + if( fd != -1 ) + { + close( fd ); + break; + } + pe.precise_ip--; + } + TracyDebug( " Probed precise_ip: %i\n", pe.precise_ip ); +} + +static void ProbePreciseIp( perf_event_attr& pe, pid_t pid ) +{ + pe.precise_ip = 3; + while( pe.precise_ip != 0 ) + { + const int fd = perf_event_open( &pe, pid, 0, -1, PERF_FLAG_FD_CLOEXEC ); + if( fd != -1 ) + { + close( fd ); + break; + } + pe.precise_ip--; + } + TracyDebug( " Probed precise_ip: %i\n", pe.precise_ip ); +} + +static bool IsGenuineIntel() +{ +#if defined __i386 || defined __x86_64__ + uint32_t regs[4] = {}; + __get_cpuid( 0, regs, regs+1, regs+2, regs+3 ); + char manufacturer[12]; + memcpy( manufacturer, regs+1, 4 ); + memcpy( manufacturer+4, regs+3, 4 ); + memcpy( manufacturer+8, regs+2, 4 ); + return memcmp( manufacturer, "GenuineIntel", 12 ) == 0; +#else + return false; +#endif +} + +static const char* ReadFile( const char* path ) +{ + int fd = open( path, O_RDONLY ); + if( fd < 0 ) return nullptr; + + static char tmp[64]; + const auto cnt = read( fd, tmp, 63 ); + close( fd ); + if( cnt < 0 ) return nullptr; + tmp[cnt] = '\0'; + return tmp; +} + +bool SysTraceStart( int64_t& samplingPeriod ) +{ +#ifndef CLOCK_MONOTONIC_RAW + return false; +#endif + + const auto paranoidLevelStr = ReadFile( "/proc/sys/kernel/perf_event_paranoid" ); + if( !paranoidLevelStr ) return false; +#ifdef TRACY_VERBOSE + int paranoidLevel = 2; + paranoidLevel = atoi( paranoidLevelStr ); + TracyDebug( "perf_event_paranoid: %i\n", paranoidLevel ); +#endif + + int switchId = -1, wakeupId = -1, vsyncId = -1; + const auto switchIdStr = ReadFile( "/sys/kernel/debug/tracing/events/sched/sched_switch/id" ); + if( switchIdStr ) switchId = atoi( switchIdStr ); + const auto wakeupIdStr = ReadFile( "/sys/kernel/debug/tracing/events/sched/sched_wakeup/id" ); + if( wakeupIdStr ) wakeupId = atoi( wakeupIdStr ); + const auto vsyncIdStr = ReadFile( "/sys/kernel/debug/tracing/events/drm/drm_vblank_event/id" ); + if( vsyncIdStr ) vsyncId = atoi( vsyncIdStr ); + + TracyDebug( "sched_switch id: %i\n", switchId ); + TracyDebug( "sched_wakeup id: %i\n", wakeupId ); + TracyDebug( "drm_vblank_event id: %i\n", vsyncId ); + +#ifdef TRACY_NO_SAMPLING + const bool noSoftwareSampling = true; +#else + const char* noSoftwareSamplingEnv = GetEnvVar( "TRACY_NO_SAMPLING" ); + const bool noSoftwareSampling = noSoftwareSamplingEnv && noSoftwareSamplingEnv[0] == '1'; +#endif + +#ifdef TRACY_NO_SAMPLE_RETIREMENT + const bool noRetirement = true; +#else + const char* noRetirementEnv = GetEnvVar( "TRACY_NO_SAMPLE_RETIREMENT" ); + const bool noRetirement = noRetirementEnv && noRetirementEnv[0] == '1'; +#endif + +#ifdef TRACY_NO_SAMPLE_CACHE + const bool noCache = true; +#else + const char* noCacheEnv = GetEnvVar( "TRACY_NO_SAMPLE_CACHE" ); + const bool noCache = noCacheEnv && noCacheEnv[0] == '1'; +#endif + +#ifdef TRACY_NO_SAMPLE_BRANCH + const bool noBranch = true; +#else + const char* noBranchEnv = GetEnvVar( "TRACY_NO_SAMPLE_BRANCH" ); + const bool noBranch = noBranchEnv && noBranchEnv[0] == '1'; +#endif + +#ifdef TRACY_NO_CONTEXT_SWITCH + const bool noCtxSwitch = true; +#else + const char* noCtxSwitchEnv = GetEnvVar( "TRACY_NO_CONTEXT_SWITCH" ); + const bool noCtxSwitch = noCtxSwitchEnv && noCtxSwitchEnv[0] == '1'; +#endif + +#ifdef TRACY_NO_VSYNC_CAPTURE + const bool noVsync = true; +#else + const char* noVsyncEnv = GetEnvVar( "TRACY_NO_VSYNC_CAPTURE" ); + const bool noVsync = noVsyncEnv && noVsyncEnv[0] == '1'; +#endif + + samplingPeriod = GetSamplingPeriod(); + uint32_t currentPid = (uint32_t)getpid(); + + s_numCpus = (int)std::thread::hardware_concurrency(); + + const auto maxNumBuffers = s_numCpus * ( + 1 + // software sampling + 2 + // CPU cycles + instructions retired + 2 + // cache reference + miss + 2 + // branch retired + miss + 2 + // context switches + wakeups + 1 // vsync + ); + s_ring = (RingBuffer*)tracy_malloc( sizeof( RingBuffer ) * maxNumBuffers ); + s_numBuffers = 0; + + // software sampling + perf_event_attr pe = {}; + pe.type = PERF_TYPE_SOFTWARE; + pe.size = sizeof( perf_event_attr ); + pe.config = PERF_COUNT_SW_CPU_CLOCK; + pe.sample_freq = GetSamplingFrequency(); + pe.sample_type = PERF_SAMPLE_TID | PERF_SAMPLE_TIME | PERF_SAMPLE_CALLCHAIN; +#if LINUX_VERSION_CODE >= KERNEL_VERSION( 4, 8, 0 ) + pe.sample_max_stack = 127; +#endif + pe.disabled = 1; + pe.freq = 1; + pe.inherit = 1; +#if !defined TRACY_HW_TIMER || !( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 ) + pe.use_clockid = 1; + pe.clockid = CLOCK_MONOTONIC_RAW; +#endif + + if( !noSoftwareSampling ) + { + TracyDebug( "Setup software sampling\n" ); + ProbePreciseIp( pe, currentPid ); + for( int i=0; i= KERNEL_VERSION( 4, 8, 0 ) + pe.sample_max_stack = 127; +#endif + pe.disabled = 1; + pe.inherit = 1; + pe.config = switchId; +#if !defined TRACY_HW_TIMER || !( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 ) + pe.use_clockid = 1; + pe.clockid = CLOCK_MONOTONIC_RAW; +#endif + + TracyDebug( "Setup context switch capture\n" ); + for( int i=0; i> 63; + const auto m2 = test >> 47; + if( m1 == m2 ) break; + } + while( --cnt > 0 ); + for( uint64_t j=1; j> 63; + const auto m2 = test >> 47; + if( m1 != m2 ) trace[j] = 0; + } +#endif + + for( uint64_t j=1; j<=cnt; j++ ) + { + if( trace[j] >= (uint64_t)-4095 ) // PERF_CONTEXT_MAX + { + memmove( trace+j, trace+j+1, sizeof( uint64_t ) * ( cnt - j ) ); + cnt--; + } + } + + memcpy( trace, &cnt, sizeof( uint64_t ) ); + return trace; +} + +void SysTraceWorker( void* ptr ) +{ + ThreadExitHandler threadExitHandler; + SetThreadName( "Tracy Sampling" ); + InitRpmalloc(); + sched_param sp = { 99 }; + if( pthread_setschedparam( pthread_self(), SCHED_FIFO, &sp ) != 0 ) TracyDebug( "Failed to increase SysTraceWorker thread priority!\n" ); + auto ctxBufferIdx = s_ctxBufferIdx; + auto ringArray = s_ring; + auto numBuffers = s_numBuffers; + for( int i=0; i tail ); + hadData = true; + + const auto id = ring.GetId(); + assert( id != EventContextSwitch ); + const auto end = head - tail; + uint64_t pos = 0; + if( id == EventCallstack ) + { + while( pos < end ) + { + perf_event_header hdr; + ring.Read( &hdr, pos, sizeof( perf_event_header ) ); + if( hdr.type == PERF_RECORD_SAMPLE ) + { + auto offset = pos + sizeof( perf_event_header ); + + // Layout: + // u32 pid, tid + // u64 time + // u64 cnt + // u64 ip[cnt] + + uint32_t tid; + uint64_t t0; + uint64_t cnt; + + offset += sizeof( uint32_t ); + ring.Read( &tid, offset, sizeof( uint32_t ) ); + offset += sizeof( uint32_t ); + ring.Read( &t0, offset, sizeof( uint64_t ) ); + offset += sizeof( uint64_t ); + ring.Read( &cnt, offset, sizeof( uint64_t ) ); + offset += sizeof( uint64_t ); + + if( cnt > 0 ) + { +#if defined TRACY_HW_TIMER && ( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 ) + t0 = ring.ConvertTimeToTsc( t0 ); +#endif + auto trace = GetCallstackBlock( cnt, ring, offset ); + + TracyLfqPrepare( QueueType::CallstackSample ); + MemWrite( &item->callstackSampleFat.time, t0 ); + MemWrite( &item->callstackSampleFat.thread, tid ); + MemWrite( &item->callstackSampleFat.ptr, (uint64_t)trace ); + TracyLfqCommit; + } + } + pos += hdr.size; + } + } + else + { + while( pos < end ) + { + perf_event_header hdr; + ring.Read( &hdr, pos, sizeof( perf_event_header ) ); + if( hdr.type == PERF_RECORD_SAMPLE ) + { + auto offset = pos + sizeof( perf_event_header ); + + // Layout: + // u64 ip + // u64 time + + uint64_t ip, t0; + ring.Read( &ip, offset, sizeof( uint64_t ) ); + offset += sizeof( uint64_t ); + ring.Read( &t0, offset, sizeof( uint64_t ) ); + +#if defined TRACY_HW_TIMER && ( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 ) + t0 = ring.ConvertTimeToTsc( t0 ); +#endif + QueueType type; + switch( id ) + { + case EventCpuCycles: + type = QueueType::HwSampleCpuCycle; + break; + case EventInstructionsRetired: + type = QueueType::HwSampleInstructionRetired; + break; + case EventCacheReference: + type = QueueType::HwSampleCacheReference; + break; + case EventCacheMiss: + type = QueueType::HwSampleCacheMiss; + break; + case EventBranchRetired: + type = QueueType::HwSampleBranchRetired; + break; + case EventBranchMiss: + type = QueueType::HwSampleBranchMiss; + break; + default: + abort(); + } + + TracyLfqPrepare( type ); + MemWrite( &item->hwSample.ip, ip ); + MemWrite( &item->hwSample.time, t0 ); + TracyLfqCommit; + } + pos += hdr.size; + } + } + assert( pos == end ); + ring.Advance( end ); + } + if( !traceActive.load( std::memory_order_relaxed ) ) break; + + if( ctxBufferIdx != numBuffers ) + { + const auto ctxBufNum = numBuffers - ctxBufferIdx; + + int activeNum = 0; + uint16_t active[512]; + uint32_t end[512]; + uint32_t pos[512]; + for( int i=0; i 0 ) + { + hadData = true; + while( activeNum > 0 ) + { + int sel = -1; + int selPos; + int64_t t0 = std::numeric_limits::max(); + for( int i=0; i= 0 ) + { + auto& ring = ringArray[ctxBufferIdx + sel]; + auto rbPos = pos[sel]; + auto offset = rbPos; + perf_event_header hdr; + ring.Read( &hdr, offset, sizeof( perf_event_header ) ); + +#if defined TRACY_HW_TIMER && ( defined __i386 || defined _M_IX86 || defined __x86_64__ || defined _M_X64 ) + t0 = ring.ConvertTimeToTsc( t0 ); +#endif + + const auto rid = ring.GetId(); + if( rid == EventContextSwitch ) + { + // Layout: + // u64 time + // u64 cnt + // u64 ip[cnt] + // u32 size + // u8 data[size] + // Data (not ABI stable, but has not changed since it was added, in 2009): + // u8 hdr[8] + // u8 prev_comm[16] + // u32 prev_pid + // u32 prev_prio + // lng prev_state + // u8 next_comm[16] + // u32 next_pid + // u32 next_prio + + offset += sizeof( perf_event_header ) + sizeof( uint64_t ); + + uint64_t cnt; + ring.Read( &cnt, offset, sizeof( uint64_t ) ); + offset += sizeof( uint64_t ); + const auto traceOffset = offset; + offset += sizeof( uint64_t ) * cnt + sizeof( uint32_t ) + 8 + 16; + + uint32_t prev_pid, next_pid; + long prev_state; + + ring.Read( &prev_pid, offset, sizeof( uint32_t ) ); + offset += sizeof( uint32_t ) + sizeof( uint32_t ); + ring.Read( &prev_state, offset, sizeof( long ) ); + offset += sizeof( long ) + 16; + ring.Read( &next_pid, offset, sizeof( uint32_t ) ); + + uint8_t reason = 100; + uint8_t state; + + if( prev_state & 0x0001 ) state = 104; + else if( prev_state & 0x0002 ) state = 101; + else if( prev_state & 0x0004 ) state = 105; + else if( prev_state & 0x0008 ) state = 106; + else if( prev_state & 0x0010 ) state = 108; + else if( prev_state & 0x0020 ) state = 109; + else if( prev_state & 0x0040 ) state = 110; + else if( prev_state & 0x0080 ) state = 102; + else state = 103; + + TracyLfqPrepare( QueueType::ContextSwitch ); + MemWrite( &item->contextSwitch.time, t0 ); + MemWrite( &item->contextSwitch.oldThread, prev_pid ); + MemWrite( &item->contextSwitch.newThread, next_pid ); + MemWrite( &item->contextSwitch.cpu, uint8_t( ring.GetCpu() ) ); + MemWrite( &item->contextSwitch.reason, reason ); + MemWrite( &item->contextSwitch.state, state ); + TracyLfqCommit; + + if( cnt > 0 && prev_pid != 0 && CurrentProcOwnsThread( prev_pid ) ) + { + auto trace = GetCallstackBlock( cnt, ring, traceOffset ); + + TracyLfqPrepare( QueueType::CallstackSampleContextSwitch ); + MemWrite( &item->callstackSampleFat.time, t0 ); + MemWrite( &item->callstackSampleFat.thread, prev_pid ); + MemWrite( &item->callstackSampleFat.ptr, (uint64_t)trace ); + TracyLfqCommit; + } + } + else if( rid == EventWakeup ) + { + // Layout: + // u64 time + // u32 size + // u8 data[size] + // Data: + // u8 hdr[8] + // u8 comm[16] + // u32 pid + // u32 prio + // u64 target_cpu + + offset += sizeof( perf_event_header ) + sizeof( uint64_t ) + sizeof( uint32_t ) + 8 + 16; + + uint32_t pid; + ring.Read( &pid, offset, sizeof( uint32_t ) ); + + TracyLfqPrepare( QueueType::ThreadWakeup ); + MemWrite( &item->threadWakeup.time, t0 ); + MemWrite( &item->threadWakeup.thread, pid ); + TracyLfqCommit; + } + else + { + assert( rid == EventVsync ); + // Layout: + // u64 time + // u32 size + // u8 data[size] + // Data (not ABI stable): + // u8 hdr[8] + // i32 crtc + // u32 seq + // i64 ktime + // u8 high precision + + offset += sizeof( perf_event_header ) + sizeof( uint64_t ) + sizeof( uint32_t ) + 8; + + int32_t crtc; + ring.Read( &crtc, offset, sizeof( int32_t ) ); + + // Note: The timestamp value t0 might be off by a number of microseconds from the + // true hardware vblank event. The ktime value should be used instead, but it is + // measured in CLOCK_MONOTONIC time. Tracy only supports the timestamp counter + // register (TSC) or CLOCK_MONOTONIC_RAW clock. +#if 0 + offset += sizeof( uint32_t ) * 2; + int64_t ktime; + ring.Read( &ktime, offset, sizeof( int64_t ) ); +#endif + + TracyLfqPrepare( QueueType::FrameVsync ); + MemWrite( &item->frameVsync.id, crtc ); + MemWrite( &item->frameVsync.time, t0 ); + TracyLfqCommit; + } + + rbPos += hdr.size; + if( rbPos == end[sel] ) + { + memmove( active+selPos, active+selPos+1, sizeof(*active) * ( activeNum - selPos - 1 ) ); + activeNum--; + } + else + { + pos[sel] = rbPos; + } + } + } + for( int i=0; i 0 && buf[sz-1] == '\n' ) buf[sz-1] = '\0'; + threadName = CopyString( buf ); + fclose( f ); + } + else + { + threadName = CopyString( "???", 3 ); + } + + sprintf( fn, "/proc/%" PRIu64 "/status", thread ); + f = fopen( fn, "rb" ); + if( f ) + { + char* tmp = (char*)tracy_malloc_fast( 8*1024 ); + const auto fsz = (ptrdiff_t)fread( tmp, 1, 8*1024, f ); + fclose( f ); + + int pid = -1; + auto line = tmp; + for(;;) + { + if( memcmp( "Tgid:\t", line, 6 ) == 0 ) + { + pid = atoi( line + 6 ); + break; + } + while( line - tmp < fsz && *line != '\n' ) line++; + if( *line != '\n' ) break; + line++; + } + tracy_free_fast( tmp ); + + if( pid >= 0 ) + { + { + uint64_t _pid = pid; + TracyLfqPrepare( QueueType::TidToPid ); + MemWrite( &item->tidToPid.tid, thread ); + MemWrite( &item->tidToPid.pid, _pid ); + TracyLfqCommit; + } + sprintf( fn, "/proc/%i/comm", pid ); + f = fopen( fn, "rb" ); + if( f ) + { + char buf[256]; + const auto sz = fread( buf, 1, 256, f ); + if( sz > 0 && buf[sz-1] == '\n' ) buf[sz-1] = '\0'; + name = CopyStringFast( buf ); + fclose( f ); + return; + } + } + } + name = CopyStringFast( "???", 3 ); +} + +} + +# endif + +#endif diff --git a/Dependencies/tracy/client/TracySysTrace.hpp b/Dependencies/tracy/client/TracySysTrace.hpp new file mode 100644 index 000000000..8c663cd7a --- /dev/null +++ b/Dependencies/tracy/client/TracySysTrace.hpp @@ -0,0 +1,28 @@ +#ifndef __TRACYSYSTRACE_HPP__ +#define __TRACYSYSTRACE_HPP__ + +#if !defined TRACY_NO_SYSTEM_TRACING && ( defined _WIN32 || defined __linux__ ) +# include "../common/TracyUwp.hpp" +# ifndef TRACY_UWP +# define TRACY_HAS_SYSTEM_TRACING +# endif +#endif + +#ifdef TRACY_HAS_SYSTEM_TRACING + +#include + +namespace tracy +{ + +bool SysTraceStart( int64_t& samplingPeriod ); +void SysTraceStop(); +void SysTraceWorker( void* ptr ); + +void SysTraceGetExternalName( uint64_t thread, const char*& threadName, const char*& name ); + +} + +#endif + +#endif diff --git a/Dependencies/tracy/client/TracyThread.hpp b/Dependencies/tracy/client/TracyThread.hpp new file mode 100644 index 000000000..5638756ac --- /dev/null +++ b/Dependencies/tracy/client/TracyThread.hpp @@ -0,0 +1,90 @@ +#ifndef __TRACYTHREAD_HPP__ +#define __TRACYTHREAD_HPP__ + +#if defined _WIN32 +# include +#else +# include +#endif + +#ifdef TRACY_MANUAL_LIFETIME +# include "tracy_rpmalloc.hpp" +#endif + +namespace tracy +{ + +#ifdef TRACY_MANUAL_LIFETIME +extern thread_local bool RpThreadInitDone; +#endif + +class ThreadExitHandler +{ +public: + ~ThreadExitHandler() + { +#ifdef TRACY_MANUAL_LIFETIME + rpmalloc_thread_finalize( 1 ); + RpThreadInitDone = false; +#endif + } +}; + +#if defined _WIN32 + +class Thread +{ +public: + Thread( void(*func)( void* ptr ), void* ptr ) + : m_func( func ) + , m_ptr( ptr ) + , m_hnd( CreateThread( nullptr, 0, Launch, this, 0, nullptr ) ) + {} + + ~Thread() + { + WaitForSingleObject( m_hnd, INFINITE ); + CloseHandle( m_hnd ); + } + + HANDLE Handle() const { return m_hnd; } + +private: + static DWORD WINAPI Launch( void* ptr ) { ((Thread*)ptr)->m_func( ((Thread*)ptr)->m_ptr ); return 0; } + + void(*m_func)( void* ptr ); + void* m_ptr; + HANDLE m_hnd; +}; + +#else + +class Thread +{ +public: + Thread( void(*func)( void* ptr ), void* ptr ) + : m_func( func ) + , m_ptr( ptr ) + { + pthread_create( &m_thread, nullptr, Launch, this ); + } + + ~Thread() + { + pthread_join( m_thread, nullptr ); + } + + pthread_t Handle() const { return m_thread; } + +private: + static void* Launch( void* ptr ) { ((Thread*)ptr)->m_func( ((Thread*)ptr)->m_ptr ); return nullptr; } + void(*m_func)( void* ptr ); + void* m_ptr; + pthread_t m_thread; +}; + +#endif + +} + +#endif diff --git a/Dependencies/tracy/client/tracy_SPSCQueue.h b/Dependencies/tracy/client/tracy_SPSCQueue.h new file mode 100644 index 000000000..7f1752b56 --- /dev/null +++ b/Dependencies/tracy/client/tracy_SPSCQueue.h @@ -0,0 +1,148 @@ +/* +Copyright (c) 2020 Erik Rigtorp + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + */ + +#pragma once + +#include +#include +#include +#include +#include // std::enable_if, std::is_*_constructible + +#include "../common/TracyAlloc.hpp" + +#if defined (_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4324) +#endif + +namespace tracy { + +template class SPSCQueue { +public: + explicit SPSCQueue(const size_t capacity) + : capacity_(capacity) { + capacity_++; // Needs one slack element + slots_ = (T*)tracy_malloc(sizeof(T) * (capacity_ + 2 * kPadding)); + + static_assert(alignof(SPSCQueue) == kCacheLineSize, ""); + static_assert(sizeof(SPSCQueue) >= 3 * kCacheLineSize, ""); + assert(reinterpret_cast(&readIdx_) - + reinterpret_cast(&writeIdx_) >= + static_cast(kCacheLineSize)); + } + + ~SPSCQueue() { + while (front()) { + pop(); + } + tracy_free(slots_); + } + + // non-copyable and non-movable + SPSCQueue(const SPSCQueue &) = delete; + SPSCQueue &operator=(const SPSCQueue &) = delete; + + template + void emplace(Args &&...args) noexcept( + std::is_nothrow_constructible::value) { + static_assert(std::is_constructible::value, + "T must be constructible with Args&&..."); + auto const writeIdx = writeIdx_.load(std::memory_order_relaxed); + auto nextWriteIdx = writeIdx + 1; + if (nextWriteIdx == capacity_) { + nextWriteIdx = 0; + } + while (nextWriteIdx == readIdxCache_) { + readIdxCache_ = readIdx_.load(std::memory_order_acquire); + } + new (&slots_[writeIdx + kPadding]) T(std::forward(args)...); + writeIdx_.store(nextWriteIdx, std::memory_order_release); + } + + T *front() noexcept { + auto const readIdx = readIdx_.load(std::memory_order_relaxed); + if (readIdx == writeIdxCache_) { + writeIdxCache_ = writeIdx_.load(std::memory_order_acquire); + if (writeIdxCache_ == readIdx) { + return nullptr; + } + } + return &slots_[readIdx + kPadding]; + } + + void pop() noexcept { + static_assert(std::is_nothrow_destructible::value, + "T must be nothrow destructible"); + auto const readIdx = readIdx_.load(std::memory_order_relaxed); + assert(writeIdx_.load(std::memory_order_acquire) != readIdx); + slots_[readIdx + kPadding].~T(); + auto nextReadIdx = readIdx + 1; + if (nextReadIdx == capacity_) { + nextReadIdx = 0; + } + readIdx_.store(nextReadIdx, std::memory_order_release); + } + + size_t size() const noexcept { + std::ptrdiff_t diff = writeIdx_.load(std::memory_order_acquire) - + readIdx_.load(std::memory_order_acquire); + if (diff < 0) { + diff += capacity_; + } + return static_cast(diff); + } + + bool empty() const noexcept { + return writeIdx_.load(std::memory_order_acquire) == + readIdx_.load(std::memory_order_acquire); + } + + size_t capacity() const noexcept { return capacity_ - 1; } + +private: + static constexpr size_t kCacheLineSize = 64; + + // Padding to avoid false sharing between slots_ and adjacent allocations + static constexpr size_t kPadding = (kCacheLineSize - 1) / sizeof(T) + 1; + +private: + size_t capacity_; + T *slots_; + + // Align to cache line size in order to avoid false sharing + // readIdxCache_ and writeIdxCache_ is used to reduce the amount of cache + // coherency traffic + alignas(kCacheLineSize) std::atomic writeIdx_ = {0}; + alignas(kCacheLineSize) size_t readIdxCache_ = 0; + alignas(kCacheLineSize) std::atomic readIdx_ = {0}; + alignas(kCacheLineSize) size_t writeIdxCache_ = 0; + + // Padding to avoid adjacent allocations to share cache line with + // writeIdxCache_ + char padding_[kCacheLineSize - sizeof(SPSCQueue::writeIdxCache_)]; +}; +} // namespace rigtorp + +#if defined (_MSC_VER) +#pragma warning(pop) +#endif diff --git a/Dependencies/tracy/client/tracy_concurrentqueue.h b/Dependencies/tracy/client/tracy_concurrentqueue.h new file mode 100644 index 000000000..4178d39ea --- /dev/null +++ b/Dependencies/tracy/client/tracy_concurrentqueue.h @@ -0,0 +1,1441 @@ +// Provides a C++11 implementation of a multi-producer, multi-consumer lock-free queue. +// An overview, including benchmark results, is provided here: +// http://moodycamel.com/blog/2014/a-fast-general-purpose-lock-free-queue-for-c++ +// The full design is also described in excruciating detail at: +// http://moodycamel.com/blog/2014/detailed-design-of-a-lock-free-queue + +// Simplified BSD license: +// Copyright (c) 2013-2016, Cameron Desrochers. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, this list of +// conditions and the following disclaimer. +// - Redistributions in binary form must reproduce the above copyright notice, this list of +// conditions and the following disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY +// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL +// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT +// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +// TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +#pragma once + +#include "../common/TracyAlloc.hpp" +#include "../common/TracyForceInline.hpp" +#include "../common/TracySystem.hpp" + +#if defined(__GNUC__) +// Disable -Wconversion warnings (spuriously triggered when Traits::size_t and +// Traits::index_t are set to < 32 bits, causing integer promotion, causing warnings +// upon assigning any computed values) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + +#if defined(__APPLE__) +#include "TargetConditionals.h" +#endif + +#include // Requires C++11. Sorry VS2010. +#include +#include // for max_align_t +#include +#include +#include +#include +#include +#include +#include // for CHAR_BIT +#include +#include // partly for __WINPTHREADS_VERSION if on MinGW-w64 w/ POSIX threading + +namespace tracy +{ + +// Compiler-specific likely/unlikely hints +namespace moodycamel { namespace details { +#if defined(__GNUC__) + inline bool cqLikely(bool x) { return __builtin_expect((x), true); } + inline bool cqUnlikely(bool x) { return __builtin_expect((x), false); } +#else + inline bool cqLikely(bool x) { return x; } + inline bool cqUnlikely(bool x) { return x; } +#endif +} } + +namespace +{ + // to avoid MSVC warning 4127: conditional expression is constant + template + struct compile_time_condition + { + static const bool value = false; + }; + template <> + struct compile_time_condition + { + static const bool value = true; + }; +} + +namespace moodycamel { +namespace details { + template + struct const_numeric_max { + static_assert(std::is_integral::value, "const_numeric_max can only be used with integers"); + static const T value = std::numeric_limits::is_signed + ? (static_cast(1) << (sizeof(T) * CHAR_BIT - 1)) - static_cast(1) + : static_cast(-1); + }; + +#if defined(__GLIBCXX__) + typedef ::max_align_t std_max_align_t; // libstdc++ forgot to add it to std:: for a while +#else + typedef std::max_align_t std_max_align_t; // Others (e.g. MSVC) insist it can *only* be accessed via std:: +#endif + + // Some platforms have incorrectly set max_align_t to a type with <8 bytes alignment even while supporting + // 8-byte aligned scalar values (*cough* 32-bit iOS). Work around this with our own union. See issue #64. + typedef union { + std_max_align_t x; + long long y; + void* z; + } max_align_t; +} + +// Default traits for the ConcurrentQueue. To change some of the +// traits without re-implementing all of them, inherit from this +// struct and shadow the declarations you wish to be different; +// since the traits are used as a template type parameter, the +// shadowed declarations will be used where defined, and the defaults +// otherwise. +struct ConcurrentQueueDefaultTraits +{ + // General-purpose size type. std::size_t is strongly recommended. + typedef std::size_t size_t; + + // The type used for the enqueue and dequeue indices. Must be at least as + // large as size_t. Should be significantly larger than the number of elements + // you expect to hold at once, especially if you have a high turnover rate; + // for example, on 32-bit x86, if you expect to have over a hundred million + // elements or pump several million elements through your queue in a very + // short space of time, using a 32-bit type *may* trigger a race condition. + // A 64-bit int type is recommended in that case, and in practice will + // prevent a race condition no matter the usage of the queue. Note that + // whether the queue is lock-free with a 64-int type depends on the whether + // std::atomic is lock-free, which is platform-specific. + typedef std::size_t index_t; + + // Internally, all elements are enqueued and dequeued from multi-element + // blocks; this is the smallest controllable unit. If you expect few elements + // but many producers, a smaller block size should be favoured. For few producers + // and/or many elements, a larger block size is preferred. A sane default + // is provided. Must be a power of 2. + static const size_t BLOCK_SIZE = 64*1024; + + // For explicit producers (i.e. when using a producer token), the block is + // checked for being empty by iterating through a list of flags, one per element. + // For large block sizes, this is too inefficient, and switching to an atomic + // counter-based approach is faster. The switch is made for block sizes strictly + // larger than this threshold. + static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = 32; + + // How many full blocks can be expected for a single explicit producer? This should + // reflect that number's maximum for optimal performance. Must be a power of 2. + static const size_t EXPLICIT_INITIAL_INDEX_SIZE = 32; + + // Controls the number of items that an explicit consumer (i.e. one with a token) + // must consume before it causes all consumers to rotate and move on to the next + // internal queue. + static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = 256; + + // The maximum number of elements (inclusive) that can be enqueued to a sub-queue. + // Enqueue operations that would cause this limit to be surpassed will fail. Note + // that this limit is enforced at the block level (for performance reasons), i.e. + // it's rounded up to the nearest block size. + static const size_t MAX_SUBQUEUE_SIZE = details::const_numeric_max::value; + + + // Memory allocation can be customized if needed. + // malloc should return nullptr on failure, and handle alignment like std::malloc. +#if defined(malloc) || defined(free) + // Gah, this is 2015, stop defining macros that break standard code already! + // Work around malloc/free being special macros: + static inline void* WORKAROUND_malloc(size_t size) { return malloc(size); } + static inline void WORKAROUND_free(void* ptr) { return free(ptr); } + static inline void* (malloc)(size_t size) { return WORKAROUND_malloc(size); } + static inline void (free)(void* ptr) { return WORKAROUND_free(ptr); } +#else + static inline void* malloc(size_t size) { return tracy::tracy_malloc(size); } + static inline void free(void* ptr) { return tracy::tracy_free(ptr); } +#endif +}; + + +// When producing or consuming many elements, the most efficient way is to: +// 1) Use one of the bulk-operation methods of the queue with a token +// 2) Failing that, use the bulk-operation methods without a token +// 3) Failing that, create a token and use that with the single-item methods +// 4) Failing that, use the single-parameter methods of the queue +// Having said that, don't create tokens willy-nilly -- ideally there should be +// a maximum of one token per thread (of each kind). +struct ProducerToken; +struct ConsumerToken; + +template class ConcurrentQueue; + + +namespace details +{ + struct ConcurrentQueueProducerTypelessBase + { + ConcurrentQueueProducerTypelessBase* next; + std::atomic inactive; + ProducerToken* token; + uint32_t threadId; + + ConcurrentQueueProducerTypelessBase() + : next(nullptr), inactive(false), token(nullptr), threadId(0) + { + } + }; + + template + static inline bool circular_less_than(T a, T b) + { + static_assert(std::is_integral::value && !std::numeric_limits::is_signed, "circular_less_than is intended to be used only with unsigned integer types"); + return static_cast(a - b) > static_cast(static_cast(1) << (static_cast(sizeof(T) * CHAR_BIT - 1))); + // Note: extra parens around rhs of operator<< is MSVC bug: https://developercommunity2.visualstudio.com/t/C4554-triggers-when-both-lhs-and-rhs-is/10034931 + // silencing the bug requires #pragma warning(disable: 4554) around the calling code and has no effect when done here. + } + + template + static inline char* align_for(char* ptr) + { + const std::size_t alignment = std::alignment_of::value; + return ptr + (alignment - (reinterpret_cast(ptr) % alignment)) % alignment; + } + + template + static inline T ceil_to_pow_2(T x) + { + static_assert(std::is_integral::value && !std::numeric_limits::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types"); + + // Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 + --x; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + for (std::size_t i = 1; i < sizeof(T); i <<= 1) { + x |= x >> (i << 3); + } + ++x; + return x; + } + + template + static inline void swap_relaxed(std::atomic& left, std::atomic& right) + { + T temp = std::move(left.load(std::memory_order_relaxed)); + left.store(std::move(right.load(std::memory_order_relaxed)), std::memory_order_relaxed); + right.store(std::move(temp), std::memory_order_relaxed); + } + + template + static inline T const& nomove(T const& x) + { + return x; + } + + template + struct nomove_if + { + template + static inline T const& eval(T const& x) + { + return x; + } + }; + + template<> + struct nomove_if + { + template + static inline auto eval(U&& x) + -> decltype(std::forward(x)) + { + return std::forward(x); + } + }; + + template + static inline auto deref_noexcept(It& it) noexcept -> decltype(*it) + { + return *it; + } + +#if defined(__clang__) || !defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + template struct is_trivially_destructible : std::is_trivially_destructible { }; +#else + template struct is_trivially_destructible : std::has_trivial_destructor { }; +#endif + + template struct static_is_lock_free_num { enum { value = 0 }; }; + template<> struct static_is_lock_free_num { enum { value = ATOMIC_CHAR_LOCK_FREE }; }; + template<> struct static_is_lock_free_num { enum { value = ATOMIC_SHORT_LOCK_FREE }; }; + template<> struct static_is_lock_free_num { enum { value = ATOMIC_INT_LOCK_FREE }; }; + template<> struct static_is_lock_free_num { enum { value = ATOMIC_LONG_LOCK_FREE }; }; + template<> struct static_is_lock_free_num { enum { value = ATOMIC_LLONG_LOCK_FREE }; }; + template struct static_is_lock_free : static_is_lock_free_num::type> { }; + template<> struct static_is_lock_free { enum { value = ATOMIC_BOOL_LOCK_FREE }; }; + template struct static_is_lock_free { enum { value = ATOMIC_POINTER_LOCK_FREE }; }; +} + + +struct ProducerToken +{ + template + explicit ProducerToken(ConcurrentQueue& queue); + + ProducerToken(ProducerToken&& other) noexcept + : producer(other.producer) + { + other.producer = nullptr; + if (producer != nullptr) { + producer->token = this; + } + } + + inline ProducerToken& operator=(ProducerToken&& other) noexcept + { + swap(other); + return *this; + } + + void swap(ProducerToken& other) noexcept + { + std::swap(producer, other.producer); + if (producer != nullptr) { + producer->token = this; + } + if (other.producer != nullptr) { + other.producer->token = &other; + } + } + + // A token is always valid unless: + // 1) Memory allocation failed during construction + // 2) It was moved via the move constructor + // (Note: assignment does a swap, leaving both potentially valid) + // 3) The associated queue was destroyed + // Note that if valid() returns true, that only indicates + // that the token is valid for use with a specific queue, + // but not which one; that's up to the user to track. + inline bool valid() const { return producer != nullptr; } + + ~ProducerToken() + { + if (producer != nullptr) { + producer->token = nullptr; + producer->inactive.store(true, std::memory_order_release); + } + } + + // Disable copying and assignment + ProducerToken(ProducerToken const&) = delete; + ProducerToken& operator=(ProducerToken const&) = delete; + +private: + template friend class ConcurrentQueue; + +protected: + details::ConcurrentQueueProducerTypelessBase* producer; +}; + + +struct ConsumerToken +{ + template + explicit ConsumerToken(ConcurrentQueue& q); + + ConsumerToken(ConsumerToken&& other) noexcept + : initialOffset(other.initialOffset), lastKnownGlobalOffset(other.lastKnownGlobalOffset), itemsConsumedFromCurrent(other.itemsConsumedFromCurrent), currentProducer(other.currentProducer), desiredProducer(other.desiredProducer) + { + } + + inline ConsumerToken& operator=(ConsumerToken&& other) noexcept + { + swap(other); + return *this; + } + + void swap(ConsumerToken& other) noexcept + { + std::swap(initialOffset, other.initialOffset); + std::swap(lastKnownGlobalOffset, other.lastKnownGlobalOffset); + std::swap(itemsConsumedFromCurrent, other.itemsConsumedFromCurrent); + std::swap(currentProducer, other.currentProducer); + std::swap(desiredProducer, other.desiredProducer); + } + + // Disable copying and assignment + ConsumerToken(ConsumerToken const&) = delete; + ConsumerToken& operator=(ConsumerToken const&) = delete; + +private: + template friend class ConcurrentQueue; + +private: // but shared with ConcurrentQueue + std::uint32_t initialOffset; + std::uint32_t lastKnownGlobalOffset; + std::uint32_t itemsConsumedFromCurrent; + details::ConcurrentQueueProducerTypelessBase* currentProducer; + details::ConcurrentQueueProducerTypelessBase* desiredProducer; +}; + + +template +class ConcurrentQueue +{ +public: + struct ExplicitProducer; + + typedef moodycamel::ProducerToken producer_token_t; + typedef moodycamel::ConsumerToken consumer_token_t; + + typedef typename Traits::index_t index_t; + typedef typename Traits::size_t size_t; + + static const size_t BLOCK_SIZE = static_cast(Traits::BLOCK_SIZE); + static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = static_cast(Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD); + static const size_t EXPLICIT_INITIAL_INDEX_SIZE = static_cast(Traits::EXPLICIT_INITIAL_INDEX_SIZE); + static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = static_cast(Traits::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE); +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable: 4307) // + integral constant overflow (that's what the ternary expression is for!) +#pragma warning(disable: 4309) // static_cast: Truncation of constant value +#endif + static const size_t MAX_SUBQUEUE_SIZE = (details::const_numeric_max::value - static_cast(Traits::MAX_SUBQUEUE_SIZE) < BLOCK_SIZE) ? details::const_numeric_max::value : ((static_cast(Traits::MAX_SUBQUEUE_SIZE) + (BLOCK_SIZE - 1)) / BLOCK_SIZE * BLOCK_SIZE); +#ifdef _MSC_VER +#pragma warning(pop) +#endif + + static_assert(!std::numeric_limits::is_signed && std::is_integral::value, "Traits::size_t must be an unsigned integral type"); + static_assert(!std::numeric_limits::is_signed && std::is_integral::value, "Traits::index_t must be an unsigned integral type"); + static_assert(sizeof(index_t) >= sizeof(size_t), "Traits::index_t must be at least as wide as Traits::size_t"); + static_assert((BLOCK_SIZE > 1) && !(BLOCK_SIZE & (BLOCK_SIZE - 1)), "Traits::BLOCK_SIZE must be a power of 2 (and at least 2)"); + static_assert((EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD > 1) && !(EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD & (EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD - 1)), "Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD must be a power of 2 (and greater than 1)"); + static_assert((EXPLICIT_INITIAL_INDEX_SIZE > 1) && !(EXPLICIT_INITIAL_INDEX_SIZE & (EXPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::EXPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)"); + +public: + // Creates a queue with at least `capacity` element slots; note that the + // actual number of elements that can be inserted without additional memory + // allocation depends on the number of producers and the block size (e.g. if + // the block size is equal to `capacity`, only a single block will be allocated + // up-front, which means only a single producer will be able to enqueue elements + // without an extra allocation -- blocks aren't shared between producers). + // This method is not thread safe -- it is up to the user to ensure that the + // queue is fully constructed before it starts being used by other threads (this + // includes making the memory effects of construction visible, possibly with a + // memory barrier). + explicit ConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE) + : producerListTail(nullptr), + producerCount(0), + initialBlockPoolIndex(0), + nextExplicitConsumerId(0), + globalExplicitConsumerOffset(0) + { + populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1)); + } + + // Computes the correct amount of pre-allocated blocks for you based + // on the minimum number of elements you want available at any given + // time, and the maximum concurrent number of each type of producer. + ConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers) + : producerListTail(nullptr), + producerCount(0), + initialBlockPoolIndex(0), + nextExplicitConsumerId(0), + globalExplicitConsumerOffset(0) + { + size_t blocks = (((minCapacity + BLOCK_SIZE - 1) / BLOCK_SIZE) - 1) * (maxExplicitProducers + 1) + 2 * (maxExplicitProducers); + populate_initial_block_list(blocks); + } + + // Note: The queue should not be accessed concurrently while it's + // being deleted. It's up to the user to synchronize this. + // This method is not thread safe. + ~ConcurrentQueue() + { + // Destroy producers + auto ptr = producerListTail.load(std::memory_order_relaxed); + while (ptr != nullptr) { + auto next = ptr->next_prod(); + if (ptr->token != nullptr) { + ptr->token->producer = nullptr; + } + destroy(ptr); + ptr = next; + } + + // Destroy global free list + auto block = freeList.head_unsafe(); + while (block != nullptr) { + auto next = block->freeListNext.load(std::memory_order_relaxed); + if (block->dynamicallyAllocated) { + destroy(block); + } + block = next; + } + + // Destroy initial free list + destroy_array(initialBlockPool, initialBlockPoolSize); + } + + // Disable copying and copy assignment + ConcurrentQueue(ConcurrentQueue const&) = delete; + ConcurrentQueue(ConcurrentQueue&& other) = delete; + ConcurrentQueue& operator=(ConcurrentQueue const&) = delete; + ConcurrentQueue& operator=(ConcurrentQueue&& other) = delete; + +public: + tracy_force_inline T* enqueue_begin(producer_token_t const& token, index_t& currentTailIndex) + { + return static_cast(token.producer)->ConcurrentQueue::ExplicitProducer::enqueue_begin(currentTailIndex); + } + + template + size_t try_dequeue_bulk_single(consumer_token_t& token, NotifyThread notifyThread, ProcessData processData ) + { + if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) { + if (!update_current_producer_after_rotation(token)) { + return 0; + } + } + + size_t count = static_cast(token.currentProducer)->dequeue_bulk(notifyThread, processData); + token.itemsConsumedFromCurrent += static_cast(count); + + auto tail = producerListTail.load(std::memory_order_acquire); + auto ptr = static_cast(token.currentProducer)->next_prod(); + if (ptr == nullptr) { + ptr = tail; + } + if( count == 0 ) + { + while (ptr != static_cast(token.currentProducer)) { + auto dequeued = ptr->dequeue_bulk(notifyThread, processData); + if (dequeued != 0) { + token.currentProducer = ptr; + token.itemsConsumedFromCurrent = static_cast(dequeued); + return dequeued; + } + ptr = ptr->next_prod(); + if (ptr == nullptr) { + ptr = tail; + } + } + return 0; + } + else + { + token.currentProducer = ptr; + token.itemsConsumedFromCurrent = 0; + return count; + } + } + + + // Returns an estimate of the total number of elements currently in the queue. This + // estimate is only accurate if the queue has completely stabilized before it is called + // (i.e. all enqueue and dequeue operations have completed and their memory effects are + // visible on the calling thread, and no further operations start while this method is + // being called). + // Thread-safe. + size_t size_approx() const + { + size_t size = 0; + for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) { + size += ptr->size_approx(); + } + return size; + } + + + // Returns true if the underlying atomic variables used by + // the queue are lock-free (they should be on most platforms). + // Thread-safe. + static bool is_lock_free() + { + return + details::static_is_lock_free::value == 2 && + details::static_is_lock_free::value == 2 && + details::static_is_lock_free::value == 2 && + details::static_is_lock_free::value == 2 && + details::static_is_lock_free::value == 2; + } + + +private: + friend struct ProducerToken; + friend struct ConsumerToken; + friend struct ExplicitProducer; + + + /////////////////////////////// + // Queue methods + /////////////////////////////// + + inline bool update_current_producer_after_rotation(consumer_token_t& token) + { + // Ah, there's been a rotation, figure out where we should be! + auto tail = producerListTail.load(std::memory_order_acquire); + if (token.desiredProducer == nullptr && tail == nullptr) { + return false; + } + auto prodCount = producerCount.load(std::memory_order_relaxed); + auto globalOffset = globalExplicitConsumerOffset.load(std::memory_order_relaxed); + if (details::cqUnlikely(token.desiredProducer == nullptr)) { + // Aha, first time we're dequeueing anything. + // Figure out our local position + // Note: offset is from start, not end, but we're traversing from end -- subtract from count first + std::uint32_t offset = prodCount - 1 - (token.initialOffset % prodCount); + token.desiredProducer = tail; + for (std::uint32_t i = 0; i != offset; ++i) { + token.desiredProducer = static_cast(token.desiredProducer)->next_prod(); + if (token.desiredProducer == nullptr) { + token.desiredProducer = tail; + } + } + } + + std::uint32_t delta = globalOffset - token.lastKnownGlobalOffset; + if (delta >= prodCount) { + delta = delta % prodCount; + } + for (std::uint32_t i = 0; i != delta; ++i) { + token.desiredProducer = static_cast(token.desiredProducer)->next_prod(); + if (token.desiredProducer == nullptr) { + token.desiredProducer = tail; + } + } + + token.lastKnownGlobalOffset = globalOffset; + token.currentProducer = token.desiredProducer; + token.itemsConsumedFromCurrent = 0; + return true; + } + + + /////////////////////////// + // Free list + /////////////////////////// + + template + struct FreeListNode + { + FreeListNode() : freeListRefs(0), freeListNext(nullptr) { } + + std::atomic freeListRefs; + std::atomic freeListNext; + }; + + // A simple CAS-based lock-free free list. Not the fastest thing in the world under heavy contention, but + // simple and correct (assuming nodes are never freed until after the free list is destroyed), and fairly + // speedy under low contention. + template // N must inherit FreeListNode or have the same fields (and initialization of them) + struct FreeList + { + FreeList() : freeListHead(nullptr) { } + FreeList(FreeList&& other) : freeListHead(other.freeListHead.load(std::memory_order_relaxed)) { other.freeListHead.store(nullptr, std::memory_order_relaxed); } + void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.freeListHead); } + + FreeList(FreeList const&) = delete; + FreeList& operator=(FreeList const&) = delete; + + inline void add(N* node) + { + // We know that the should-be-on-freelist bit is 0 at this point, so it's safe to + // set it using a fetch_add + if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST, std::memory_order_acq_rel) == 0) { + // Oh look! We were the last ones referencing this node, and we know + // we want to add it to the free list, so let's do it! + add_knowing_refcount_is_zero(node); + } + } + + inline N* try_get() + { + auto head = freeListHead.load(std::memory_order_acquire); + while (head != nullptr) { + auto prevHead = head; + auto refs = head->freeListRefs.load(std::memory_order_relaxed); + if ((refs & REFS_MASK) == 0 || !head->freeListRefs.compare_exchange_strong(refs, refs + 1, std::memory_order_acquire, std::memory_order_relaxed)) { + head = freeListHead.load(std::memory_order_acquire); + continue; + } + + // Good, reference count has been incremented (it wasn't at zero), which means we can read the + // next and not worry about it changing between now and the time we do the CAS + auto next = head->freeListNext.load(std::memory_order_relaxed); + if (freeListHead.compare_exchange_strong(head, next, std::memory_order_acquire, std::memory_order_relaxed)) { + // Yay, got the node. This means it was on the list, which means shouldBeOnFreeList must be false no + // matter the refcount (because nobody else knows it's been taken off yet, it can't have been put back on). + assert((head->freeListRefs.load(std::memory_order_relaxed) & SHOULD_BE_ON_FREELIST) == 0); + + // Decrease refcount twice, once for our ref, and once for the list's ref + head->freeListRefs.fetch_sub(2, std::memory_order_release); + return head; + } + + // OK, the head must have changed on us, but we still need to decrease the refcount we increased. + // Note that we don't need to release any memory effects, but we do need to ensure that the reference + // count decrement happens-after the CAS on the head. + refs = prevHead->freeListRefs.fetch_sub(1, std::memory_order_acq_rel); + if (refs == SHOULD_BE_ON_FREELIST + 1) { + add_knowing_refcount_is_zero(prevHead); + } + } + + return nullptr; + } + + // Useful for traversing the list when there's no contention (e.g. to destroy remaining nodes) + N* head_unsafe() const { return freeListHead.load(std::memory_order_relaxed); } + + private: + inline void add_knowing_refcount_is_zero(N* node) + { + // Since the refcount is zero, and nobody can increase it once it's zero (except us, and we run + // only one copy of this method per node at a time, i.e. the single thread case), then we know + // we can safely change the next pointer of the node; however, once the refcount is back above + // zero, then other threads could increase it (happens under heavy contention, when the refcount + // goes to zero in between a load and a refcount increment of a node in try_get, then back up to + // something non-zero, then the refcount increment is done by the other thread) -- so, if the CAS + // to add the node to the actual list fails, decrease the refcount and leave the add operation to + // the next thread who puts the refcount back at zero (which could be us, hence the loop). + auto head = freeListHead.load(std::memory_order_relaxed); + while (true) { + node->freeListNext.store(head, std::memory_order_relaxed); + node->freeListRefs.store(1, std::memory_order_release); + if (!freeListHead.compare_exchange_strong(head, node, std::memory_order_release, std::memory_order_relaxed)) { + // Hmm, the add failed, but we can only try again when the refcount goes back to zero + if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST - 1, std::memory_order_release) == 1) { + continue; + } + } + return; + } + } + + private: + // Implemented like a stack, but where node order doesn't matter (nodes are inserted out of order under contention) + std::atomic freeListHead; + + static const std::uint32_t REFS_MASK = 0x7FFFFFFF; + static const std::uint32_t SHOULD_BE_ON_FREELIST = 0x80000000; + }; + + + /////////////////////////// + // Block + /////////////////////////// + + struct Block + { + Block() + : next(nullptr), elementsCompletelyDequeued(0), freeListRefs(0), freeListNext(nullptr), shouldBeOnFreeList(false), dynamicallyAllocated(true) + { + } + + inline bool is_empty() const + { + if (compile_time_condition::value) { + // Check flags + for (size_t i = 0; i < BLOCK_SIZE; ++i) { + if (!emptyFlags[i].load(std::memory_order_relaxed)) { + return false; + } + } + + // Aha, empty; make sure we have all other memory effects that happened before the empty flags were set + std::atomic_thread_fence(std::memory_order_acquire); + return true; + } + else { + // Check counter + if (elementsCompletelyDequeued.load(std::memory_order_relaxed) == BLOCK_SIZE) { + std::atomic_thread_fence(std::memory_order_acquire); + return true; + } + assert(elementsCompletelyDequeued.load(std::memory_order_relaxed) <= BLOCK_SIZE); + return false; + } + } + + // Returns true if the block is now empty (does not apply in explicit context) + inline bool set_empty(index_t i) + { + if (BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) { + // Set flag + assert(!emptyFlags[BLOCK_SIZE - 1 - static_cast(i & static_cast(BLOCK_SIZE - 1))].load(std::memory_order_relaxed)); + emptyFlags[BLOCK_SIZE - 1 - static_cast(i & static_cast(BLOCK_SIZE - 1))].store(true, std::memory_order_release); + return false; + } + else { + // Increment counter + auto prevVal = elementsCompletelyDequeued.fetch_add(1, std::memory_order_release); + assert(prevVal < BLOCK_SIZE); + return prevVal == BLOCK_SIZE - 1; + } + } + + // Sets multiple contiguous item statuses to 'empty' (assumes no wrapping and count > 0). + // Returns true if the block is now empty (does not apply in explicit context). + inline bool set_many_empty(index_t i, size_t count) + { + if (compile_time_condition::value) { + // Set flags + std::atomic_thread_fence(std::memory_order_release); + i = BLOCK_SIZE - 1 - static_cast(i & static_cast(BLOCK_SIZE - 1)) - count + 1; + for (size_t j = 0; j != count; ++j) { + assert(!emptyFlags[i + j].load(std::memory_order_relaxed)); + emptyFlags[i + j].store(true, std::memory_order_relaxed); + } + return false; + } + else { + // Increment counter + auto prevVal = elementsCompletelyDequeued.fetch_add(count, std::memory_order_release); + assert(prevVal + count <= BLOCK_SIZE); + return prevVal + count == BLOCK_SIZE; + } + } + + inline void set_all_empty() + { + if (BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) { + // Set all flags + for (size_t i = 0; i != BLOCK_SIZE; ++i) { + emptyFlags[i].store(true, std::memory_order_relaxed); + } + } + else { + // Reset counter + elementsCompletelyDequeued.store(BLOCK_SIZE, std::memory_order_relaxed); + } + } + + inline void reset_empty() + { + if (compile_time_condition::value) { + // Reset flags + for (size_t i = 0; i != BLOCK_SIZE; ++i) { + emptyFlags[i].store(false, std::memory_order_relaxed); + } + } + else { + // Reset counter + elementsCompletelyDequeued.store(0, std::memory_order_relaxed); + } + } + + inline T* operator[](index_t idx) noexcept { return static_cast(static_cast(elements)) + static_cast(idx & static_cast(BLOCK_SIZE - 1)); } + inline T const* operator[](index_t idx) const noexcept { return static_cast(static_cast(elements)) + static_cast(idx & static_cast(BLOCK_SIZE - 1)); } + + private: + // IMPORTANT: This must be the first member in Block, so that if T depends on the alignment of + // addresses returned by malloc, that alignment will be preserved. Apparently clang actually + // generates code that uses this assumption for AVX instructions in some cases. Ideally, we + // should also align Block to the alignment of T in case it's higher than malloc's 16-byte + // alignment, but this is hard to do in a cross-platform way. Assert for this case: + static_assert(std::alignment_of::value <= std::alignment_of::value, "The queue does not support super-aligned types at this time"); + // Additionally, we need the alignment of Block itself to be a multiple of max_align_t since + // otherwise the appropriate padding will not be added at the end of Block in order to make + // arrays of Blocks all be properly aligned (not just the first one). We use a union to force + // this. + union { + char elements[sizeof(T) * BLOCK_SIZE]; + details::max_align_t dummy; + }; + public: + Block* next; + std::atomic elementsCompletelyDequeued; + std::atomic emptyFlags[BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD ? BLOCK_SIZE : 1]; + public: + std::atomic freeListRefs; + std::atomic freeListNext; + std::atomic shouldBeOnFreeList; + bool dynamicallyAllocated; // Perhaps a better name for this would be 'isNotPartOfInitialBlockPool' + }; + static_assert(std::alignment_of::value >= std::alignment_of::value, "Internal error: Blocks must be at least as aligned as the type they are wrapping"); + + + /////////////////////////// + // Producer base + /////////////////////////// + + struct ProducerBase : public details::ConcurrentQueueProducerTypelessBase + { + ProducerBase(ConcurrentQueue* parent_) : + tailIndex(0), + headIndex(0), + dequeueOptimisticCount(0), + dequeueOvercommit(0), + tailBlock(nullptr), + parent(parent_) + { + } + + virtual ~ProducerBase() { }; + + template + inline size_t dequeue_bulk(NotifyThread notifyThread, ProcessData processData) + { + return static_cast(this)->dequeue_bulk(notifyThread, processData); + } + + inline ProducerBase* next_prod() const { return static_cast(next); } + + inline size_t size_approx() const + { + auto tail = tailIndex.load(std::memory_order_relaxed); + auto head = headIndex.load(std::memory_order_relaxed); + return details::circular_less_than(head, tail) ? static_cast(tail - head) : 0; + } + + inline index_t getTail() const { return tailIndex.load(std::memory_order_relaxed); } + protected: + std::atomic tailIndex; // Where to enqueue to next + std::atomic headIndex; // Where to dequeue from next + + std::atomic dequeueOptimisticCount; + std::atomic dequeueOvercommit; + + Block* tailBlock; + + public: + ConcurrentQueue* parent; + }; + + + public: + /////////////////////////// + // Explicit queue + /////////////////////////// + struct ExplicitProducer : public ProducerBase + { + explicit ExplicitProducer(ConcurrentQueue* _parent) : + ProducerBase(_parent), + blockIndex(nullptr), + pr_blockIndexSlotsUsed(0), + pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1), + pr_blockIndexFront(0), + pr_blockIndexEntries(nullptr), + pr_blockIndexRaw(nullptr) + { + size_t poolBasedIndexSize = details::ceil_to_pow_2(_parent->initialBlockPoolSize) >> 1; + if (poolBasedIndexSize > pr_blockIndexSize) { + pr_blockIndexSize = poolBasedIndexSize; + } + + new_block_index(0); // This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE + } + + ~ExplicitProducer() + { + // Destruct any elements not yet dequeued. + // Since we're in the destructor, we can assume all elements + // are either completely dequeued or completely not (no halfways). + if (this->tailBlock != nullptr) { // Note this means there must be a block index too + // First find the block that's partially dequeued, if any + Block* halfDequeuedBlock = nullptr; + if ((this->headIndex.load(std::memory_order_relaxed) & static_cast(BLOCK_SIZE - 1)) != 0) { + // The head's not on a block boundary, meaning a block somewhere is partially dequeued + // (or the head block is the tail block and was fully dequeued, but the head/tail are still not on a boundary) + size_t i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & (pr_blockIndexSize - 1); + while (details::circular_less_than(pr_blockIndexEntries[i].base + BLOCK_SIZE, this->headIndex.load(std::memory_order_relaxed))) { + i = (i + 1) & (pr_blockIndexSize - 1); + } + assert(details::circular_less_than(pr_blockIndexEntries[i].base, this->headIndex.load(std::memory_order_relaxed))); + halfDequeuedBlock = pr_blockIndexEntries[i].block; + } + + // Start at the head block (note the first line in the loop gives us the head from the tail on the first iteration) + auto block = this->tailBlock; + do { + block = block->next; + if (block->ConcurrentQueue::Block::is_empty()) { + continue; + } + + size_t i = 0; // Offset into block + if (block == halfDequeuedBlock) { + i = static_cast(this->headIndex.load(std::memory_order_relaxed) & static_cast(BLOCK_SIZE - 1)); + } + + // Walk through all the items in the block; if this is the tail block, we need to stop when we reach the tail index + auto lastValidIndex = (this->tailIndex.load(std::memory_order_relaxed) & static_cast(BLOCK_SIZE - 1)) == 0 ? BLOCK_SIZE : static_cast(this->tailIndex.load(std::memory_order_relaxed) & static_cast(BLOCK_SIZE - 1)); + while (i != BLOCK_SIZE && (block != this->tailBlock || i != lastValidIndex)) { + (*block)[i++]->~T(); + } + } while (block != this->tailBlock); + } + + // Destroy all blocks that we own + if (this->tailBlock != nullptr) { + auto block = this->tailBlock; + do { + auto nextBlock = block->next; + if (block->dynamicallyAllocated) { + destroy(block); + } + else { + this->parent->add_block_to_free_list(block); + } + block = nextBlock; + } while (block != this->tailBlock); + } + + // Destroy the block indices + auto header = static_cast(pr_blockIndexRaw); + while (header != nullptr) { + auto prev = static_cast(header->prev); + header->~BlockIndexHeader(); + (Traits::free)(header); + header = prev; + } + } + + inline void enqueue_begin_alloc(index_t currentTailIndex) + { + // We reached the end of a block, start a new one + if (this->tailBlock != nullptr && this->tailBlock->next->ConcurrentQueue::Block::is_empty()) { + // We can re-use the block ahead of us, it's empty! + this->tailBlock = this->tailBlock->next; + this->tailBlock->ConcurrentQueue::Block::reset_empty(); + + // We'll put the block on the block index (guaranteed to be room since we're conceptually removing the + // last block from it first -- except instead of removing then adding, we can just overwrite). + // Note that there must be a valid block index here, since even if allocation failed in the ctor, + // it would have been re-attempted when adding the first block to the queue; since there is such + // a block, a block index must have been successfully allocated. + } + else { + // We're going to need a new block; check that the block index has room + if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize) { + // Hmm, the circular block index is already full -- we'll need + // to allocate a new index. Note pr_blockIndexRaw can only be nullptr if + // the initial allocation failed in the constructor. + new_block_index(pr_blockIndexSlotsUsed); + } + + // Insert a new block in the circular linked list + auto newBlock = this->parent->ConcurrentQueue::requisition_block(); + newBlock->ConcurrentQueue::Block::reset_empty(); + if (this->tailBlock == nullptr) { + newBlock->next = newBlock; + } + else { + newBlock->next = this->tailBlock->next; + this->tailBlock->next = newBlock; + } + this->tailBlock = newBlock; + ++pr_blockIndexSlotsUsed; + } + + // Add block to block index + auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront]; + entry.base = currentTailIndex; + entry.block = this->tailBlock; + blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release); + pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1); + } + + tracy_force_inline T* enqueue_begin(index_t& currentTailIndex) + { + currentTailIndex = this->tailIndex.load(std::memory_order_relaxed); + if (details::cqUnlikely((currentTailIndex & static_cast(BLOCK_SIZE - 1)) == 0)) { + this->enqueue_begin_alloc(currentTailIndex); + } + return (*this->tailBlock)[currentTailIndex]; + } + + tracy_force_inline std::atomic& get_tail_index() + { + return this->tailIndex; + } + + template + size_t dequeue_bulk(NotifyThread notifyThread, ProcessData processData) + { + auto tail = this->tailIndex.load(std::memory_order_relaxed); + auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed); + auto desiredCount = static_cast(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit)); + if (details::circular_less_than(0, desiredCount)) { + desiredCount = desiredCount < 8192 ? desiredCount : 8192; + std::atomic_thread_fence(std::memory_order_acquire); + + auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed); + assert(overcommit <= myDequeueCount); + + tail = this->tailIndex.load(std::memory_order_acquire); + auto actualCount = static_cast(tail - (myDequeueCount - overcommit)); + if (details::circular_less_than(0, actualCount)) { + actualCount = desiredCount < actualCount ? desiredCount : actualCount; + if (actualCount < desiredCount) { + this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release); + } + + // Get the first index. Note that since there's guaranteed to be at least actualCount elements, this + // will never exceed tail. + auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel); + + // Determine which block the first element is in + auto localBlockIndex = blockIndex.load(std::memory_order_acquire); + auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire); + + auto headBase = localBlockIndex->entries[localBlockIndexHead].base; + auto firstBlockBaseIndex = firstIndex & ~static_cast(BLOCK_SIZE - 1); + auto offset = static_cast(static_cast::type>(firstBlockBaseIndex - headBase) / BLOCK_SIZE); + auto indexIndex = (localBlockIndexHead + offset) & (localBlockIndex->size - 1); + + notifyThread( this->threadId ); + + // Iterate the blocks and dequeue + auto index = firstIndex; + do { + auto firstIndexInBlock = index; + auto endIndex = (index & ~static_cast(BLOCK_SIZE - 1)) + static_cast(BLOCK_SIZE); + endIndex = details::circular_less_than(firstIndex + static_cast(actualCount), endIndex) ? firstIndex + static_cast(actualCount) : endIndex; + auto block = localBlockIndex->entries[indexIndex].block; + + const auto sz = endIndex - index; + processData( (*block)[index], sz ); + index += sz; + + block->ConcurrentQueue::Block::set_many_empty(firstIndexInBlock, static_cast(endIndex - firstIndexInBlock)); + indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1); + } while (index != firstIndex + actualCount); + + return actualCount; + } + else { + // Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent + this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release); + } + } + + return 0; + } + + private: + struct BlockIndexEntry + { + index_t base; + Block* block; + }; + + struct BlockIndexHeader + { + size_t size; + std::atomic front; // Current slot (not next, like pr_blockIndexFront) + BlockIndexEntry* entries; + void* prev; + }; + + + bool new_block_index(size_t numberOfFilledSlotsToExpose) + { + auto prevBlockSizeMask = pr_blockIndexSize - 1; + + // Create the new block + pr_blockIndexSize <<= 1; + auto newRawPtr = static_cast((Traits::malloc)(sizeof(BlockIndexHeader) + std::alignment_of::value - 1 + sizeof(BlockIndexEntry) * pr_blockIndexSize)); + if (newRawPtr == nullptr) { + pr_blockIndexSize >>= 1; // Reset to allow graceful retry + return false; + } + + auto newBlockIndexEntries = reinterpret_cast(details::align_for(newRawPtr + sizeof(BlockIndexHeader))); + + // Copy in all the old indices, if any + size_t j = 0; + if (pr_blockIndexSlotsUsed != 0) { + auto i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & prevBlockSizeMask; + do { + newBlockIndexEntries[j++] = pr_blockIndexEntries[i]; + i = (i + 1) & prevBlockSizeMask; + } while (i != pr_blockIndexFront); + } + + // Update everything + auto header = new (newRawPtr) BlockIndexHeader; + header->size = pr_blockIndexSize; + header->front.store(numberOfFilledSlotsToExpose - 1, std::memory_order_relaxed); + header->entries = newBlockIndexEntries; + header->prev = pr_blockIndexRaw; // we link the new block to the old one so we can free it later + + pr_blockIndexFront = j; + pr_blockIndexEntries = newBlockIndexEntries; + pr_blockIndexRaw = newRawPtr; + blockIndex.store(header, std::memory_order_release); + + return true; + } + + private: + std::atomic blockIndex; + + // To be used by producer only -- consumer must use the ones in referenced by blockIndex + size_t pr_blockIndexSlotsUsed; + size_t pr_blockIndexSize; + size_t pr_blockIndexFront; // Next slot (not current) + BlockIndexEntry* pr_blockIndexEntries; + void* pr_blockIndexRaw; + }; + + ExplicitProducer* get_explicit_producer(producer_token_t const& token) + { + return static_cast(token.producer); + } + + private: + + ////////////////////////////////// + // Block pool manipulation + ////////////////////////////////// + + void populate_initial_block_list(size_t blockCount) + { + initialBlockPoolSize = blockCount; + if (initialBlockPoolSize == 0) { + initialBlockPool = nullptr; + return; + } + + initialBlockPool = create_array(blockCount); + if (initialBlockPool == nullptr) { + initialBlockPoolSize = 0; + } + for (size_t i = 0; i < initialBlockPoolSize; ++i) { + initialBlockPool[i].dynamicallyAllocated = false; + } + } + + inline Block* try_get_block_from_initial_pool() + { + if (initialBlockPoolIndex.load(std::memory_order_relaxed) >= initialBlockPoolSize) { + return nullptr; + } + + auto index = initialBlockPoolIndex.fetch_add(1, std::memory_order_relaxed); + + return index < initialBlockPoolSize ? (initialBlockPool + index) : nullptr; + } + + inline void add_block_to_free_list(Block* block) + { + freeList.add(block); + } + + inline void add_blocks_to_free_list(Block* block) + { + while (block != nullptr) { + auto next = block->next; + add_block_to_free_list(block); + block = next; + } + } + + inline Block* try_get_block_from_free_list() + { + return freeList.try_get(); + } + + // Gets a free block from one of the memory pools, or allocates a new one (if applicable) + Block* requisition_block() + { + auto block = try_get_block_from_initial_pool(); + if (block != nullptr) { + return block; + } + + block = try_get_block_from_free_list(); + if (block != nullptr) { + return block; + } + + return create(); + } + + + ////////////////////////////////// + // Producer list manipulation + ////////////////////////////////// + + ProducerBase* recycle_or_create_producer() + { + bool recycled; + return recycle_or_create_producer(recycled); + } + + ProducerBase* recycle_or_create_producer(bool& recycled) + { + // Try to re-use one first + for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) { + if (ptr->inactive.load(std::memory_order_relaxed)) { + if( ptr->size_approx() == 0 ) + { + bool expected = true; + if (ptr->inactive.compare_exchange_strong(expected, /* desired */ false, std::memory_order_acquire, std::memory_order_relaxed)) { + // We caught one! It's been marked as activated, the caller can have it + recycled = true; + return ptr; + } + } + } + } + + recycled = false; + return add_producer(static_cast(create(this))); + } + + ProducerBase* add_producer(ProducerBase* producer) + { + // Handle failed memory allocation + if (producer == nullptr) { + return nullptr; + } + + producerCount.fetch_add(1, std::memory_order_relaxed); + + // Add it to the lock-free list + auto prevTail = producerListTail.load(std::memory_order_relaxed); + do { + producer->next = prevTail; + } while (!producerListTail.compare_exchange_weak(prevTail, producer, std::memory_order_release, std::memory_order_relaxed)); + + return producer; + } + + void reown_producers() + { + // After another instance is moved-into/swapped-with this one, all the + // producers we stole still think their parents are the other queue. + // So fix them up! + for (auto ptr = producerListTail.load(std::memory_order_relaxed); ptr != nullptr; ptr = ptr->next_prod()) { + ptr->parent = this; + } + } + + ////////////////////////////////// + // Utility functions + ////////////////////////////////// + + template + static inline U* create_array(size_t count) + { + assert(count > 0); + return static_cast((Traits::malloc)(sizeof(U) * count)); + } + + template + static inline void destroy_array(U* p, size_t count) + { + ((void)count); + if (p != nullptr) { + assert(count > 0); + (Traits::free)(p); + } + } + + template + static inline U* create() + { + auto p = (Traits::malloc)(sizeof(U)); + return new (p) U; + } + + template + static inline U* create(A1&& a1) + { + auto p = (Traits::malloc)(sizeof(U)); + return new (p) U(std::forward(a1)); + } + + template + static inline void destroy(U* p) + { + if (p != nullptr) { + p->~U(); + } + (Traits::free)(p); + } + +private: + std::atomic producerListTail; + std::atomic producerCount; + + std::atomic initialBlockPoolIndex; + Block* initialBlockPool; + size_t initialBlockPoolSize; + + FreeList freeList; + + std::atomic nextExplicitConsumerId; + std::atomic globalExplicitConsumerOffset; +}; + + +template +ProducerToken::ProducerToken(ConcurrentQueue& queue) + : producer(queue.recycle_or_create_producer()) +{ + if (producer != nullptr) { + producer->token = this; + producer->threadId = detail::GetThreadHandleImpl(); + } +} + +template +ConsumerToken::ConsumerToken(ConcurrentQueue& queue) + : itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr) +{ + initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release); + lastKnownGlobalOffset = static_cast(-1); +} + +template +inline void swap(ConcurrentQueue& a, ConcurrentQueue& b) noexcept +{ + a.swap(b); +} + +inline void swap(ProducerToken& a, ProducerToken& b) noexcept +{ + a.swap(b); +} + +inline void swap(ConsumerToken& a, ConsumerToken& b) noexcept +{ + a.swap(b); +} + +} + +} /* namespace tracy */ + +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif diff --git a/Dependencies/tracy/client/tracy_rpmalloc.cpp b/Dependencies/tracy/client/tracy_rpmalloc.cpp new file mode 100644 index 000000000..4a0d0b400 --- /dev/null +++ b/Dependencies/tracy/client/tracy_rpmalloc.cpp @@ -0,0 +1,3517 @@ +#ifdef TRACY_ENABLE + +/* rpmalloc.c - Memory allocator - Public Domain - 2016-2020 Mattias Jansson + * + * This library provides a cross-platform lock free thread caching malloc implementation in C11. + * The latest source code is always available at + * + * https://github.com/mjansson/rpmalloc + * + * This library is put in the public domain; you can redistribute it and/or modify it without any restrictions. + * + */ + +#include "tracy_rpmalloc.hpp" + +#define BUILD_DYNAMIC_LINK 1 + +//////////// +/// +/// Build time configurable limits +/// +////// + +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-macros" +#pragma clang diagnostic ignored "-Wunused-function" +#if __has_warning("-Wreserved-identifier") +#pragma clang diagnostic ignored "-Wreserved-identifier" +#endif +#elif defined(__GNUC__) +#pragma GCC diagnostic ignored "-Wunused-macros" +#pragma GCC diagnostic ignored "-Wunused-function" +#pragma GCC diagnostic ignored "-Warray-bounds" +#endif + +#ifndef HEAP_ARRAY_SIZE +//! Size of heap hashmap +#define HEAP_ARRAY_SIZE 47 +#endif +#ifndef ENABLE_THREAD_CACHE +//! Enable per-thread cache +#define ENABLE_THREAD_CACHE 1 +#endif +#ifndef ENABLE_GLOBAL_CACHE +//! Enable global cache shared between all threads, requires thread cache +#define ENABLE_GLOBAL_CACHE 1 +#endif +#ifndef ENABLE_VALIDATE_ARGS +//! Enable validation of args to public entry points +#define ENABLE_VALIDATE_ARGS 0 +#endif +#ifndef ENABLE_STATISTICS +//! Enable statistics collection +#define ENABLE_STATISTICS 0 +#endif +#ifndef ENABLE_ASSERTS +//! Enable asserts +#define ENABLE_ASSERTS 0 +#endif +#ifndef ENABLE_OVERRIDE +//! Override standard library malloc/free and new/delete entry points +#define ENABLE_OVERRIDE 0 +#endif +#ifndef ENABLE_PRELOAD +//! Support preloading +#define ENABLE_PRELOAD 0 +#endif +#ifndef DISABLE_UNMAP +//! Disable unmapping memory pages (also enables unlimited cache) +#define DISABLE_UNMAP 0 +#endif +#ifndef ENABLE_UNLIMITED_CACHE +//! Enable unlimited global cache (no unmapping until finalization) +#define ENABLE_UNLIMITED_CACHE 0 +#endif +#ifndef ENABLE_ADAPTIVE_THREAD_CACHE +//! Enable adaptive thread cache size based on use heuristics +#define ENABLE_ADAPTIVE_THREAD_CACHE 0 +#endif +#ifndef DEFAULT_SPAN_MAP_COUNT +//! Default number of spans to map in call to map more virtual memory (default values yield 4MiB here) +#define DEFAULT_SPAN_MAP_COUNT 64 +#endif +#ifndef GLOBAL_CACHE_MULTIPLIER +//! Multiplier for global cache +#define GLOBAL_CACHE_MULTIPLIER 8 +#endif + +#if DISABLE_UNMAP && !ENABLE_GLOBAL_CACHE +#error Must use global cache if unmap is disabled +#endif + +#if DISABLE_UNMAP +#undef ENABLE_UNLIMITED_CACHE +#define ENABLE_UNLIMITED_CACHE 1 +#endif + +#if !ENABLE_GLOBAL_CACHE +#undef ENABLE_UNLIMITED_CACHE +#define ENABLE_UNLIMITED_CACHE 0 +#endif + +#if !ENABLE_THREAD_CACHE +#undef ENABLE_ADAPTIVE_THREAD_CACHE +#define ENABLE_ADAPTIVE_THREAD_CACHE 0 +#endif + +#if defined(_WIN32) || defined(__WIN32__) || defined(_WIN64) +# define PLATFORM_WINDOWS 1 +# define PLATFORM_POSIX 0 +#else +# define PLATFORM_WINDOWS 0 +# define PLATFORM_POSIX 1 +#endif + +/// Platform and arch specifics +#if defined(_MSC_VER) && !defined(__clang__) +# pragma warning (disable: 5105) +# ifndef FORCEINLINE +# define FORCEINLINE inline __forceinline +# endif +#else +# ifndef FORCEINLINE +# define FORCEINLINE inline __attribute__((__always_inline__)) +# endif +#endif +#if PLATFORM_WINDOWS +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include +# if ENABLE_VALIDATE_ARGS +# include +# endif +#else +# include +# include +# include +# include +# if defined(__linux__) || defined(__ANDROID__) +# include +# if !defined(PR_SET_VMA) +# define PR_SET_VMA 0x53564d41 +# define PR_SET_VMA_ANON_NAME 0 +# endif +# endif +# if defined(__APPLE__) +# include +# if !TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR +# include +# include +# endif +# include +# endif +# if defined(__HAIKU__) || defined(__TINYC__) +# include +# endif +#endif + +#include +#include +#include + +#if defined(_WIN32) && (!defined(BUILD_DYNAMIC_LINK) || !BUILD_DYNAMIC_LINK) +#include +static DWORD fls_key; +#endif + +#if PLATFORM_POSIX +# include +# include +# ifdef __FreeBSD__ +# include +# define MAP_HUGETLB MAP_ALIGNED_SUPER +# ifndef PROT_MAX +# define PROT_MAX(f) 0 +# endif +# else +# define PROT_MAX(f) 0 +# endif +# ifdef __sun +extern int madvise(caddr_t, size_t, int); +# endif +# ifndef MAP_UNINITIALIZED +# define MAP_UNINITIALIZED 0 +# endif +#endif +#include + +#if ENABLE_ASSERTS +# undef NDEBUG +# if defined(_MSC_VER) && !defined(_DEBUG) +# define _DEBUG +# endif +# include +#define RPMALLOC_TOSTRING_M(x) #x +#define RPMALLOC_TOSTRING(x) RPMALLOC_TOSTRING_M(x) +#define rpmalloc_assert(truth, message) \ + do { \ + if (!(truth)) { \ + if (_memory_config.error_callback) { \ + _memory_config.error_callback( \ + message " (" RPMALLOC_TOSTRING(truth) ") at " __FILE__ ":" RPMALLOC_TOSTRING(__LINE__)); \ + } else { \ + assert((truth) && message); \ + } \ + } \ + } while (0) +#else +# define rpmalloc_assert(truth, message) do {} while(0) +#endif +#if ENABLE_STATISTICS +# include +#endif + +////// +/// +/// Atomic access abstraction (since MSVC does not do C11 yet) +/// +////// + +#include + +typedef std::atomic atomic32_t; +typedef std::atomic atomic64_t; +typedef std::atomic atomicptr_t; + +static FORCEINLINE int32_t atomic_load32(atomic32_t* src) { return std::atomic_load_explicit(src, std::memory_order_relaxed); } +static FORCEINLINE void atomic_store32(atomic32_t* dst, int32_t val) { std::atomic_store_explicit(dst, val, std::memory_order_relaxed); } +static FORCEINLINE int32_t atomic_incr32(atomic32_t* val) { return std::atomic_fetch_add_explicit(val, 1, std::memory_order_relaxed) + 1; } +static FORCEINLINE int32_t atomic_decr32(atomic32_t* val) { return std::atomic_fetch_add_explicit(val, -1, std::memory_order_relaxed) - 1; } +static FORCEINLINE int32_t atomic_add32(atomic32_t* val, int32_t add) { return std::atomic_fetch_add_explicit(val, add, std::memory_order_relaxed) + add; } +static FORCEINLINE int atomic_cas32_acquire(atomic32_t* dst, int32_t val, int32_t ref) { return std::atomic_compare_exchange_weak_explicit(dst, &ref, val, std::memory_order_acquire, std::memory_order_relaxed); } +static FORCEINLINE void atomic_store32_release(atomic32_t* dst, int32_t val) { std::atomic_store_explicit(dst, val, std::memory_order_release); } +static FORCEINLINE int64_t atomic_load64(atomic64_t* val) { return std::atomic_load_explicit(val, std::memory_order_relaxed); } +static FORCEINLINE int64_t atomic_add64(atomic64_t* val, int64_t add) { return std::atomic_fetch_add_explicit(val, add, std::memory_order_relaxed) + add; } +static FORCEINLINE void* atomic_load_ptr(atomicptr_t* src) { return std::atomic_load_explicit(src, std::memory_order_relaxed); } +static FORCEINLINE void atomic_store_ptr(atomicptr_t* dst, void* val) { std::atomic_store_explicit(dst, val, std::memory_order_relaxed); } +static FORCEINLINE void atomic_store_ptr_release(atomicptr_t* dst, void* val) { std::atomic_store_explicit(dst, val, std::memory_order_release); } +static FORCEINLINE void* atomic_exchange_ptr_acquire(atomicptr_t* dst, void* val) { return std::atomic_exchange_explicit(dst, val, std::memory_order_acquire); } +static FORCEINLINE int atomic_cas_ptr(atomicptr_t* dst, void* val, void* ref) { return std::atomic_compare_exchange_weak_explicit(dst, &ref, val, std::memory_order_relaxed, std::memory_order_relaxed); } + +#if defined(_MSC_VER) && !defined(__clang__) + +#define EXPECTED(x) (x) +#define UNEXPECTED(x) (x) + +#else + +#define EXPECTED(x) __builtin_expect((x), 1) +#define UNEXPECTED(x) __builtin_expect((x), 0) + +#endif + +//////////// +/// +/// Statistics related functions (evaluate to nothing when statistics not enabled) +/// +////// + +#if ENABLE_STATISTICS +# define _rpmalloc_stat_inc(counter) atomic_incr32(counter) +# define _rpmalloc_stat_dec(counter) atomic_decr32(counter) +# define _rpmalloc_stat_add(counter, value) atomic_add32(counter, (int32_t)(value)) +# define _rpmalloc_stat_add64(counter, value) atomic_add64(counter, (int64_t)(value)) +# define _rpmalloc_stat_add_peak(counter, value, peak) do { int32_t _cur_count = atomic_add32(counter, (int32_t)(value)); if (_cur_count > (peak)) peak = _cur_count; } while (0) +# define _rpmalloc_stat_sub(counter, value) atomic_add32(counter, -(int32_t)(value)) +# define _rpmalloc_stat_inc_alloc(heap, class_idx) do { \ + int32_t alloc_current = atomic_incr32(&heap->size_class_use[class_idx].alloc_current); \ + if (alloc_current > heap->size_class_use[class_idx].alloc_peak) \ + heap->size_class_use[class_idx].alloc_peak = alloc_current; \ + atomic_incr32(&heap->size_class_use[class_idx].alloc_total); \ +} while(0) +# define _rpmalloc_stat_inc_free(heap, class_idx) do { \ + atomic_decr32(&heap->size_class_use[class_idx].alloc_current); \ + atomic_incr32(&heap->size_class_use[class_idx].free_total); \ +} while(0) +#else +# define _rpmalloc_stat_inc(counter) do {} while(0) +# define _rpmalloc_stat_dec(counter) do {} while(0) +# define _rpmalloc_stat_add(counter, value) do {} while(0) +# define _rpmalloc_stat_add64(counter, value) do {} while(0) +# define _rpmalloc_stat_add_peak(counter, value, peak) do {} while (0) +# define _rpmalloc_stat_sub(counter, value) do {} while(0) +# define _rpmalloc_stat_inc_alloc(heap, class_idx) do {} while(0) +# define _rpmalloc_stat_inc_free(heap, class_idx) do {} while(0) +#endif + + +/// +/// Preconfigured limits and sizes +/// + +//! Granularity of a small allocation block (must be power of two) +#define SMALL_GRANULARITY 16 +//! Small granularity shift count +#define SMALL_GRANULARITY_SHIFT 4 +//! Number of small block size classes +#define SMALL_CLASS_COUNT 65 +//! Maximum size of a small block +#define SMALL_SIZE_LIMIT (SMALL_GRANULARITY * (SMALL_CLASS_COUNT - 1)) +//! Granularity of a medium allocation block +#define MEDIUM_GRANULARITY 512 +//! Medium granularity shift count +#define MEDIUM_GRANULARITY_SHIFT 9 +//! Number of medium block size classes +#define MEDIUM_CLASS_COUNT 61 +//! Total number of small + medium size classes +#define SIZE_CLASS_COUNT (SMALL_CLASS_COUNT + MEDIUM_CLASS_COUNT) +//! Number of large block size classes +#define LARGE_CLASS_COUNT 63 +//! Maximum size of a medium block +#define MEDIUM_SIZE_LIMIT (SMALL_SIZE_LIMIT + (MEDIUM_GRANULARITY * MEDIUM_CLASS_COUNT)) +//! Maximum size of a large block +#define LARGE_SIZE_LIMIT ((LARGE_CLASS_COUNT * _memory_span_size) - SPAN_HEADER_SIZE) +//! Size of a span header (must be a multiple of SMALL_GRANULARITY and a power of two) +#define SPAN_HEADER_SIZE 128 +//! Number of spans in thread cache +#define MAX_THREAD_SPAN_CACHE 400 +//! Number of spans to transfer between thread and global cache +#define THREAD_SPAN_CACHE_TRANSFER 64 +//! Number of spans in thread cache for large spans (must be greater than LARGE_CLASS_COUNT / 2) +#define MAX_THREAD_SPAN_LARGE_CACHE 100 +//! Number of spans to transfer between thread and global cache for large spans +#define THREAD_SPAN_LARGE_CACHE_TRANSFER 6 + +static_assert((SMALL_GRANULARITY & (SMALL_GRANULARITY - 1)) == 0, "Small granularity must be power of two"); +static_assert((SPAN_HEADER_SIZE & (SPAN_HEADER_SIZE - 1)) == 0, "Span header size must be power of two"); + +#if ENABLE_VALIDATE_ARGS +//! Maximum allocation size to avoid integer overflow +#undef MAX_ALLOC_SIZE +#define MAX_ALLOC_SIZE (((size_t)-1) - _memory_span_size) +#endif + +#define pointer_offset(ptr, ofs) (void*)((char*)(ptr) + (ptrdiff_t)(ofs)) +#define pointer_diff(first, second) (ptrdiff_t)((const char*)(first) - (const char*)(second)) + +#define INVALID_POINTER ((void*)((uintptr_t)-1)) + +#define SIZE_CLASS_LARGE SIZE_CLASS_COUNT +#define SIZE_CLASS_HUGE ((uint32_t)-1) + +//////////// +/// +/// Data types +/// +////// + +namespace tracy +{ + +//! A memory heap, per thread +typedef struct heap_t heap_t; +//! Span of memory pages +typedef struct span_t span_t; +//! Span list +typedef struct span_list_t span_list_t; +//! Span active data +typedef struct span_active_t span_active_t; +//! Size class definition +typedef struct size_class_t size_class_t; +//! Global cache +typedef struct global_cache_t global_cache_t; + +//! Flag indicating span is the first (master) span of a split superspan +#define SPAN_FLAG_MASTER 1U +//! Flag indicating span is a secondary (sub) span of a split superspan +#define SPAN_FLAG_SUBSPAN 2U +//! Flag indicating span has blocks with increased alignment +#define SPAN_FLAG_ALIGNED_BLOCKS 4U +//! Flag indicating an unmapped master span +#define SPAN_FLAG_UNMAPPED_MASTER 8U + +#if ENABLE_ADAPTIVE_THREAD_CACHE || ENABLE_STATISTICS +struct span_use_t { + //! Current number of spans used (actually used, not in cache) + atomic32_t current; + //! High water mark of spans used + atomic32_t high; +#if ENABLE_STATISTICS + //! Number of spans in deferred list + atomic32_t spans_deferred; + //! Number of spans transitioned to global cache + atomic32_t spans_to_global; + //! Number of spans transitioned from global cache + atomic32_t spans_from_global; + //! Number of spans transitioned to thread cache + atomic32_t spans_to_cache; + //! Number of spans transitioned from thread cache + atomic32_t spans_from_cache; + //! Number of spans transitioned to reserved state + atomic32_t spans_to_reserved; + //! Number of spans transitioned from reserved state + atomic32_t spans_from_reserved; + //! Number of raw memory map calls + atomic32_t spans_map_calls; +#endif +}; +typedef struct span_use_t span_use_t; +#endif + +#if ENABLE_STATISTICS +struct size_class_use_t { + //! Current number of allocations + atomic32_t alloc_current; + //! Peak number of allocations + int32_t alloc_peak; + //! Total number of allocations + atomic32_t alloc_total; + //! Total number of frees + atomic32_t free_total; + //! Number of spans in use + atomic32_t spans_current; + //! Number of spans transitioned to cache + int32_t spans_peak; + //! Number of spans transitioned to cache + atomic32_t spans_to_cache; + //! Number of spans transitioned from cache + atomic32_t spans_from_cache; + //! Number of spans transitioned from reserved state + atomic32_t spans_from_reserved; + //! Number of spans mapped + atomic32_t spans_map_calls; + int32_t unused; +}; +typedef struct size_class_use_t size_class_use_t; +#endif + +// A span can either represent a single span of memory pages with size declared by span_map_count configuration variable, +// or a set of spans in a continuous region, a super span. Any reference to the term "span" usually refers to both a single +// span or a super span. A super span can further be divided into multiple spans (or this, super spans), where the first +// (super)span is the master and subsequent (super)spans are subspans. The master span keeps track of how many subspans +// that are still alive and mapped in virtual memory, and once all subspans and master have been unmapped the entire +// superspan region is released and unmapped (on Windows for example, the entire superspan range has to be released +// in the same call to release the virtual memory range, but individual subranges can be decommitted individually +// to reduce physical memory use). +struct span_t { + //! Free list + void* free_list; + //! Total block count of size class + uint32_t block_count; + //! Size class + uint32_t size_class; + //! Index of last block initialized in free list + uint32_t free_list_limit; + //! Number of used blocks remaining when in partial state + uint32_t used_count; + //! Deferred free list + atomicptr_t free_list_deferred; + //! Size of deferred free list, or list of spans when part of a cache list + uint32_t list_size; + //! Size of a block + uint32_t block_size; + //! Flags and counters + uint32_t flags; + //! Number of spans + uint32_t span_count; + //! Total span counter for master spans + uint32_t total_spans; + //! Offset from master span for subspans + uint32_t offset_from_master; + //! Remaining span counter, for master spans + atomic32_t remaining_spans; + //! Alignment offset + uint32_t align_offset; + //! Owning heap + heap_t* heap; + //! Next span + span_t* next; + //! Previous span + span_t* prev; +}; +static_assert(sizeof(span_t) <= SPAN_HEADER_SIZE, "span size mismatch"); + +struct span_cache_t { + size_t count; + span_t* span[MAX_THREAD_SPAN_CACHE]; +}; +typedef struct span_cache_t span_cache_t; + +struct span_large_cache_t { + size_t count; + span_t* span[MAX_THREAD_SPAN_LARGE_CACHE]; +}; +typedef struct span_large_cache_t span_large_cache_t; + +struct heap_size_class_t { + //! Free list of active span + void* free_list; + //! Double linked list of partially used spans with free blocks. + // Previous span pointer in head points to tail span of list. + span_t* partial_span; + //! Early level cache of fully free spans + span_t* cache; +}; +typedef struct heap_size_class_t heap_size_class_t; + +// Control structure for a heap, either a thread heap or a first class heap if enabled +struct heap_t { + //! Owning thread ID + uintptr_t owner_thread; + //! Free lists for each size class + heap_size_class_t size_class[SIZE_CLASS_COUNT]; +#if ENABLE_THREAD_CACHE + //! Arrays of fully freed spans, single span + span_cache_t span_cache; +#endif + //! List of deferred free spans (single linked list) + atomicptr_t span_free_deferred; + //! Number of full spans + size_t full_span_count; + //! Mapped but unused spans + span_t* span_reserve; + //! Master span for mapped but unused spans + span_t* span_reserve_master; + //! Number of mapped but unused spans + uint32_t spans_reserved; + //! Child count + atomic32_t child_count; + //! Next heap in id list + heap_t* next_heap; + //! Next heap in orphan list + heap_t* next_orphan; + //! Heap ID + int32_t id; + //! Finalization state flag + int finalize; + //! Master heap owning the memory pages + heap_t* master_heap; +#if ENABLE_THREAD_CACHE + //! Arrays of fully freed spans, large spans with > 1 span count + span_large_cache_t span_large_cache[LARGE_CLASS_COUNT - 1]; +#endif +#if RPMALLOC_FIRST_CLASS_HEAPS + //! Double linked list of fully utilized spans with free blocks for each size class. + // Previous span pointer in head points to tail span of list. + span_t* full_span[SIZE_CLASS_COUNT]; + //! Double linked list of large and huge spans allocated by this heap + span_t* large_huge_span; +#endif +#if ENABLE_ADAPTIVE_THREAD_CACHE || ENABLE_STATISTICS + //! Current and high water mark of spans used per span count + span_use_t span_use[LARGE_CLASS_COUNT]; +#endif +#if ENABLE_STATISTICS + //! Allocation stats per size class + size_class_use_t size_class_use[SIZE_CLASS_COUNT + 1]; + //! Number of bytes transitioned thread -> global + atomic64_t thread_to_global; + //! Number of bytes transitioned global -> thread + atomic64_t global_to_thread; +#endif +}; + +// Size class for defining a block size bucket +struct size_class_t { + //! Size of blocks in this class + uint32_t block_size; + //! Number of blocks in each chunk + uint16_t block_count; + //! Class index this class is merged with + uint16_t class_idx; +}; +static_assert(sizeof(size_class_t) == 8, "Size class size mismatch"); + +struct global_cache_t { + //! Cache lock + atomic32_t lock; + //! Cache count + uint32_t count; +#if ENABLE_STATISTICS + //! Insert count + size_t insert_count; + //! Extract count + size_t extract_count; +#endif + //! Cached spans + span_t* span[GLOBAL_CACHE_MULTIPLIER * MAX_THREAD_SPAN_CACHE]; + //! Unlimited cache overflow + span_t* overflow; +}; + +//////////// +/// +/// Global data +/// +////// + +//! Default span size (64KiB) +#define _memory_default_span_size (64 * 1024) +#define _memory_default_span_size_shift 16 +#define _memory_default_span_mask (~((uintptr_t)(_memory_span_size - 1))) + +//! Initialized flag +static int _rpmalloc_initialized; +//! Main thread ID +static uintptr_t _rpmalloc_main_thread_id; +//! Configuration +static rpmalloc_config_t _memory_config; +//! Memory page size +static size_t _memory_page_size; +//! Shift to divide by page size +static size_t _memory_page_size_shift; +//! Granularity at which memory pages are mapped by OS +static size_t _memory_map_granularity; +#if RPMALLOC_CONFIGURABLE +//! Size of a span of memory pages +static size_t _memory_span_size; +//! Shift to divide by span size +static size_t _memory_span_size_shift; +//! Mask to get to start of a memory span +static uintptr_t _memory_span_mask; +#else +//! Hardwired span size +#define _memory_span_size _memory_default_span_size +#define _memory_span_size_shift _memory_default_span_size_shift +#define _memory_span_mask _memory_default_span_mask +#endif +//! Number of spans to map in each map call +static size_t _memory_span_map_count; +//! Number of spans to keep reserved in each heap +static size_t _memory_heap_reserve_count; +//! Global size classes +static size_class_t _memory_size_class[SIZE_CLASS_COUNT]; +//! Run-time size limit of medium blocks +static size_t _memory_medium_size_limit; +//! Heap ID counter +static atomic32_t _memory_heap_id; +//! Huge page support +static int _memory_huge_pages; +#if ENABLE_GLOBAL_CACHE +//! Global span cache +static global_cache_t _memory_span_cache[LARGE_CLASS_COUNT]; +#endif +//! Global reserved spans +static span_t* _memory_global_reserve; +//! Global reserved count +static size_t _memory_global_reserve_count; +//! Global reserved master +static span_t* _memory_global_reserve_master; +//! All heaps +static heap_t* _memory_heaps[HEAP_ARRAY_SIZE]; +//! Used to restrict access to mapping memory for huge pages +static atomic32_t _memory_global_lock; +//! Orphaned heaps +static heap_t* _memory_orphan_heaps; +#if RPMALLOC_FIRST_CLASS_HEAPS +//! Orphaned heaps (first class heaps) +static heap_t* _memory_first_class_orphan_heaps; +#endif +#if ENABLE_STATISTICS +//! Allocations counter +static atomic64_t _allocation_counter; +//! Deallocations counter +static atomic64_t _deallocation_counter; +//! Active heap count +static atomic32_t _memory_active_heaps; +//! Number of currently mapped memory pages +static atomic32_t _mapped_pages; +//! Peak number of concurrently mapped memory pages +static int32_t _mapped_pages_peak; +//! Number of mapped master spans +static atomic32_t _master_spans; +//! Number of unmapped dangling master spans +static atomic32_t _unmapped_master_spans; +//! Running counter of total number of mapped memory pages since start +static atomic32_t _mapped_total; +//! Running counter of total number of unmapped memory pages since start +static atomic32_t _unmapped_total; +//! Number of currently mapped memory pages in OS calls +static atomic32_t _mapped_pages_os; +//! Number of currently allocated pages in huge allocations +static atomic32_t _huge_pages_current; +//! Peak number of currently allocated pages in huge allocations +static int32_t _huge_pages_peak; +#endif + +//////////// +/// +/// Thread local heap and ID +/// +////// + +//! Current thread heap +#if ((defined(__APPLE__) || defined(__HAIKU__)) && ENABLE_PRELOAD) || defined(__TINYC__) +static pthread_key_t _memory_thread_heap; +#else +# ifdef _MSC_VER +# define _Thread_local __declspec(thread) +# define TLS_MODEL +# else +# ifndef __HAIKU__ +# define TLS_MODEL __attribute__((tls_model("initial-exec"))) +# else +# define TLS_MODEL +# endif +# if !defined(__clang__) && defined(__GNUC__) +# define _Thread_local __thread +# endif +# endif +static _Thread_local heap_t* _memory_thread_heap TLS_MODEL; +#endif + +static inline heap_t* +get_thread_heap_raw(void) { +#if (defined(__APPLE__) || defined(__HAIKU__)) && ENABLE_PRELOAD + return pthread_getspecific(_memory_thread_heap); +#else + return _memory_thread_heap; +#endif +} + +//! Get the current thread heap +static inline heap_t* +get_thread_heap(void) { + heap_t* heap = get_thread_heap_raw(); +#if ENABLE_PRELOAD + if (EXPECTED(heap != 0)) + return heap; + rpmalloc_initialize(); + return get_thread_heap_raw(); +#else + return heap; +#endif +} + +//! Fast thread ID +static inline uintptr_t +get_thread_id(void) { +#if defined(_WIN32) + return (uintptr_t)((void*)NtCurrentTeb()); +#elif (defined(__GNUC__) || defined(__clang__)) && !defined(__CYGWIN__) + uintptr_t tid; +# if defined(__i386__) + __asm__("movl %%gs:0, %0" : "=r" (tid) : : ); +# elif defined(__x86_64__) +# if defined(__MACH__) + __asm__("movq %%gs:0, %0" : "=r" (tid) : : ); +# else + __asm__("movq %%fs:0, %0" : "=r" (tid) : : ); +# endif +# elif defined(__arm__) + __asm__ volatile ("mrc p15, 0, %0, c13, c0, 3" : "=r" (tid)); +# elif defined(__aarch64__) +# if defined(__MACH__) + // tpidr_el0 likely unused, always return 0 on iOS + __asm__ volatile ("mrs %0, tpidrro_el0" : "=r" (tid)); +# else + __asm__ volatile ("mrs %0, tpidr_el0" : "=r" (tid)); +# endif +# else + tid = (uintptr_t)((void*)get_thread_heap_raw()); +# endif + return tid; +#else + return (uintptr_t)((void*)get_thread_heap_raw()); +#endif +} + +//! Set the current thread heap +static void +set_thread_heap(heap_t* heap) { +#if ((defined(__APPLE__) || defined(__HAIKU__)) && ENABLE_PRELOAD) || defined(__TINYC__) + pthread_setspecific(_memory_thread_heap, heap); +#else + _memory_thread_heap = heap; +#endif + if (heap) + heap->owner_thread = get_thread_id(); +} + +//! Set main thread ID +extern void +rpmalloc_set_main_thread(void); + +void +rpmalloc_set_main_thread(void) { + _rpmalloc_main_thread_id = get_thread_id(); +} + +static void +_rpmalloc_spin(void) { +#if defined(_MSC_VER) && !(defined(_M_ARM) || defined(_M_ARM64)) + _mm_pause(); +#elif defined(__x86_64__) || defined(__i386__) + __asm__ volatile("pause" ::: "memory"); +#elif defined(__aarch64__) || (defined(__arm__) && __ARM_ARCH >= 7) + __asm__ volatile("yield" ::: "memory"); +#elif defined(__powerpc__) || defined(__powerpc64__) + // No idea if ever been compiled in such archs but ... as precaution + __asm__ volatile("or 27,27,27"); +#elif defined(__sparc__) + __asm__ volatile("rd %ccr, %g0 \n\trd %ccr, %g0 \n\trd %ccr, %g0"); +#else + std::this_thread::yield(); +#endif +} + +#if defined(_WIN32) && (!defined(BUILD_DYNAMIC_LINK) || !BUILD_DYNAMIC_LINK) +static void NTAPI +_rpmalloc_thread_destructor(void* value) { +#if ENABLE_OVERRIDE + // If this is called on main thread it means rpmalloc_finalize + // has not been called and shutdown is forced (through _exit) or unclean + if (get_thread_id() == _rpmalloc_main_thread_id) + return; +#endif + if (value) + rpmalloc_thread_finalize(1); +} +#endif + + +//////////// +/// +/// Low level memory map/unmap +/// +////// + +static void +_rpmalloc_set_name(void* address, size_t size) { +#if defined(__linux__) || defined(__ANDROID__) + const char *name = _memory_huge_pages ? _memory_config.huge_page_name : _memory_config.page_name; + if (address == MAP_FAILED || !name) + return; + // If the kernel does not support CONFIG_ANON_VMA_NAME or if the call fails + // (e.g. invalid name) it is a no-op basically. + (void)prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, (uintptr_t)address, size, (uintptr_t)name); +#else + (void)sizeof(size); + (void)sizeof(address); +#endif +} + + +//! Map more virtual memory +// size is number of bytes to map +// offset receives the offset in bytes from start of mapped region +// returns address to start of mapped region to use +static void* +_rpmalloc_mmap(size_t size, size_t* offset) { + rpmalloc_assert(!(size % _memory_page_size), "Invalid mmap size"); + rpmalloc_assert(size >= _memory_page_size, "Invalid mmap size"); + void* address = _memory_config.memory_map(size, offset); + if (EXPECTED(address != 0)) { + _rpmalloc_stat_add_peak(&_mapped_pages, (size >> _memory_page_size_shift), _mapped_pages_peak); + _rpmalloc_stat_add(&_mapped_total, (size >> _memory_page_size_shift)); + } + return address; +} + +//! Unmap virtual memory +// address is the memory address to unmap, as returned from _memory_map +// size is the number of bytes to unmap, which might be less than full region for a partial unmap +// offset is the offset in bytes to the actual mapped region, as set by _memory_map +// release is set to 0 for partial unmap, or size of entire range for a full unmap +static void +_rpmalloc_unmap(void* address, size_t size, size_t offset, size_t release) { + rpmalloc_assert(!release || (release >= size), "Invalid unmap size"); + rpmalloc_assert(!release || (release >= _memory_page_size), "Invalid unmap size"); + if (release) { + rpmalloc_assert(!(release % _memory_page_size), "Invalid unmap size"); + _rpmalloc_stat_sub(&_mapped_pages, (release >> _memory_page_size_shift)); + _rpmalloc_stat_add(&_unmapped_total, (release >> _memory_page_size_shift)); + } + _memory_config.memory_unmap(address, size, offset, release); +} + +//! Default implementation to map new pages to virtual memory +static void* +_rpmalloc_mmap_os(size_t size, size_t* offset) { + //Either size is a heap (a single page) or a (multiple) span - we only need to align spans, and only if larger than map granularity + size_t padding = ((size >= _memory_span_size) && (_memory_span_size > _memory_map_granularity)) ? _memory_span_size : 0; + rpmalloc_assert(size >= _memory_page_size, "Invalid mmap size"); +#if PLATFORM_WINDOWS + //Ok to MEM_COMMIT - according to MSDN, "actual physical pages are not allocated unless/until the virtual addresses are actually accessed" + void* ptr = VirtualAlloc(0, size + padding, (_memory_huge_pages ? MEM_LARGE_PAGES : 0) | MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); + if (!ptr) { + if (_memory_config.map_fail_callback) { + if (_memory_config.map_fail_callback(size + padding)) + return _rpmalloc_mmap_os(size, offset); + } else { + rpmalloc_assert(ptr, "Failed to map virtual memory block"); + } + return 0; + } +#else + int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_UNINITIALIZED; +# if defined(__APPLE__) && !TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR + int fd = (int)VM_MAKE_TAG(240U); + if (_memory_huge_pages) + fd |= VM_FLAGS_SUPERPAGE_SIZE_2MB; + void* ptr = mmap(0, size + padding, PROT_READ | PROT_WRITE, flags, fd, 0); +# elif defined(MAP_HUGETLB) + void* ptr = mmap(0, size + padding, PROT_READ | PROT_WRITE | PROT_MAX(PROT_READ | PROT_WRITE), (_memory_huge_pages ? MAP_HUGETLB : 0) | flags, -1, 0); +# if defined(MADV_HUGEPAGE) + // In some configurations, huge pages allocations might fail thus + // we fallback to normal allocations and promote the region as transparent huge page + if ((ptr == MAP_FAILED || !ptr) && _memory_huge_pages) { + ptr = mmap(0, size + padding, PROT_READ | PROT_WRITE, flags, -1, 0); + if (ptr && ptr != MAP_FAILED) { + int prm = madvise(ptr, size + padding, MADV_HUGEPAGE); + (void)prm; + rpmalloc_assert((prm == 0), "Failed to promote the page to THP"); + } + } +# endif + _rpmalloc_set_name(ptr, size + padding); +# elif defined(MAP_ALIGNED) + const size_t align = (sizeof(size_t) * 8) - (size_t)(__builtin_clzl(size - 1)); + void* ptr = mmap(0, size + padding, PROT_READ | PROT_WRITE, (_memory_huge_pages ? MAP_ALIGNED(align) : 0) | flags, -1, 0); +# elif defined(MAP_ALIGN) + caddr_t base = (_memory_huge_pages ? (caddr_t)(4 << 20) : 0); + void* ptr = mmap(base, size + padding, PROT_READ | PROT_WRITE, (_memory_huge_pages ? MAP_ALIGN : 0) | flags, -1, 0); +# else + void* ptr = mmap(0, size + padding, PROT_READ | PROT_WRITE, flags, -1, 0); +# endif + if ((ptr == MAP_FAILED) || !ptr) { + if (_memory_config.map_fail_callback) { + if (_memory_config.map_fail_callback(size + padding)) + return _rpmalloc_mmap_os(size, offset); + } else if (errno != ENOMEM) { + rpmalloc_assert((ptr != MAP_FAILED) && ptr, "Failed to map virtual memory block"); + } + return 0; + } +#endif + _rpmalloc_stat_add(&_mapped_pages_os, (int32_t)((size + padding) >> _memory_page_size_shift)); + if (padding) { + size_t final_padding = padding - ((uintptr_t)ptr & ~_memory_span_mask); + rpmalloc_assert(final_padding <= _memory_span_size, "Internal failure in padding"); + rpmalloc_assert(final_padding <= padding, "Internal failure in padding"); + rpmalloc_assert(!(final_padding % 8), "Internal failure in padding"); + ptr = pointer_offset(ptr, final_padding); + *offset = final_padding >> 3; + } + rpmalloc_assert((size < _memory_span_size) || !((uintptr_t)ptr & ~_memory_span_mask), "Internal failure in padding"); + return ptr; +} + +//! Default implementation to unmap pages from virtual memory +static void +_rpmalloc_unmap_os(void* address, size_t size, size_t offset, size_t release) { + rpmalloc_assert(release || (offset == 0), "Invalid unmap size"); + rpmalloc_assert(!release || (release >= _memory_page_size), "Invalid unmap size"); + rpmalloc_assert(size >= _memory_page_size, "Invalid unmap size"); + if (release && offset) { + offset <<= 3; + address = pointer_offset(address, -(int32_t)offset); + if ((release >= _memory_span_size) && (_memory_span_size > _memory_map_granularity)) { + //Padding is always one span size + release += _memory_span_size; + } + } +#if !DISABLE_UNMAP +#if PLATFORM_WINDOWS + if (!VirtualFree(address, release ? 0 : size, release ? MEM_RELEASE : MEM_DECOMMIT)) { + rpmalloc_assert(0, "Failed to unmap virtual memory block"); + } +#else + if (release) { + if (munmap(address, release)) { + rpmalloc_assert(0, "Failed to unmap virtual memory block"); + } + } else { +#if defined(MADV_FREE_REUSABLE) + int ret; + while ((ret = madvise(address, size, MADV_FREE_REUSABLE)) == -1 && (errno == EAGAIN)) + errno = 0; + if ((ret == -1) && (errno != 0)) { +#elif defined(MADV_DONTNEED) + if (madvise(address, size, MADV_DONTNEED)) { +#elif defined(MADV_PAGEOUT) + if (madvise(address, size, MADV_PAGEOUT)) { +#elif defined(MADV_FREE) + if (madvise(address, size, MADV_FREE)) { +#else + if (posix_madvise(address, size, POSIX_MADV_DONTNEED)) { +#endif + rpmalloc_assert(0, "Failed to madvise virtual memory block as free"); + } + } +#endif +#endif + if (release) + _rpmalloc_stat_sub(&_mapped_pages_os, release >> _memory_page_size_shift); +} + +static void +_rpmalloc_span_mark_as_subspan_unless_master(span_t* master, span_t* subspan, size_t span_count); + +//! Use global reserved spans to fulfill a memory map request (reserve size must be checked by caller) +static span_t* +_rpmalloc_global_get_reserved_spans(size_t span_count) { + span_t* span = _memory_global_reserve; + _rpmalloc_span_mark_as_subspan_unless_master(_memory_global_reserve_master, span, span_count); + _memory_global_reserve_count -= span_count; + if (_memory_global_reserve_count) + _memory_global_reserve = (span_t*)pointer_offset(span, span_count << _memory_span_size_shift); + else + _memory_global_reserve = 0; + return span; +} + +//! Store the given spans as global reserve (must only be called from within new heap allocation, not thread safe) +static void +_rpmalloc_global_set_reserved_spans(span_t* master, span_t* reserve, size_t reserve_span_count) { + _memory_global_reserve_master = master; + _memory_global_reserve_count = reserve_span_count; + _memory_global_reserve = reserve; +} + + +//////////// +/// +/// Span linked list management +/// +////// + +//! Add a span to double linked list at the head +static void +_rpmalloc_span_double_link_list_add(span_t** head, span_t* span) { + if (*head) + (*head)->prev = span; + span->next = *head; + *head = span; +} + +//! Pop head span from double linked list +static void +_rpmalloc_span_double_link_list_pop_head(span_t** head, span_t* span) { + rpmalloc_assert(*head == span, "Linked list corrupted"); + span = *head; + *head = span->next; +} + +//! Remove a span from double linked list +static void +_rpmalloc_span_double_link_list_remove(span_t** head, span_t* span) { + rpmalloc_assert(*head, "Linked list corrupted"); + if (*head == span) { + *head = span->next; + } else { + span_t* next_span = span->next; + span_t* prev_span = span->prev; + prev_span->next = next_span; + if (EXPECTED(next_span != 0)) + next_span->prev = prev_span; + } +} + + +//////////// +/// +/// Span control +/// +////// + +static void +_rpmalloc_heap_cache_insert(heap_t* heap, span_t* span); + +static void +_rpmalloc_heap_finalize(heap_t* heap); + +static void +_rpmalloc_heap_set_reserved_spans(heap_t* heap, span_t* master, span_t* reserve, size_t reserve_span_count); + +//! Declare the span to be a subspan and store distance from master span and span count +static void +_rpmalloc_span_mark_as_subspan_unless_master(span_t* master, span_t* subspan, size_t span_count) { + rpmalloc_assert((subspan != master) || (subspan->flags & SPAN_FLAG_MASTER), "Span master pointer and/or flag mismatch"); + if (subspan != master) { + subspan->flags = SPAN_FLAG_SUBSPAN; + subspan->offset_from_master = (uint32_t)((uintptr_t)pointer_diff(subspan, master) >> _memory_span_size_shift); + subspan->align_offset = 0; + } + subspan->span_count = (uint32_t)span_count; +} + +//! Use reserved spans to fulfill a memory map request (reserve size must be checked by caller) +static span_t* +_rpmalloc_span_map_from_reserve(heap_t* heap, size_t span_count) { + //Update the heap span reserve + span_t* span = heap->span_reserve; + heap->span_reserve = (span_t*)pointer_offset(span, span_count * _memory_span_size); + heap->spans_reserved -= (uint32_t)span_count; + + _rpmalloc_span_mark_as_subspan_unless_master(heap->span_reserve_master, span, span_count); + if (span_count <= LARGE_CLASS_COUNT) + _rpmalloc_stat_inc(&heap->span_use[span_count - 1].spans_from_reserved); + + return span; +} + +//! Get the aligned number of spans to map in based on wanted count, configured mapping granularity and the page size +static size_t +_rpmalloc_span_align_count(size_t span_count) { + size_t request_count = (span_count > _memory_span_map_count) ? span_count : _memory_span_map_count; + if ((_memory_page_size > _memory_span_size) && ((request_count * _memory_span_size) % _memory_page_size)) + request_count += _memory_span_map_count - (request_count % _memory_span_map_count); + return request_count; +} + +//! Setup a newly mapped span +static void +_rpmalloc_span_initialize(span_t* span, size_t total_span_count, size_t span_count, size_t align_offset) { + span->total_spans = (uint32_t)total_span_count; + span->span_count = (uint32_t)span_count; + span->align_offset = (uint32_t)align_offset; + span->flags = SPAN_FLAG_MASTER; + atomic_store32(&span->remaining_spans, (int32_t)total_span_count); +} + +static void +_rpmalloc_span_unmap(span_t* span); + +//! Map an aligned set of spans, taking configured mapping granularity and the page size into account +static span_t* +_rpmalloc_span_map_aligned_count(heap_t* heap, size_t span_count) { + //If we already have some, but not enough, reserved spans, release those to heap cache and map a new + //full set of spans. Otherwise we would waste memory if page size > span size (huge pages) + size_t aligned_span_count = _rpmalloc_span_align_count(span_count); + size_t align_offset = 0; + span_t* span = (span_t*)_rpmalloc_mmap(aligned_span_count * _memory_span_size, &align_offset); + if (!span) + return 0; + _rpmalloc_span_initialize(span, aligned_span_count, span_count, align_offset); + _rpmalloc_stat_inc(&_master_spans); + if (span_count <= LARGE_CLASS_COUNT) + _rpmalloc_stat_inc(&heap->span_use[span_count - 1].spans_map_calls); + if (aligned_span_count > span_count) { + span_t* reserved_spans = (span_t*)pointer_offset(span, span_count * _memory_span_size); + size_t reserved_count = aligned_span_count - span_count; + if (heap->spans_reserved) { + _rpmalloc_span_mark_as_subspan_unless_master(heap->span_reserve_master, heap->span_reserve, heap->spans_reserved); + _rpmalloc_heap_cache_insert(heap, heap->span_reserve); + } + if (reserved_count > _memory_heap_reserve_count) { + // If huge pages or eager spam map count, the global reserve spin lock is held by caller, _rpmalloc_span_map + rpmalloc_assert(atomic_load32(&_memory_global_lock) == 1, "Global spin lock not held as expected"); + size_t remain_count = reserved_count - _memory_heap_reserve_count; + reserved_count = _memory_heap_reserve_count; + span_t* remain_span = (span_t*)pointer_offset(reserved_spans, reserved_count * _memory_span_size); + if (_memory_global_reserve) { + _rpmalloc_span_mark_as_subspan_unless_master(_memory_global_reserve_master, _memory_global_reserve, _memory_global_reserve_count); + _rpmalloc_span_unmap(_memory_global_reserve); + } + _rpmalloc_global_set_reserved_spans(span, remain_span, remain_count); + } + _rpmalloc_heap_set_reserved_spans(heap, span, reserved_spans, reserved_count); + } + return span; +} + +//! Map in memory pages for the given number of spans (or use previously reserved pages) +static span_t* +_rpmalloc_span_map(heap_t* heap, size_t span_count) { + if (span_count <= heap->spans_reserved) + return _rpmalloc_span_map_from_reserve(heap, span_count); + span_t* span = 0; + int use_global_reserve = (_memory_page_size > _memory_span_size) || (_memory_span_map_count > _memory_heap_reserve_count); + if (use_global_reserve) { + // If huge pages, make sure only one thread maps more memory to avoid bloat + while (!atomic_cas32_acquire(&_memory_global_lock, 1, 0)) + _rpmalloc_spin(); + if (_memory_global_reserve_count >= span_count) { + size_t reserve_count = (!heap->spans_reserved ? _memory_heap_reserve_count : span_count); + if (_memory_global_reserve_count < reserve_count) + reserve_count = _memory_global_reserve_count; + span = _rpmalloc_global_get_reserved_spans(reserve_count); + if (span) { + if (reserve_count > span_count) { + span_t* reserved_span = (span_t*)pointer_offset(span, span_count << _memory_span_size_shift); + _rpmalloc_heap_set_reserved_spans(heap, _memory_global_reserve_master, reserved_span, reserve_count - span_count); + } + // Already marked as subspan in _rpmalloc_global_get_reserved_spans + span->span_count = (uint32_t)span_count; + } + } + } + if (!span) + span = _rpmalloc_span_map_aligned_count(heap, span_count); + if (use_global_reserve) + atomic_store32_release(&_memory_global_lock, 0); + return span; +} + +//! Unmap memory pages for the given number of spans (or mark as unused if no partial unmappings) +static void +_rpmalloc_span_unmap(span_t* span) { + rpmalloc_assert((span->flags & SPAN_FLAG_MASTER) || (span->flags & SPAN_FLAG_SUBSPAN), "Span flag corrupted"); + rpmalloc_assert(!(span->flags & SPAN_FLAG_MASTER) || !(span->flags & SPAN_FLAG_SUBSPAN), "Span flag corrupted"); + + int is_master = !!(span->flags & SPAN_FLAG_MASTER); + span_t* master = is_master ? span : ((span_t*)pointer_offset(span, -(intptr_t)((uintptr_t)span->offset_from_master * _memory_span_size))); + rpmalloc_assert(is_master || (span->flags & SPAN_FLAG_SUBSPAN), "Span flag corrupted"); + rpmalloc_assert(master->flags & SPAN_FLAG_MASTER, "Span flag corrupted"); + + size_t span_count = span->span_count; + if (!is_master) { + //Directly unmap subspans (unless huge pages, in which case we defer and unmap entire page range with master) + rpmalloc_assert(span->align_offset == 0, "Span align offset corrupted"); + if (_memory_span_size >= _memory_page_size) + _rpmalloc_unmap(span, span_count * _memory_span_size, 0, 0); + } else { + //Special double flag to denote an unmapped master + //It must be kept in memory since span header must be used + span->flags |= SPAN_FLAG_MASTER | SPAN_FLAG_SUBSPAN | SPAN_FLAG_UNMAPPED_MASTER; + _rpmalloc_stat_add(&_unmapped_master_spans, 1); + } + + if (atomic_add32(&master->remaining_spans, -(int32_t)span_count) <= 0) { + //Everything unmapped, unmap the master span with release flag to unmap the entire range of the super span + rpmalloc_assert(!!(master->flags & SPAN_FLAG_MASTER) && !!(master->flags & SPAN_FLAG_SUBSPAN), "Span flag corrupted"); + size_t unmap_count = master->span_count; + if (_memory_span_size < _memory_page_size) + unmap_count = master->total_spans; + _rpmalloc_stat_sub(&_master_spans, 1); + _rpmalloc_stat_sub(&_unmapped_master_spans, 1); + _rpmalloc_unmap(master, unmap_count * _memory_span_size, master->align_offset, (size_t)master->total_spans * _memory_span_size); + } +} + +//! Move the span (used for small or medium allocations) to the heap thread cache +static void +_rpmalloc_span_release_to_cache(heap_t* heap, span_t* span) { + rpmalloc_assert(heap == span->heap, "Span heap pointer corrupted"); + rpmalloc_assert(span->size_class < SIZE_CLASS_COUNT, "Invalid span size class"); + rpmalloc_assert(span->span_count == 1, "Invalid span count"); +#if ENABLE_ADAPTIVE_THREAD_CACHE || ENABLE_STATISTICS + atomic_decr32(&heap->span_use[0].current); +#endif + _rpmalloc_stat_dec(&heap->size_class_use[span->size_class].spans_current); + if (!heap->finalize) { + _rpmalloc_stat_inc(&heap->span_use[0].spans_to_cache); + _rpmalloc_stat_inc(&heap->size_class_use[span->size_class].spans_to_cache); + if (heap->size_class[span->size_class].cache) + _rpmalloc_heap_cache_insert(heap, heap->size_class[span->size_class].cache); + heap->size_class[span->size_class].cache = span; + } else { + _rpmalloc_span_unmap(span); + } +} + +//! Initialize a (partial) free list up to next system memory page, while reserving the first block +//! as allocated, returning number of blocks in list +static uint32_t +free_list_partial_init(void** list, void** first_block, void* page_start, void* block_start, uint32_t block_count, uint32_t block_size) { + rpmalloc_assert(block_count, "Internal failure"); + *first_block = block_start; + if (block_count > 1) { + void* free_block = pointer_offset(block_start, block_size); + void* block_end = pointer_offset(block_start, (size_t)block_size * block_count); + //If block size is less than half a memory page, bound init to next memory page boundary + if (block_size < (_memory_page_size >> 1)) { + void* page_end = pointer_offset(page_start, _memory_page_size); + if (page_end < block_end) + block_end = page_end; + } + *list = free_block; + block_count = 2; + void* next_block = pointer_offset(free_block, block_size); + while (next_block < block_end) { + *((void**)free_block) = next_block; + free_block = next_block; + ++block_count; + next_block = pointer_offset(next_block, block_size); + } + *((void**)free_block) = 0; + } else { + *list = 0; + } + return block_count; +} + +//! Initialize an unused span (from cache or mapped) to be new active span, putting the initial free list in heap class free list +static void* +_rpmalloc_span_initialize_new(heap_t* heap, heap_size_class_t* heap_size_class, span_t* span, uint32_t class_idx) { + rpmalloc_assert(span->span_count == 1, "Internal failure"); + size_class_t* size_class = _memory_size_class + class_idx; + span->size_class = class_idx; + span->heap = heap; + span->flags &= ~SPAN_FLAG_ALIGNED_BLOCKS; + span->block_size = size_class->block_size; + span->block_count = size_class->block_count; + span->free_list = 0; + span->list_size = 0; + atomic_store_ptr_release(&span->free_list_deferred, 0); + + //Setup free list. Only initialize one system page worth of free blocks in list + void* block; + span->free_list_limit = free_list_partial_init(&heap_size_class->free_list, &block, + span, pointer_offset(span, SPAN_HEADER_SIZE), size_class->block_count, size_class->block_size); + //Link span as partial if there remains blocks to be initialized as free list, or full if fully initialized + if (span->free_list_limit < span->block_count) { + _rpmalloc_span_double_link_list_add(&heap_size_class->partial_span, span); + span->used_count = span->free_list_limit; + } else { +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_add(&heap->full_span[class_idx], span); +#endif + ++heap->full_span_count; + span->used_count = span->block_count; + } + return block; +} + +static void +_rpmalloc_span_extract_free_list_deferred(span_t* span) { + // We need acquire semantics on the CAS operation since we are interested in the list size + // Refer to _rpmalloc_deallocate_defer_small_or_medium for further comments on this dependency + do { + span->free_list = atomic_exchange_ptr_acquire(&span->free_list_deferred, INVALID_POINTER); + } while (span->free_list == INVALID_POINTER); + span->used_count -= span->list_size; + span->list_size = 0; + atomic_store_ptr_release(&span->free_list_deferred, 0); +} + +static int +_rpmalloc_span_is_fully_utilized(span_t* span) { + rpmalloc_assert(span->free_list_limit <= span->block_count, "Span free list corrupted"); + return !span->free_list && (span->free_list_limit >= span->block_count); +} + +static int +_rpmalloc_span_finalize(heap_t* heap, size_t iclass, span_t* span, span_t** list_head) { + void* free_list = heap->size_class[iclass].free_list; + span_t* class_span = (span_t*)((uintptr_t)free_list & _memory_span_mask); + if (span == class_span) { + // Adopt the heap class free list back into the span free list + void* block = span->free_list; + void* last_block = 0; + while (block) { + last_block = block; + block = *((void**)block); + } + uint32_t free_count = 0; + block = free_list; + while (block) { + ++free_count; + block = *((void**)block); + } + if (last_block) { + *((void**)last_block) = free_list; + } else { + span->free_list = free_list; + } + heap->size_class[iclass].free_list = 0; + span->used_count -= free_count; + } + //If this assert triggers you have memory leaks + rpmalloc_assert(span->list_size == span->used_count, "Memory leak detected"); + if (span->list_size == span->used_count) { + _rpmalloc_stat_dec(&heap->span_use[0].current); + _rpmalloc_stat_dec(&heap->size_class_use[iclass].spans_current); + // This function only used for spans in double linked lists + if (list_head) + _rpmalloc_span_double_link_list_remove(list_head, span); + _rpmalloc_span_unmap(span); + return 1; + } + return 0; +} + + +//////////// +/// +/// Global cache +/// +////// + +#if ENABLE_GLOBAL_CACHE + +//! Finalize a global cache +static void +_rpmalloc_global_cache_finalize(global_cache_t* cache) { + while (!atomic_cas32_acquire(&cache->lock, 1, 0)) + _rpmalloc_spin(); + + for (size_t ispan = 0; ispan < cache->count; ++ispan) + _rpmalloc_span_unmap(cache->span[ispan]); + cache->count = 0; + + while (cache->overflow) { + span_t* span = cache->overflow; + cache->overflow = span->next; + _rpmalloc_span_unmap(span); + } + + atomic_store32_release(&cache->lock, 0); +} + +static void +_rpmalloc_global_cache_insert_spans(span_t** span, size_t span_count, size_t count) { + const size_t cache_limit = (span_count == 1) ? + GLOBAL_CACHE_MULTIPLIER * MAX_THREAD_SPAN_CACHE : + GLOBAL_CACHE_MULTIPLIER * (MAX_THREAD_SPAN_LARGE_CACHE - (span_count >> 1)); + + global_cache_t* cache = &_memory_span_cache[span_count - 1]; + + size_t insert_count = count; + while (!atomic_cas32_acquire(&cache->lock, 1, 0)) + _rpmalloc_spin(); + +#if ENABLE_STATISTICS + cache->insert_count += count; +#endif + if ((cache->count + insert_count) > cache_limit) + insert_count = cache_limit - cache->count; + + memcpy(cache->span + cache->count, span, sizeof(span_t*) * insert_count); + cache->count += (uint32_t)insert_count; + +#if ENABLE_UNLIMITED_CACHE + while (insert_count < count) { +#else + // Enable unlimited cache if huge pages, or we will leak since it is unlikely that an entire huge page + // will be unmapped, and we're unable to partially decommit a huge page + while ((_memory_page_size > _memory_span_size) && (insert_count < count)) { +#endif + span_t* current_span = span[insert_count++]; + current_span->next = cache->overflow; + cache->overflow = current_span; + } + atomic_store32_release(&cache->lock, 0); + + span_t* keep = 0; + for (size_t ispan = insert_count; ispan < count; ++ispan) { + span_t* current_span = span[ispan]; + // Keep master spans that has remaining subspans to avoid dangling them + if ((current_span->flags & SPAN_FLAG_MASTER) && + (atomic_load32(¤t_span->remaining_spans) > (int32_t)current_span->span_count)) { + current_span->next = keep; + keep = current_span; + } else { + _rpmalloc_span_unmap(current_span); + } + } + + if (keep) { + while (!atomic_cas32_acquire(&cache->lock, 1, 0)) + _rpmalloc_spin(); + + size_t islot = 0; + while (keep) { + for (; islot < cache->count; ++islot) { + span_t* current_span = cache->span[islot]; + if (!(current_span->flags & SPAN_FLAG_MASTER) || ((current_span->flags & SPAN_FLAG_MASTER) && + (atomic_load32(¤t_span->remaining_spans) <= (int32_t)current_span->span_count))) { + _rpmalloc_span_unmap(current_span); + cache->span[islot] = keep; + break; + } + } + if (islot == cache->count) + break; + keep = keep->next; + } + + if (keep) { + span_t* tail = keep; + while (tail->next) + tail = tail->next; + tail->next = cache->overflow; + cache->overflow = keep; + } + + atomic_store32_release(&cache->lock, 0); + } +} + +static size_t +_rpmalloc_global_cache_extract_spans(span_t** span, size_t span_count, size_t count) { + global_cache_t* cache = &_memory_span_cache[span_count - 1]; + + size_t extract_count = 0; + while (!atomic_cas32_acquire(&cache->lock, 1, 0)) + _rpmalloc_spin(); + +#if ENABLE_STATISTICS + cache->extract_count += count; +#endif + size_t want = count - extract_count; + if (want > cache->count) + want = cache->count; + + memcpy(span + extract_count, cache->span + (cache->count - want), sizeof(span_t*) * want); + cache->count -= (uint32_t)want; + extract_count += want; + + while ((extract_count < count) && cache->overflow) { + span_t* current_span = cache->overflow; + span[extract_count++] = current_span; + cache->overflow = current_span->next; + } + +#if ENABLE_ASSERTS + for (size_t ispan = 0; ispan < extract_count; ++ispan) { + assert(span[ispan]->span_count == span_count); + } +#endif + + atomic_store32_release(&cache->lock, 0); + + return extract_count; +} + +#endif + +//////////// +/// +/// Heap control +/// +////// + +static void _rpmalloc_deallocate_huge(span_t*); + +//! Store the given spans as reserve in the given heap +static void +_rpmalloc_heap_set_reserved_spans(heap_t* heap, span_t* master, span_t* reserve, size_t reserve_span_count) { + heap->span_reserve_master = master; + heap->span_reserve = reserve; + heap->spans_reserved = (uint32_t)reserve_span_count; +} + +//! Adopt the deferred span cache list, optionally extracting the first single span for immediate re-use +static void +_rpmalloc_heap_cache_adopt_deferred(heap_t* heap, span_t** single_span) { + span_t* span = (span_t*)((void*)atomic_exchange_ptr_acquire(&heap->span_free_deferred, 0)); + while (span) { + span_t* next_span = (span_t*)span->free_list; + rpmalloc_assert(span->heap == heap, "Span heap pointer corrupted"); + if (EXPECTED(span->size_class < SIZE_CLASS_COUNT)) { + rpmalloc_assert(heap->full_span_count, "Heap span counter corrupted"); + --heap->full_span_count; + _rpmalloc_stat_dec(&heap->span_use[0].spans_deferred); +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_remove(&heap->full_span[span->size_class], span); +#endif + _rpmalloc_stat_dec(&heap->span_use[0].current); + _rpmalloc_stat_dec(&heap->size_class_use[span->size_class].spans_current); + if (single_span && !*single_span) + *single_span = span; + else + _rpmalloc_heap_cache_insert(heap, span); + } else { + if (span->size_class == SIZE_CLASS_HUGE) { + _rpmalloc_deallocate_huge(span); + } else { + rpmalloc_assert(span->size_class == SIZE_CLASS_LARGE, "Span size class invalid"); + rpmalloc_assert(heap->full_span_count, "Heap span counter corrupted"); + --heap->full_span_count; +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_remove(&heap->large_huge_span, span); +#endif + uint32_t idx = span->span_count - 1; + _rpmalloc_stat_dec(&heap->span_use[idx].spans_deferred); + _rpmalloc_stat_dec(&heap->span_use[idx].current); + if (!idx && single_span && !*single_span) + *single_span = span; + else + _rpmalloc_heap_cache_insert(heap, span); + } + } + span = next_span; + } +} + +static void +_rpmalloc_heap_unmap(heap_t* heap) { + if (!heap->master_heap) { + if ((heap->finalize > 1) && !atomic_load32(&heap->child_count)) { + span_t* span = (span_t*)((uintptr_t)heap & _memory_span_mask); + _rpmalloc_span_unmap(span); + } + } else { + if (atomic_decr32(&heap->master_heap->child_count) == 0) { + _rpmalloc_heap_unmap(heap->master_heap); + } + } +} + +static void +_rpmalloc_heap_global_finalize(heap_t* heap) { + if (heap->finalize++ > 1) { + --heap->finalize; + return; + } + + _rpmalloc_heap_finalize(heap); + +#if ENABLE_THREAD_CACHE + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + span_cache_t* span_cache; + if (!iclass) + span_cache = &heap->span_cache; + else + span_cache = (span_cache_t*)(heap->span_large_cache + (iclass - 1)); + for (size_t ispan = 0; ispan < span_cache->count; ++ispan) + _rpmalloc_span_unmap(span_cache->span[ispan]); + span_cache->count = 0; + } +#endif + + if (heap->full_span_count) { + --heap->finalize; + return; + } + + for (size_t iclass = 0; iclass < SIZE_CLASS_COUNT; ++iclass) { + if (heap->size_class[iclass].free_list || heap->size_class[iclass].partial_span) { + --heap->finalize; + return; + } + } + //Heap is now completely free, unmap and remove from heap list + size_t list_idx = (size_t)heap->id % HEAP_ARRAY_SIZE; + heap_t* list_heap = _memory_heaps[list_idx]; + if (list_heap == heap) { + _memory_heaps[list_idx] = heap->next_heap; + } else { + while (list_heap->next_heap != heap) + list_heap = list_heap->next_heap; + list_heap->next_heap = heap->next_heap; + } + + _rpmalloc_heap_unmap(heap); +} + +//! Insert a single span into thread heap cache, releasing to global cache if overflow +static void +_rpmalloc_heap_cache_insert(heap_t* heap, span_t* span) { + if (UNEXPECTED(heap->finalize != 0)) { + _rpmalloc_span_unmap(span); + _rpmalloc_heap_global_finalize(heap); + return; + } +#if ENABLE_THREAD_CACHE + size_t span_count = span->span_count; + _rpmalloc_stat_inc(&heap->span_use[span_count - 1].spans_to_cache); + if (span_count == 1) { + span_cache_t* span_cache = &heap->span_cache; + span_cache->span[span_cache->count++] = span; + if (span_cache->count == MAX_THREAD_SPAN_CACHE) { + const size_t remain_count = MAX_THREAD_SPAN_CACHE - THREAD_SPAN_CACHE_TRANSFER; +#if ENABLE_GLOBAL_CACHE + _rpmalloc_stat_add64(&heap->thread_to_global, THREAD_SPAN_CACHE_TRANSFER * _memory_span_size); + _rpmalloc_stat_add(&heap->span_use[span_count - 1].spans_to_global, THREAD_SPAN_CACHE_TRANSFER); + _rpmalloc_global_cache_insert_spans(span_cache->span + remain_count, span_count, THREAD_SPAN_CACHE_TRANSFER); +#else + for (size_t ispan = 0; ispan < THREAD_SPAN_CACHE_TRANSFER; ++ispan) + _rpmalloc_span_unmap(span_cache->span[remain_count + ispan]); +#endif + span_cache->count = remain_count; + } + } else { + size_t cache_idx = span_count - 2; + span_large_cache_t* span_cache = heap->span_large_cache + cache_idx; + span_cache->span[span_cache->count++] = span; + const size_t cache_limit = (MAX_THREAD_SPAN_LARGE_CACHE - (span_count >> 1)); + if (span_cache->count == cache_limit) { + const size_t transfer_limit = 2 + (cache_limit >> 2); + const size_t transfer_count = (THREAD_SPAN_LARGE_CACHE_TRANSFER <= transfer_limit ? THREAD_SPAN_LARGE_CACHE_TRANSFER : transfer_limit); + const size_t remain_count = cache_limit - transfer_count; +#if ENABLE_GLOBAL_CACHE + _rpmalloc_stat_add64(&heap->thread_to_global, transfer_count * span_count * _memory_span_size); + _rpmalloc_stat_add(&heap->span_use[span_count - 1].spans_to_global, transfer_count); + _rpmalloc_global_cache_insert_spans(span_cache->span + remain_count, span_count, transfer_count); +#else + for (size_t ispan = 0; ispan < transfer_count; ++ispan) + _rpmalloc_span_unmap(span_cache->span[remain_count + ispan]); +#endif + span_cache->count = remain_count; + } + } +#else + (void)sizeof(heap); + _rpmalloc_span_unmap(span); +#endif +} + +//! Extract the given number of spans from the different cache levels +static span_t* +_rpmalloc_heap_thread_cache_extract(heap_t* heap, size_t span_count) { + span_t* span = 0; +#if ENABLE_THREAD_CACHE + span_cache_t* span_cache; + if (span_count == 1) + span_cache = &heap->span_cache; + else + span_cache = (span_cache_t*)(heap->span_large_cache + (span_count - 2)); + if (span_cache->count) { + _rpmalloc_stat_inc(&heap->span_use[span_count - 1].spans_from_cache); + return span_cache->span[--span_cache->count]; + } +#endif + return span; +} + +static span_t* +_rpmalloc_heap_thread_cache_deferred_extract(heap_t* heap, size_t span_count) { + span_t* span = 0; + if (span_count == 1) { + _rpmalloc_heap_cache_adopt_deferred(heap, &span); + } else { + _rpmalloc_heap_cache_adopt_deferred(heap, 0); + span = _rpmalloc_heap_thread_cache_extract(heap, span_count); + } + return span; +} + +static span_t* +_rpmalloc_heap_reserved_extract(heap_t* heap, size_t span_count) { + if (heap->spans_reserved >= span_count) + return _rpmalloc_span_map(heap, span_count); + return 0; +} + +//! Extract a span from the global cache +static span_t* +_rpmalloc_heap_global_cache_extract(heap_t* heap, size_t span_count) { +#if ENABLE_GLOBAL_CACHE +#if ENABLE_THREAD_CACHE + span_cache_t* span_cache; + size_t wanted_count; + if (span_count == 1) { + span_cache = &heap->span_cache; + wanted_count = THREAD_SPAN_CACHE_TRANSFER; + } else { + span_cache = (span_cache_t*)(heap->span_large_cache + (span_count - 2)); + wanted_count = THREAD_SPAN_LARGE_CACHE_TRANSFER; + } + span_cache->count = _rpmalloc_global_cache_extract_spans(span_cache->span, span_count, wanted_count); + if (span_cache->count) { + _rpmalloc_stat_add64(&heap->global_to_thread, span_count * span_cache->count * _memory_span_size); + _rpmalloc_stat_add(&heap->span_use[span_count - 1].spans_from_global, span_cache->count); + return span_cache->span[--span_cache->count]; + } +#else + span_t* span = 0; + size_t count = _rpmalloc_global_cache_extract_spans(&span, span_count, 1); + if (count) { + _rpmalloc_stat_add64(&heap->global_to_thread, span_count * count * _memory_span_size); + _rpmalloc_stat_add(&heap->span_use[span_count - 1].spans_from_global, count); + return span; + } +#endif +#endif + (void)sizeof(heap); + (void)sizeof(span_count); + return 0; +} + +static void +_rpmalloc_inc_span_statistics(heap_t* heap, size_t span_count, uint32_t class_idx) { + (void)sizeof(heap); + (void)sizeof(span_count); + (void)sizeof(class_idx); +#if ENABLE_ADAPTIVE_THREAD_CACHE || ENABLE_STATISTICS + uint32_t idx = (uint32_t)span_count - 1; + uint32_t current_count = (uint32_t)atomic_incr32(&heap->span_use[idx].current); + if (current_count > (uint32_t)atomic_load32(&heap->span_use[idx].high)) + atomic_store32(&heap->span_use[idx].high, (int32_t)current_count); + _rpmalloc_stat_add_peak(&heap->size_class_use[class_idx].spans_current, 1, heap->size_class_use[class_idx].spans_peak); +#endif +} + +//! Get a span from one of the cache levels (thread cache, reserved, global cache) or fallback to mapping more memory +static span_t* +_rpmalloc_heap_extract_new_span(heap_t* heap, heap_size_class_t* heap_size_class, size_t span_count, uint32_t class_idx) { + span_t* span; +#if ENABLE_THREAD_CACHE + if (heap_size_class && heap_size_class->cache) { + span = heap_size_class->cache; + heap_size_class->cache = (heap->span_cache.count ? heap->span_cache.span[--heap->span_cache.count] : 0); + _rpmalloc_inc_span_statistics(heap, span_count, class_idx); + return span; + } +#endif + (void)sizeof(class_idx); + // Allow 50% overhead to increase cache hits + size_t base_span_count = span_count; + size_t limit_span_count = (span_count > 2) ? (span_count + (span_count >> 1)) : span_count; + if (limit_span_count > LARGE_CLASS_COUNT) + limit_span_count = LARGE_CLASS_COUNT; + do { + span = _rpmalloc_heap_thread_cache_extract(heap, span_count); + if (EXPECTED(span != 0)) { + _rpmalloc_stat_inc(&heap->size_class_use[class_idx].spans_from_cache); + _rpmalloc_inc_span_statistics(heap, span_count, class_idx); + return span; + } + span = _rpmalloc_heap_thread_cache_deferred_extract(heap, span_count); + if (EXPECTED(span != 0)) { + _rpmalloc_stat_inc(&heap->size_class_use[class_idx].spans_from_cache); + _rpmalloc_inc_span_statistics(heap, span_count, class_idx); + return span; + } + span = _rpmalloc_heap_reserved_extract(heap, span_count); + if (EXPECTED(span != 0)) { + _rpmalloc_stat_inc(&heap->size_class_use[class_idx].spans_from_reserved); + _rpmalloc_inc_span_statistics(heap, span_count, class_idx); + return span; + } + span = _rpmalloc_heap_global_cache_extract(heap, span_count); + if (EXPECTED(span != 0)) { + _rpmalloc_stat_inc(&heap->size_class_use[class_idx].spans_from_cache); + _rpmalloc_inc_span_statistics(heap, span_count, class_idx); + return span; + } + ++span_count; + } while (span_count <= limit_span_count); + //Final fallback, map in more virtual memory + span = _rpmalloc_span_map(heap, base_span_count); + _rpmalloc_inc_span_statistics(heap, base_span_count, class_idx); + _rpmalloc_stat_inc(&heap->size_class_use[class_idx].spans_map_calls); + return span; +} + +static void +_rpmalloc_heap_initialize(heap_t* heap) { + memset((void*)heap, 0, sizeof(heap_t)); + //Get a new heap ID + heap->id = 1 + atomic_incr32(&_memory_heap_id); + + //Link in heap in heap ID map + size_t list_idx = (size_t)heap->id % HEAP_ARRAY_SIZE; + heap->next_heap = _memory_heaps[list_idx]; + _memory_heaps[list_idx] = heap; +} + +static void +_rpmalloc_heap_orphan(heap_t* heap, int first_class) { + heap->owner_thread = (uintptr_t)-1; +#if RPMALLOC_FIRST_CLASS_HEAPS + heap_t** heap_list = (first_class ? &_memory_first_class_orphan_heaps : &_memory_orphan_heaps); +#else + (void)sizeof(first_class); + heap_t** heap_list = &_memory_orphan_heaps; +#endif + heap->next_orphan = *heap_list; + *heap_list = heap; +} + +//! Allocate a new heap from newly mapped memory pages +static heap_t* +_rpmalloc_heap_allocate_new(void) { + // Map in pages for a 16 heaps. If page size is greater than required size for this, map a page and + // use first part for heaps and remaining part for spans for allocations. Adds a lot of complexity, + // but saves a lot of memory on systems where page size > 64 spans (4MiB) + size_t heap_size = sizeof(heap_t); + size_t aligned_heap_size = 16 * ((heap_size + 15) / 16); + size_t request_heap_count = 16; + size_t heap_span_count = ((aligned_heap_size * request_heap_count) + sizeof(span_t) + _memory_span_size - 1) / _memory_span_size; + size_t block_size = _memory_span_size * heap_span_count; + size_t span_count = heap_span_count; + span_t* span = 0; + // If there are global reserved spans, use these first + if (_memory_global_reserve_count >= heap_span_count) { + span = _rpmalloc_global_get_reserved_spans(heap_span_count); + } + if (!span) { + if (_memory_page_size > block_size) { + span_count = _memory_page_size / _memory_span_size; + block_size = _memory_page_size; + // If using huge pages, make sure to grab enough heaps to avoid reallocating a huge page just to serve new heaps + size_t possible_heap_count = (block_size - sizeof(span_t)) / aligned_heap_size; + if (possible_heap_count >= (request_heap_count * 16)) + request_heap_count *= 16; + else if (possible_heap_count < request_heap_count) + request_heap_count = possible_heap_count; + heap_span_count = ((aligned_heap_size * request_heap_count) + sizeof(span_t) + _memory_span_size - 1) / _memory_span_size; + } + + size_t align_offset = 0; + span = (span_t*)_rpmalloc_mmap(block_size, &align_offset); + if (!span) + return 0; + + // Master span will contain the heaps + _rpmalloc_stat_inc(&_master_spans); + _rpmalloc_span_initialize(span, span_count, heap_span_count, align_offset); + } + + size_t remain_size = _memory_span_size - sizeof(span_t); + heap_t* heap = (heap_t*)pointer_offset(span, sizeof(span_t)); + _rpmalloc_heap_initialize(heap); + + // Put extra heaps as orphans + size_t num_heaps = remain_size / aligned_heap_size; + if (num_heaps < request_heap_count) + num_heaps = request_heap_count; + atomic_store32(&heap->child_count, (int32_t)num_heaps - 1); + heap_t* extra_heap = (heap_t*)pointer_offset(heap, aligned_heap_size); + while (num_heaps > 1) { + _rpmalloc_heap_initialize(extra_heap); + extra_heap->master_heap = heap; + _rpmalloc_heap_orphan(extra_heap, 1); + extra_heap = (heap_t*)pointer_offset(extra_heap, aligned_heap_size); + --num_heaps; + } + + if (span_count > heap_span_count) { + // Cap reserved spans + size_t remain_count = span_count - heap_span_count; + size_t reserve_count = (remain_count > _memory_heap_reserve_count ? _memory_heap_reserve_count : remain_count); + span_t* remain_span = (span_t*)pointer_offset(span, heap_span_count * _memory_span_size); + _rpmalloc_heap_set_reserved_spans(heap, span, remain_span, reserve_count); + + if (remain_count > reserve_count) { + // Set to global reserved spans + remain_span = (span_t*)pointer_offset(remain_span, reserve_count * _memory_span_size); + reserve_count = remain_count - reserve_count; + _rpmalloc_global_set_reserved_spans(span, remain_span, reserve_count); + } + } + + return heap; +} + +static heap_t* +_rpmalloc_heap_extract_orphan(heap_t** heap_list) { + heap_t* heap = *heap_list; + *heap_list = (heap ? heap->next_orphan : 0); + return heap; +} + +//! Allocate a new heap, potentially reusing a previously orphaned heap +static heap_t* +_rpmalloc_heap_allocate(int first_class) { + heap_t* heap = 0; + while (!atomic_cas32_acquire(&_memory_global_lock, 1, 0)) + _rpmalloc_spin(); + if (first_class == 0) + heap = _rpmalloc_heap_extract_orphan(&_memory_orphan_heaps); +#if RPMALLOC_FIRST_CLASS_HEAPS + if (!heap) + heap = _rpmalloc_heap_extract_orphan(&_memory_first_class_orphan_heaps); +#endif + if (!heap) + heap = _rpmalloc_heap_allocate_new(); + atomic_store32_release(&_memory_global_lock, 0); + _rpmalloc_heap_cache_adopt_deferred(heap, 0); + return heap; +} + +extern thread_local bool RpThreadShutdown; + +static void +_rpmalloc_heap_release(void* heapptr, int first_class, int release_cache) { + heap_t* heap = (heap_t*)heapptr; + if (!heap) + return; + RpThreadShutdown = true; + //Release thread cache spans back to global cache + _rpmalloc_heap_cache_adopt_deferred(heap, 0); + if (release_cache || heap->finalize) { +#if ENABLE_THREAD_CACHE + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + span_cache_t* span_cache; + if (!iclass) + span_cache = &heap->span_cache; + else + span_cache = (span_cache_t*)(heap->span_large_cache + (iclass - 1)); + if (!span_cache->count) + continue; +#if ENABLE_GLOBAL_CACHE + if (heap->finalize) { + for (size_t ispan = 0; ispan < span_cache->count; ++ispan) + _rpmalloc_span_unmap(span_cache->span[ispan]); + } else { + _rpmalloc_stat_add64(&heap->thread_to_global, span_cache->count * (iclass + 1) * _memory_span_size); + _rpmalloc_stat_add(&heap->span_use[iclass].spans_to_global, span_cache->count); + _rpmalloc_global_cache_insert_spans(span_cache->span, iclass + 1, span_cache->count); + } +#else + for (size_t ispan = 0; ispan < span_cache->count; ++ispan) + _rpmalloc_span_unmap(span_cache->span[ispan]); +#endif + span_cache->count = 0; + } +#endif + } + + if (get_thread_heap_raw() == heap) + set_thread_heap(0); + +#if ENABLE_STATISTICS + atomic_decr32(&_memory_active_heaps); + rpmalloc_assert(atomic_load32(&_memory_active_heaps) >= 0, "Still active heaps during finalization"); +#endif + + // If we are forcibly terminating with _exit the state of the + // lock atomic is unknown and it's best to just go ahead and exit + if (get_thread_id() != _rpmalloc_main_thread_id) { + while (!atomic_cas32_acquire(&_memory_global_lock, 1, 0)) + _rpmalloc_spin(); + } + _rpmalloc_heap_orphan(heap, first_class); + atomic_store32_release(&_memory_global_lock, 0); +} + +static void +_rpmalloc_heap_release_raw(void* heapptr, int release_cache) { + _rpmalloc_heap_release(heapptr, 0, release_cache); +} + +static void +_rpmalloc_heap_release_raw_fc(void* heapptr) { + _rpmalloc_heap_release_raw(heapptr, 1); +} + +static void +_rpmalloc_heap_finalize(heap_t* heap) { + if (heap->spans_reserved) { + span_t* span = _rpmalloc_span_map(heap, heap->spans_reserved); + _rpmalloc_span_unmap(span); + heap->spans_reserved = 0; + } + + _rpmalloc_heap_cache_adopt_deferred(heap, 0); + + for (size_t iclass = 0; iclass < SIZE_CLASS_COUNT; ++iclass) { + if (heap->size_class[iclass].cache) + _rpmalloc_span_unmap(heap->size_class[iclass].cache); + heap->size_class[iclass].cache = 0; + span_t* span = heap->size_class[iclass].partial_span; + while (span) { + span_t* next = span->next; + _rpmalloc_span_finalize(heap, iclass, span, &heap->size_class[iclass].partial_span); + span = next; + } + // If class still has a free list it must be a full span + if (heap->size_class[iclass].free_list) { + span_t* class_span = (span_t*)((uintptr_t)heap->size_class[iclass].free_list & _memory_span_mask); + span_t** list = 0; +#if RPMALLOC_FIRST_CLASS_HEAPS + list = &heap->full_span[iclass]; +#endif + --heap->full_span_count; + if (!_rpmalloc_span_finalize(heap, iclass, class_span, list)) { + if (list) + _rpmalloc_span_double_link_list_remove(list, class_span); + _rpmalloc_span_double_link_list_add(&heap->size_class[iclass].partial_span, class_span); + } + } + } + +#if ENABLE_THREAD_CACHE + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + span_cache_t* span_cache; + if (!iclass) + span_cache = &heap->span_cache; + else + span_cache = (span_cache_t*)(heap->span_large_cache + (iclass - 1)); + for (size_t ispan = 0; ispan < span_cache->count; ++ispan) + _rpmalloc_span_unmap(span_cache->span[ispan]); + span_cache->count = 0; + } +#endif + rpmalloc_assert(!atomic_load_ptr(&heap->span_free_deferred), "Heaps still active during finalization"); +} + + +//////////// +/// +/// Allocation entry points +/// +////// + +//! Pop first block from a free list +static void* +free_list_pop(void** list) { + void* block = *list; + *list = *((void**)block); + return block; +} + +//! Allocate a small/medium sized memory block from the given heap +static void* +_rpmalloc_allocate_from_heap_fallback(heap_t* heap, heap_size_class_t* heap_size_class, uint32_t class_idx) { + span_t* span = heap_size_class->partial_span; + if (EXPECTED(span != 0)) { + rpmalloc_assert(span->block_count == _memory_size_class[span->size_class].block_count, "Span block count corrupted"); + rpmalloc_assert(!_rpmalloc_span_is_fully_utilized(span), "Internal failure"); + void* block; + if (span->free_list) { + //Span local free list is not empty, swap to size class free list + block = free_list_pop(&span->free_list); + heap_size_class->free_list = span->free_list; + span->free_list = 0; + } else { + //If the span did not fully initialize free list, link up another page worth of blocks + void* block_start = pointer_offset(span, SPAN_HEADER_SIZE + ((size_t)span->free_list_limit * span->block_size)); + span->free_list_limit += free_list_partial_init(&heap_size_class->free_list, &block, + (void*)((uintptr_t)block_start & ~(_memory_page_size - 1)), block_start, + span->block_count - span->free_list_limit, span->block_size); + } + rpmalloc_assert(span->free_list_limit <= span->block_count, "Span block count corrupted"); + span->used_count = span->free_list_limit; + + //Swap in deferred free list if present + if (atomic_load_ptr(&span->free_list_deferred)) + _rpmalloc_span_extract_free_list_deferred(span); + + //If span is still not fully utilized keep it in partial list and early return block + if (!_rpmalloc_span_is_fully_utilized(span)) + return block; + + //The span is fully utilized, unlink from partial list and add to fully utilized list + _rpmalloc_span_double_link_list_pop_head(&heap_size_class->partial_span, span); +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_add(&heap->full_span[class_idx], span); +#endif + ++heap->full_span_count; + return block; + } + + //Find a span in one of the cache levels + span = _rpmalloc_heap_extract_new_span(heap, heap_size_class, 1, class_idx); + if (EXPECTED(span != 0)) { + //Mark span as owned by this heap and set base data, return first block + return _rpmalloc_span_initialize_new(heap, heap_size_class, span, class_idx); + } + + return 0; +} + +//! Allocate a small sized memory block from the given heap +static void* +_rpmalloc_allocate_small(heap_t* heap, size_t size) { + rpmalloc_assert(heap, "No thread heap"); + //Small sizes have unique size classes + const uint32_t class_idx = (uint32_t)((size + (SMALL_GRANULARITY - 1)) >> SMALL_GRANULARITY_SHIFT); + heap_size_class_t* heap_size_class = heap->size_class + class_idx; + _rpmalloc_stat_inc_alloc(heap, class_idx); + if (EXPECTED(heap_size_class->free_list != 0)) + return free_list_pop(&heap_size_class->free_list); + return _rpmalloc_allocate_from_heap_fallback(heap, heap_size_class, class_idx); +} + +//! Allocate a medium sized memory block from the given heap +static void* +_rpmalloc_allocate_medium(heap_t* heap, size_t size) { + rpmalloc_assert(heap, "No thread heap"); + //Calculate the size class index and do a dependent lookup of the final class index (in case of merged classes) + const uint32_t base_idx = (uint32_t)(SMALL_CLASS_COUNT + ((size - (SMALL_SIZE_LIMIT + 1)) >> MEDIUM_GRANULARITY_SHIFT)); + const uint32_t class_idx = _memory_size_class[base_idx].class_idx; + heap_size_class_t* heap_size_class = heap->size_class + class_idx; + _rpmalloc_stat_inc_alloc(heap, class_idx); + if (EXPECTED(heap_size_class->free_list != 0)) + return free_list_pop(&heap_size_class->free_list); + return _rpmalloc_allocate_from_heap_fallback(heap, heap_size_class, class_idx); +} + +//! Allocate a large sized memory block from the given heap +static void* +_rpmalloc_allocate_large(heap_t* heap, size_t size) { + rpmalloc_assert(heap, "No thread heap"); + //Calculate number of needed max sized spans (including header) + //Since this function is never called if size > LARGE_SIZE_LIMIT + //the span_count is guaranteed to be <= LARGE_CLASS_COUNT + size += SPAN_HEADER_SIZE; + size_t span_count = size >> _memory_span_size_shift; + if (size & (_memory_span_size - 1)) + ++span_count; + + //Find a span in one of the cache levels + span_t* span = _rpmalloc_heap_extract_new_span(heap, 0, span_count, SIZE_CLASS_LARGE); + if (!span) + return span; + + //Mark span as owned by this heap and set base data + rpmalloc_assert(span->span_count >= span_count, "Internal failure"); + span->size_class = SIZE_CLASS_LARGE; + span->heap = heap; + +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_add(&heap->large_huge_span, span); +#endif + ++heap->full_span_count; + + return pointer_offset(span, SPAN_HEADER_SIZE); +} + +//! Allocate a huge block by mapping memory pages directly +static void* +_rpmalloc_allocate_huge(heap_t* heap, size_t size) { + rpmalloc_assert(heap, "No thread heap"); + _rpmalloc_heap_cache_adopt_deferred(heap, 0); + size += SPAN_HEADER_SIZE; + size_t num_pages = size >> _memory_page_size_shift; + if (size & (_memory_page_size - 1)) + ++num_pages; + size_t align_offset = 0; + span_t* span = (span_t*)_rpmalloc_mmap(num_pages * _memory_page_size, &align_offset); + if (!span) + return span; + + //Store page count in span_count + span->size_class = SIZE_CLASS_HUGE; + span->span_count = (uint32_t)num_pages; + span->align_offset = (uint32_t)align_offset; + span->heap = heap; + _rpmalloc_stat_add_peak(&_huge_pages_current, num_pages, _huge_pages_peak); + +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_add(&heap->large_huge_span, span); +#endif + ++heap->full_span_count; + + return pointer_offset(span, SPAN_HEADER_SIZE); +} + +//! Allocate a block of the given size +static void* +_rpmalloc_allocate(heap_t* heap, size_t size) { + _rpmalloc_stat_add64(&_allocation_counter, 1); + if (EXPECTED(size <= SMALL_SIZE_LIMIT)) + return _rpmalloc_allocate_small(heap, size); + else if (size <= _memory_medium_size_limit) + return _rpmalloc_allocate_medium(heap, size); + else if (size <= LARGE_SIZE_LIMIT) + return _rpmalloc_allocate_large(heap, size); + return _rpmalloc_allocate_huge(heap, size); +} + +static void* +_rpmalloc_aligned_allocate(heap_t* heap, size_t alignment, size_t size) { + if (alignment <= SMALL_GRANULARITY) + return _rpmalloc_allocate(heap, size); + +#if ENABLE_VALIDATE_ARGS + if ((size + alignment) < size) { + errno = EINVAL; + return 0; + } + if (alignment & (alignment - 1)) { + errno = EINVAL; + return 0; + } +#endif + + if ((alignment <= SPAN_HEADER_SIZE) && (size < _memory_medium_size_limit)) { + // If alignment is less or equal to span header size (which is power of two), + // and size aligned to span header size multiples is less than size + alignment, + // then use natural alignment of blocks to provide alignment + size_t multiple_size = size ? (size + (SPAN_HEADER_SIZE - 1)) & ~(uintptr_t)(SPAN_HEADER_SIZE - 1) : SPAN_HEADER_SIZE; + rpmalloc_assert(!(multiple_size % SPAN_HEADER_SIZE), "Failed alignment calculation"); + if (multiple_size <= (size + alignment)) + return _rpmalloc_allocate(heap, multiple_size); + } + + void* ptr = 0; + size_t align_mask = alignment - 1; + if (alignment <= _memory_page_size) { + ptr = _rpmalloc_allocate(heap, size + alignment); + if ((uintptr_t)ptr & align_mask) { + ptr = (void*)(((uintptr_t)ptr & ~(uintptr_t)align_mask) + alignment); + //Mark as having aligned blocks + span_t* span = (span_t*)((uintptr_t)ptr & _memory_span_mask); + span->flags |= SPAN_FLAG_ALIGNED_BLOCKS; + } + return ptr; + } + + // Fallback to mapping new pages for this request. Since pointers passed + // to rpfree must be able to reach the start of the span by bitmasking of + // the address with the span size, the returned aligned pointer from this + // function must be with a span size of the start of the mapped area. + // In worst case this requires us to loop and map pages until we get a + // suitable memory address. It also means we can never align to span size + // or greater, since the span header will push alignment more than one + // span size away from span start (thus causing pointer mask to give us + // an invalid span start on free) + if (alignment & align_mask) { + errno = EINVAL; + return 0; + } + if (alignment >= _memory_span_size) { + errno = EINVAL; + return 0; + } + + size_t extra_pages = alignment / _memory_page_size; + + // Since each span has a header, we will at least need one extra memory page + size_t num_pages = 1 + (size / _memory_page_size); + if (size & (_memory_page_size - 1)) + ++num_pages; + + if (extra_pages > num_pages) + num_pages = 1 + extra_pages; + + size_t original_pages = num_pages; + size_t limit_pages = (_memory_span_size / _memory_page_size) * 2; + if (limit_pages < (original_pages * 2)) + limit_pages = original_pages * 2; + + size_t mapped_size, align_offset; + span_t* span; + +retry: + align_offset = 0; + mapped_size = num_pages * _memory_page_size; + + span = (span_t*)_rpmalloc_mmap(mapped_size, &align_offset); + if (!span) { + errno = ENOMEM; + return 0; + } + ptr = pointer_offset(span, SPAN_HEADER_SIZE); + + if ((uintptr_t)ptr & align_mask) + ptr = (void*)(((uintptr_t)ptr & ~(uintptr_t)align_mask) + alignment); + + if (((size_t)pointer_diff(ptr, span) >= _memory_span_size) || + (pointer_offset(ptr, size) > pointer_offset(span, mapped_size)) || + (((uintptr_t)ptr & _memory_span_mask) != (uintptr_t)span)) { + _rpmalloc_unmap(span, mapped_size, align_offset, mapped_size); + ++num_pages; + if (num_pages > limit_pages) { + errno = EINVAL; + return 0; + } + goto retry; + } + + //Store page count in span_count + span->size_class = SIZE_CLASS_HUGE; + span->span_count = (uint32_t)num_pages; + span->align_offset = (uint32_t)align_offset; + span->heap = heap; + _rpmalloc_stat_add_peak(&_huge_pages_current, num_pages, _huge_pages_peak); + +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_add(&heap->large_huge_span, span); +#endif + ++heap->full_span_count; + + _rpmalloc_stat_add64(&_allocation_counter, 1); + + return ptr; +} + + +//////////// +/// +/// Deallocation entry points +/// +////// + +//! Deallocate the given small/medium memory block in the current thread local heap +static void +_rpmalloc_deallocate_direct_small_or_medium(span_t* span, void* block) { + heap_t* heap = span->heap; + rpmalloc_assert(heap->owner_thread == get_thread_id() || !heap->owner_thread || heap->finalize, "Internal failure"); + //Add block to free list + if (UNEXPECTED(_rpmalloc_span_is_fully_utilized(span))) { + span->used_count = span->block_count; +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_remove(&heap->full_span[span->size_class], span); +#endif + _rpmalloc_span_double_link_list_add(&heap->size_class[span->size_class].partial_span, span); + --heap->full_span_count; + } + *((void**)block) = span->free_list; + --span->used_count; + span->free_list = block; + if (UNEXPECTED(span->used_count == span->list_size)) { + // If there are no used blocks it is guaranteed that no other external thread is accessing the span + if (span->used_count) { + // Make sure we have synchronized the deferred list and list size by using acquire semantics + // and guarantee that no external thread is accessing span concurrently + void* free_list; + do { + free_list = atomic_exchange_ptr_acquire(&span->free_list_deferred, INVALID_POINTER); + } while (free_list == INVALID_POINTER); + atomic_store_ptr_release(&span->free_list_deferred, free_list); + } + _rpmalloc_span_double_link_list_remove(&heap->size_class[span->size_class].partial_span, span); + _rpmalloc_span_release_to_cache(heap, span); + } +} + +static void +_rpmalloc_deallocate_defer_free_span(heap_t* heap, span_t* span) { + if (span->size_class != SIZE_CLASS_HUGE) + _rpmalloc_stat_inc(&heap->span_use[span->span_count - 1].spans_deferred); + //This list does not need ABA protection, no mutable side state + do { + span->free_list = (void*)atomic_load_ptr(&heap->span_free_deferred); + } while (!atomic_cas_ptr(&heap->span_free_deferred, span, span->free_list)); +} + +//! Put the block in the deferred free list of the owning span +static void +_rpmalloc_deallocate_defer_small_or_medium(span_t* span, void* block) { + // The memory ordering here is a bit tricky, to avoid having to ABA protect + // the deferred free list to avoid desynchronization of list and list size + // we need to have acquire semantics on successful CAS of the pointer to + // guarantee the list_size variable validity + release semantics on pointer store + void* free_list; + do { + free_list = atomic_exchange_ptr_acquire(&span->free_list_deferred, INVALID_POINTER); + } while (free_list == INVALID_POINTER); + *((void**)block) = free_list; + uint32_t free_count = ++span->list_size; + int all_deferred_free = (free_count == span->block_count); + atomic_store_ptr_release(&span->free_list_deferred, block); + if (all_deferred_free) { + // Span was completely freed by this block. Due to the INVALID_POINTER spin lock + // no other thread can reach this state simultaneously on this span. + // Safe to move to owner heap deferred cache + _rpmalloc_deallocate_defer_free_span(span->heap, span); + } +} + +static void +_rpmalloc_deallocate_small_or_medium(span_t* span, void* p) { + _rpmalloc_stat_inc_free(span->heap, span->size_class); + if (span->flags & SPAN_FLAG_ALIGNED_BLOCKS) { + //Realign pointer to block start + void* blocks_start = pointer_offset(span, SPAN_HEADER_SIZE); + uint32_t block_offset = (uint32_t)pointer_diff(p, blocks_start); + p = pointer_offset(p, -(int32_t)(block_offset % span->block_size)); + } + //Check if block belongs to this heap or if deallocation should be deferred +#if RPMALLOC_FIRST_CLASS_HEAPS + int defer = (span->heap->owner_thread && (span->heap->owner_thread != get_thread_id()) && !span->heap->finalize); +#else + int defer = ((span->heap->owner_thread != get_thread_id()) && !span->heap->finalize); +#endif + if (!defer) + _rpmalloc_deallocate_direct_small_or_medium(span, p); + else + _rpmalloc_deallocate_defer_small_or_medium(span, p); +} + +//! Deallocate the given large memory block to the current heap +static void +_rpmalloc_deallocate_large(span_t* span) { + rpmalloc_assert(span->size_class == SIZE_CLASS_LARGE, "Bad span size class"); + rpmalloc_assert(!(span->flags & SPAN_FLAG_MASTER) || !(span->flags & SPAN_FLAG_SUBSPAN), "Span flag corrupted"); + rpmalloc_assert((span->flags & SPAN_FLAG_MASTER) || (span->flags & SPAN_FLAG_SUBSPAN), "Span flag corrupted"); + //We must always defer (unless finalizing) if from another heap since we cannot touch the list or counters of another heap +#if RPMALLOC_FIRST_CLASS_HEAPS + int defer = (span->heap->owner_thread && (span->heap->owner_thread != get_thread_id()) && !span->heap->finalize); +#else + int defer = ((span->heap->owner_thread != get_thread_id()) && !span->heap->finalize); +#endif + if (defer) { + _rpmalloc_deallocate_defer_free_span(span->heap, span); + return; + } + rpmalloc_assert(span->heap->full_span_count, "Heap span counter corrupted"); + --span->heap->full_span_count; +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_remove(&span->heap->large_huge_span, span); +#endif +#if ENABLE_ADAPTIVE_THREAD_CACHE || ENABLE_STATISTICS + //Decrease counter + size_t idx = span->span_count - 1; + atomic_decr32(&span->heap->span_use[idx].current); +#endif + heap_t* heap = span->heap; + rpmalloc_assert(heap, "No thread heap"); +#if ENABLE_THREAD_CACHE + const int set_as_reserved = ((span->span_count > 1) && (heap->span_cache.count == 0) && !heap->finalize && !heap->spans_reserved); +#else + const int set_as_reserved = ((span->span_count > 1) && !heap->finalize && !heap->spans_reserved); +#endif + if (set_as_reserved) { + heap->span_reserve = span; + heap->spans_reserved = span->span_count; + if (span->flags & SPAN_FLAG_MASTER) { + heap->span_reserve_master = span; + } else { //SPAN_FLAG_SUBSPAN + span_t* master = (span_t*)pointer_offset(span, -(intptr_t)((size_t)span->offset_from_master * _memory_span_size)); + heap->span_reserve_master = master; + rpmalloc_assert(master->flags & SPAN_FLAG_MASTER, "Span flag corrupted"); + rpmalloc_assert(atomic_load32(&master->remaining_spans) >= (int32_t)span->span_count, "Master span count corrupted"); + } + _rpmalloc_stat_inc(&heap->span_use[idx].spans_to_reserved); + } else { + //Insert into cache list + _rpmalloc_heap_cache_insert(heap, span); + } +} + +//! Deallocate the given huge span +static void +_rpmalloc_deallocate_huge(span_t* span) { + rpmalloc_assert(span->heap, "No span heap"); +#if RPMALLOC_FIRST_CLASS_HEAPS + int defer = (span->heap->owner_thread && (span->heap->owner_thread != get_thread_id()) && !span->heap->finalize); +#else + int defer = ((span->heap->owner_thread != get_thread_id()) && !span->heap->finalize); +#endif + if (defer) { + _rpmalloc_deallocate_defer_free_span(span->heap, span); + return; + } + rpmalloc_assert(span->heap->full_span_count, "Heap span counter corrupted"); + --span->heap->full_span_count; +#if RPMALLOC_FIRST_CLASS_HEAPS + _rpmalloc_span_double_link_list_remove(&span->heap->large_huge_span, span); +#endif + + //Oversized allocation, page count is stored in span_count + size_t num_pages = span->span_count; + _rpmalloc_unmap(span, num_pages * _memory_page_size, span->align_offset, num_pages * _memory_page_size); + _rpmalloc_stat_sub(&_huge_pages_current, num_pages); +} + +//! Deallocate the given block +static void +_rpmalloc_deallocate(void* p) { + _rpmalloc_stat_add64(&_deallocation_counter, 1); + //Grab the span (always at start of span, using span alignment) + span_t* span = (span_t*)((uintptr_t)p & _memory_span_mask); + if (UNEXPECTED(!span)) + return; + if (EXPECTED(span->size_class < SIZE_CLASS_COUNT)) + _rpmalloc_deallocate_small_or_medium(span, p); + else if (span->size_class == SIZE_CLASS_LARGE) + _rpmalloc_deallocate_large(span); + else + _rpmalloc_deallocate_huge(span); +} + +//////////// +/// +/// Reallocation entry points +/// +////// + +static size_t +_rpmalloc_usable_size(void* p); + +//! Reallocate the given block to the given size +static void* +_rpmalloc_reallocate(heap_t* heap, void* p, size_t size, size_t oldsize, unsigned int flags) { + if (p) { + //Grab the span using guaranteed span alignment + span_t* span = (span_t*)((uintptr_t)p & _memory_span_mask); + if (EXPECTED(span->size_class < SIZE_CLASS_COUNT)) { + //Small/medium sized block + rpmalloc_assert(span->span_count == 1, "Span counter corrupted"); + void* blocks_start = pointer_offset(span, SPAN_HEADER_SIZE); + uint32_t block_offset = (uint32_t)pointer_diff(p, blocks_start); + uint32_t block_idx = block_offset / span->block_size; + void* block = pointer_offset(blocks_start, (size_t)block_idx * span->block_size); + if (!oldsize) + oldsize = (size_t)((ptrdiff_t)span->block_size - pointer_diff(p, block)); + if ((size_t)span->block_size >= size) { + //Still fits in block, never mind trying to save memory, but preserve data if alignment changed + if ((p != block) && !(flags & RPMALLOC_NO_PRESERVE)) + memmove(block, p, oldsize); + return block; + } + } else if (span->size_class == SIZE_CLASS_LARGE) { + //Large block + size_t total_size = size + SPAN_HEADER_SIZE; + size_t num_spans = total_size >> _memory_span_size_shift; + if (total_size & (_memory_span_mask - 1)) + ++num_spans; + size_t current_spans = span->span_count; + void* block = pointer_offset(span, SPAN_HEADER_SIZE); + if (!oldsize) + oldsize = (current_spans * _memory_span_size) - (size_t)pointer_diff(p, block) - SPAN_HEADER_SIZE; + if ((current_spans >= num_spans) && (total_size >= (oldsize / 2))) { + //Still fits in block, never mind trying to save memory, but preserve data if alignment changed + if ((p != block) && !(flags & RPMALLOC_NO_PRESERVE)) + memmove(block, p, oldsize); + return block; + } + } else { + //Oversized block + size_t total_size = size + SPAN_HEADER_SIZE; + size_t num_pages = total_size >> _memory_page_size_shift; + if (total_size & (_memory_page_size - 1)) + ++num_pages; + //Page count is stored in span_count + size_t current_pages = span->span_count; + void* block = pointer_offset(span, SPAN_HEADER_SIZE); + if (!oldsize) + oldsize = (current_pages * _memory_page_size) - (size_t)pointer_diff(p, block) - SPAN_HEADER_SIZE; + if ((current_pages >= num_pages) && (num_pages >= (current_pages / 2))) { + //Still fits in block, never mind trying to save memory, but preserve data if alignment changed + if ((p != block) && !(flags & RPMALLOC_NO_PRESERVE)) + memmove(block, p, oldsize); + return block; + } + } + } else { + oldsize = 0; + } + + if (!!(flags & RPMALLOC_GROW_OR_FAIL)) + return 0; + + //Size is greater than block size, need to allocate a new block and deallocate the old + //Avoid hysteresis by overallocating if increase is small (below 37%) + size_t lower_bound = oldsize + (oldsize >> 2) + (oldsize >> 3); + size_t new_size = (size > lower_bound) ? size : ((size > oldsize) ? lower_bound : size); + void* block = _rpmalloc_allocate(heap, new_size); + if (p && block) { + if (!(flags & RPMALLOC_NO_PRESERVE)) + memcpy(block, p, oldsize < new_size ? oldsize : new_size); + _rpmalloc_deallocate(p); + } + + return block; +} + +static void* +_rpmalloc_aligned_reallocate(heap_t* heap, void* ptr, size_t alignment, size_t size, size_t oldsize, + unsigned int flags) { + if (alignment <= SMALL_GRANULARITY) + return _rpmalloc_reallocate(heap, ptr, size, oldsize, flags); + + int no_alloc = !!(flags & RPMALLOC_GROW_OR_FAIL); + size_t usablesize = (ptr ? _rpmalloc_usable_size(ptr) : 0); + if ((usablesize >= size) && !((uintptr_t)ptr & (alignment - 1))) { + if (no_alloc || (size >= (usablesize / 2))) + return ptr; + } + // Aligned alloc marks span as having aligned blocks + void* block = (!no_alloc ? _rpmalloc_aligned_allocate(heap, alignment, size) : 0); + if (EXPECTED(block != 0)) { + if (!(flags & RPMALLOC_NO_PRESERVE) && ptr) { + if (!oldsize) + oldsize = usablesize; + memcpy(block, ptr, oldsize < size ? oldsize : size); + } + _rpmalloc_deallocate(ptr); + } + return block; +} + + +//////////// +/// +/// Initialization, finalization and utility +/// +////// + +//! Get the usable size of the given block +static size_t +_rpmalloc_usable_size(void* p) { + //Grab the span using guaranteed span alignment + span_t* span = (span_t*)((uintptr_t)p & _memory_span_mask); + if (span->size_class < SIZE_CLASS_COUNT) { + //Small/medium block + void* blocks_start = pointer_offset(span, SPAN_HEADER_SIZE); + return span->block_size - ((size_t)pointer_diff(p, blocks_start) % span->block_size); + } + if (span->size_class == SIZE_CLASS_LARGE) { + //Large block + size_t current_spans = span->span_count; + return (current_spans * _memory_span_size) - (size_t)pointer_diff(p, span); + } + //Oversized block, page count is stored in span_count + size_t current_pages = span->span_count; + return (current_pages * _memory_page_size) - (size_t)pointer_diff(p, span); +} + +//! Adjust and optimize the size class properties for the given class +static void +_rpmalloc_adjust_size_class(size_t iclass) { + size_t block_size = _memory_size_class[iclass].block_size; + size_t block_count = (_memory_span_size - SPAN_HEADER_SIZE) / block_size; + + _memory_size_class[iclass].block_count = (uint16_t)block_count; + _memory_size_class[iclass].class_idx = (uint16_t)iclass; + + //Check if previous size classes can be merged + if (iclass >= SMALL_CLASS_COUNT) { + size_t prevclass = iclass; + while (prevclass > 0) { + --prevclass; + //A class can be merged if number of pages and number of blocks are equal + if (_memory_size_class[prevclass].block_count == _memory_size_class[iclass].block_count) + memcpy(_memory_size_class + prevclass, _memory_size_class + iclass, sizeof(_memory_size_class[iclass])); + else + break; + } + } +} + +//! Initialize the allocator and setup global data +TRACY_API int +rpmalloc_initialize(void) { + if (_rpmalloc_initialized) { + rpmalloc_thread_initialize(); + return 0; + } + return rpmalloc_initialize_config(0); +} + +int +rpmalloc_initialize_config(const rpmalloc_config_t* config) { + if (_rpmalloc_initialized) { + rpmalloc_thread_initialize(); + return 0; + } + _rpmalloc_initialized = 1; + + if (config) + memcpy(&_memory_config, config, sizeof(rpmalloc_config_t)); + else + memset(&_memory_config, 0, sizeof(rpmalloc_config_t)); + + if (!_memory_config.memory_map || !_memory_config.memory_unmap) { + _memory_config.memory_map = _rpmalloc_mmap_os; + _memory_config.memory_unmap = _rpmalloc_unmap_os; + } + +#if PLATFORM_WINDOWS + SYSTEM_INFO system_info; + memset(&system_info, 0, sizeof(system_info)); + GetSystemInfo(&system_info); + _memory_map_granularity = system_info.dwAllocationGranularity; +#else + _memory_map_granularity = (size_t)sysconf(_SC_PAGESIZE); +#endif + +#if RPMALLOC_CONFIGURABLE + _memory_page_size = _memory_config.page_size; +#else + _memory_page_size = 0; +#endif + _memory_huge_pages = 0; + if (!_memory_page_size) { +#if PLATFORM_WINDOWS + _memory_page_size = system_info.dwPageSize; +#else + _memory_page_size = _memory_map_granularity; + if (_memory_config.enable_huge_pages) { +#if defined(__linux__) + size_t huge_page_size = 0; + FILE* meminfo = fopen("/proc/meminfo", "r"); + if (meminfo) { + char line[128]; + while (!huge_page_size && fgets(line, sizeof(line) - 1, meminfo)) { + line[sizeof(line) - 1] = 0; + if (strstr(line, "Hugepagesize:")) + huge_page_size = (size_t)strtol(line + 13, 0, 10) * 1024; + } + fclose(meminfo); + } + if (huge_page_size) { + _memory_huge_pages = 1; + _memory_page_size = huge_page_size; + _memory_map_granularity = huge_page_size; + } +#elif defined(__FreeBSD__) + int rc; + size_t sz = sizeof(rc); + + if (sysctlbyname("vm.pmap.pg_ps_enabled", &rc, &sz, NULL, 0) == 0 && rc == 1) { + _memory_huge_pages = 1; + _memory_page_size = 2 * 1024 * 1024; + _memory_map_granularity = _memory_page_size; + } +#elif defined(__APPLE__) || defined(__NetBSD__) + _memory_huge_pages = 1; + _memory_page_size = 2 * 1024 * 1024; + _memory_map_granularity = _memory_page_size; +#endif + } +#endif + } else { + if (_memory_config.enable_huge_pages) + _memory_huge_pages = 1; + } + +#if PLATFORM_WINDOWS + if (_memory_config.enable_huge_pages) { + HANDLE token = 0; + size_t large_page_minimum = GetLargePageMinimum(); + if (large_page_minimum) + OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token); + if (token) { + LUID luid; + if (LookupPrivilegeValue(0, SE_LOCK_MEMORY_NAME, &luid)) { + TOKEN_PRIVILEGES token_privileges; + memset(&token_privileges, 0, sizeof(token_privileges)); + token_privileges.PrivilegeCount = 1; + token_privileges.Privileges[0].Luid = luid; + token_privileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; + if (AdjustTokenPrivileges(token, FALSE, &token_privileges, 0, 0, 0)) { + if (GetLastError() == ERROR_SUCCESS) + _memory_huge_pages = 1; + } + } + CloseHandle(token); + } + if (_memory_huge_pages) { + if (large_page_minimum > _memory_page_size) + _memory_page_size = large_page_minimum; + if (large_page_minimum > _memory_map_granularity) + _memory_map_granularity = large_page_minimum; + } + } +#endif + + size_t min_span_size = 256; + size_t max_page_size; +#if UINTPTR_MAX > 0xFFFFFFFF + max_page_size = 4096ULL * 1024ULL * 1024ULL; +#else + max_page_size = 4 * 1024 * 1024; +#endif + if (_memory_page_size < min_span_size) + _memory_page_size = min_span_size; + if (_memory_page_size > max_page_size) + _memory_page_size = max_page_size; + _memory_page_size_shift = 0; + size_t page_size_bit = _memory_page_size; + while (page_size_bit != 1) { + ++_memory_page_size_shift; + page_size_bit >>= 1; + } + _memory_page_size = ((size_t)1 << _memory_page_size_shift); + +#if RPMALLOC_CONFIGURABLE + if (!_memory_config.span_size) { + _memory_span_size = _memory_default_span_size; + _memory_span_size_shift = _memory_default_span_size_shift; + _memory_span_mask = _memory_default_span_mask; + } else { + size_t span_size = _memory_config.span_size; + if (span_size > (256 * 1024)) + span_size = (256 * 1024); + _memory_span_size = 4096; + _memory_span_size_shift = 12; + while (_memory_span_size < span_size) { + _memory_span_size <<= 1; + ++_memory_span_size_shift; + } + _memory_span_mask = ~(uintptr_t)(_memory_span_size - 1); + } +#endif + + _memory_span_map_count = ( _memory_config.span_map_count ? _memory_config.span_map_count : DEFAULT_SPAN_MAP_COUNT); + if ((_memory_span_size * _memory_span_map_count) < _memory_page_size) + _memory_span_map_count = (_memory_page_size / _memory_span_size); + if ((_memory_page_size >= _memory_span_size) && ((_memory_span_map_count * _memory_span_size) % _memory_page_size)) + _memory_span_map_count = (_memory_page_size / _memory_span_size); + _memory_heap_reserve_count = (_memory_span_map_count > DEFAULT_SPAN_MAP_COUNT) ? DEFAULT_SPAN_MAP_COUNT : _memory_span_map_count; + + _memory_config.page_size = _memory_page_size; + _memory_config.span_size = _memory_span_size; + _memory_config.span_map_count = _memory_span_map_count; + _memory_config.enable_huge_pages = _memory_huge_pages; + +#if ((defined(__APPLE__) || defined(__HAIKU__)) && ENABLE_PRELOAD) || defined(__TINYC__) + if (pthread_key_create(&_memory_thread_heap, _rpmalloc_heap_release_raw_fc)) + return -1; +#endif +#if defined(_WIN32) && (!defined(BUILD_DYNAMIC_LINK) || !BUILD_DYNAMIC_LINK) + fls_key = FlsAlloc(&_rpmalloc_thread_destructor); +#endif + + //Setup all small and medium size classes + size_t iclass = 0; + _memory_size_class[iclass].block_size = SMALL_GRANULARITY; + _rpmalloc_adjust_size_class(iclass); + for (iclass = 1; iclass < SMALL_CLASS_COUNT; ++iclass) { + size_t size = iclass * SMALL_GRANULARITY; + _memory_size_class[iclass].block_size = (uint32_t)size; + _rpmalloc_adjust_size_class(iclass); + } + //At least two blocks per span, then fall back to large allocations + _memory_medium_size_limit = (_memory_span_size - SPAN_HEADER_SIZE) >> 1; + if (_memory_medium_size_limit > MEDIUM_SIZE_LIMIT) + _memory_medium_size_limit = MEDIUM_SIZE_LIMIT; + for (iclass = 0; iclass < MEDIUM_CLASS_COUNT; ++iclass) { + size_t size = SMALL_SIZE_LIMIT + ((iclass + 1) * MEDIUM_GRANULARITY); + if (size > _memory_medium_size_limit) + break; + _memory_size_class[SMALL_CLASS_COUNT + iclass].block_size = (uint32_t)size; + _rpmalloc_adjust_size_class(SMALL_CLASS_COUNT + iclass); + } + + _memory_orphan_heaps = 0; +#if RPMALLOC_FIRST_CLASS_HEAPS + _memory_first_class_orphan_heaps = 0; +#endif +#if ENABLE_STATISTICS + atomic_store32(&_memory_active_heaps, 0); + atomic_store32(&_mapped_pages, 0); + _mapped_pages_peak = 0; + atomic_store32(&_master_spans, 0); + atomic_store32(&_mapped_total, 0); + atomic_store32(&_unmapped_total, 0); + atomic_store32(&_mapped_pages_os, 0); + atomic_store32(&_huge_pages_current, 0); + _huge_pages_peak = 0; +#endif + memset(_memory_heaps, 0, sizeof(_memory_heaps)); + atomic_store32_release(&_memory_global_lock, 0); + + //Initialize this thread + rpmalloc_thread_initialize(); + return 0; +} + +//! Finalize the allocator +TRACY_API void +rpmalloc_finalize(void) { + rpmalloc_thread_finalize(1); + //rpmalloc_dump_statistics(stdout); + + if (_memory_global_reserve) { + atomic_add32(&_memory_global_reserve_master->remaining_spans, -(int32_t)_memory_global_reserve_count); + _memory_global_reserve_master = 0; + _memory_global_reserve_count = 0; + _memory_global_reserve = 0; + } + atomic_store32_release(&_memory_global_lock, 0); + + //Free all thread caches and fully free spans + for (size_t list_idx = 0; list_idx < HEAP_ARRAY_SIZE; ++list_idx) { + heap_t* heap = _memory_heaps[list_idx]; + while (heap) { + heap_t* next_heap = heap->next_heap; + heap->finalize = 1; + _rpmalloc_heap_global_finalize(heap); + heap = next_heap; + } + } + +#if ENABLE_GLOBAL_CACHE + //Free global caches + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) + _rpmalloc_global_cache_finalize(&_memory_span_cache[iclass]); +#endif + +#if (defined(__APPLE__) || defined(__HAIKU__)) && ENABLE_PRELOAD + pthread_key_delete(_memory_thread_heap); +#endif +#if defined(_WIN32) && (!defined(BUILD_DYNAMIC_LINK) || !BUILD_DYNAMIC_LINK) + FlsFree(fls_key); + fls_key = 0; +#endif +#if ENABLE_STATISTICS + //If you hit these asserts you probably have memory leaks (perhaps global scope data doing dynamic allocations) or double frees in your code + rpmalloc_assert(atomic_load32(&_mapped_pages) == 0, "Memory leak detected"); + rpmalloc_assert(atomic_load32(&_mapped_pages_os) == 0, "Memory leak detected"); +#endif + + _rpmalloc_initialized = 0; +} + +//! Initialize thread, assign heap +TRACY_API void +rpmalloc_thread_initialize(void) { + if (!get_thread_heap_raw()) { + heap_t* heap = _rpmalloc_heap_allocate(0); + if (heap) { + _rpmalloc_stat_inc(&_memory_active_heaps); + set_thread_heap(heap); +#if defined(_WIN32) && (!defined(BUILD_DYNAMIC_LINK) || !BUILD_DYNAMIC_LINK) + FlsSetValue(fls_key, heap); +#endif + } + } +} + +//! Finalize thread, orphan heap +TRACY_API void +rpmalloc_thread_finalize(int release_caches) { + heap_t* heap = get_thread_heap_raw(); + if (heap) + _rpmalloc_heap_release_raw(heap, release_caches); + set_thread_heap(0); +#if defined(_WIN32) && (!defined(BUILD_DYNAMIC_LINK) || !BUILD_DYNAMIC_LINK) + FlsSetValue(fls_key, 0); +#endif +} + +int +rpmalloc_is_thread_initialized(void) { + return (get_thread_heap_raw() != 0) ? 1 : 0; +} + +const rpmalloc_config_t* +rpmalloc_config(void) { + return &_memory_config; +} + +// Extern interface + +TRACY_API RPMALLOC_ALLOCATOR void* +rpmalloc(size_t size) { +#if ENABLE_VALIDATE_ARGS + if (size >= MAX_ALLOC_SIZE) { + errno = EINVAL; + return 0; + } +#endif + heap_t* heap = get_thread_heap(); + return _rpmalloc_allocate(heap, size); +} + +TRACY_API void +rpfree(void* ptr) { + _rpmalloc_deallocate(ptr); +} + +extern inline RPMALLOC_ALLOCATOR void* +rpcalloc(size_t num, size_t size) { + size_t total; +#if ENABLE_VALIDATE_ARGS +#if PLATFORM_WINDOWS + int err = SizeTMult(num, size, &total); + if ((err != S_OK) || (total >= MAX_ALLOC_SIZE)) { + errno = EINVAL; + return 0; + } +#else + int err = __builtin_umull_overflow(num, size, &total); + if (err || (total >= MAX_ALLOC_SIZE)) { + errno = EINVAL; + return 0; + } +#endif +#else + total = num * size; +#endif + heap_t* heap = get_thread_heap(); + void* block = _rpmalloc_allocate(heap, total); + if (block) + memset(block, 0, total); + return block; +} + +TRACY_API RPMALLOC_ALLOCATOR void* +rprealloc(void* ptr, size_t size) { +#if ENABLE_VALIDATE_ARGS + if (size >= MAX_ALLOC_SIZE) { + errno = EINVAL; + return ptr; + } +#endif + heap_t* heap = get_thread_heap(); + return _rpmalloc_reallocate(heap, ptr, size, 0, 0); +} + +extern RPMALLOC_ALLOCATOR void* +rpaligned_realloc(void* ptr, size_t alignment, size_t size, size_t oldsize, + unsigned int flags) { +#if ENABLE_VALIDATE_ARGS + if ((size + alignment < size) || (alignment > _memory_page_size)) { + errno = EINVAL; + return 0; + } +#endif + heap_t* heap = get_thread_heap(); + return _rpmalloc_aligned_reallocate(heap, ptr, alignment, size, oldsize, flags); +} + +extern RPMALLOC_ALLOCATOR void* +rpaligned_alloc(size_t alignment, size_t size) { + heap_t* heap = get_thread_heap(); + return _rpmalloc_aligned_allocate(heap, alignment, size); +} + +extern inline RPMALLOC_ALLOCATOR void* +rpaligned_calloc(size_t alignment, size_t num, size_t size) { + size_t total; +#if ENABLE_VALIDATE_ARGS +#if PLATFORM_WINDOWS + int err = SizeTMult(num, size, &total); + if ((err != S_OK) || (total >= MAX_ALLOC_SIZE)) { + errno = EINVAL; + return 0; + } +#else + int err = __builtin_umull_overflow(num, size, &total); + if (err || (total >= MAX_ALLOC_SIZE)) { + errno = EINVAL; + return 0; + } +#endif +#else + total = num * size; +#endif + void* block = rpaligned_alloc(alignment, total); + if (block) + memset(block, 0, total); + return block; +} + +extern inline RPMALLOC_ALLOCATOR void* +rpmemalign(size_t alignment, size_t size) { + return rpaligned_alloc(alignment, size); +} + +extern inline int +rpposix_memalign(void **memptr, size_t alignment, size_t size) { + if (memptr) + *memptr = rpaligned_alloc(alignment, size); + else + return EINVAL; + return *memptr ? 0 : ENOMEM; +} + +extern inline size_t +rpmalloc_usable_size(void* ptr) { + return (ptr ? _rpmalloc_usable_size(ptr) : 0); +} + +extern inline void +rpmalloc_thread_collect(void) { +} + +void +rpmalloc_thread_statistics(rpmalloc_thread_statistics_t* stats) { + memset(stats, 0, sizeof(rpmalloc_thread_statistics_t)); + heap_t* heap = get_thread_heap_raw(); + if (!heap) + return; + + for (size_t iclass = 0; iclass < SIZE_CLASS_COUNT; ++iclass) { + size_class_t* size_class = _memory_size_class + iclass; + span_t* span = heap->size_class[iclass].partial_span; + while (span) { + size_t free_count = span->list_size; + size_t block_count = size_class->block_count; + if (span->free_list_limit < block_count) + block_count = span->free_list_limit; + free_count += (block_count - span->used_count); + stats->sizecache = free_count * size_class->block_size; + span = span->next; + } + } + +#if ENABLE_THREAD_CACHE + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + span_cache_t* span_cache; + if (!iclass) + span_cache = &heap->span_cache; + else + span_cache = (span_cache_t*)(heap->span_large_cache + (iclass - 1)); + stats->spancache = span_cache->count * (iclass + 1) * _memory_span_size; + } +#endif + + span_t* deferred = (span_t*)atomic_load_ptr(&heap->span_free_deferred); + while (deferred) { + if (deferred->size_class != SIZE_CLASS_HUGE) + stats->spancache = (size_t)deferred->span_count * _memory_span_size; + deferred = (span_t*)deferred->free_list; + } + +#if ENABLE_STATISTICS + stats->thread_to_global = (size_t)atomic_load64(&heap->thread_to_global); + stats->global_to_thread = (size_t)atomic_load64(&heap->global_to_thread); + + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + stats->span_use[iclass].current = (size_t)atomic_load32(&heap->span_use[iclass].current); + stats->span_use[iclass].peak = (size_t)atomic_load32(&heap->span_use[iclass].high); + stats->span_use[iclass].to_global = (size_t)atomic_load32(&heap->span_use[iclass].spans_to_global); + stats->span_use[iclass].from_global = (size_t)atomic_load32(&heap->span_use[iclass].spans_from_global); + stats->span_use[iclass].to_cache = (size_t)atomic_load32(&heap->span_use[iclass].spans_to_cache); + stats->span_use[iclass].from_cache = (size_t)atomic_load32(&heap->span_use[iclass].spans_from_cache); + stats->span_use[iclass].to_reserved = (size_t)atomic_load32(&heap->span_use[iclass].spans_to_reserved); + stats->span_use[iclass].from_reserved = (size_t)atomic_load32(&heap->span_use[iclass].spans_from_reserved); + stats->span_use[iclass].map_calls = (size_t)atomic_load32(&heap->span_use[iclass].spans_map_calls); + } + for (size_t iclass = 0; iclass < SIZE_CLASS_COUNT; ++iclass) { + stats->size_use[iclass].alloc_current = (size_t)atomic_load32(&heap->size_class_use[iclass].alloc_current); + stats->size_use[iclass].alloc_peak = (size_t)heap->size_class_use[iclass].alloc_peak; + stats->size_use[iclass].alloc_total = (size_t)atomic_load32(&heap->size_class_use[iclass].alloc_total); + stats->size_use[iclass].free_total = (size_t)atomic_load32(&heap->size_class_use[iclass].free_total); + stats->size_use[iclass].spans_to_cache = (size_t)atomic_load32(&heap->size_class_use[iclass].spans_to_cache); + stats->size_use[iclass].spans_from_cache = (size_t)atomic_load32(&heap->size_class_use[iclass].spans_from_cache); + stats->size_use[iclass].spans_from_reserved = (size_t)atomic_load32(&heap->size_class_use[iclass].spans_from_reserved); + stats->size_use[iclass].map_calls = (size_t)atomic_load32(&heap->size_class_use[iclass].spans_map_calls); + } +#endif +} + +void +rpmalloc_global_statistics(rpmalloc_global_statistics_t* stats) { + memset(stats, 0, sizeof(rpmalloc_global_statistics_t)); +#if ENABLE_STATISTICS + stats->mapped = (size_t)atomic_load32(&_mapped_pages) * _memory_page_size; + stats->mapped_peak = (size_t)_mapped_pages_peak * _memory_page_size; + stats->mapped_total = (size_t)atomic_load32(&_mapped_total) * _memory_page_size; + stats->unmapped_total = (size_t)atomic_load32(&_unmapped_total) * _memory_page_size; + stats->huge_alloc = (size_t)atomic_load32(&_huge_pages_current) * _memory_page_size; + stats->huge_alloc_peak = (size_t)_huge_pages_peak * _memory_page_size; +#endif +#if ENABLE_GLOBAL_CACHE + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) + stats->cached += _memory_span_cache[iclass].count * (iclass + 1) * _memory_span_size; +#endif +} + +#if ENABLE_STATISTICS + +static void +_memory_heap_dump_statistics(heap_t* heap, void* file) { + fprintf(file, "Heap %d stats:\n", heap->id); + fprintf(file, "Class CurAlloc PeakAlloc TotAlloc TotFree BlkSize BlkCount SpansCur SpansPeak PeakAllocMiB ToCacheMiB FromCacheMiB FromReserveMiB MmapCalls\n"); + for (size_t iclass = 0; iclass < SIZE_CLASS_COUNT; ++iclass) { + if (!atomic_load32(&heap->size_class_use[iclass].alloc_total)) + continue; + fprintf(file, "%3u: %10u %10u %10u %10u %8u %8u %8d %9d %13zu %11zu %12zu %14zu %9u\n", (uint32_t)iclass, + atomic_load32(&heap->size_class_use[iclass].alloc_current), + heap->size_class_use[iclass].alloc_peak, + atomic_load32(&heap->size_class_use[iclass].alloc_total), + atomic_load32(&heap->size_class_use[iclass].free_total), + _memory_size_class[iclass].block_size, + _memory_size_class[iclass].block_count, + atomic_load32(&heap->size_class_use[iclass].spans_current), + heap->size_class_use[iclass].spans_peak, + ((size_t)heap->size_class_use[iclass].alloc_peak * (size_t)_memory_size_class[iclass].block_size) / (size_t)(1024 * 1024), + ((size_t)atomic_load32(&heap->size_class_use[iclass].spans_to_cache) * _memory_span_size) / (size_t)(1024 * 1024), + ((size_t)atomic_load32(&heap->size_class_use[iclass].spans_from_cache) * _memory_span_size) / (size_t)(1024 * 1024), + ((size_t)atomic_load32(&heap->size_class_use[iclass].spans_from_reserved) * _memory_span_size) / (size_t)(1024 * 1024), + atomic_load32(&heap->size_class_use[iclass].spans_map_calls)); + } + fprintf(file, "Spans Current Peak Deferred PeakMiB Cached ToCacheMiB FromCacheMiB ToReserveMiB FromReserveMiB ToGlobalMiB FromGlobalMiB MmapCalls\n"); + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + if (!atomic_load32(&heap->span_use[iclass].high) && !atomic_load32(&heap->span_use[iclass].spans_map_calls)) + continue; + fprintf(file, "%4u: %8d %8u %8u %8zu %7u %11zu %12zu %12zu %14zu %11zu %13zu %10u\n", (uint32_t)(iclass + 1), + atomic_load32(&heap->span_use[iclass].current), + atomic_load32(&heap->span_use[iclass].high), + atomic_load32(&heap->span_use[iclass].spans_deferred), + ((size_t)atomic_load32(&heap->span_use[iclass].high) * (size_t)_memory_span_size * (iclass + 1)) / (size_t)(1024 * 1024), +#if ENABLE_THREAD_CACHE + (unsigned int)(!iclass ? heap->span_cache.count : heap->span_large_cache[iclass - 1].count), + ((size_t)atomic_load32(&heap->span_use[iclass].spans_to_cache) * (iclass + 1) * _memory_span_size) / (size_t)(1024 * 1024), + ((size_t)atomic_load32(&heap->span_use[iclass].spans_from_cache) * (iclass + 1) * _memory_span_size) / (size_t)(1024 * 1024), +#else + 0, (size_t)0, (size_t)0, +#endif + ((size_t)atomic_load32(&heap->span_use[iclass].spans_to_reserved) * (iclass + 1) * _memory_span_size) / (size_t)(1024 * 1024), + ((size_t)atomic_load32(&heap->span_use[iclass].spans_from_reserved) * (iclass + 1) * _memory_span_size) / (size_t)(1024 * 1024), + ((size_t)atomic_load32(&heap->span_use[iclass].spans_to_global) * (size_t)_memory_span_size * (iclass + 1)) / (size_t)(1024 * 1024), + ((size_t)atomic_load32(&heap->span_use[iclass].spans_from_global) * (size_t)_memory_span_size * (iclass + 1)) / (size_t)(1024 * 1024), + atomic_load32(&heap->span_use[iclass].spans_map_calls)); + } + fprintf(file, "Full spans: %zu\n", heap->full_span_count); + fprintf(file, "ThreadToGlobalMiB GlobalToThreadMiB\n"); + fprintf(file, "%17zu %17zu\n", (size_t)atomic_load64(&heap->thread_to_global) / (size_t)(1024 * 1024), (size_t)atomic_load64(&heap->global_to_thread) / (size_t)(1024 * 1024)); +} + +#endif + +void +rpmalloc_dump_statistics(void* file) { +#if ENABLE_STATISTICS + for (size_t list_idx = 0; list_idx < HEAP_ARRAY_SIZE; ++list_idx) { + heap_t* heap = _memory_heaps[list_idx]; + while (heap) { + int need_dump = 0; + for (size_t iclass = 0; !need_dump && (iclass < SIZE_CLASS_COUNT); ++iclass) { + if (!atomic_load32(&heap->size_class_use[iclass].alloc_total)) { + rpmalloc_assert(!atomic_load32(&heap->size_class_use[iclass].free_total), "Heap statistics counter mismatch"); + rpmalloc_assert(!atomic_load32(&heap->size_class_use[iclass].spans_map_calls), "Heap statistics counter mismatch"); + continue; + } + need_dump = 1; + } + for (size_t iclass = 0; !need_dump && (iclass < LARGE_CLASS_COUNT); ++iclass) { + if (!atomic_load32(&heap->span_use[iclass].high) && !atomic_load32(&heap->span_use[iclass].spans_map_calls)) + continue; + need_dump = 1; + } + if (need_dump) + _memory_heap_dump_statistics(heap, file); + heap = heap->next_heap; + } + } + fprintf(file, "Global stats:\n"); + size_t huge_current = (size_t)atomic_load32(&_huge_pages_current) * _memory_page_size; + size_t huge_peak = (size_t)_huge_pages_peak * _memory_page_size; + fprintf(file, "HugeCurrentMiB HugePeakMiB\n"); + fprintf(file, "%14zu %11zu\n", huge_current / (size_t)(1024 * 1024), huge_peak / (size_t)(1024 * 1024)); + + fprintf(file, "GlobalCacheMiB\n"); + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + global_cache_t* cache = _memory_span_cache + iclass; + size_t global_cache = (size_t)cache->count * iclass * _memory_span_size; + + size_t global_overflow_cache = 0; + span_t* span = cache->overflow; + while (span) { + global_overflow_cache += iclass * _memory_span_size; + span = span->next; + } + if (global_cache || global_overflow_cache || cache->insert_count || cache->extract_count) + fprintf(file, "%4zu: %8zuMiB (%8zuMiB overflow) %14zu insert %14zu extract\n", iclass + 1, global_cache / (size_t)(1024 * 1024), global_overflow_cache / (size_t)(1024 * 1024), cache->insert_count, cache->extract_count); + } + + size_t mapped = (size_t)atomic_load32(&_mapped_pages) * _memory_page_size; + size_t mapped_os = (size_t)atomic_load32(&_mapped_pages_os) * _memory_page_size; + size_t mapped_peak = (size_t)_mapped_pages_peak * _memory_page_size; + size_t mapped_total = (size_t)atomic_load32(&_mapped_total) * _memory_page_size; + size_t unmapped_total = (size_t)atomic_load32(&_unmapped_total) * _memory_page_size; + fprintf(file, "MappedMiB MappedOSMiB MappedPeakMiB MappedTotalMiB UnmappedTotalMiB\n"); + fprintf(file, "%9zu %11zu %13zu %14zu %16zu\n", + mapped / (size_t)(1024 * 1024), + mapped_os / (size_t)(1024 * 1024), + mapped_peak / (size_t)(1024 * 1024), + mapped_total / (size_t)(1024 * 1024), + unmapped_total / (size_t)(1024 * 1024)); + + fprintf(file, "\n"); +#if 0 + int64_t allocated = atomic_load64(&_allocation_counter); + int64_t deallocated = atomic_load64(&_deallocation_counter); + fprintf(file, "Allocation count: %lli\n", allocated); + fprintf(file, "Deallocation count: %lli\n", deallocated); + fprintf(file, "Current allocations: %lli\n", (allocated - deallocated)); + fprintf(file, "Master spans: %d\n", atomic_load32(&_master_spans)); + fprintf(file, "Dangling master spans: %d\n", atomic_load32(&_unmapped_master_spans)); +#endif +#endif + (void)sizeof(file); +} + +#if RPMALLOC_FIRST_CLASS_HEAPS + +extern inline rpmalloc_heap_t* +rpmalloc_heap_acquire(void) { + // Must be a pristine heap from newly mapped memory pages, or else memory blocks + // could already be allocated from the heap which would (wrongly) be released when + // heap is cleared with rpmalloc_heap_free_all(). Also heaps guaranteed to be + // pristine from the dedicated orphan list can be used. + heap_t* heap = _rpmalloc_heap_allocate(1); + heap->owner_thread = 0; + _rpmalloc_stat_inc(&_memory_active_heaps); + return heap; +} + +extern inline void +rpmalloc_heap_release(rpmalloc_heap_t* heap) { + if (heap) + _rpmalloc_heap_release(heap, 1, 1); +} + +extern inline RPMALLOC_ALLOCATOR void* +rpmalloc_heap_alloc(rpmalloc_heap_t* heap, size_t size) { +#if ENABLE_VALIDATE_ARGS + if (size >= MAX_ALLOC_SIZE) { + errno = EINVAL; + return 0; + } +#endif + return _rpmalloc_allocate(heap, size); +} + +extern inline RPMALLOC_ALLOCATOR void* +rpmalloc_heap_aligned_alloc(rpmalloc_heap_t* heap, size_t alignment, size_t size) { +#if ENABLE_VALIDATE_ARGS + if (size >= MAX_ALLOC_SIZE) { + errno = EINVAL; + return 0; + } +#endif + return _rpmalloc_aligned_allocate(heap, alignment, size); +} + +extern inline RPMALLOC_ALLOCATOR void* +rpmalloc_heap_calloc(rpmalloc_heap_t* heap, size_t num, size_t size) { + return rpmalloc_heap_aligned_calloc(heap, 0, num, size); +} + +extern inline RPMALLOC_ALLOCATOR void* +rpmalloc_heap_aligned_calloc(rpmalloc_heap_t* heap, size_t alignment, size_t num, size_t size) { + size_t total; +#if ENABLE_VALIDATE_ARGS +#if PLATFORM_WINDOWS + int err = SizeTMult(num, size, &total); + if ((err != S_OK) || (total >= MAX_ALLOC_SIZE)) { + errno = EINVAL; + return 0; + } +#else + int err = __builtin_umull_overflow(num, size, &total); + if (err || (total >= MAX_ALLOC_SIZE)) { + errno = EINVAL; + return 0; + } +#endif +#else + total = num * size; +#endif + void* block = _rpmalloc_aligned_allocate(heap, alignment, total); + if (block) + memset(block, 0, total); + return block; +} + +extern inline RPMALLOC_ALLOCATOR void* +rpmalloc_heap_realloc(rpmalloc_heap_t* heap, void* ptr, size_t size, unsigned int flags) { +#if ENABLE_VALIDATE_ARGS + if (size >= MAX_ALLOC_SIZE) { + errno = EINVAL; + return ptr; + } +#endif + return _rpmalloc_reallocate(heap, ptr, size, 0, flags); +} + +extern inline RPMALLOC_ALLOCATOR void* +rpmalloc_heap_aligned_realloc(rpmalloc_heap_t* heap, void* ptr, size_t alignment, size_t size, unsigned int flags) { +#if ENABLE_VALIDATE_ARGS + if ((size + alignment < size) || (alignment > _memory_page_size)) { + errno = EINVAL; + return 0; + } +#endif + return _rpmalloc_aligned_reallocate(heap, ptr, alignment, size, 0, flags); +} + +extern inline void +rpmalloc_heap_free(rpmalloc_heap_t* heap, void* ptr) { + (void)sizeof(heap); + _rpmalloc_deallocate(ptr); +} + +extern inline void +rpmalloc_heap_free_all(rpmalloc_heap_t* heap) { + span_t* span; + span_t* next_span; + + _rpmalloc_heap_cache_adopt_deferred(heap, 0); + + for (size_t iclass = 0; iclass < SIZE_CLASS_COUNT; ++iclass) { + span = heap->size_class[iclass].partial_span; + while (span) { + next_span = span->next; + _rpmalloc_heap_cache_insert(heap, span); + span = next_span; + } + heap->size_class[iclass].partial_span = 0; + span = heap->full_span[iclass]; + while (span) { + next_span = span->next; + _rpmalloc_heap_cache_insert(heap, span); + span = next_span; + } + } + memset(heap->size_class, 0, sizeof(heap->size_class)); + memset(heap->full_span, 0, sizeof(heap->full_span)); + + span = heap->large_huge_span; + while (span) { + next_span = span->next; + if (UNEXPECTED(span->size_class == SIZE_CLASS_HUGE)) + _rpmalloc_deallocate_huge(span); + else + _rpmalloc_heap_cache_insert(heap, span); + span = next_span; + } + heap->large_huge_span = 0; + heap->full_span_count = 0; + +#if ENABLE_THREAD_CACHE + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + span_cache_t* span_cache; + if (!iclass) + span_cache = &heap->span_cache; + else + span_cache = (span_cache_t*)(heap->span_large_cache + (iclass - 1)); + if (!span_cache->count) + continue; +#if ENABLE_GLOBAL_CACHE + _rpmalloc_stat_add64(&heap->thread_to_global, span_cache->count * (iclass + 1) * _memory_span_size); + _rpmalloc_stat_add(&heap->span_use[iclass].spans_to_global, span_cache->count); + _rpmalloc_global_cache_insert_spans(span_cache->span, iclass + 1, span_cache->count); +#else + for (size_t ispan = 0; ispan < span_cache->count; ++ispan) + _rpmalloc_span_unmap(span_cache->span[ispan]); +#endif + span_cache->count = 0; + } +#endif + +#if ENABLE_STATISTICS + for (size_t iclass = 0; iclass < SIZE_CLASS_COUNT; ++iclass) { + atomic_store32(&heap->size_class_use[iclass].alloc_current, 0); + atomic_store32(&heap->size_class_use[iclass].spans_current, 0); + } + for (size_t iclass = 0; iclass < LARGE_CLASS_COUNT; ++iclass) { + atomic_store32(&heap->span_use[iclass].current, 0); + } +#endif +} + +extern inline void +rpmalloc_heap_thread_set_current(rpmalloc_heap_t* heap) { + heap_t* prev_heap = get_thread_heap_raw(); + if (prev_heap != heap) { + set_thread_heap(heap); + if (prev_heap) + rpmalloc_heap_release(prev_heap); + } +} + +#endif + +} + +#endif diff --git a/Dependencies/tracy/client/tracy_rpmalloc.hpp b/Dependencies/tracy/client/tracy_rpmalloc.hpp new file mode 100644 index 000000000..51216a21b --- /dev/null +++ b/Dependencies/tracy/client/tracy_rpmalloc.hpp @@ -0,0 +1,363 @@ +/* rpmalloc.h - Memory allocator - Public Domain - 2016 Mattias Jansson + * + * This library provides a cross-platform lock free thread caching malloc implementation in C11. + * The latest source code is always available at + * + * https://github.com/mjansson/rpmalloc + * + * This library is put in the public domain; you can redistribute it and/or modify it without any restrictions. + * + */ + +#pragma once + +#include +#include "../common/TracyApi.h" + +namespace tracy +{ + +#if defined(__clang__) || defined(__GNUC__) +# define RPMALLOC_EXPORT __attribute__((visibility("default"))) +# define RPMALLOC_ALLOCATOR +# if (defined(__clang_major__) && (__clang_major__ < 4)) || (defined(__GNUC__) && defined(ENABLE_PRELOAD) && ENABLE_PRELOAD) +# define RPMALLOC_ATTRIB_MALLOC +# define RPMALLOC_ATTRIB_ALLOC_SIZE(size) +# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count, size) +# else +# define RPMALLOC_ATTRIB_MALLOC __attribute__((__malloc__)) +# define RPMALLOC_ATTRIB_ALLOC_SIZE(size) __attribute__((alloc_size(size))) +# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count, size) __attribute__((alloc_size(count, size))) +# endif +# define RPMALLOC_CDECL +#elif defined(_MSC_VER) +# define RPMALLOC_EXPORT +# define RPMALLOC_ALLOCATOR __declspec(allocator) __declspec(restrict) +# define RPMALLOC_ATTRIB_MALLOC +# define RPMALLOC_ATTRIB_ALLOC_SIZE(size) +# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count,size) +# define RPMALLOC_CDECL __cdecl +#else +# define RPMALLOC_EXPORT +# define RPMALLOC_ALLOCATOR +# define RPMALLOC_ATTRIB_MALLOC +# define RPMALLOC_ATTRIB_ALLOC_SIZE(size) +# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count,size) +# define RPMALLOC_CDECL +#endif + +//! Define RPMALLOC_CONFIGURABLE to enable configuring sizes. Will introduce +// a very small overhead due to some size calculations not being compile time constants +#ifndef RPMALLOC_CONFIGURABLE +#define RPMALLOC_CONFIGURABLE 0 +#endif + +//! Define RPMALLOC_FIRST_CLASS_HEAPS to enable heap based API (rpmalloc_heap_* functions). +// Will introduce a very small overhead to track fully allocated spans in heaps +#ifndef RPMALLOC_FIRST_CLASS_HEAPS +#define RPMALLOC_FIRST_CLASS_HEAPS 0 +#endif + +//! Flag to rpaligned_realloc to not preserve content in reallocation +#define RPMALLOC_NO_PRESERVE 1 +//! Flag to rpaligned_realloc to fail and return null pointer if grow cannot be done in-place, +// in which case the original pointer is still valid (just like a call to realloc which failes to allocate +// a new block). +#define RPMALLOC_GROW_OR_FAIL 2 + +typedef struct rpmalloc_global_statistics_t { + //! Current amount of virtual memory mapped, all of which might not have been committed (only if ENABLE_STATISTICS=1) + size_t mapped; + //! Peak amount of virtual memory mapped, all of which might not have been committed (only if ENABLE_STATISTICS=1) + size_t mapped_peak; + //! Current amount of memory in global caches for small and medium sizes (<32KiB) + size_t cached; + //! Current amount of memory allocated in huge allocations, i.e larger than LARGE_SIZE_LIMIT which is 2MiB by default (only if ENABLE_STATISTICS=1) + size_t huge_alloc; + //! Peak amount of memory allocated in huge allocations, i.e larger than LARGE_SIZE_LIMIT which is 2MiB by default (only if ENABLE_STATISTICS=1) + size_t huge_alloc_peak; + //! Total amount of memory mapped since initialization (only if ENABLE_STATISTICS=1) + size_t mapped_total; + //! Total amount of memory unmapped since initialization (only if ENABLE_STATISTICS=1) + size_t unmapped_total; +} rpmalloc_global_statistics_t; + +typedef struct rpmalloc_thread_statistics_t { + //! Current number of bytes available in thread size class caches for small and medium sizes (<32KiB) + size_t sizecache; + //! Current number of bytes available in thread span caches for small and medium sizes (<32KiB) + size_t spancache; + //! Total number of bytes transitioned from thread cache to global cache (only if ENABLE_STATISTICS=1) + size_t thread_to_global; + //! Total number of bytes transitioned from global cache to thread cache (only if ENABLE_STATISTICS=1) + size_t global_to_thread; + //! Per span count statistics (only if ENABLE_STATISTICS=1) + struct { + //! Currently used number of spans + size_t current; + //! High water mark of spans used + size_t peak; + //! Number of spans transitioned to global cache + size_t to_global; + //! Number of spans transitioned from global cache + size_t from_global; + //! Number of spans transitioned to thread cache + size_t to_cache; + //! Number of spans transitioned from thread cache + size_t from_cache; + //! Number of spans transitioned to reserved state + size_t to_reserved; + //! Number of spans transitioned from reserved state + size_t from_reserved; + //! Number of raw memory map calls (not hitting the reserve spans but resulting in actual OS mmap calls) + size_t map_calls; + } span_use[64]; + //! Per size class statistics (only if ENABLE_STATISTICS=1) + struct { + //! Current number of allocations + size_t alloc_current; + //! Peak number of allocations + size_t alloc_peak; + //! Total number of allocations + size_t alloc_total; + //! Total number of frees + size_t free_total; + //! Number of spans transitioned to cache + size_t spans_to_cache; + //! Number of spans transitioned from cache + size_t spans_from_cache; + //! Number of spans transitioned from reserved state + size_t spans_from_reserved; + //! Number of raw memory map calls (not hitting the reserve spans but resulting in actual OS mmap calls) + size_t map_calls; + } size_use[128]; +} rpmalloc_thread_statistics_t; + +typedef struct rpmalloc_config_t { + //! Map memory pages for the given number of bytes. The returned address MUST be + // aligned to the rpmalloc span size, which will always be a power of two. + // Optionally the function can store an alignment offset in the offset variable + // in case it performs alignment and the returned pointer is offset from the + // actual start of the memory region due to this alignment. The alignment offset + // will be passed to the memory unmap function. The alignment offset MUST NOT be + // larger than 65535 (storable in an uint16_t), if it is you must use natural + // alignment to shift it into 16 bits. If you set a memory_map function, you + // must also set a memory_unmap function or else the default implementation will + // be used for both. This function must be thread safe, it can be called by + // multiple threads simultaneously. + void* (*memory_map)(size_t size, size_t* offset); + //! Unmap the memory pages starting at address and spanning the given number of bytes. + // If release is set to non-zero, the unmap is for an entire span range as returned by + // a previous call to memory_map and that the entire range should be released. The + // release argument holds the size of the entire span range. If release is set to 0, + // the unmap is a partial decommit of a subset of the mapped memory range. + // If you set a memory_unmap function, you must also set a memory_map function or + // else the default implementation will be used for both. This function must be thread + // safe, it can be called by multiple threads simultaneously. + void (*memory_unmap)(void* address, size_t size, size_t offset, size_t release); + //! Called when an assert fails, if asserts are enabled. Will use the standard assert() + // if this is not set. + void (*error_callback)(const char* message); + //! Called when a call to map memory pages fails (out of memory). If this callback is + // not set or returns zero the library will return a null pointer in the allocation + // call. If this callback returns non-zero the map call will be retried. The argument + // passed is the number of bytes that was requested in the map call. Only used if + // the default system memory map function is used (memory_map callback is not set). + int (*map_fail_callback)(size_t size); + //! Size of memory pages. The page size MUST be a power of two. All memory mapping + // requests to memory_map will be made with size set to a multiple of the page size. + // Used if RPMALLOC_CONFIGURABLE is defined to 1, otherwise system page size is used. + size_t page_size; + //! Size of a span of memory blocks. MUST be a power of two, and in [4096,262144] + // range (unless 0 - set to 0 to use the default span size). Used if RPMALLOC_CONFIGURABLE + // is defined to 1. + size_t span_size; + //! Number of spans to map at each request to map new virtual memory blocks. This can + // be used to minimize the system call overhead at the cost of virtual memory address + // space. The extra mapped pages will not be written until actually used, so physical + // committed memory should not be affected in the default implementation. Will be + // aligned to a multiple of spans that match memory page size in case of huge pages. + size_t span_map_count; + //! Enable use of large/huge pages. If this flag is set to non-zero and page size is + // zero, the allocator will try to enable huge pages and auto detect the configuration. + // If this is set to non-zero and page_size is also non-zero, the allocator will + // assume huge pages have been configured and enabled prior to initializing the + // allocator. + // For Windows, see https://docs.microsoft.com/en-us/windows/desktop/memory/large-page-support + // For Linux, see https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt + int enable_huge_pages; + //! Respectively allocated pages and huge allocated pages names for systems + // supporting it to be able to distinguish among anonymous regions. + const char *page_name; + const char *huge_page_name; +} rpmalloc_config_t; + +//! Initialize allocator with default configuration +TRACY_API int +rpmalloc_initialize(void); + +//! Initialize allocator with given configuration +RPMALLOC_EXPORT int +rpmalloc_initialize_config(const rpmalloc_config_t* config); + +//! Get allocator configuration +RPMALLOC_EXPORT const rpmalloc_config_t* +rpmalloc_config(void); + +//! Finalize allocator +TRACY_API void +rpmalloc_finalize(void); + +//! Initialize allocator for calling thread +TRACY_API void +rpmalloc_thread_initialize(void); + +//! Finalize allocator for calling thread +TRACY_API void +rpmalloc_thread_finalize(int release_caches); + +//! Perform deferred deallocations pending for the calling thread heap +RPMALLOC_EXPORT void +rpmalloc_thread_collect(void); + +//! Query if allocator is initialized for calling thread +RPMALLOC_EXPORT int +rpmalloc_is_thread_initialized(void); + +//! Get per-thread statistics +RPMALLOC_EXPORT void +rpmalloc_thread_statistics(rpmalloc_thread_statistics_t* stats); + +//! Get global statistics +RPMALLOC_EXPORT void +rpmalloc_global_statistics(rpmalloc_global_statistics_t* stats); + +//! Dump all statistics in human readable format to file (should be a FILE*) +RPMALLOC_EXPORT void +rpmalloc_dump_statistics(void* file); + +//! Allocate a memory block of at least the given size +TRACY_API RPMALLOC_ALLOCATOR void* +rpmalloc(size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(1); + +//! Free the given memory block +TRACY_API void +rpfree(void* ptr); + +//! Allocate a memory block of at least the given size and zero initialize it +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpcalloc(size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(1, 2); + +//! Reallocate the given block to at least the given size +TRACY_API RPMALLOC_ALLOCATOR void* +rprealloc(void* ptr, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2); + +//! Reallocate the given block to at least the given size and alignment, +// with optional control flags (see RPMALLOC_NO_PRESERVE). +// Alignment must be a power of two and a multiple of sizeof(void*), +// and should ideally be less than memory page size. A caveat of rpmalloc +// internals is that this must also be strictly less than the span size (default 64KiB) +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpaligned_realloc(void* ptr, size_t alignment, size_t size, size_t oldsize, unsigned int flags) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(3); + +//! Allocate a memory block of at least the given size and alignment. +// Alignment must be a power of two and a multiple of sizeof(void*), +// and should ideally be less than memory page size. A caveat of rpmalloc +// internals is that this must also be strictly less than the span size (default 64KiB) +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpaligned_alloc(size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2); + +//! Allocate a memory block of at least the given size and alignment, and zero initialize it. +// Alignment must be a power of two and a multiple of sizeof(void*), +// and should ideally be less than memory page size. A caveat of rpmalloc +// internals is that this must also be strictly less than the span size (default 64KiB) +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpaligned_calloc(size_t alignment, size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(2, 3); + +//! Allocate a memory block of at least the given size and alignment. +// Alignment must be a power of two and a multiple of sizeof(void*), +// and should ideally be less than memory page size. A caveat of rpmalloc +// internals is that this must also be strictly less than the span size (default 64KiB) +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpmemalign(size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2); + +//! Allocate a memory block of at least the given size and alignment. +// Alignment must be a power of two and a multiple of sizeof(void*), +// and should ideally be less than memory page size. A caveat of rpmalloc +// internals is that this must also be strictly less than the span size (default 64KiB) +RPMALLOC_EXPORT int +rpposix_memalign(void** memptr, size_t alignment, size_t size); + +//! Query the usable size of the given memory block (from given pointer to the end of block) +RPMALLOC_EXPORT size_t +rpmalloc_usable_size(void* ptr); + +#if RPMALLOC_FIRST_CLASS_HEAPS + +//! Heap type +typedef struct heap_t rpmalloc_heap_t; + +//! Acquire a new heap. Will reuse existing released heaps or allocate memory for a new heap +// if none available. Heap API is implemented with the strict assumption that only one single +// thread will call heap functions for a given heap at any given time, no functions are thread safe. +RPMALLOC_EXPORT rpmalloc_heap_t* +rpmalloc_heap_acquire(void); + +//! Release a heap (does NOT free the memory allocated by the heap, use rpmalloc_heap_free_all before destroying the heap). +// Releasing a heap will enable it to be reused by other threads. Safe to pass a null pointer. +RPMALLOC_EXPORT void +rpmalloc_heap_release(rpmalloc_heap_t* heap); + +//! Allocate a memory block of at least the given size using the given heap. +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpmalloc_heap_alloc(rpmalloc_heap_t* heap, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2); + +//! Allocate a memory block of at least the given size using the given heap. The returned +// block will have the requested alignment. Alignment must be a power of two and a multiple of sizeof(void*), +// and should ideally be less than memory page size. A caveat of rpmalloc +// internals is that this must also be strictly less than the span size (default 64KiB). +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpmalloc_heap_aligned_alloc(rpmalloc_heap_t* heap, size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(3); + +//! Allocate a memory block of at least the given size using the given heap and zero initialize it. +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpmalloc_heap_calloc(rpmalloc_heap_t* heap, size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(2, 3); + +//! Allocate a memory block of at least the given size using the given heap and zero initialize it. The returned +// block will have the requested alignment. Alignment must either be zero, or a power of two and a multiple of sizeof(void*), +// and should ideally be less than memory page size. A caveat of rpmalloc +// internals is that this must also be strictly less than the span size (default 64KiB). +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpmalloc_heap_aligned_calloc(rpmalloc_heap_t* heap, size_t alignment, size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(2, 3); + +//! Reallocate the given block to at least the given size. The memory block MUST be allocated +// by the same heap given to this function. +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpmalloc_heap_realloc(rpmalloc_heap_t* heap, void* ptr, size_t size, unsigned int flags) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(3); + +//! Reallocate the given block to at least the given size. The memory block MUST be allocated +// by the same heap given to this function. The returned block will have the requested alignment. +// Alignment must be either zero, or a power of two and a multiple of sizeof(void*), and should ideally be +// less than memory page size. A caveat of rpmalloc internals is that this must also be strictly less than +// the span size (default 64KiB). +RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void* +rpmalloc_heap_aligned_realloc(rpmalloc_heap_t* heap, void* ptr, size_t alignment, size_t size, unsigned int flags) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(4); + +//! Free the given memory block from the given heap. The memory block MUST be allocated +// by the same heap given to this function. +RPMALLOC_EXPORT void +rpmalloc_heap_free(rpmalloc_heap_t* heap, void* ptr); + +//! Free all memory allocated by the heap +RPMALLOC_EXPORT void +rpmalloc_heap_free_all(rpmalloc_heap_t* heap); + +//! Set the given heap as the current heap for the calling thread. A heap MUST only be current heap +// for a single thread, a heap can never be shared between multiple threads. The previous +// current heap for the calling thread is released to be reused by other threads. +RPMALLOC_EXPORT void +rpmalloc_heap_thread_set_current(rpmalloc_heap_t* heap); + +#endif + +} diff --git a/Dependencies/tracy/common/TracyAlign.hpp b/Dependencies/tracy/common/TracyAlign.hpp new file mode 100644 index 000000000..c3531ba0d --- /dev/null +++ b/Dependencies/tracy/common/TracyAlign.hpp @@ -0,0 +1,27 @@ +#ifndef __TRACYALIGN_HPP__ +#define __TRACYALIGN_HPP__ + +#include + +#include "TracyForceInline.hpp" + +namespace tracy +{ + +template +tracy_force_inline T MemRead( const void* ptr ) +{ + T val; + memcpy( &val, ptr, sizeof( T ) ); + return val; +} + +template +tracy_force_inline void MemWrite( void* ptr, T val ) +{ + memcpy( ptr, &val, sizeof( T ) ); +} + +} + +#endif diff --git a/Dependencies/tracy/common/TracyAlloc.hpp b/Dependencies/tracy/common/TracyAlloc.hpp new file mode 100644 index 000000000..ddb0e5df6 --- /dev/null +++ b/Dependencies/tracy/common/TracyAlloc.hpp @@ -0,0 +1,72 @@ +#ifndef __TRACYALLOC_HPP__ +#define __TRACYALLOC_HPP__ + +#include + +#if defined TRACY_ENABLE && !defined __EMSCRIPTEN__ +# include "TracyApi.h" +# include "TracyForceInline.hpp" +# include "../client/tracy_rpmalloc.hpp" +# define TRACY_USE_RPMALLOC +#endif + +namespace tracy +{ + +#ifdef TRACY_USE_RPMALLOC +TRACY_API void InitRpmalloc(); +#else +static inline void InitRpmalloc() {} +#endif + +static inline void* tracy_malloc( size_t size ) +{ +#ifdef TRACY_USE_RPMALLOC + InitRpmalloc(); + return rpmalloc( size ); +#else + return malloc( size ); +#endif +} + +static inline void* tracy_malloc_fast( size_t size ) +{ +#ifdef TRACY_USE_RPMALLOC + return rpmalloc( size ); +#else + return malloc( size ); +#endif +} + +static inline void tracy_free( void* ptr ) +{ +#ifdef TRACY_USE_RPMALLOC + InitRpmalloc(); + rpfree( ptr ); +#else + free( ptr ); +#endif +} + +static inline void tracy_free_fast( void* ptr ) +{ +#ifdef TRACY_USE_RPMALLOC + rpfree( ptr ); +#else + free( ptr ); +#endif +} + +static inline void* tracy_realloc( void* ptr, size_t size ) +{ +#ifdef TRACY_USE_RPMALLOC + InitRpmalloc(); + return rprealloc( ptr, size ); +#else + return realloc( ptr, size ); +#endif +} + +} + +#endif diff --git a/Dependencies/tracy/common/TracyApi.h b/Dependencies/tracy/common/TracyApi.h new file mode 100644 index 000000000..f396ce0c6 --- /dev/null +++ b/Dependencies/tracy/common/TracyApi.h @@ -0,0 +1,16 @@ +#ifndef __TRACYAPI_H__ +#define __TRACYAPI_H__ + +#if defined _WIN32 +# if defined TRACY_EXPORTS +# define TRACY_API __declspec(dllexport) +# elif defined TRACY_IMPORTS +# define TRACY_API __declspec(dllimport) +# else +# define TRACY_API +# endif +#else +# define TRACY_API __attribute__((visibility("default"))) +#endif + +#endif // __TRACYAPI_H__ diff --git a/Dependencies/tracy/common/TracyColor.hpp b/Dependencies/tracy/common/TracyColor.hpp new file mode 100644 index 000000000..4825c0fba --- /dev/null +++ b/Dependencies/tracy/common/TracyColor.hpp @@ -0,0 +1,690 @@ +#ifndef __TRACYCOLOR_HPP__ +#define __TRACYCOLOR_HPP__ + +namespace tracy +{ +struct Color +{ +enum ColorType +{ + Snow = 0xfffafa, + GhostWhite = 0xf8f8ff, + WhiteSmoke = 0xf5f5f5, + Gainsboro = 0xdcdcdc, + FloralWhite = 0xfffaf0, + OldLace = 0xfdf5e6, + Linen = 0xfaf0e6, + AntiqueWhite = 0xfaebd7, + PapayaWhip = 0xffefd5, + BlanchedAlmond = 0xffebcd, + Bisque = 0xffe4c4, + PeachPuff = 0xffdab9, + NavajoWhite = 0xffdead, + Moccasin = 0xffe4b5, + Cornsilk = 0xfff8dc, + Ivory = 0xfffff0, + LemonChiffon = 0xfffacd, + Seashell = 0xfff5ee, + Honeydew = 0xf0fff0, + MintCream = 0xf5fffa, + Azure = 0xf0ffff, + AliceBlue = 0xf0f8ff, + Lavender = 0xe6e6fa, + LavenderBlush = 0xfff0f5, + MistyRose = 0xffe4e1, + White = 0xffffff, + Black = 0x000000, + DarkSlateGray = 0x2f4f4f, + DarkSlateGrey = 0x2f4f4f, + DimGray = 0x696969, + DimGrey = 0x696969, + SlateGray = 0x708090, + SlateGrey = 0x708090, + LightSlateGray = 0x778899, + LightSlateGrey = 0x778899, + Gray = 0xbebebe, + Grey = 0xbebebe, + X11Gray = 0xbebebe, + X11Grey = 0xbebebe, + WebGray = 0x808080, + WebGrey = 0x808080, + LightGrey = 0xd3d3d3, + LightGray = 0xd3d3d3, + MidnightBlue = 0x191970, + Navy = 0x000080, + NavyBlue = 0x000080, + CornflowerBlue = 0x6495ed, + DarkSlateBlue = 0x483d8b, + SlateBlue = 0x6a5acd, + MediumSlateBlue = 0x7b68ee, + LightSlateBlue = 0x8470ff, + MediumBlue = 0x0000cd, + RoyalBlue = 0x4169e1, + Blue = 0x0000ff, + DodgerBlue = 0x1e90ff, + DeepSkyBlue = 0x00bfff, + SkyBlue = 0x87ceeb, + LightSkyBlue = 0x87cefa, + SteelBlue = 0x4682b4, + LightSteelBlue = 0xb0c4de, + LightBlue = 0xadd8e6, + PowderBlue = 0xb0e0e6, + PaleTurquoise = 0xafeeee, + DarkTurquoise = 0x00ced1, + MediumTurquoise = 0x48d1cc, + Turquoise = 0x40e0d0, + Cyan = 0x00ffff, + Aqua = 0x00ffff, + LightCyan = 0xe0ffff, + CadetBlue = 0x5f9ea0, + MediumAquamarine = 0x66cdaa, + Aquamarine = 0x7fffd4, + DarkGreen = 0x006400, + DarkOliveGreen = 0x556b2f, + DarkSeaGreen = 0x8fbc8f, + SeaGreen = 0x2e8b57, + MediumSeaGreen = 0x3cb371, + LightSeaGreen = 0x20b2aa, + PaleGreen = 0x98fb98, + SpringGreen = 0x00ff7f, + LawnGreen = 0x7cfc00, + Green = 0x00ff00, + Lime = 0x00ff00, + X11Green = 0x00ff00, + WebGreen = 0x008000, + Chartreuse = 0x7fff00, + MediumSpringGreen = 0x00fa9a, + GreenYellow = 0xadff2f, + LimeGreen = 0x32cd32, + YellowGreen = 0x9acd32, + ForestGreen = 0x228b22, + OliveDrab = 0x6b8e23, + DarkKhaki = 0xbdb76b, + Khaki = 0xf0e68c, + PaleGoldenrod = 0xeee8aa, + LightGoldenrodYellow = 0xfafad2, + LightYellow = 0xffffe0, + Yellow = 0xffff00, + Gold = 0xffd700, + LightGoldenrod = 0xeedd82, + Goldenrod = 0xdaa520, + DarkGoldenrod = 0xb8860b, + RosyBrown = 0xbc8f8f, + IndianRed = 0xcd5c5c, + SaddleBrown = 0x8b4513, + Sienna = 0xa0522d, + Peru = 0xcd853f, + Burlywood = 0xdeb887, + Beige = 0xf5f5dc, + Wheat = 0xf5deb3, + SandyBrown = 0xf4a460, + Tan = 0xd2b48c, + Chocolate = 0xd2691e, + Firebrick = 0xb22222, + Brown = 0xa52a2a, + DarkSalmon = 0xe9967a, + Salmon = 0xfa8072, + LightSalmon = 0xffa07a, + Orange = 0xffa500, + DarkOrange = 0xff8c00, + Coral = 0xff7f50, + LightCoral = 0xf08080, + Tomato = 0xff6347, + OrangeRed = 0xff4500, + Red = 0xff0000, + HotPink = 0xff69b4, + DeepPink = 0xff1493, + Pink = 0xffc0cb, + LightPink = 0xffb6c1, + PaleVioletRed = 0xdb7093, + Maroon = 0xb03060, + X11Maroon = 0xb03060, + WebMaroon = 0x800000, + MediumVioletRed = 0xc71585, + VioletRed = 0xd02090, + Magenta = 0xff00ff, + Fuchsia = 0xff00ff, + Violet = 0xee82ee, + Plum = 0xdda0dd, + Orchid = 0xda70d6, + MediumOrchid = 0xba55d3, + DarkOrchid = 0x9932cc, + DarkViolet = 0x9400d3, + BlueViolet = 0x8a2be2, + Purple = 0xa020f0, + X11Purple = 0xa020f0, + WebPurple = 0x800080, + MediumPurple = 0x9370db, + Thistle = 0xd8bfd8, + Snow1 = 0xfffafa, + Snow2 = 0xeee9e9, + Snow3 = 0xcdc9c9, + Snow4 = 0x8b8989, + Seashell1 = 0xfff5ee, + Seashell2 = 0xeee5de, + Seashell3 = 0xcdc5bf, + Seashell4 = 0x8b8682, + AntiqueWhite1 = 0xffefdb, + AntiqueWhite2 = 0xeedfcc, + AntiqueWhite3 = 0xcdc0b0, + AntiqueWhite4 = 0x8b8378, + Bisque1 = 0xffe4c4, + Bisque2 = 0xeed5b7, + Bisque3 = 0xcdb79e, + Bisque4 = 0x8b7d6b, + PeachPuff1 = 0xffdab9, + PeachPuff2 = 0xeecbad, + PeachPuff3 = 0xcdaf95, + PeachPuff4 = 0x8b7765, + NavajoWhite1 = 0xffdead, + NavajoWhite2 = 0xeecfa1, + NavajoWhite3 = 0xcdb38b, + NavajoWhite4 = 0x8b795e, + LemonChiffon1 = 0xfffacd, + LemonChiffon2 = 0xeee9bf, + LemonChiffon3 = 0xcdc9a5, + LemonChiffon4 = 0x8b8970, + Cornsilk1 = 0xfff8dc, + Cornsilk2 = 0xeee8cd, + Cornsilk3 = 0xcdc8b1, + Cornsilk4 = 0x8b8878, + Ivory1 = 0xfffff0, + Ivory2 = 0xeeeee0, + Ivory3 = 0xcdcdc1, + Ivory4 = 0x8b8b83, + Honeydew1 = 0xf0fff0, + Honeydew2 = 0xe0eee0, + Honeydew3 = 0xc1cdc1, + Honeydew4 = 0x838b83, + LavenderBlush1 = 0xfff0f5, + LavenderBlush2 = 0xeee0e5, + LavenderBlush3 = 0xcdc1c5, + LavenderBlush4 = 0x8b8386, + MistyRose1 = 0xffe4e1, + MistyRose2 = 0xeed5d2, + MistyRose3 = 0xcdb7b5, + MistyRose4 = 0x8b7d7b, + Azure1 = 0xf0ffff, + Azure2 = 0xe0eeee, + Azure3 = 0xc1cdcd, + Azure4 = 0x838b8b, + SlateBlue1 = 0x836fff, + SlateBlue2 = 0x7a67ee, + SlateBlue3 = 0x6959cd, + SlateBlue4 = 0x473c8b, + RoyalBlue1 = 0x4876ff, + RoyalBlue2 = 0x436eee, + RoyalBlue3 = 0x3a5fcd, + RoyalBlue4 = 0x27408b, + Blue1 = 0x0000ff, + Blue2 = 0x0000ee, + Blue3 = 0x0000cd, + Blue4 = 0x00008b, + DodgerBlue1 = 0x1e90ff, + DodgerBlue2 = 0x1c86ee, + DodgerBlue3 = 0x1874cd, + DodgerBlue4 = 0x104e8b, + SteelBlue1 = 0x63b8ff, + SteelBlue2 = 0x5cacee, + SteelBlue3 = 0x4f94cd, + SteelBlue4 = 0x36648b, + DeepSkyBlue1 = 0x00bfff, + DeepSkyBlue2 = 0x00b2ee, + DeepSkyBlue3 = 0x009acd, + DeepSkyBlue4 = 0x00688b, + SkyBlue1 = 0x87ceff, + SkyBlue2 = 0x7ec0ee, + SkyBlue3 = 0x6ca6cd, + SkyBlue4 = 0x4a708b, + LightSkyBlue1 = 0xb0e2ff, + LightSkyBlue2 = 0xa4d3ee, + LightSkyBlue3 = 0x8db6cd, + LightSkyBlue4 = 0x607b8b, + SlateGray1 = 0xc6e2ff, + SlateGray2 = 0xb9d3ee, + SlateGray3 = 0x9fb6cd, + SlateGray4 = 0x6c7b8b, + LightSteelBlue1 = 0xcae1ff, + LightSteelBlue2 = 0xbcd2ee, + LightSteelBlue3 = 0xa2b5cd, + LightSteelBlue4 = 0x6e7b8b, + LightBlue1 = 0xbfefff, + LightBlue2 = 0xb2dfee, + LightBlue3 = 0x9ac0cd, + LightBlue4 = 0x68838b, + LightCyan1 = 0xe0ffff, + LightCyan2 = 0xd1eeee, + LightCyan3 = 0xb4cdcd, + LightCyan4 = 0x7a8b8b, + PaleTurquoise1 = 0xbbffff, + PaleTurquoise2 = 0xaeeeee, + PaleTurquoise3 = 0x96cdcd, + PaleTurquoise4 = 0x668b8b, + CadetBlue1 = 0x98f5ff, + CadetBlue2 = 0x8ee5ee, + CadetBlue3 = 0x7ac5cd, + CadetBlue4 = 0x53868b, + Turquoise1 = 0x00f5ff, + Turquoise2 = 0x00e5ee, + Turquoise3 = 0x00c5cd, + Turquoise4 = 0x00868b, + Cyan1 = 0x00ffff, + Cyan2 = 0x00eeee, + Cyan3 = 0x00cdcd, + Cyan4 = 0x008b8b, + DarkSlateGray1 = 0x97ffff, + DarkSlateGray2 = 0x8deeee, + DarkSlateGray3 = 0x79cdcd, + DarkSlateGray4 = 0x528b8b, + Aquamarine1 = 0x7fffd4, + Aquamarine2 = 0x76eec6, + Aquamarine3 = 0x66cdaa, + Aquamarine4 = 0x458b74, + DarkSeaGreen1 = 0xc1ffc1, + DarkSeaGreen2 = 0xb4eeb4, + DarkSeaGreen3 = 0x9bcd9b, + DarkSeaGreen4 = 0x698b69, + SeaGreen1 = 0x54ff9f, + SeaGreen2 = 0x4eee94, + SeaGreen3 = 0x43cd80, + SeaGreen4 = 0x2e8b57, + PaleGreen1 = 0x9aff9a, + PaleGreen2 = 0x90ee90, + PaleGreen3 = 0x7ccd7c, + PaleGreen4 = 0x548b54, + SpringGreen1 = 0x00ff7f, + SpringGreen2 = 0x00ee76, + SpringGreen3 = 0x00cd66, + SpringGreen4 = 0x008b45, + Green1 = 0x00ff00, + Green2 = 0x00ee00, + Green3 = 0x00cd00, + Green4 = 0x008b00, + Chartreuse1 = 0x7fff00, + Chartreuse2 = 0x76ee00, + Chartreuse3 = 0x66cd00, + Chartreuse4 = 0x458b00, + OliveDrab1 = 0xc0ff3e, + OliveDrab2 = 0xb3ee3a, + OliveDrab3 = 0x9acd32, + OliveDrab4 = 0x698b22, + DarkOliveGreen1 = 0xcaff70, + DarkOliveGreen2 = 0xbcee68, + DarkOliveGreen3 = 0xa2cd5a, + DarkOliveGreen4 = 0x6e8b3d, + Khaki1 = 0xfff68f, + Khaki2 = 0xeee685, + Khaki3 = 0xcdc673, + Khaki4 = 0x8b864e, + LightGoldenrod1 = 0xffec8b, + LightGoldenrod2 = 0xeedc82, + LightGoldenrod3 = 0xcdbe70, + LightGoldenrod4 = 0x8b814c, + LightYellow1 = 0xffffe0, + LightYellow2 = 0xeeeed1, + LightYellow3 = 0xcdcdb4, + LightYellow4 = 0x8b8b7a, + Yellow1 = 0xffff00, + Yellow2 = 0xeeee00, + Yellow3 = 0xcdcd00, + Yellow4 = 0x8b8b00, + Gold1 = 0xffd700, + Gold2 = 0xeec900, + Gold3 = 0xcdad00, + Gold4 = 0x8b7500, + Goldenrod1 = 0xffc125, + Goldenrod2 = 0xeeb422, + Goldenrod3 = 0xcd9b1d, + Goldenrod4 = 0x8b6914, + DarkGoldenrod1 = 0xffb90f, + DarkGoldenrod2 = 0xeead0e, + DarkGoldenrod3 = 0xcd950c, + DarkGoldenrod4 = 0x8b6508, + RosyBrown1 = 0xffc1c1, + RosyBrown2 = 0xeeb4b4, + RosyBrown3 = 0xcd9b9b, + RosyBrown4 = 0x8b6969, + IndianRed1 = 0xff6a6a, + IndianRed2 = 0xee6363, + IndianRed3 = 0xcd5555, + IndianRed4 = 0x8b3a3a, + Sienna1 = 0xff8247, + Sienna2 = 0xee7942, + Sienna3 = 0xcd6839, + Sienna4 = 0x8b4726, + Burlywood1 = 0xffd39b, + Burlywood2 = 0xeec591, + Burlywood3 = 0xcdaa7d, + Burlywood4 = 0x8b7355, + Wheat1 = 0xffe7ba, + Wheat2 = 0xeed8ae, + Wheat3 = 0xcdba96, + Wheat4 = 0x8b7e66, + Tan1 = 0xffa54f, + Tan2 = 0xee9a49, + Tan3 = 0xcd853f, + Tan4 = 0x8b5a2b, + Chocolate1 = 0xff7f24, + Chocolate2 = 0xee7621, + Chocolate3 = 0xcd661d, + Chocolate4 = 0x8b4513, + Firebrick1 = 0xff3030, + Firebrick2 = 0xee2c2c, + Firebrick3 = 0xcd2626, + Firebrick4 = 0x8b1a1a, + Brown1 = 0xff4040, + Brown2 = 0xee3b3b, + Brown3 = 0xcd3333, + Brown4 = 0x8b2323, + Salmon1 = 0xff8c69, + Salmon2 = 0xee8262, + Salmon3 = 0xcd7054, + Salmon4 = 0x8b4c39, + LightSalmon1 = 0xffa07a, + LightSalmon2 = 0xee9572, + LightSalmon3 = 0xcd8162, + LightSalmon4 = 0x8b5742, + Orange1 = 0xffa500, + Orange2 = 0xee9a00, + Orange3 = 0xcd8500, + Orange4 = 0x8b5a00, + DarkOrange1 = 0xff7f00, + DarkOrange2 = 0xee7600, + DarkOrange3 = 0xcd6600, + DarkOrange4 = 0x8b4500, + Coral1 = 0xff7256, + Coral2 = 0xee6a50, + Coral3 = 0xcd5b45, + Coral4 = 0x8b3e2f, + Tomato1 = 0xff6347, + Tomato2 = 0xee5c42, + Tomato3 = 0xcd4f39, + Tomato4 = 0x8b3626, + OrangeRed1 = 0xff4500, + OrangeRed2 = 0xee4000, + OrangeRed3 = 0xcd3700, + OrangeRed4 = 0x8b2500, + Red1 = 0xff0000, + Red2 = 0xee0000, + Red3 = 0xcd0000, + Red4 = 0x8b0000, + DeepPink1 = 0xff1493, + DeepPink2 = 0xee1289, + DeepPink3 = 0xcd1076, + DeepPink4 = 0x8b0a50, + HotPink1 = 0xff6eb4, + HotPink2 = 0xee6aa7, + HotPink3 = 0xcd6090, + HotPink4 = 0x8b3a62, + Pink1 = 0xffb5c5, + Pink2 = 0xeea9b8, + Pink3 = 0xcd919e, + Pink4 = 0x8b636c, + LightPink1 = 0xffaeb9, + LightPink2 = 0xeea2ad, + LightPink3 = 0xcd8c95, + LightPink4 = 0x8b5f65, + PaleVioletRed1 = 0xff82ab, + PaleVioletRed2 = 0xee799f, + PaleVioletRed3 = 0xcd6889, + PaleVioletRed4 = 0x8b475d, + Maroon1 = 0xff34b3, + Maroon2 = 0xee30a7, + Maroon3 = 0xcd2990, + Maroon4 = 0x8b1c62, + VioletRed1 = 0xff3e96, + VioletRed2 = 0xee3a8c, + VioletRed3 = 0xcd3278, + VioletRed4 = 0x8b2252, + Magenta1 = 0xff00ff, + Magenta2 = 0xee00ee, + Magenta3 = 0xcd00cd, + Magenta4 = 0x8b008b, + Orchid1 = 0xff83fa, + Orchid2 = 0xee7ae9, + Orchid3 = 0xcd69c9, + Orchid4 = 0x8b4789, + Plum1 = 0xffbbff, + Plum2 = 0xeeaeee, + Plum3 = 0xcd96cd, + Plum4 = 0x8b668b, + MediumOrchid1 = 0xe066ff, + MediumOrchid2 = 0xd15fee, + MediumOrchid3 = 0xb452cd, + MediumOrchid4 = 0x7a378b, + DarkOrchid1 = 0xbf3eff, + DarkOrchid2 = 0xb23aee, + DarkOrchid3 = 0x9a32cd, + DarkOrchid4 = 0x68228b, + Purple1 = 0x9b30ff, + Purple2 = 0x912cee, + Purple3 = 0x7d26cd, + Purple4 = 0x551a8b, + MediumPurple1 = 0xab82ff, + MediumPurple2 = 0x9f79ee, + MediumPurple3 = 0x8968cd, + MediumPurple4 = 0x5d478b, + Thistle1 = 0xffe1ff, + Thistle2 = 0xeed2ee, + Thistle3 = 0xcdb5cd, + Thistle4 = 0x8b7b8b, + Gray0 = 0x000000, + Grey0 = 0x000000, + Gray1 = 0x030303, + Grey1 = 0x030303, + Gray2 = 0x050505, + Grey2 = 0x050505, + Gray3 = 0x080808, + Grey3 = 0x080808, + Gray4 = 0x0a0a0a, + Grey4 = 0x0a0a0a, + Gray5 = 0x0d0d0d, + Grey5 = 0x0d0d0d, + Gray6 = 0x0f0f0f, + Grey6 = 0x0f0f0f, + Gray7 = 0x121212, + Grey7 = 0x121212, + Gray8 = 0x141414, + Grey8 = 0x141414, + Gray9 = 0x171717, + Grey9 = 0x171717, + Gray10 = 0x1a1a1a, + Grey10 = 0x1a1a1a, + Gray11 = 0x1c1c1c, + Grey11 = 0x1c1c1c, + Gray12 = 0x1f1f1f, + Grey12 = 0x1f1f1f, + Gray13 = 0x212121, + Grey13 = 0x212121, + Gray14 = 0x242424, + Grey14 = 0x242424, + Gray15 = 0x262626, + Grey15 = 0x262626, + Gray16 = 0x292929, + Grey16 = 0x292929, + Gray17 = 0x2b2b2b, + Grey17 = 0x2b2b2b, + Gray18 = 0x2e2e2e, + Grey18 = 0x2e2e2e, + Gray19 = 0x303030, + Grey19 = 0x303030, + Gray20 = 0x333333, + Grey20 = 0x333333, + Gray21 = 0x363636, + Grey21 = 0x363636, + Gray22 = 0x383838, + Grey22 = 0x383838, + Gray23 = 0x3b3b3b, + Grey23 = 0x3b3b3b, + Gray24 = 0x3d3d3d, + Grey24 = 0x3d3d3d, + Gray25 = 0x404040, + Grey25 = 0x404040, + Gray26 = 0x424242, + Grey26 = 0x424242, + Gray27 = 0x454545, + Grey27 = 0x454545, + Gray28 = 0x474747, + Grey28 = 0x474747, + Gray29 = 0x4a4a4a, + Grey29 = 0x4a4a4a, + Gray30 = 0x4d4d4d, + Grey30 = 0x4d4d4d, + Gray31 = 0x4f4f4f, + Grey31 = 0x4f4f4f, + Gray32 = 0x525252, + Grey32 = 0x525252, + Gray33 = 0x545454, + Grey33 = 0x545454, + Gray34 = 0x575757, + Grey34 = 0x575757, + Gray35 = 0x595959, + Grey35 = 0x595959, + Gray36 = 0x5c5c5c, + Grey36 = 0x5c5c5c, + Gray37 = 0x5e5e5e, + Grey37 = 0x5e5e5e, + Gray38 = 0x616161, + Grey38 = 0x616161, + Gray39 = 0x636363, + Grey39 = 0x636363, + Gray40 = 0x666666, + Grey40 = 0x666666, + Gray41 = 0x696969, + Grey41 = 0x696969, + Gray42 = 0x6b6b6b, + Grey42 = 0x6b6b6b, + Gray43 = 0x6e6e6e, + Grey43 = 0x6e6e6e, + Gray44 = 0x707070, + Grey44 = 0x707070, + Gray45 = 0x737373, + Grey45 = 0x737373, + Gray46 = 0x757575, + Grey46 = 0x757575, + Gray47 = 0x787878, + Grey47 = 0x787878, + Gray48 = 0x7a7a7a, + Grey48 = 0x7a7a7a, + Gray49 = 0x7d7d7d, + Grey49 = 0x7d7d7d, + Gray50 = 0x7f7f7f, + Grey50 = 0x7f7f7f, + Gray51 = 0x828282, + Grey51 = 0x828282, + Gray52 = 0x858585, + Grey52 = 0x858585, + Gray53 = 0x878787, + Grey53 = 0x878787, + Gray54 = 0x8a8a8a, + Grey54 = 0x8a8a8a, + Gray55 = 0x8c8c8c, + Grey55 = 0x8c8c8c, + Gray56 = 0x8f8f8f, + Grey56 = 0x8f8f8f, + Gray57 = 0x919191, + Grey57 = 0x919191, + Gray58 = 0x949494, + Grey58 = 0x949494, + Gray59 = 0x969696, + Grey59 = 0x969696, + Gray60 = 0x999999, + Grey60 = 0x999999, + Gray61 = 0x9c9c9c, + Grey61 = 0x9c9c9c, + Gray62 = 0x9e9e9e, + Grey62 = 0x9e9e9e, + Gray63 = 0xa1a1a1, + Grey63 = 0xa1a1a1, + Gray64 = 0xa3a3a3, + Grey64 = 0xa3a3a3, + Gray65 = 0xa6a6a6, + Grey65 = 0xa6a6a6, + Gray66 = 0xa8a8a8, + Grey66 = 0xa8a8a8, + Gray67 = 0xababab, + Grey67 = 0xababab, + Gray68 = 0xadadad, + Grey68 = 0xadadad, + Gray69 = 0xb0b0b0, + Grey69 = 0xb0b0b0, + Gray70 = 0xb3b3b3, + Grey70 = 0xb3b3b3, + Gray71 = 0xb5b5b5, + Grey71 = 0xb5b5b5, + Gray72 = 0xb8b8b8, + Grey72 = 0xb8b8b8, + Gray73 = 0xbababa, + Grey73 = 0xbababa, + Gray74 = 0xbdbdbd, + Grey74 = 0xbdbdbd, + Gray75 = 0xbfbfbf, + Grey75 = 0xbfbfbf, + Gray76 = 0xc2c2c2, + Grey76 = 0xc2c2c2, + Gray77 = 0xc4c4c4, + Grey77 = 0xc4c4c4, + Gray78 = 0xc7c7c7, + Grey78 = 0xc7c7c7, + Gray79 = 0xc9c9c9, + Grey79 = 0xc9c9c9, + Gray80 = 0xcccccc, + Grey80 = 0xcccccc, + Gray81 = 0xcfcfcf, + Grey81 = 0xcfcfcf, + Gray82 = 0xd1d1d1, + Grey82 = 0xd1d1d1, + Gray83 = 0xd4d4d4, + Grey83 = 0xd4d4d4, + Gray84 = 0xd6d6d6, + Grey84 = 0xd6d6d6, + Gray85 = 0xd9d9d9, + Grey85 = 0xd9d9d9, + Gray86 = 0xdbdbdb, + Grey86 = 0xdbdbdb, + Gray87 = 0xdedede, + Grey87 = 0xdedede, + Gray88 = 0xe0e0e0, + Grey88 = 0xe0e0e0, + Gray89 = 0xe3e3e3, + Grey89 = 0xe3e3e3, + Gray90 = 0xe5e5e5, + Grey90 = 0xe5e5e5, + Gray91 = 0xe8e8e8, + Grey91 = 0xe8e8e8, + Gray92 = 0xebebeb, + Grey92 = 0xebebeb, + Gray93 = 0xededed, + Grey93 = 0xededed, + Gray94 = 0xf0f0f0, + Grey94 = 0xf0f0f0, + Gray95 = 0xf2f2f2, + Grey95 = 0xf2f2f2, + Gray96 = 0xf5f5f5, + Grey96 = 0xf5f5f5, + Gray97 = 0xf7f7f7, + Grey97 = 0xf7f7f7, + Gray98 = 0xfafafa, + Grey98 = 0xfafafa, + Gray99 = 0xfcfcfc, + Grey99 = 0xfcfcfc, + Gray100 = 0xffffff, + Grey100 = 0xffffff, + DarkGrey = 0xa9a9a9, + DarkGray = 0xa9a9a9, + DarkBlue = 0x00008b, + DarkCyan = 0x008b8b, + DarkMagenta = 0x8b008b, + DarkRed = 0x8b0000, + LightGreen = 0x90ee90, + Crimson = 0xdc143c, + Indigo = 0x4b0082, + Olive = 0x808000, + RebeccaPurple = 0x663399, + Silver = 0xc0c0c0, + Teal = 0x008080, +}; +}; +} + +#endif diff --git a/Dependencies/tracy/common/TracyForceInline.hpp b/Dependencies/tracy/common/TracyForceInline.hpp new file mode 100644 index 000000000..b6a5833e5 --- /dev/null +++ b/Dependencies/tracy/common/TracyForceInline.hpp @@ -0,0 +1,20 @@ +#ifndef __TRACYFORCEINLINE_HPP__ +#define __TRACYFORCEINLINE_HPP__ + +#if defined(__GNUC__) +# define tracy_force_inline __attribute__((always_inline)) inline +#elif defined(_MSC_VER) +# define tracy_force_inline __forceinline +#else +# define tracy_force_inline inline +#endif + +#if defined(__GNUC__) +# define tracy_no_inline __attribute__((noinline)) +#elif defined(_MSC_VER) +# define tracy_no_inline __declspec(noinline) +#else +# define tracy_no_inline +#endif + +#endif diff --git a/Dependencies/tracy/common/TracyMutex.hpp b/Dependencies/tracy/common/TracyMutex.hpp new file mode 100644 index 000000000..57fb01a0c --- /dev/null +++ b/Dependencies/tracy/common/TracyMutex.hpp @@ -0,0 +1,24 @@ +#ifndef __TRACYMUTEX_HPP__ +#define __TRACYMUTEX_HPP__ + +#if defined _MSC_VER + +# include + +namespace tracy +{ +using TracyMutex = std::shared_mutex; +} + +#else + +#include + +namespace tracy +{ +using TracyMutex = std::mutex; +} + +#endif + +#endif diff --git a/Dependencies/tracy/common/TracyProtocol.hpp b/Dependencies/tracy/common/TracyProtocol.hpp new file mode 100644 index 000000000..54124586a --- /dev/null +++ b/Dependencies/tracy/common/TracyProtocol.hpp @@ -0,0 +1,169 @@ +#ifndef __TRACYPROTOCOL_HPP__ +#define __TRACYPROTOCOL_HPP__ + +#include +#include + +namespace tracy +{ + +constexpr unsigned Lz4CompressBound( unsigned isize ) { return isize + ( isize / 255 ) + 16; } + +enum : uint32_t { ProtocolVersion = 69 }; +enum : uint16_t { BroadcastVersion = 3 }; + +using lz4sz_t = uint32_t; + +enum { TargetFrameSize = 256 * 1024 }; +enum { LZ4Size = Lz4CompressBound( TargetFrameSize ) }; +static_assert( LZ4Size <= (std::numeric_limits::max)(), "LZ4Size greater than lz4sz_t" ); +static_assert( TargetFrameSize * 2 >= 64 * 1024, "Not enough space for LZ4 stream buffer" ); + +enum { HandshakeShibbolethSize = 8 }; +static const char HandshakeShibboleth[HandshakeShibbolethSize] = { 'T', 'r', 'a', 'c', 'y', 'P', 'r', 'f' }; + +enum HandshakeStatus : uint8_t +{ + HandshakePending, + HandshakeWelcome, + HandshakeProtocolMismatch, + HandshakeNotAvailable, + HandshakeDropped +}; + +enum { WelcomeMessageProgramNameSize = 64 }; +enum { WelcomeMessageHostInfoSize = 1024 }; + +#pragma pack( push, 1 ) + +// Must increase left query space after handling! +enum ServerQuery : uint8_t +{ + ServerQueryTerminate, + ServerQueryString, + ServerQueryThreadString, + ServerQuerySourceLocation, + ServerQueryPlotName, + ServerQueryFrameName, + ServerQueryParameter, + ServerQueryFiberName, + ServerQueryExternalName, + // Items above are high priority. Split order must be preserved. See IsQueryPrio(). + ServerQueryDisconnect, + ServerQueryCallstackFrame, + ServerQuerySymbol, + ServerQuerySymbolCode, + ServerQuerySourceCode, + ServerQueryDataTransfer, + ServerQueryDataTransferPart +}; + +struct ServerQueryPacket +{ + ServerQuery type; + uint64_t ptr; + uint32_t extra; +}; + +enum { ServerQueryPacketSize = sizeof( ServerQueryPacket ) }; + + +enum CpuArchitecture : uint8_t +{ + CpuArchUnknown, + CpuArchX86, + CpuArchX64, + CpuArchArm32, + CpuArchArm64 +}; + + +struct WelcomeFlag +{ + enum _t : uint8_t + { + OnDemand = 1 << 0, + IsApple = 1 << 1, + CodeTransfer = 1 << 2, + CombineSamples = 1 << 3, + IdentifySamples = 1 << 4, + }; +}; + +struct WelcomeMessage +{ + double timerMul; + int64_t initBegin; + int64_t initEnd; + uint64_t delay; + uint64_t resolution; + uint64_t epoch; + uint64_t exectime; + uint64_t pid; + int64_t samplingPeriod; + uint8_t flags; + uint8_t cpuArch; + char cpuManufacturer[12]; + uint32_t cpuId; + char programName[WelcomeMessageProgramNameSize]; + char hostInfo[WelcomeMessageHostInfoSize]; +}; + +enum { WelcomeMessageSize = sizeof( WelcomeMessage ) }; + + +struct OnDemandPayloadMessage +{ + uint64_t frames; + uint64_t currentTime; +}; + +enum { OnDemandPayloadMessageSize = sizeof( OnDemandPayloadMessage ) }; + + +struct BroadcastMessage +{ + uint16_t broadcastVersion; + uint16_t listenPort; + uint32_t protocolVersion; + uint64_t pid; + int32_t activeTime; // in seconds + char programName[WelcomeMessageProgramNameSize]; +}; + +struct BroadcastMessage_v2 +{ + uint16_t broadcastVersion; + uint16_t listenPort; + uint32_t protocolVersion; + int32_t activeTime; + char programName[WelcomeMessageProgramNameSize]; +}; + +struct BroadcastMessage_v1 +{ + uint32_t broadcastVersion; + uint32_t protocolVersion; + uint32_t listenPort; + uint32_t activeTime; + char programName[WelcomeMessageProgramNameSize]; +}; + +struct BroadcastMessage_v0 +{ + uint32_t broadcastVersion; + uint32_t protocolVersion; + uint32_t activeTime; + char programName[WelcomeMessageProgramNameSize]; +}; + +enum { BroadcastMessageSize = sizeof( BroadcastMessage ) }; +enum { BroadcastMessageSize_v2 = sizeof( BroadcastMessage_v2 ) }; +enum { BroadcastMessageSize_v1 = sizeof( BroadcastMessage_v1 ) }; +enum { BroadcastMessageSize_v0 = sizeof( BroadcastMessage_v0 ) }; + +#pragma pack( pop ) + +} + +#endif diff --git a/Dependencies/tracy/common/TracyQueue.hpp b/Dependencies/tracy/common/TracyQueue.hpp new file mode 100644 index 000000000..affbd67ab --- /dev/null +++ b/Dependencies/tracy/common/TracyQueue.hpp @@ -0,0 +1,905 @@ +#ifndef __TRACYQUEUE_HPP__ +#define __TRACYQUEUE_HPP__ + +#include +#include + +namespace tracy +{ + +enum class QueueType : uint8_t +{ + ZoneText, + ZoneName, + Message, + MessageColor, + MessageCallstack, + MessageColorCallstack, + MessageAppInfo, + ZoneBeginAllocSrcLoc, + ZoneBeginAllocSrcLocCallstack, + CallstackSerial, + Callstack, + CallstackAlloc, + CallstackSample, + CallstackSampleContextSwitch, + FrameImage, + ZoneBegin, + ZoneBeginCallstack, + ZoneEnd, + LockWait, + LockObtain, + LockRelease, + LockSharedWait, + LockSharedObtain, + LockSharedRelease, + LockName, + MemAlloc, + MemAllocNamed, + MemFree, + MemFreeNamed, + MemAllocCallstack, + MemAllocCallstackNamed, + MemFreeCallstack, + MemFreeCallstackNamed, + GpuZoneBegin, + GpuZoneBeginCallstack, + GpuZoneBeginAllocSrcLoc, + GpuZoneBeginAllocSrcLocCallstack, + GpuZoneEnd, + GpuZoneBeginSerial, + GpuZoneBeginCallstackSerial, + GpuZoneBeginAllocSrcLocSerial, + GpuZoneBeginAllocSrcLocCallstackSerial, + GpuZoneEndSerial, + PlotDataInt, + PlotDataFloat, + PlotDataDouble, + ContextSwitch, + ThreadWakeup, + GpuTime, + GpuContextName, + CallstackFrameSize, + SymbolInformation, + ExternalNameMetadata, + SymbolCodeMetadata, + SourceCodeMetadata, + FiberEnter, + FiberLeave, + Terminate, + KeepAlive, + ThreadContext, + GpuCalibration, + GpuTimeSync, + Crash, + CrashReport, + ZoneValidation, + ZoneColor, + ZoneValue, + FrameMarkMsg, + FrameMarkMsgStart, + FrameMarkMsgEnd, + FrameVsync, + SourceLocation, + LockAnnounce, + LockTerminate, + LockMark, + MessageLiteral, + MessageLiteralColor, + MessageLiteralCallstack, + MessageLiteralColorCallstack, + GpuNewContext, + CallstackFrame, + SysTimeReport, + SysPowerReport, + TidToPid, + HwSampleCpuCycle, + HwSampleInstructionRetired, + HwSampleCacheReference, + HwSampleCacheMiss, + HwSampleBranchRetired, + HwSampleBranchMiss, + PlotConfig, + ParamSetup, + AckServerQueryNoop, + AckSourceCodeNotAvailable, + AckSymbolCodeNotAvailable, + CpuTopology, + SingleStringData, + SecondStringData, + MemNamePayload, + ThreadGroupHint, + StringData, + ThreadName, + PlotName, + SourceLocationPayload, + CallstackPayload, + CallstackAllocPayload, + FrameName, + FrameImageData, + ExternalName, + ExternalThreadName, + SymbolCode, + SourceCode, + FiberName, + NUM_TYPES +}; + +#pragma pack( push, 1 ) + +struct QueueThreadContext +{ + uint32_t thread; +}; + +struct QueueZoneBeginLean +{ + int64_t time; +}; + +struct QueueZoneBegin : public QueueZoneBeginLean +{ + uint64_t srcloc; // ptr +}; + +struct QueueZoneBeginThread : public QueueZoneBegin +{ + uint32_t thread; +}; + +struct QueueZoneEnd +{ + int64_t time; +}; + +struct QueueZoneEndThread : public QueueZoneEnd +{ + uint32_t thread; +}; + +struct QueueZoneValidation +{ + uint32_t id; +}; + +struct QueueZoneValidationThread : public QueueZoneValidation +{ + uint32_t thread; +}; + +struct QueueZoneColor +{ + uint8_t b; + uint8_t g; + uint8_t r; +}; + +struct QueueZoneColorThread : public QueueZoneColor +{ + uint32_t thread; +}; + +struct QueueZoneValue +{ + uint64_t value; +}; + +struct QueueZoneValueThread : public QueueZoneValue +{ + uint32_t thread; +}; + +struct QueueStringTransfer +{ + uint64_t ptr; +}; + +struct QueueFrameMark +{ + int64_t time; + uint64_t name; // ptr +}; + +struct QueueFrameVsync +{ + int64_t time; + uint32_t id; +}; + +struct QueueFrameImage +{ + uint32_t frame; + uint16_t w; + uint16_t h; + uint8_t flip; +}; + +struct QueueFrameImageFat : public QueueFrameImage +{ + uint64_t image; // ptr +}; + +struct QueueSourceLocation +{ + uint64_t name; + uint64_t function; // ptr + uint64_t file; // ptr + uint32_t line; + uint8_t b; + uint8_t g; + uint8_t r; +}; + +struct QueueZoneTextFat +{ + uint64_t text; // ptr + uint16_t size; +}; + +struct QueueZoneTextFatThread : public QueueZoneTextFat +{ + uint32_t thread; +}; + +enum class LockType : uint8_t +{ + Lockable, + SharedLockable +}; + +struct QueueLockAnnounce +{ + uint32_t id; + int64_t time; + uint64_t lckloc; // ptr + LockType type; +}; + +struct QueueFiberEnter +{ + int64_t time; + uint64_t fiber; // ptr + uint32_t thread; + int32_t groupHint; +}; + +struct QueueFiberLeave +{ + int64_t time; + uint32_t thread; +}; + +struct QueueLockTerminate +{ + uint32_t id; + int64_t time; +}; + +struct QueueLockWait +{ + uint32_t thread; + uint32_t id; + int64_t time; +}; + +struct QueueLockObtain +{ + uint32_t thread; + uint32_t id; + int64_t time; +}; + +struct QueueLockRelease +{ + uint32_t id; + int64_t time; +}; + +struct QueueLockReleaseShared : public QueueLockRelease +{ + uint32_t thread; +}; + +struct QueueLockMark +{ + uint32_t thread; + uint32_t id; + uint64_t srcloc; // ptr +}; + +struct QueueLockName +{ + uint32_t id; +}; + +struct QueueLockNameFat : public QueueLockName +{ + uint64_t name; // ptr + uint16_t size; +}; + +struct QueuePlotDataBase +{ + uint64_t name; // ptr + int64_t time; +}; + +struct QueuePlotDataInt : public QueuePlotDataBase +{ + int64_t val; +}; + +struct QueuePlotDataFloat : public QueuePlotDataBase +{ + float val; +}; + +struct QueuePlotDataDouble : public QueuePlotDataBase +{ + double val; +}; + +struct QueueMessage +{ + int64_t time; +}; + +struct QueueMessageColor : public QueueMessage +{ + uint8_t b; + uint8_t g; + uint8_t r; +}; + +struct QueueMessageLiteral : public QueueMessage +{ + uint64_t text; // ptr +}; + +struct QueueMessageLiteralThread : public QueueMessageLiteral +{ + uint32_t thread; +}; + +struct QueueMessageColorLiteral : public QueueMessageColor +{ + uint64_t text; // ptr +}; + +struct QueueMessageColorLiteralThread : public QueueMessageColorLiteral +{ + uint32_t thread; +}; + +struct QueueMessageFat : public QueueMessage +{ + uint64_t text; // ptr + uint16_t size; +}; + +struct QueueMessageFatThread : public QueueMessageFat +{ + uint32_t thread; +}; + +struct QueueMessageColorFat : public QueueMessageColor +{ + uint64_t text; // ptr + uint16_t size; +}; + +struct QueueMessageColorFatThread : public QueueMessageColorFat +{ + uint32_t thread; +}; + +// Don't change order, only add new entries at the end, this is also used on trace dumps! +enum class GpuContextType : uint8_t +{ + Invalid, + OpenGl, + Vulkan, + OpenCL, + Direct3D12, + Direct3D11 +}; + +enum GpuContextFlags : uint8_t +{ + GpuContextCalibration = 1 << 0 +}; + +struct QueueGpuNewContext +{ + int64_t cpuTime; + int64_t gpuTime; + uint32_t thread; + float period; + uint8_t context; + GpuContextFlags flags; + GpuContextType type; +}; + +struct QueueGpuZoneBeginLean +{ + int64_t cpuTime; + uint32_t thread; + uint16_t queryId; + uint8_t context; +}; + +struct QueueGpuZoneBegin : public QueueGpuZoneBeginLean +{ + uint64_t srcloc; +}; + +struct QueueGpuZoneEnd +{ + int64_t cpuTime; + uint32_t thread; + uint16_t queryId; + uint8_t context; +}; + +struct QueueGpuTime +{ + int64_t gpuTime; + uint16_t queryId; + uint8_t context; +}; + +struct QueueGpuCalibration +{ + int64_t gpuTime; + int64_t cpuTime; + int64_t cpuDelta; + uint8_t context; +}; + +struct QueueGpuTimeSync +{ + int64_t gpuTime; + int64_t cpuTime; + uint8_t context; +}; + +struct QueueGpuContextName +{ + uint8_t context; +}; + +struct QueueGpuContextNameFat : public QueueGpuContextName +{ + uint64_t ptr; + uint16_t size; +}; + +struct QueueMemNamePayload +{ + uint64_t name; +}; + +struct QueueThreadGroupHint +{ + uint32_t thread; + int32_t groupHint; +}; + +struct QueueMemAlloc +{ + int64_t time; + uint32_t thread; + uint64_t ptr; + char size[6]; +}; + +struct QueueMemFree +{ + int64_t time; + uint32_t thread; + uint64_t ptr; +}; + +struct QueueCallstackFat +{ + uint64_t ptr; +}; + +struct QueueCallstackFatThread : public QueueCallstackFat +{ + uint32_t thread; +}; + +struct QueueCallstackAllocFat +{ + uint64_t ptr; + uint64_t nativePtr; +}; + +struct QueueCallstackAllocFatThread : public QueueCallstackAllocFat +{ + uint32_t thread; +}; + +struct QueueCallstackSample +{ + int64_t time; + uint32_t thread; +}; + +struct QueueCallstackSampleFat : public QueueCallstackSample +{ + uint64_t ptr; +}; + +struct QueueCallstackFrameSize +{ + uint64_t ptr; + uint8_t size; +}; + +struct QueueCallstackFrameSizeFat : public QueueCallstackFrameSize +{ + uint64_t data; + uint64_t imageName; +}; + +struct QueueCallstackFrame +{ + uint32_t line; + uint64_t symAddr; + uint32_t symLen; +}; + +struct QueueSymbolInformation +{ + uint32_t line; + uint64_t symAddr; +}; + +struct QueueSymbolInformationFat : public QueueSymbolInformation +{ + uint64_t fileString; + uint8_t needFree; +}; + +struct QueueCrashReport +{ + int64_t time; + uint64_t text; // ptr +}; + +struct QueueCrashReportThread +{ + uint32_t thread; +}; + +struct QueueSysTime +{ + int64_t time; + float sysTime; +}; + +struct QueueSysPower +{ + int64_t time; + uint64_t delta; + uint64_t name; // ptr +}; + +struct QueueContextSwitch +{ + int64_t time; + uint32_t oldThread; + uint32_t newThread; + uint8_t cpu; + uint8_t reason; + uint8_t state; +}; + +struct QueueThreadWakeup +{ + int64_t time; + uint32_t thread; +}; + +struct QueueTidToPid +{ + uint64_t tid; + uint64_t pid; +}; + +struct QueueHwSample +{ + uint64_t ip; + int64_t time; +}; + +enum class PlotFormatType : uint8_t +{ + Number, + Memory, + Percentage +}; + +struct QueuePlotConfig +{ + uint64_t name; // ptr + uint8_t type; + uint8_t step; + uint8_t fill; + uint32_t color; +}; + +struct QueueParamSetup +{ + uint32_t idx; + uint64_t name; // ptr + uint8_t isBool; + int32_t val; +}; + +struct QueueSourceCodeNotAvailable +{ + uint32_t id; +}; + +struct QueueCpuTopology +{ + uint32_t package; + uint32_t die; + uint32_t core; + uint32_t thread; +}; + +struct QueueExternalNameMetadata +{ + uint64_t thread; + uint64_t name; + uint64_t threadName; +}; + +struct QueueSymbolCodeMetadata +{ + uint64_t symbol; + uint64_t ptr; + uint32_t size; +}; + +struct QueueSourceCodeMetadata +{ + uint64_t ptr; + uint32_t size; + uint32_t id; +}; + +struct QueueHeader +{ + union + { + QueueType type; + uint8_t idx; + }; +}; + +struct QueueItem +{ + QueueHeader hdr; + union + { + QueueThreadContext threadCtx; + QueueZoneBegin zoneBegin; + QueueZoneBeginLean zoneBeginLean; + QueueZoneBeginThread zoneBeginThread; + QueueZoneEnd zoneEnd; + QueueZoneEndThread zoneEndThread; + QueueZoneValidation zoneValidation; + QueueZoneValidationThread zoneValidationThread; + QueueZoneColor zoneColor; + QueueZoneColorThread zoneColorThread; + QueueZoneValue zoneValue; + QueueZoneValueThread zoneValueThread; + QueueStringTransfer stringTransfer; + QueueFrameMark frameMark; + QueueFrameVsync frameVsync; + QueueFrameImage frameImage; + QueueFrameImageFat frameImageFat; + QueueSourceLocation srcloc; + QueueZoneTextFat zoneTextFat; + QueueZoneTextFatThread zoneTextFatThread; + QueueLockAnnounce lockAnnounce; + QueueLockTerminate lockTerminate; + QueueLockWait lockWait; + QueueLockObtain lockObtain; + QueueLockRelease lockRelease; + QueueLockReleaseShared lockReleaseShared; + QueueLockMark lockMark; + QueueLockName lockName; + QueueLockNameFat lockNameFat; + QueuePlotDataInt plotDataInt; + QueuePlotDataFloat plotDataFloat; + QueuePlotDataDouble plotDataDouble; + QueueMessage message; + QueueMessageColor messageColor; + QueueMessageLiteral messageLiteral; + QueueMessageLiteralThread messageLiteralThread; + QueueMessageColorLiteral messageColorLiteral; + QueueMessageColorLiteralThread messageColorLiteralThread; + QueueMessageFat messageFat; + QueueMessageFatThread messageFatThread; + QueueMessageColorFat messageColorFat; + QueueMessageColorFatThread messageColorFatThread; + QueueGpuNewContext gpuNewContext; + QueueGpuZoneBegin gpuZoneBegin; + QueueGpuZoneBeginLean gpuZoneBeginLean; + QueueGpuZoneEnd gpuZoneEnd; + QueueGpuTime gpuTime; + QueueGpuCalibration gpuCalibration; + QueueGpuTimeSync gpuTimeSync; + QueueGpuContextName gpuContextName; + QueueGpuContextNameFat gpuContextNameFat; + QueueMemAlloc memAlloc; + QueueMemFree memFree; + QueueMemNamePayload memName; + QueueThreadGroupHint threadGroupHint; + QueueCallstackFat callstackFat; + QueueCallstackFatThread callstackFatThread; + QueueCallstackAllocFat callstackAllocFat; + QueueCallstackAllocFatThread callstackAllocFatThread; + QueueCallstackSample callstackSample; + QueueCallstackSampleFat callstackSampleFat; + QueueCallstackFrameSize callstackFrameSize; + QueueCallstackFrameSizeFat callstackFrameSizeFat; + QueueCallstackFrame callstackFrame; + QueueSymbolInformation symbolInformation; + QueueSymbolInformationFat symbolInformationFat; + QueueCrashReport crashReport; + QueueCrashReportThread crashReportThread; + QueueSysTime sysTime; + QueueSysPower sysPower; + QueueContextSwitch contextSwitch; + QueueThreadWakeup threadWakeup; + QueueTidToPid tidToPid; + QueueHwSample hwSample; + QueuePlotConfig plotConfig; + QueueParamSetup paramSetup; + QueueCpuTopology cpuTopology; + QueueExternalNameMetadata externalNameMetadata; + QueueSymbolCodeMetadata symbolCodeMetadata; + QueueSourceCodeMetadata sourceCodeMetadata; + QueueSourceCodeNotAvailable sourceCodeNotAvailable; + QueueFiberEnter fiberEnter; + QueueFiberLeave fiberLeave; + }; +}; +#pragma pack( pop ) + + +enum { QueueItemSize = sizeof( QueueItem ) }; + +static constexpr size_t QueueDataSize[] = { + sizeof( QueueHeader ), // zone text + sizeof( QueueHeader ), // zone name + sizeof( QueueHeader ) + sizeof( QueueMessage ), + sizeof( QueueHeader ) + sizeof( QueueMessageColor ), + sizeof( QueueHeader ) + sizeof( QueueMessage ), // callstack + sizeof( QueueHeader ) + sizeof( QueueMessageColor ), // callstack + sizeof( QueueHeader ) + sizeof( QueueMessage ), // app info + sizeof( QueueHeader ) + sizeof( QueueZoneBeginLean ), // allocated source location + sizeof( QueueHeader ) + sizeof( QueueZoneBeginLean ), // allocated source location, callstack + sizeof( QueueHeader ), // callstack memory + sizeof( QueueHeader ), // callstack + sizeof( QueueHeader ), // callstack alloc + sizeof( QueueHeader ) + sizeof( QueueCallstackSample ), + sizeof( QueueHeader ) + sizeof( QueueCallstackSample ), // context switch + sizeof( QueueHeader ) + sizeof( QueueFrameImage ), + sizeof( QueueHeader ) + sizeof( QueueZoneBegin ), + sizeof( QueueHeader ) + sizeof( QueueZoneBegin ), // callstack + sizeof( QueueHeader ) + sizeof( QueueZoneEnd ), + sizeof( QueueHeader ) + sizeof( QueueLockWait ), + sizeof( QueueHeader ) + sizeof( QueueLockObtain ), + sizeof( QueueHeader ) + sizeof( QueueLockRelease ), + sizeof( QueueHeader ) + sizeof( QueueLockWait ), // shared + sizeof( QueueHeader ) + sizeof( QueueLockObtain ), // shared + sizeof( QueueHeader ) + sizeof( QueueLockReleaseShared ), + sizeof( QueueHeader ) + sizeof( QueueLockName ), + sizeof( QueueHeader ) + sizeof( QueueMemAlloc ), + sizeof( QueueHeader ) + sizeof( QueueMemAlloc ), // named + sizeof( QueueHeader ) + sizeof( QueueMemFree ), + sizeof( QueueHeader ) + sizeof( QueueMemFree ), // named + sizeof( QueueHeader ) + sizeof( QueueMemAlloc ), // callstack + sizeof( QueueHeader ) + sizeof( QueueMemAlloc ), // callstack, named + sizeof( QueueHeader ) + sizeof( QueueMemFree ), // callstack + sizeof( QueueHeader ) + sizeof( QueueMemFree ), // callstack, named + sizeof( QueueHeader ) + sizeof( QueueGpuZoneBegin ), + sizeof( QueueHeader ) + sizeof( QueueGpuZoneBegin ), // callstack + sizeof( QueueHeader ) + sizeof( QueueGpuZoneBeginLean ),// allocated source location + sizeof( QueueHeader ) + sizeof( QueueGpuZoneBeginLean ),// allocated source location, callstack + sizeof( QueueHeader ) + sizeof( QueueGpuZoneEnd ), + sizeof( QueueHeader ) + sizeof( QueueGpuZoneBegin ), // serial + sizeof( QueueHeader ) + sizeof( QueueGpuZoneBegin ), // serial, callstack + sizeof( QueueHeader ) + sizeof( QueueGpuZoneBeginLean ),// serial, allocated source location + sizeof( QueueHeader ) + sizeof( QueueGpuZoneBeginLean ),// serial, allocated source location, callstack + sizeof( QueueHeader ) + sizeof( QueueGpuZoneEnd ), // serial + sizeof( QueueHeader ) + sizeof( QueuePlotDataInt ), + sizeof( QueueHeader ) + sizeof( QueuePlotDataFloat ), + sizeof( QueueHeader ) + sizeof( QueuePlotDataDouble ), + sizeof( QueueHeader ) + sizeof( QueueContextSwitch ), + sizeof( QueueHeader ) + sizeof( QueueThreadWakeup ), + sizeof( QueueHeader ) + sizeof( QueueGpuTime ), + sizeof( QueueHeader ) + sizeof( QueueGpuContextName ), + sizeof( QueueHeader ) + sizeof( QueueCallstackFrameSize ), + sizeof( QueueHeader ) + sizeof( QueueSymbolInformation ), + sizeof( QueueHeader ), // ExternalNameMetadata - not for wire transfer + sizeof( QueueHeader ), // SymbolCodeMetadata - not for wire transfer + sizeof( QueueHeader ), // SourceCodeMetadata - not for wire transfer + sizeof( QueueHeader ) + sizeof( QueueFiberEnter ), + sizeof( QueueHeader ) + sizeof( QueueFiberLeave ), + // above items must be first + sizeof( QueueHeader ), // terminate + sizeof( QueueHeader ), // keep alive + sizeof( QueueHeader ) + sizeof( QueueThreadContext ), + sizeof( QueueHeader ) + sizeof( QueueGpuCalibration ), + sizeof( QueueHeader ) + sizeof( QueueGpuTimeSync ), + sizeof( QueueHeader ), // crash + sizeof( QueueHeader ) + sizeof( QueueCrashReport ), + sizeof( QueueHeader ) + sizeof( QueueZoneValidation ), + sizeof( QueueHeader ) + sizeof( QueueZoneColor ), + sizeof( QueueHeader ) + sizeof( QueueZoneValue ), + sizeof( QueueHeader ) + sizeof( QueueFrameMark ), // continuous frames + sizeof( QueueHeader ) + sizeof( QueueFrameMark ), // start + sizeof( QueueHeader ) + sizeof( QueueFrameMark ), // end + sizeof( QueueHeader ) + sizeof( QueueFrameVsync ), + sizeof( QueueHeader ) + sizeof( QueueSourceLocation ), + sizeof( QueueHeader ) + sizeof( QueueLockAnnounce ), + sizeof( QueueHeader ) + sizeof( QueueLockTerminate ), + sizeof( QueueHeader ) + sizeof( QueueLockMark ), + sizeof( QueueHeader ) + sizeof( QueueMessageLiteral ), + sizeof( QueueHeader ) + sizeof( QueueMessageColorLiteral ), + sizeof( QueueHeader ) + sizeof( QueueMessageLiteral ), // callstack + sizeof( QueueHeader ) + sizeof( QueueMessageColorLiteral ), // callstack + sizeof( QueueHeader ) + sizeof( QueueGpuNewContext ), + sizeof( QueueHeader ) + sizeof( QueueCallstackFrame ), + sizeof( QueueHeader ) + sizeof( QueueSysTime ), + sizeof( QueueHeader ) + sizeof( QueueSysPower ), + sizeof( QueueHeader ) + sizeof( QueueTidToPid ), + sizeof( QueueHeader ) + sizeof( QueueHwSample ), // cpu cycle + sizeof( QueueHeader ) + sizeof( QueueHwSample ), // instruction retired + sizeof( QueueHeader ) + sizeof( QueueHwSample ), // cache reference + sizeof( QueueHeader ) + sizeof( QueueHwSample ), // cache miss + sizeof( QueueHeader ) + sizeof( QueueHwSample ), // branch retired + sizeof( QueueHeader ) + sizeof( QueueHwSample ), // branch miss + sizeof( QueueHeader ) + sizeof( QueuePlotConfig ), + sizeof( QueueHeader ) + sizeof( QueueParamSetup ), + sizeof( QueueHeader ), // server query acknowledgement + sizeof( QueueHeader ) + sizeof( QueueSourceCodeNotAvailable ), + sizeof( QueueHeader ), // symbol code not available + sizeof( QueueHeader ) + sizeof( QueueCpuTopology ), + sizeof( QueueHeader ), // single string data + sizeof( QueueHeader ), // second string data + sizeof( QueueHeader ) + sizeof( QueueMemNamePayload ), + sizeof( QueueHeader ) + sizeof( QueueThreadGroupHint ), + // keep all QueueStringTransfer below + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // string data + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // thread name + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // plot name + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // allocated source location payload + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // callstack payload + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // callstack alloc payload + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // frame name + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // frame image data + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // external name + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // external thread name + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // symbol code + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // source code + sizeof( QueueHeader ) + sizeof( QueueStringTransfer ), // fiber name +}; + +static_assert( QueueItemSize == 32, "Queue item size not 32 bytes" ); +static_assert( sizeof( QueueDataSize ) / sizeof( size_t ) == (uint8_t)QueueType::NUM_TYPES, "QueueDataSize mismatch" ); +static_assert( sizeof( void* ) <= sizeof( uint64_t ), "Pointer size > 8 bytes" ); +static_assert( sizeof( void* ) == sizeof( uintptr_t ), "Pointer size != uintptr_t" ); + +} + +#endif diff --git a/Dependencies/tracy/common/TracySocket.cpp b/Dependencies/tracy/common/TracySocket.cpp new file mode 100644 index 000000000..bdba36196 --- /dev/null +++ b/Dependencies/tracy/common/TracySocket.cpp @@ -0,0 +1,752 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "TracyAlloc.hpp" +#include "TracySocket.hpp" +#include "TracySystem.hpp" + +#ifdef _WIN32 +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +# include +# ifdef _MSC_VER +# pragma warning(disable:4244) +# pragma warning(disable:4267) +# endif +# define poll WSAPoll +# ifdef _MSC_VER +# pragma comment(lib, "ws2_32.lib") +# endif +#else +# include +# include +# include +# include +# include +# include +# include +# include +# include +#endif + +#ifndef MSG_NOSIGNAL +# define MSG_NOSIGNAL 0 +#endif + +namespace tracy +{ + +#ifdef _WIN32 +typedef SOCKET socket_t; +#else +typedef int socket_t; +#endif + +#ifdef _WIN32 +struct __wsinit +{ + __wsinit() + { + WSADATA wsaData; + if( WSAStartup( MAKEWORD( 2, 2 ), &wsaData ) != 0 ) + { + fprintf( stderr, "Cannot init winsock.\n" ); + exit( 1 ); + } + } +}; + +void InitWinSock() +{ + static __wsinit init; +} +#endif + + +enum { BufSize = 128 * 1024 }; + +Socket::Socket() + : m_buf( (char*)tracy_malloc( BufSize ) ) + , m_bufPtr( nullptr ) + , m_sock( -1 ) + , m_bufLeft( 0 ) + , m_ptr( nullptr ) +{ +#ifdef _WIN32 + InitWinSock(); +#endif +} + +Socket::Socket( int sock ) + : m_buf( (char*)tracy_malloc( BufSize ) ) + , m_bufPtr( nullptr ) + , m_sock( sock ) + , m_bufLeft( 0 ) + , m_ptr( nullptr ) +{ +} + +Socket::~Socket() +{ + tracy_free( m_buf ); + if( m_sock.load( std::memory_order_relaxed ) != -1 ) + { + Close(); + } + if( m_ptr ) + { + freeaddrinfo( m_res ); +#ifdef _WIN32 + closesocket( m_connSock ); +#else + close( m_connSock ); +#endif + } +} + +bool Socket::Connect( const char* addr, uint16_t port ) +{ + assert( !IsValid() ); + + if( m_ptr ) + { + const auto c = connect( m_connSock, m_ptr->ai_addr, m_ptr->ai_addrlen ); + if( c == -1 ) + { +#if defined _WIN32 + const auto err = WSAGetLastError(); + if( err == WSAEALREADY || err == WSAEINPROGRESS ) return false; + if( err != WSAEISCONN ) + { + freeaddrinfo( m_res ); + closesocket( m_connSock ); + m_ptr = nullptr; + return false; + } +#else + const auto err = errno; + if( err == EALREADY || err == EINPROGRESS ) return false; + if( err != EISCONN ) + { + freeaddrinfo( m_res ); + close( m_connSock ); + m_ptr = nullptr; + return false; + } +#endif + } + +#if defined _WIN32 + u_long nonblocking = 0; + ioctlsocket( m_connSock, FIONBIO, &nonblocking ); +#else + int flags = fcntl( m_connSock, F_GETFL, 0 ); + fcntl( m_connSock, F_SETFL, flags & ~O_NONBLOCK ); +#endif + m_sock.store( m_connSock, std::memory_order_relaxed ); + freeaddrinfo( m_res ); + m_ptr = nullptr; + return true; + } + + struct addrinfo hints; + struct addrinfo *res, *ptr; + + memset( &hints, 0, sizeof( hints ) ); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + + char portbuf[32]; + sprintf( portbuf, "%" PRIu16, port ); + + if( getaddrinfo( addr, portbuf, &hints, &res ) != 0 ) return false; + int sock = 0; + for( ptr = res; ptr; ptr = ptr->ai_next ) + { + if( ( sock = socket( ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol ) ) == -1 ) continue; +#if defined __APPLE__ + int val = 1; + setsockopt( sock, SOL_SOCKET, SO_NOSIGPIPE, &val, sizeof( val ) ); +#endif +#if defined _WIN32 + u_long nonblocking = 1; + ioctlsocket( sock, FIONBIO, &nonblocking ); +#else + int flags = fcntl( sock, F_GETFL, 0 ); + fcntl( sock, F_SETFL, flags | O_NONBLOCK ); +#endif + if( connect( sock, ptr->ai_addr, ptr->ai_addrlen ) == 0 ) + { + break; + } + else + { +#if defined _WIN32 + const auto err = WSAGetLastError(); + if( err != WSAEWOULDBLOCK ) + { + closesocket( sock ); + continue; + } +#else + if( errno != EINPROGRESS ) + { + close( sock ); + continue; + } +#endif + } + m_res = res; + m_ptr = ptr; + m_connSock = sock; + return false; + } + freeaddrinfo( res ); + if( !ptr ) return false; + +#if defined _WIN32 + u_long nonblocking = 0; + ioctlsocket( sock, FIONBIO, &nonblocking ); +#else + int flags = fcntl( sock, F_GETFL, 0 ); + fcntl( sock, F_SETFL, flags & ~O_NONBLOCK ); +#endif + + m_sock.store( sock, std::memory_order_relaxed ); + return true; +} + +bool Socket::ConnectBlocking( const char* addr, uint16_t port ) +{ + assert( !IsValid() ); + assert( !m_ptr ); + + struct addrinfo hints; + struct addrinfo *res, *ptr; + + memset( &hints, 0, sizeof( hints ) ); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + + char portbuf[32]; + sprintf( portbuf, "%" PRIu16, port ); + + if( getaddrinfo( addr, portbuf, &hints, &res ) != 0 ) return false; + int sock = 0; + for( ptr = res; ptr; ptr = ptr->ai_next ) + { + if( ( sock = socket( ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol ) ) == -1 ) continue; +#if defined __APPLE__ + int val = 1; + setsockopt( sock, SOL_SOCKET, SO_NOSIGPIPE, &val, sizeof( val ) ); +#endif + if( connect( sock, ptr->ai_addr, ptr->ai_addrlen ) == -1 ) + { +#ifdef _WIN32 + closesocket( sock ); +#else + close( sock ); +#endif + continue; + } + break; + } + freeaddrinfo( res ); + if( !ptr ) return false; + + m_sock.store( sock, std::memory_order_relaxed ); + return true; +} + +void Socket::Close() +{ + const auto sock = m_sock.load( std::memory_order_relaxed ); + assert( sock != -1 ); +#ifdef _WIN32 + closesocket( sock ); +#else + close( sock ); +#endif + m_sock.store( -1, std::memory_order_relaxed ); +} + +int Socket::Send( const void* _buf, int len ) +{ + const auto sock = m_sock.load( std::memory_order_relaxed ); + auto buf = (const char*)_buf; + assert( sock != -1 ); + auto start = buf; + while( len > 0 ) + { + auto ret = send( sock, buf, len, MSG_NOSIGNAL ); + if( ret == -1 ) return -1; + len -= ret; + buf += ret; + } + return int( buf - start ); +} + +int Socket::GetSendBufSize() +{ + const auto sock = m_sock.load( std::memory_order_relaxed ); + int bufSize; +#if defined _WIN32 + int sz = sizeof( bufSize ); + getsockopt( sock, SOL_SOCKET, SO_SNDBUF, (char*)&bufSize, &sz ); +#else + socklen_t sz = sizeof( bufSize ); + getsockopt( sock, SOL_SOCKET, SO_SNDBUF, &bufSize, &sz ); +#endif + return bufSize; +} + +int Socket::RecvBuffered( void* buf, int len, int timeout ) +{ + if( len <= m_bufLeft ) + { + memcpy( buf, m_bufPtr, len ); + m_bufPtr += len; + m_bufLeft -= len; + return len; + } + + if( m_bufLeft > 0 ) + { + memcpy( buf, m_bufPtr, m_bufLeft ); + const auto ret = m_bufLeft; + m_bufLeft = 0; + return ret; + } + + if( len >= BufSize ) return Recv( buf, len, timeout ); + + m_bufLeft = Recv( m_buf, BufSize, timeout ); + if( m_bufLeft <= 0 ) return m_bufLeft; + + const auto sz = len < m_bufLeft ? len : m_bufLeft; + memcpy( buf, m_buf, sz ); + m_bufPtr = m_buf + sz; + m_bufLeft -= sz; + return sz; +} + +int Socket::Recv( void* _buf, int len, int timeout ) +{ + const auto sock = m_sock.load( std::memory_order_relaxed ); + auto buf = (char*)_buf; + + struct pollfd fd; + fd.fd = (socket_t)sock; + fd.events = POLLIN; + + if( poll( &fd, 1, timeout ) > 0 ) + { + return recv( sock, buf, len, 0 ); + } + else + { + return -1; + } +} + +int Socket::ReadUpTo( void* _buf, int len ) +{ + const auto sock = m_sock.load( std::memory_order_relaxed ); + auto buf = (char*)_buf; + + int rd = 0; + while( len > 0 ) + { + const auto res = recv( sock, buf, len, 0 ); + if( res == 0 ) break; + if( res == -1 ) return -1; + len -= res; + rd += res; + buf += res; + } + return rd; +} + +bool Socket::Read( void* buf, int len, int timeout ) +{ + auto cbuf = (char*)buf; + while( len > 0 ) + { + if( !ReadImpl( cbuf, len, timeout ) ) return false; + } + return true; +} + +bool Socket::ReadImpl( char*& buf, int& len, int timeout ) +{ + const auto sz = RecvBuffered( buf, len, timeout ); + switch( sz ) + { + case 0: + return false; + case -1: +#ifdef _WIN32 + { + auto err = WSAGetLastError(); + if( err == WSAECONNABORTED || err == WSAECONNRESET ) return false; + } +#endif + break; + default: + len -= sz; + buf += sz; + break; + } + return true; +} + +bool Socket::ReadRaw( void* _buf, int len, int timeout ) +{ + auto buf = (char*)_buf; + while( len > 0 ) + { + const auto sz = Recv( buf, len, timeout ); + if( sz <= 0 ) return false; + len -= sz; + buf += sz; + } + return true; +} + +bool Socket::HasData() +{ + const auto sock = m_sock.load( std::memory_order_relaxed ); + if( m_bufLeft > 0 ) return true; + + struct pollfd fd; + fd.fd = (socket_t)sock; + fd.events = POLLIN; + + return poll( &fd, 1, 0 ) > 0; +} + +bool Socket::IsValid() const +{ + return m_sock.load( std::memory_order_relaxed ) >= 0; +} + + +ListenSocket::ListenSocket() + : m_sock( -1 ) +{ +#ifdef _WIN32 + InitWinSock(); +#endif +} + +ListenSocket::~ListenSocket() +{ + if( m_sock != -1 ) Close(); +} + +static int addrinfo_and_socket_for_family( uint16_t port, int ai_family, struct addrinfo** res ) +{ + struct addrinfo hints; + memset( &hints, 0, sizeof( hints ) ); + hints.ai_family = ai_family; + hints.ai_socktype = SOCK_STREAM; +#ifndef TRACY_ONLY_LOCALHOST + const char* onlyLocalhost = GetEnvVar( "TRACY_ONLY_LOCALHOST" ); + if( !onlyLocalhost || onlyLocalhost[0] != '1' ) + { + hints.ai_flags = AI_PASSIVE; + } +#endif + char portbuf[32]; + sprintf( portbuf, "%" PRIu16, port ); + if( getaddrinfo( nullptr, portbuf, &hints, res ) != 0 ) return -1; + int sock = socket( (*res)->ai_family, (*res)->ai_socktype, (*res)->ai_protocol ); + if (sock == -1) freeaddrinfo( *res ); + return sock; +} + +bool ListenSocket::Listen( uint16_t port, int backlog ) +{ + assert( m_sock == -1 ); + + struct addrinfo* res = nullptr; + +#if !defined TRACY_ONLY_IPV4 && !defined TRACY_ONLY_LOCALHOST + const char* onlyIPv4 = GetEnvVar( "TRACY_ONLY_IPV4" ); + if( !onlyIPv4 || onlyIPv4[0] != '1' ) + { + m_sock = addrinfo_and_socket_for_family( port, AF_INET6, &res ); + } +#endif + if (m_sock == -1) + { + // IPV6 protocol may not be available/is disabled. Try to create a socket + // with the IPV4 protocol + m_sock = addrinfo_and_socket_for_family( port, AF_INET, &res ); + if( m_sock == -1 ) return false; + } +#if defined _WIN32 + unsigned long val = 0; + setsockopt( m_sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&val, sizeof( val ) ); +#elif defined BSD + int val = 0; + setsockopt( m_sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&val, sizeof( val ) ); + val = 1; + setsockopt( m_sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof( val ) ); +#else + int val = 1; + setsockopt( m_sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof( val ) ); +#endif + if( bind( m_sock, res->ai_addr, res->ai_addrlen ) == -1 ) { freeaddrinfo( res ); Close(); return false; } + if( listen( m_sock, backlog ) == -1 ) { freeaddrinfo( res ); Close(); return false; } + freeaddrinfo( res ); + return true; +} + +Socket* ListenSocket::Accept() +{ + struct sockaddr_storage remote; + socklen_t sz = sizeof( remote ); + + struct pollfd fd; + fd.fd = (socket_t)m_sock; + fd.events = POLLIN; + + if( poll( &fd, 1, 10 ) > 0 ) + { + int sock = accept( m_sock, (sockaddr*)&remote, &sz); + if( sock == -1 ) return nullptr; + +#if defined __APPLE__ + int val = 1; + setsockopt( sock, SOL_SOCKET, SO_NOSIGPIPE, &val, sizeof( val ) ); +#endif + + auto ptr = (Socket*)tracy_malloc( sizeof( Socket ) ); + new(ptr) Socket( sock ); + return ptr; + } + else + { + return nullptr; + } +} + +void ListenSocket::Close() +{ + assert( m_sock != -1 ); +#ifdef _WIN32 + closesocket( m_sock ); +#else + close( m_sock ); +#endif + m_sock = -1; +} + +UdpBroadcast::UdpBroadcast() + : m_sock( -1 ) +{ +#ifdef _WIN32 + InitWinSock(); +#endif +} + +UdpBroadcast::~UdpBroadcast() +{ + if( m_sock != -1 ) Close(); +} + +bool UdpBroadcast::Open( const char* addr, uint16_t port ) +{ + assert( m_sock == -1 ); + + struct addrinfo hints; + struct addrinfo *res, *ptr; + + memset( &hints, 0, sizeof( hints ) ); + hints.ai_family = AF_INET; + hints.ai_socktype = SOCK_DGRAM; + + char portbuf[32]; + sprintf( portbuf, "%" PRIu16, port ); + + if( getaddrinfo( addr, portbuf, &hints, &res ) != 0 ) return false; + int sock = 0; + for( ptr = res; ptr; ptr = ptr->ai_next ) + { + if( ( sock = socket( ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol ) ) == -1 ) continue; +#if defined __APPLE__ + int val = 1; + setsockopt( sock, SOL_SOCKET, SO_NOSIGPIPE, &val, sizeof( val ) ); +#endif +#if defined _WIN32 + unsigned long broadcast = 1; + if( setsockopt( sock, SOL_SOCKET, SO_BROADCAST, (const char*)&broadcast, sizeof( broadcast ) ) == -1 ) +#else + int broadcast = 1; + if( setsockopt( sock, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof( broadcast ) ) == -1 ) +#endif + { +#ifdef _WIN32 + closesocket( sock ); +#else + close( sock ); +#endif + continue; + } + break; + } + freeaddrinfo( res ); + if( !ptr ) return false; + + m_sock = sock; + inet_pton( AF_INET, addr, &m_addr ); + return true; +} + +void UdpBroadcast::Close() +{ + assert( m_sock != -1 ); +#ifdef _WIN32 + closesocket( m_sock ); +#else + close( m_sock ); +#endif + m_sock = -1; +} + +int UdpBroadcast::Send( uint16_t port, const void* data, int len ) +{ + assert( m_sock != -1 ); + struct sockaddr_in addr; + addr.sin_family = AF_INET; + addr.sin_port = htons( port ); + addr.sin_addr.s_addr = m_addr; + return sendto( m_sock, (const char*)data, len, MSG_NOSIGNAL, (sockaddr*)&addr, sizeof( addr ) ); +} + +IpAddress::IpAddress() + : m_number( 0 ) +{ + *m_text = '\0'; +} + +IpAddress::~IpAddress() +{ +} + +void IpAddress::Set( const struct sockaddr& addr ) +{ +#if defined _WIN32 && ( !defined NTDDI_WIN10 || NTDDI_VERSION < NTDDI_WIN10 ) + struct sockaddr_in tmp; + memcpy( &tmp, &addr, sizeof( tmp ) ); + auto ai = &tmp; +#else + auto ai = (const struct sockaddr_in*)&addr; +#endif + inet_ntop( AF_INET, &ai->sin_addr, m_text, 17 ); + m_number = ai->sin_addr.s_addr; +} + +UdpListen::UdpListen() + : m_sock( -1 ) +{ +#ifdef _WIN32 + InitWinSock(); +#endif +} + +UdpListen::~UdpListen() +{ + if( m_sock != -1 ) Close(); +} + +bool UdpListen::Listen( uint16_t port ) +{ + assert( m_sock == -1 ); + + int sock; + if( ( sock = socket( AF_INET, SOCK_DGRAM, 0 ) ) == -1 ) return false; + +#if defined __APPLE__ + int val = 1; + setsockopt( sock, SOL_SOCKET, SO_NOSIGPIPE, &val, sizeof( val ) ); +#endif +#if defined _WIN32 + unsigned long reuse = 1; + setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse, sizeof( reuse ) ); +#else + int reuse = 1; + setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof( reuse ) ); +#endif +#if defined _WIN32 + unsigned long broadcast = 1; + if( setsockopt( sock, SOL_SOCKET, SO_BROADCAST, (const char*)&broadcast, sizeof( broadcast ) ) == -1 ) +#else + int broadcast = 1; + if( setsockopt( sock, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof( broadcast ) ) == -1 ) +#endif + { +#ifdef _WIN32 + closesocket( sock ); +#else + close( sock ); +#endif + return false; + } + + struct sockaddr_in addr; + addr.sin_family = AF_INET; + addr.sin_port = htons( port ); + addr.sin_addr.s_addr = INADDR_ANY; + + if( bind( sock, (sockaddr*)&addr, sizeof( addr ) ) == -1 ) + { +#ifdef _WIN32 + closesocket( sock ); +#else + close( sock ); +#endif + return false; + } + + m_sock = sock; + return true; +} + +void UdpListen::Close() +{ + assert( m_sock != -1 ); +#ifdef _WIN32 + closesocket( m_sock ); +#else + close( m_sock ); +#endif + m_sock = -1; +} + +const char* UdpListen::Read( size_t& len, IpAddress& addr, int timeout ) +{ + static char buf[2048]; + + struct pollfd fd; + fd.fd = (socket_t)m_sock; + fd.events = POLLIN; + if( poll( &fd, 1, timeout ) <= 0 ) return nullptr; + + sockaddr sa; + socklen_t salen = sizeof( struct sockaddr ); + len = (size_t)recvfrom( m_sock, buf, 2048, 0, &sa, &salen ); + addr.Set( sa ); + + return buf; +} + +} diff --git a/Dependencies/tracy/common/TracySocket.hpp b/Dependencies/tracy/common/TracySocket.hpp new file mode 100644 index 000000000..f7713aac6 --- /dev/null +++ b/Dependencies/tracy/common/TracySocket.hpp @@ -0,0 +1,155 @@ +#ifndef __TRACYSOCKET_HPP__ +#define __TRACYSOCKET_HPP__ + +#include +#include +#include + +struct addrinfo; +struct sockaddr; + +namespace tracy +{ + +#ifdef _WIN32 +void InitWinSock(); +#endif + +class Socket +{ +public: + Socket(); + Socket( int sock ); + ~Socket(); + + bool Connect( const char* addr, uint16_t port ); + bool ConnectBlocking( const char* addr, uint16_t port ); + void Close(); + + int Send( const void* buf, int len ); + int GetSendBufSize(); + + int ReadUpTo( void* buf, int len ); + bool Read( void* buf, int len, int timeout ); + + template + bool Read( void* buf, int len, int timeout, ShouldExit exitCb ) + { + auto cbuf = (char*)buf; + while( len > 0 ) + { + if( exitCb() ) return false; + if( !ReadImpl( cbuf, len, timeout ) ) return false; + } + return true; + } + + bool ReadRaw( void* buf, int len, int timeout ); + bool HasData(); + bool IsValid() const; + + Socket( const Socket& ) = delete; + Socket( Socket&& ) = delete; + Socket& operator=( const Socket& ) = delete; + Socket& operator=( Socket&& ) = delete; + +private: + int RecvBuffered( void* buf, int len, int timeout ); + int Recv( void* buf, int len, int timeout ); + + bool ReadImpl( char*& buf, int& len, int timeout ); + + char* m_buf; + char* m_bufPtr; + std::atomic m_sock; + int m_bufLeft; + + struct addrinfo *m_res; + struct addrinfo *m_ptr; + int m_connSock; +}; + +class ListenSocket +{ +public: + ListenSocket(); + ~ListenSocket(); + + bool Listen( uint16_t port, int backlog ); + Socket* Accept(); + void Close(); + + ListenSocket( const ListenSocket& ) = delete; + ListenSocket( ListenSocket&& ) = delete; + ListenSocket& operator=( const ListenSocket& ) = delete; + ListenSocket& operator=( ListenSocket&& ) = delete; + +private: + int m_sock; +}; + +class UdpBroadcast +{ +public: + UdpBroadcast(); + ~UdpBroadcast(); + + bool Open( const char* addr, uint16_t port ); + void Close(); + + int Send( uint16_t port, const void* data, int len ); + + UdpBroadcast( const UdpBroadcast& ) = delete; + UdpBroadcast( UdpBroadcast&& ) = delete; + UdpBroadcast& operator=( const UdpBroadcast& ) = delete; + UdpBroadcast& operator=( UdpBroadcast&& ) = delete; + +private: + int m_sock; + uint32_t m_addr; +}; + +class IpAddress +{ +public: + IpAddress(); + ~IpAddress(); + + void Set( const struct sockaddr& addr ); + + uint32_t GetNumber() const { return m_number; } + const char* GetText() const { return m_text; } + + IpAddress( const IpAddress& ) = delete; + IpAddress( IpAddress&& ) = delete; + IpAddress& operator=( const IpAddress& ) = delete; + IpAddress& operator=( IpAddress&& ) = delete; + +private: + uint32_t m_number; + char m_text[17]; +}; + +class UdpListen +{ +public: + UdpListen(); + ~UdpListen(); + + bool Listen( uint16_t port ); + void Close(); + + const char* Read( size_t& len, IpAddress& addr, int timeout ); + + UdpListen( const UdpListen& ) = delete; + UdpListen( UdpListen&& ) = delete; + UdpListen& operator=( const UdpListen& ) = delete; + UdpListen& operator=( UdpListen&& ) = delete; + +private: + int m_sock; +}; + +} + +#endif diff --git a/Dependencies/tracy/common/TracyStackFrames.cpp b/Dependencies/tracy/common/TracyStackFrames.cpp new file mode 100644 index 000000000..7b0abace3 --- /dev/null +++ b/Dependencies/tracy/common/TracyStackFrames.cpp @@ -0,0 +1,122 @@ +#include "TracyStackFrames.hpp" + +namespace tracy +{ + +const char* s_tracyStackFrames_[] = { + "tracy::Callstack", + "tracy::Callstack(int)", + "tracy::GpuCtxScope::{ctor}", + "tracy::Profiler::SendCallstack", + "tracy::Profiler::SendCallstack(int)", + "tracy::Profiler::SendCallstack(int, unsigned long)", + "tracy::Profiler::MemAllocCallstack", + "tracy::Profiler::MemAllocCallstack(void const*, unsigned long, int)", + "tracy::Profiler::MemFreeCallstack", + "tracy::Profiler::MemFreeCallstack(void const*, int)", + "tracy::ScopedZone::{ctor}", + "tracy::ScopedZone::ScopedZone(tracy::SourceLocationData const*, int, bool)", + "tracy::Profiler::Message", + nullptr +}; + +const char** s_tracyStackFrames = s_tracyStackFrames_; + +const StringMatch s_tracySkipSubframes_[] = { + { "/include/arm_neon.h", 19 }, + { "/include/adxintrin.h", 20 }, + { "/include/ammintrin.h", 20 }, + { "/include/amxbf16intrin.h", 24 }, + { "/include/amxint8intrin.h", 24 }, + { "/include/amxtileintrin.h", 24 }, + { "/include/avx2intrin.h", 21 }, + { "/include/avx5124fmapsintrin.h", 29 }, + { "/include/avx5124vnniwintrin.h", 29 }, + { "/include/avx512bf16intrin.h", 27 }, + { "/include/avx512bf16vlintrin.h", 29 }, + { "/include/avx512bitalgintrin.h", 29 }, + { "/include/avx512bwintrin.h", 25 }, + { "/include/avx512cdintrin.h", 25 }, + { "/include/avx512dqintrin.h", 25 }, + { "/include/avx512erintrin.h", 25 }, + { "/include/avx512fintrin.h", 24 }, + { "/include/avx512ifmaintrin.h", 27 }, + { "/include/avx512ifmavlintrin.h", 29 }, + { "/include/avx512pfintrin.h", 25 }, + { "/include/avx512vbmi2intrin.h", 28 }, + { "/include/avx512vbmi2vlintrin.h", 30 }, + { "/include/avx512vbmiintrin.h", 27 }, + { "/include/avx512vbmivlintrin.h", 29 }, + { "/include/avx512vlbwintrin.h", 27 }, + { "/include/avx512vldqintrin.h", 27 }, + { "/include/avx512vlintrin.h", 25 }, + { "/include/avx512vnniintrin.h", 27 }, + { "/include/avx512vnnivlintrin.h", 29 }, + { "/include/avx512vp2intersectintrin.h", 35 }, + { "/include/avx512vp2intersectvlintrin.h", 37 }, + { "/include/avx512vpopcntdqintrin.h", 32 }, + { "/include/avx512vpopcntdqvlintrin.h", 34 }, + { "/include/avxintrin.h", 20 }, + { "/include/avxvnniintrin.h", 24 }, + { "/include/bmi2intrin.h", 21 }, + { "/include/bmiintrin.h", 20 }, + { "/include/bmmintrin.h", 20 }, + { "/include/cetintrin.h", 20 }, + { "/include/cldemoteintrin.h", 25 }, + { "/include/clflushoptintrin.h", 27 }, + { "/include/clwbintrin.h", 21 }, + { "/include/clzerointrin.h", 23 }, + { "/include/emmintrin.h", 20 }, + { "/include/enqcmdintrin.h", 23 }, + { "/include/f16cintrin.h", 21 }, + { "/include/fma4intrin.h", 21 }, + { "/include/fmaintrin.h", 20 }, + { "/include/fxsrintrin.h", 21 }, + { "/include/gfniintrin.h", 21 }, + { "/include/hresetintrin.h", 23 }, + { "/include/ia32intrin.h", 21 }, + { "/include/immintrin.h", 20 }, + { "/include/keylockerintrin.h", 26 }, + { "/include/lwpintrin.h", 20 }, + { "/include/lzcntintrin.h", 22 }, + { "/include/mmintrin.h", 19 }, + { "/include/movdirintrin.h", 23 }, + { "/include/mwaitxintrin.h", 23 }, + { "/include/nmmintrin.h", 20 }, + { "/include/pconfigintrin.h", 24 }, + { "/include/pkuintrin.h", 20 }, + { "/include/pmmintrin.h", 20 }, + { "/include/popcntintrin.h", 23 }, + { "/include/prfchwintrin.h", 23 }, + { "/include/rdseedintrin.h", 23 }, + { "/include/rtmintrin.h", 20 }, + { "/include/serializeintrin.h", 26 }, + { "/include/sgxintrin.h", 20 }, + { "/include/shaintrin.h", 20 }, + { "/include/smmintrin.h", 20 }, + { "/include/tbmintrin.h", 20 }, + { "/include/tmmintrin.h", 20 }, + { "/include/tsxldtrkintrin.h", 25 }, + { "/include/uintrintrin.h", 22 }, + { "/include/vaesintrin.h", 21 }, + { "/include/vpclmulqdqintrin.h", 27 }, + { "/include/waitpkgintrin.h", 24 }, + { "/include/wbnoinvdintrin.h", 25 }, + { "/include/wmmintrin.h", 20 }, + { "/include/x86gprintrin.h", 23 }, + { "/include/x86intrin.h", 20 }, + { "/include/xmmintrin.h", 20 }, + { "/include/xopintrin.h", 20 }, + { "/include/xsavecintrin.h", 23 }, + { "/include/xsaveintrin.h", 22 }, + { "/include/xsaveoptintrin.h", 25 }, + { "/include/xsavesintrin.h", 23 }, + { "/include/xtestintrin.h", 22 }, + { "/bits/atomic_base.h", 19 }, + { "/atomic", 7 }, + {} +}; + +const StringMatch* s_tracySkipSubframes = s_tracySkipSubframes_; + +} diff --git a/Dependencies/tracy/common/TracyStackFrames.hpp b/Dependencies/tracy/common/TracyStackFrames.hpp new file mode 100644 index 000000000..9d4262c00 --- /dev/null +++ b/Dependencies/tracy/common/TracyStackFrames.hpp @@ -0,0 +1,22 @@ +#ifndef __TRACYSTACKFRAMES_HPP__ +#define __TRACYSTACKFRAMES_HPP__ + +#include + +namespace tracy +{ + +struct StringMatch +{ + const char* str; + size_t len; +}; + +extern const char** s_tracyStackFrames; +extern const StringMatch* s_tracySkipSubframes; + +static constexpr int s_tracySkipSubframesMinLen = 7; + +} + +#endif diff --git a/Dependencies/tracy/common/TracySystem.cpp b/Dependencies/tracy/common/TracySystem.cpp new file mode 100644 index 000000000..d51f5d65b --- /dev/null +++ b/Dependencies/tracy/common/TracySystem.cpp @@ -0,0 +1,347 @@ +#ifdef _MSC_VER +# pragma warning(disable:4996) +#endif +#if defined _WIN32 +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +# include +# include "TracyUwp.hpp" +#else +# include +# include +# include +#endif + +#ifdef __linux__ +# ifdef __ANDROID__ +# include +# else +# include +# endif +# include +#elif defined __FreeBSD__ +# include +#elif defined __NetBSD__ || defined __DragonFly__ +# include +#elif defined __QNX__ +# include +# include +#endif + +#ifdef __MINGW32__ +# define __STDC_FORMAT_MACROS +#endif +#include +#include +#include + +#include "TracySystem.hpp" + +#if defined _WIN32 +extern "C" typedef HRESULT (WINAPI *t_SetThreadDescription)( HANDLE, PCWSTR ); +extern "C" typedef HRESULT (WINAPI *t_GetThreadDescription)( HANDLE, PWSTR* ); +#endif + +#ifdef TRACY_ENABLE +# include +# include "TracyAlloc.hpp" +#endif + +namespace tracy +{ + +namespace detail +{ + +TRACY_API uint32_t GetThreadHandleImpl() +{ +#if defined _WIN32 + static_assert( sizeof( decltype( GetCurrentThreadId() ) ) <= sizeof( uint32_t ), "Thread handle too big to fit in protocol" ); + return uint32_t( GetCurrentThreadId() ); +#elif defined __APPLE__ + uint64_t id; + pthread_threadid_np( pthread_self(), &id ); + return uint32_t( id ); +#elif defined __ANDROID__ + return (uint32_t)gettid(); +#elif defined __linux__ + return (uint32_t)syscall( SYS_gettid ); +#elif defined __FreeBSD__ + long id; + thr_self( &id ); + return id; +#elif defined __NetBSD__ + return _lwp_self(); +#elif defined __DragonFly__ + return lwp_gettid(); +#elif defined __OpenBSD__ + return getthrid(); +#elif defined __QNX__ + return (uint32_t) gettid(); +#elif defined __EMSCRIPTEN__ + // Not supported, but let it compile. + return 0; +#else + // To add support for a platform, retrieve and return the kernel thread identifier here. + // + // Note that pthread_t (as for example returned by pthread_self()) is *not* a kernel + // thread identifier. It is a pointer to a library-allocated data structure instead. + // Such pointers will be reused heavily, making the pthread_t non-unique. Additionally + // a 64-bit pointer cannot be reliably truncated to 32 bits. + #error "Unsupported platform!" +#endif + +} + +} + +#ifdef TRACY_ENABLE +std::atomic& GetThreadNameData(); +#endif + +#if defined _MSC_VER && !defined __clang__ +# pragma pack( push, 8 ) +struct THREADNAME_INFO +{ + DWORD dwType; + LPCSTR szName; + DWORD dwThreadID; + DWORD dwFlags; +}; +# pragma pack( pop ) + +void ThreadNameMsvcMagic( const THREADNAME_INFO& info ) +{ + __try + { + RaiseException( 0x406D1388, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info ); + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + } +} +#endif + +TRACY_API void SetThreadName( const char* name ) +{ + SetThreadNameWithHint( name, 0 ); +} + +TRACY_API void SetThreadNameWithHint( const char* name, int32_t groupHint ) +{ +#if defined _WIN32 +# ifdef TRACY_UWP + static auto _SetThreadDescription = &::SetThreadDescription; +# else + static auto _SetThreadDescription = (t_SetThreadDescription)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "SetThreadDescription" ); +# endif + if( _SetThreadDescription ) + { + wchar_t buf[256]; + mbstowcs( buf, name, 256 ); + _SetThreadDescription( GetCurrentThread(), buf ); + } + else + { +# if defined _MSC_VER && !defined __clang__ + THREADNAME_INFO info; + info.dwType = 0x1000; + info.szName = name; + info.dwThreadID = GetCurrentThreadId(); + info.dwFlags = 0; + ThreadNameMsvcMagic( info ); +# endif + } +#elif defined _GNU_SOURCE && !defined __EMSCRIPTEN__ + { + const auto sz = strlen( name ); + if( sz <= 15 ) + { +#if defined __APPLE__ + pthread_setname_np( name ); +#else + pthread_setname_np( pthread_self(), name ); +#endif + } + else + { + char buf[16]; + memcpy( buf, name, 15 ); + buf[15] = '\0'; +#if defined __APPLE__ + pthread_setname_np( buf ); +#else + pthread_setname_np( pthread_self(), buf ); +#endif + } + } +#elif defined __QNX__ + { + const auto sz = strlen( name ); + if( sz <= _NTO_THREAD_NAME_MAX ) + { + pthread_setname_np( pthread_self(), name ); + } + else + { + char buf[_NTO_THREAD_NAME_MAX + 1]; + memcpy( buf, name, _NTO_THREAD_NAME_MAX ); + buf[_NTO_THREAD_NAME_MAX] = '\0'; + pthread_setname_np( pthread_self(), buf ); + } + }; +#endif +#ifdef TRACY_ENABLE + { + const auto sz = strlen( name ); + char* buf = (char*)tracy_malloc( sz+1 ); + memcpy( buf, name, sz ); + buf[sz] = '\0'; + auto data = (ThreadNameData*)tracy_malloc_fast( sizeof( ThreadNameData ) ); + data->id = detail::GetThreadHandleImpl(); + data->groupHint = groupHint; + data->name = buf; + data->next = GetThreadNameData().load( std::memory_order_relaxed ); + while( !GetThreadNameData().compare_exchange_weak( data->next, data, std::memory_order_release, std::memory_order_relaxed ) ) {} + } +#endif +} + +#ifdef TRACY_ENABLE +ThreadNameData* GetThreadNameData( uint32_t id ) +{ + auto ptr = GetThreadNameData().load( std::memory_order_relaxed ); + while( ptr ) + { + if( ptr->id == id ) + { + return ptr; + } + ptr = ptr->next; + } + return nullptr; +} +#endif + +TRACY_API const char* GetThreadName( uint32_t id ) +{ + static char buf[256]; +#ifdef TRACY_ENABLE + auto ptr = GetThreadNameData().load( std::memory_order_relaxed ); + while( ptr ) + { + if( ptr->id == id ) + { + return ptr->name; + } + ptr = ptr->next; + } +#endif + +#if defined _WIN32 +# ifdef TRACY_UWP + static auto _GetThreadDescription = &::GetThreadDescription; +# else + static auto _GetThreadDescription = (t_GetThreadDescription)GetProcAddress( GetModuleHandleA( "kernel32.dll" ), "GetThreadDescription" ); +# endif + if( _GetThreadDescription ) + { + auto hnd = OpenThread( THREAD_QUERY_LIMITED_INFORMATION, FALSE, (DWORD)id ); + if( hnd != 0 ) + { + PWSTR tmp; + if( SUCCEEDED( _GetThreadDescription( hnd, &tmp ) ) ) + { + auto ret = wcstombs( buf, tmp, 256 ); + CloseHandle( hnd ); + LocalFree( tmp ); + if( ret != static_cast( -1 ) ) + { + return buf; + } + } + } + } +#elif defined __linux__ + int cs, fd; + char path[32]; + snprintf( path, sizeof( path ), "/proc/self/task/%d/comm", id ); + sprintf( buf, "%" PRIu32, id ); +# ifndef __ANDROID__ + pthread_setcancelstate( PTHREAD_CANCEL_DISABLE, &cs ); +# endif + if ( ( fd = open( path, O_RDONLY ) ) > 0) { + int len = read( fd, buf, 255 ); + if( len > 0 ) + { + buf[len] = 0; + if( len > 1 && buf[len-1] == '\n' ) + { + buf[len-1] = 0; + } + } + close( fd ); + } +# ifndef __ANDROID__ + pthread_setcancelstate( cs, 0 ); +# endif + return buf; +#elif defined __QNX__ + static char qnxNameBuf[_NTO_THREAD_NAME_MAX + 1] = {0}; + if (pthread_getname_np(static_cast(id), qnxNameBuf, _NTO_THREAD_NAME_MAX) == 0) { + return qnxNameBuf; + }; +#endif + + sprintf( buf, "%" PRIu32, id ); + return buf; +} + +TRACY_API const char* GetEnvVar( const char* name ) +{ +#if defined _WIN32 + // unfortunately getenv() on Windows is just fundamentally broken. It caches the entire + // environment block once on startup, then never refreshes it again. If any environment + // strings are added or modified after startup of the CRT, those changes will not be + // seen by getenv(). This removes the possibility of an app using this SDK from + // programmatically setting any of the behaviour controlling envvars here. + // + // To work around this, we'll instead go directly to the Win32 environment strings APIs + // to get the current value. + static char buffer[1024]; + DWORD const kBufferSize = DWORD(sizeof(buffer) / sizeof(buffer[0])); + DWORD count = GetEnvironmentVariableA(name, buffer, kBufferSize); + + if( count == 0 ) + return nullptr; + + if( count >= kBufferSize ) + { + char* buf = reinterpret_cast(_alloca(count + 1)); + count = GetEnvironmentVariableA(name, buf, count + 1); + memcpy(buffer, buf, kBufferSize); + buffer[kBufferSize - 1] = 0; + } + + return buffer; +#else + return getenv(name); +#endif +} + +} + +#ifdef __cplusplus +extern "C" { +#endif + +TRACY_API void ___tracy_set_thread_name( const char* name ) { tracy::SetThreadName( name ); } + +#ifdef __cplusplus +} +#endif diff --git a/Dependencies/tracy/common/TracySystem.hpp b/Dependencies/tracy/common/TracySystem.hpp new file mode 100644 index 000000000..2f565e9a2 --- /dev/null +++ b/Dependencies/tracy/common/TracySystem.hpp @@ -0,0 +1,43 @@ +#ifndef __TRACYSYSTEM_HPP__ +#define __TRACYSYSTEM_HPP__ + +#include + +#include "TracyApi.h" + +namespace tracy +{ + +namespace detail +{ +TRACY_API uint32_t GetThreadHandleImpl(); +} + +#ifdef TRACY_ENABLE +struct ThreadNameData +{ + uint32_t id; + int32_t groupHint; + const char* name; + ThreadNameData* next; +}; + +ThreadNameData* GetThreadNameData( uint32_t id ); + +TRACY_API uint32_t GetThreadHandle(); +#else +static inline uint32_t GetThreadHandle() +{ + return detail::GetThreadHandleImpl(); +} +#endif + +TRACY_API void SetThreadName( const char* name ); +TRACY_API void SetThreadNameWithHint( const char* name, int32_t groupHint ); +TRACY_API const char* GetThreadName( uint32_t id ); + +TRACY_API const char* GetEnvVar( const char* name ); + +} + +#endif diff --git a/Dependencies/tracy/common/TracyUwp.hpp b/Dependencies/tracy/common/TracyUwp.hpp new file mode 100644 index 000000000..7dce96b96 --- /dev/null +++ b/Dependencies/tracy/common/TracyUwp.hpp @@ -0,0 +1,11 @@ +#ifndef __TRACYUWP_HPP__ +#define __TRACYUWP_HPP__ + +#ifdef _WIN32 +# include +# if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +# define TRACY_UWP +# endif +#endif + +#endif diff --git a/Dependencies/tracy/common/TracyVersion.hpp b/Dependencies/tracy/common/TracyVersion.hpp new file mode 100644 index 000000000..0905ef940 --- /dev/null +++ b/Dependencies/tracy/common/TracyVersion.hpp @@ -0,0 +1,14 @@ +#ifndef __TRACYVERSION_HPP__ +#define __TRACYVERSION_HPP__ + +namespace tracy +{ +namespace Version +{ +enum { Major = 0 }; +enum { Minor = 11 }; +enum { Patch = 1 }; +} +} + +#endif diff --git a/Dependencies/tracy/common/TracyYield.hpp b/Dependencies/tracy/common/TracyYield.hpp new file mode 100644 index 000000000..035836cdb --- /dev/null +++ b/Dependencies/tracy/common/TracyYield.hpp @@ -0,0 +1,28 @@ +#ifndef __TRACYYIELD_HPP__ +#define __TRACYYIELD_HPP__ + +#if defined __SSE2__ || defined _M_AMD64 || (defined _M_IX86_FP && _M_IX86_FP == 2) +# include +#else +# include +#endif + +#include "TracyForceInline.hpp" + +namespace tracy +{ + +static tracy_force_inline void YieldThread() +{ +#if defined __SSE2__ || defined _M_AMD64 || (defined _M_IX86_FP && _M_IX86_FP == 2) + _mm_pause(); +#elif defined __aarch64__ + asm volatile( "isb" : : ); +#else + std::this_thread::yield(); +#endif +} + +} + +#endif diff --git a/Dependencies/tracy/common/tracy_lz4.cpp b/Dependencies/tracy/common/tracy_lz4.cpp new file mode 100644 index 000000000..15d0990f8 --- /dev/null +++ b/Dependencies/tracy/common/tracy_lz4.cpp @@ -0,0 +1,2720 @@ +/* + LZ4 - Fast LZ compression algorithm + Copyright (C) 2011-2020, Yann Collet. + + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 homepage : http://www.lz4.org + - LZ4 source repository : https://github.com/lz4/lz4 +*/ + +/*-************************************ +* Tuning parameters +**************************************/ +/* + * LZ4_HEAPMODE : + * Select how default compression functions will allocate memory for their hash table, + * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()). + */ +#ifndef LZ4_HEAPMODE +# define LZ4_HEAPMODE 0 +#endif + +/* + * LZ4_ACCELERATION_DEFAULT : + * Select "acceleration" for LZ4_compress_fast() when parameter value <= 0 + */ +#define LZ4_ACCELERATION_DEFAULT 1 +/* + * LZ4_ACCELERATION_MAX : + * Any "acceleration" value higher than this threshold + * get treated as LZ4_ACCELERATION_MAX instead (fix #876) + */ +#define LZ4_ACCELERATION_MAX 65537 + + +/*-************************************ +* CPU Feature Detection +**************************************/ +/* LZ4_FORCE_MEMORY_ACCESS + * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable. + * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. + * The below switch allow to select different access method for improved performance. + * Method 0 (default) : use `memcpy()`. Safe and portable. + * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable). + * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`. + * Method 2 : direct access. This method is portable but violate C standard. + * It can generate buggy code on targets which assembly generation depends on alignment. + * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) + * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. + * Prefer these methods in priority order (0 > 1 > 2) + */ +#ifndef LZ4_FORCE_MEMORY_ACCESS /* can be defined externally */ +# if defined(__GNUC__) && \ + ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \ + || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) ) +# define LZ4_FORCE_MEMORY_ACCESS 2 +# elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__) +# define LZ4_FORCE_MEMORY_ACCESS 1 +# endif +#endif + +/* + * LZ4_FORCE_SW_BITCOUNT + * Define this parameter if your target system or compiler does not support hardware bit count + */ +#if defined(_MSC_VER) && defined(_WIN32_WCE) /* Visual Studio for WinCE doesn't support Hardware bit count */ +# undef LZ4_FORCE_SW_BITCOUNT /* avoid double def */ +# define LZ4_FORCE_SW_BITCOUNT +#endif + + + +/*-************************************ +* Dependency +**************************************/ +/* + * LZ4_SRC_INCLUDED: + * Amalgamation flag, whether lz4.c is included + */ +#ifndef LZ4_SRC_INCLUDED +# define LZ4_SRC_INCLUDED 1 +#endif + +#ifndef LZ4_STATIC_LINKING_ONLY +#define LZ4_STATIC_LINKING_ONLY +#endif + +#ifndef LZ4_DISABLE_DEPRECATE_WARNINGS +#define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */ +#endif + +#define LZ4_STATIC_LINKING_ONLY /* LZ4_DISTANCE_MAX */ +#include "tracy_lz4.hpp" +/* see also "memory routines" below */ + + +/*-************************************ +* Compiler Options +**************************************/ +#if defined(_MSC_VER) && (_MSC_VER >= 1400) /* Visual Studio 2005+ */ +# include /* only present in VS2005+ */ +# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ +# pragma warning(disable : 6237) /* disable: C6237: conditional expression is always 0 */ +#endif /* _MSC_VER */ + +#ifndef LZ4_FORCE_INLINE +# if defined (_MSC_VER) && !defined (__clang__) /* MSVC */ +# define LZ4_FORCE_INLINE static __forceinline +# else +# if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ +# if defined (__GNUC__) || defined (__clang__) +# define LZ4_FORCE_INLINE static inline __attribute__((always_inline)) +# else +# define LZ4_FORCE_INLINE static inline +# endif +# else +# define LZ4_FORCE_INLINE static +# endif /* __STDC_VERSION__ */ +# endif /* _MSC_VER */ +#endif /* LZ4_FORCE_INLINE */ + +/* LZ4_FORCE_O2 and LZ4_FORCE_INLINE + * gcc on ppc64le generates an unrolled SIMDized loop for LZ4_wildCopy8, + * together with a simple 8-byte copy loop as a fall-back path. + * However, this optimization hurts the decompression speed by >30%, + * because the execution does not go to the optimized loop + * for typical compressible data, and all of the preamble checks + * before going to the fall-back path become useless overhead. + * This optimization happens only with the -O3 flag, and -O2 generates + * a simple 8-byte copy loop. + * With gcc on ppc64le, all of the LZ4_decompress_* and LZ4_wildCopy8 + * functions are annotated with __attribute__((optimize("O2"))), + * and also LZ4_wildCopy8 is forcibly inlined, so that the O2 attribute + * of LZ4_wildCopy8 does not affect the compression speed. + */ +#if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) && defined(__GNUC__) && !defined(__clang__) +# define LZ4_FORCE_O2 __attribute__((optimize("O2"))) +# undef LZ4_FORCE_INLINE +# define LZ4_FORCE_INLINE static __inline __attribute__((optimize("O2"),always_inline)) +#else +# define LZ4_FORCE_O2 +#endif + +#if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__) +# define expect(expr,value) (__builtin_expect ((expr),(value)) ) +#else +# define expect(expr,value) (expr) +#endif + +#ifndef likely +#define likely(expr) expect((expr) != 0, 1) +#endif +#ifndef unlikely +#define unlikely(expr) expect((expr) != 0, 0) +#endif + +/* Should the alignment test prove unreliable, for some reason, + * it can be disabled by setting LZ4_ALIGN_TEST to 0 */ +#ifndef LZ4_ALIGN_TEST /* can be externally provided */ +# define LZ4_ALIGN_TEST 1 +#endif + + +/*-************************************ +* Memory routines +**************************************/ + +/*! LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION : + * Disable relatively high-level LZ4/HC functions that use dynamic memory + * allocation functions (malloc(), calloc(), free()). + * + * Note that this is a compile-time switch. And since it disables + * public/stable LZ4 v1 API functions, we don't recommend using this + * symbol to generate a library for distribution. + * + * The following public functions are removed when this symbol is defined. + * - lz4 : LZ4_createStream, LZ4_freeStream, + * LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated) + * - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC, + * LZ4_createHC (deprecated), LZ4_freeHC (deprecated) + * - lz4frame, lz4file : All LZ4F_* functions + */ +#if defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +# define ALLOC(s) lz4_error_memory_allocation_is_disabled +# define ALLOC_AND_ZERO(s) lz4_error_memory_allocation_is_disabled +# define FREEMEM(p) lz4_error_memory_allocation_is_disabled +#elif defined(LZ4_USER_MEMORY_FUNCTIONS) +/* memory management functions can be customized by user project. + * Below functions must exist somewhere in the Project + * and be available at link time */ +void* LZ4_malloc(size_t s); +void* LZ4_calloc(size_t n, size_t s); +void LZ4_free(void* p); +# define ALLOC(s) LZ4_malloc(s) +# define ALLOC_AND_ZERO(s) LZ4_calloc(1,s) +# define FREEMEM(p) LZ4_free(p) +#else +# include /* malloc, calloc, free */ +# define ALLOC(s) malloc(s) +# define ALLOC_AND_ZERO(s) calloc(1,s) +# define FREEMEM(p) free(p) +#endif + +#if ! LZ4_FREESTANDING +# include /* memset, memcpy */ +#endif +#if !defined(LZ4_memset) +# define LZ4_memset(p,v,s) memset((p),(v),(s)) +#endif +#define MEM_INIT(p,v,s) LZ4_memset((p),(v),(s)) + + +/*-************************************ +* Common Constants +**************************************/ +#define MINMATCH 4 + +#define WILDCOPYLENGTH 8 +#define LASTLITERALS 5 /* see ../doc/lz4_Block_format.md#parsing-restrictions */ +#define MFLIMIT 12 /* see ../doc/lz4_Block_format.md#parsing-restrictions */ +#define MATCH_SAFEGUARD_DISTANCE ((2*WILDCOPYLENGTH) - MINMATCH) /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */ +#define FASTLOOP_SAFE_DISTANCE 64 +static const int LZ4_minLength = (MFLIMIT+1); + +#define KB *(1 <<10) +#define MB *(1 <<20) +#define GB *(1U<<30) + +#define LZ4_DISTANCE_ABSOLUTE_MAX 65535 +#if (LZ4_DISTANCE_MAX > LZ4_DISTANCE_ABSOLUTE_MAX) /* max supported by LZ4 format */ +# error "LZ4_DISTANCE_MAX is too big : must be <= 65535" +#endif + +#define ML_BITS 4 +#define ML_MASK ((1U<=1) +# include +#else +# ifndef assert +# define assert(condition) ((void)0) +# endif +#endif + +#define LZ4_STATIC_ASSERT(c) { enum { LZ4_static_assert = 1/(int)(!!(c)) }; } /* use after variable declarations */ + +#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2) +# include + static int g_debuglog_enable = 1; +# define DEBUGLOG(l, ...) { \ + if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) { \ + fprintf(stderr, __FILE__ ": "); \ + fprintf(stderr, __VA_ARGS__); \ + fprintf(stderr, " \n"); \ + } } +#else +# define DEBUGLOG(l, ...) {} /* disabled */ +#endif + +static int LZ4_isAligned(const void* ptr, size_t alignment) +{ + return ((size_t)ptr & (alignment -1)) == 0; +} + + +/*-************************************ +* Types +**************************************/ +#include +#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) +# include + typedef uint8_t BYTE; + typedef uint16_t U16; + typedef uint32_t U32; + typedef int32_t S32; + typedef uint64_t U64; + typedef uintptr_t uptrval; +#else +# if UINT_MAX != 4294967295UL +# error "LZ4 code (when not C++ or C99) assumes that sizeof(int) == 4" +# endif + typedef unsigned char BYTE; + typedef unsigned short U16; + typedef unsigned int U32; + typedef signed int S32; + typedef unsigned long long U64; + typedef size_t uptrval; /* generally true, except OpenVMS-64 */ +#endif + +#if defined(__x86_64__) + typedef U64 reg_t; /* 64-bits in x32 mode */ +#else + typedef size_t reg_t; /* 32-bits in x32 mode */ +#endif + +typedef enum { + notLimited = 0, + limitedOutput = 1, + fillOutput = 2 +} limitedOutput_directive; + +namespace tracy +{ + +/*-************************************ +* Reading and writing into memory +**************************************/ + +/** + * LZ4 relies on memcpy with a constant size being inlined. In freestanding + * environments, the compiler can't assume the implementation of memcpy() is + * standard compliant, so it can't apply its specialized memcpy() inlining + * logic. When possible, use __builtin_memcpy() to tell the compiler to analyze + * memcpy() as if it were standard compliant, so it can inline it in freestanding + * environments. This is needed when decompressing the Linux Kernel, for example. + */ +#if !defined(LZ4_memcpy) +# if defined(__GNUC__) && (__GNUC__ >= 4) +# define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size) +# else +# define LZ4_memcpy(dst, src, size) memcpy(dst, src, size) +# endif +#endif + +#if !defined(LZ4_memmove) +# if defined(__GNUC__) && (__GNUC__ >= 4) +# define LZ4_memmove __builtin_memmove +# else +# define LZ4_memmove memmove +# endif +#endif + +static unsigned LZ4_isLittleEndian(void) +{ + const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ + return one.c[0]; +} + + +#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2) +/* lie to the compiler about data alignment; use with caution */ + +static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; } +static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; } +static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; } + +static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } +static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } + +#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1) + +/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ +/* currently only defined for gcc and icc */ +typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) LZ4_unalign; + +static U16 LZ4_read16(const void* ptr) { return ((const LZ4_unalign*)ptr)->u16; } +static U32 LZ4_read32(const void* ptr) { return ((const LZ4_unalign*)ptr)->u32; } +static reg_t LZ4_read_ARCH(const void* ptr) { return ((const LZ4_unalign*)ptr)->uArch; } + +static void LZ4_write16(void* memPtr, U16 value) { ((LZ4_unalign*)memPtr)->u16 = value; } +static void LZ4_write32(void* memPtr, U32 value) { ((LZ4_unalign*)memPtr)->u32 = value; } + +#else /* safe and portable access using memcpy() */ + +static U16 LZ4_read16(const void* memPtr) +{ + U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val; +} + +static U32 LZ4_read32(const void* memPtr) +{ + U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val; +} + +static reg_t LZ4_read_ARCH(const void* memPtr) +{ + reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val; +} + +static void LZ4_write16(void* memPtr, U16 value) +{ + LZ4_memcpy(memPtr, &value, sizeof(value)); +} + +static void LZ4_write32(void* memPtr, U32 value) +{ + LZ4_memcpy(memPtr, &value, sizeof(value)); +} + +#endif /* LZ4_FORCE_MEMORY_ACCESS */ + + +static U16 LZ4_readLE16(const void* memPtr) +{ + if (LZ4_isLittleEndian()) { + return LZ4_read16(memPtr); + } else { + const BYTE* p = (const BYTE*)memPtr; + return (U16)((U16)p[0] + (p[1]<<8)); + } +} + +static void LZ4_writeLE16(void* memPtr, U16 value) +{ + if (LZ4_isLittleEndian()) { + LZ4_write16(memPtr, value); + } else { + BYTE* p = (BYTE*)memPtr; + p[0] = (BYTE) value; + p[1] = (BYTE)(value>>8); + } +} + +/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */ +LZ4_FORCE_INLINE +void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd) +{ + BYTE* d = (BYTE*)dstPtr; + const BYTE* s = (const BYTE*)srcPtr; + BYTE* const e = (BYTE*)dstEnd; + + do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d= 16. */ +LZ4_FORCE_INLINE void +LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd) +{ + BYTE* d = (BYTE*)dstPtr; + const BYTE* s = (const BYTE*)srcPtr; + BYTE* const e = (BYTE*)dstEnd; + + do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d= dstPtr + MINMATCH + * - there is at least 8 bytes available to write after dstEnd */ +LZ4_FORCE_INLINE void +LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset) +{ + BYTE v[8]; + + assert(dstEnd >= dstPtr + MINMATCH); + + switch(offset) { + case 1: + MEM_INIT(v, *srcPtr, 8); + break; + case 2: + LZ4_memcpy(v, srcPtr, 2); + LZ4_memcpy(&v[2], srcPtr, 2); +#if defined(_MSC_VER) && (_MSC_VER <= 1933) /* MSVC 2022 ver 17.3 or earlier */ +# pragma warning(push) +# pragma warning(disable : 6385) /* warning C6385: Reading invalid data from 'v'. */ +#endif + LZ4_memcpy(&v[4], v, 4); +#if defined(_MSC_VER) && (_MSC_VER <= 1933) /* MSVC 2022 ver 17.3 or earlier */ +# pragma warning(pop) +#endif + break; + case 4: + LZ4_memcpy(v, srcPtr, 4); + LZ4_memcpy(&v[4], srcPtr, 4); + break; + default: + LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset); + return; + } + + LZ4_memcpy(dstPtr, v, 8); + dstPtr += 8; + while (dstPtr < dstEnd) { + LZ4_memcpy(dstPtr, v, 8); + dstPtr += 8; + } +} +#endif + + +/*-************************************ +* Common functions +**************************************/ +LZ4_FORCE_INLINE unsigned LZ4_NbCommonBytes (reg_t val) +{ + assert(val != 0); + if (LZ4_isLittleEndian()) { + if (sizeof(val) == 8) { +# if defined(_MSC_VER) && (_MSC_VER >= 1800) && (defined(_M_AMD64) && !defined(_M_ARM64EC)) && !defined(LZ4_FORCE_SW_BITCOUNT) +/*-************************************************************************************************* +* ARM64EC is a Microsoft-designed ARM64 ABI compatible with AMD64 applications on ARM64 Windows 11. +* The ARM64EC ABI does not support AVX/AVX2/AVX512 instructions, nor their relevant intrinsics +* including _tzcnt_u64. Therefore, we need to neuter the _tzcnt_u64 code path for ARM64EC. +****************************************************************************************************/ +# if defined(__clang__) && (__clang_major__ < 10) + /* Avoid undefined clang-cl intrinsics issue. + * See https://github.com/lz4/lz4/pull/1017 for details. */ + return (unsigned)__builtin_ia32_tzcnt_u64(val) >> 3; +# else + /* x64 CPUS without BMI support interpret `TZCNT` as `REP BSF` */ + return (unsigned)_tzcnt_u64(val) >> 3; +# endif +# elif defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) + unsigned long r = 0; + _BitScanForward64(&r, (U64)val); + return (unsigned)r >> 3; +# elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \ + ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \ + !defined(LZ4_FORCE_SW_BITCOUNT) + return (unsigned)__builtin_ctzll((U64)val) >> 3; +# else + const U64 m = 0x0101010101010101ULL; + val ^= val - 1; + return (unsigned)(((U64)((val & (m - 1)) * m)) >> 56); +# endif + } else /* 32 bits */ { +# if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT) + unsigned long r; + _BitScanForward(&r, (U32)val); + return (unsigned)r >> 3; +# elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \ + ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \ + !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT) + return (unsigned)__builtin_ctz((U32)val) >> 3; +# else + const U32 m = 0x01010101; + return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24; +# endif + } + } else /* Big Endian CPU */ { + if (sizeof(val)==8) { +# if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \ + ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \ + !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT) + return (unsigned)__builtin_clzll((U64)val) >> 3; +# else +#if 1 + /* this method is probably faster, + * but adds a 128 bytes lookup table */ + static const unsigned char ctz7_tab[128] = { + 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + }; + U64 const mask = 0x0101010101010101ULL; + U64 const t = (((val >> 8) - mask) | val) & mask; + return ctz7_tab[(t * 0x0080402010080402ULL) >> 57]; +#else + /* this method doesn't consume memory space like the previous one, + * but it contains several branches, + * that may end up slowing execution */ + static const U32 by32 = sizeof(val)*4; /* 32 on 64 bits (goal), 16 on 32 bits. + Just to avoid some static analyzer complaining about shift by 32 on 32-bits target. + Note that this code path is never triggered in 32-bits mode. */ + unsigned r; + if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; } + if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } + r += (!val); + return r; +#endif +# endif + } else /* 32 bits */ { +# if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \ + ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \ + !defined(LZ4_FORCE_SW_BITCOUNT) + return (unsigned)__builtin_clz((U32)val) >> 3; +# else + val >>= 8; + val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) | + (val + 0x00FF0000)) >> 24; + return (unsigned)val ^ 3; +# endif + } + } +} + + +#define STEPSIZE sizeof(reg_t) +LZ4_FORCE_INLINE +unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit) +{ + const BYTE* const pStart = pIn; + + if (likely(pIn < pInLimit-(STEPSIZE-1))) { + reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn); + if (!diff) { + pIn+=STEPSIZE; pMatch+=STEPSIZE; + } else { + return LZ4_NbCommonBytes(diff); + } } + + while (likely(pIn < pInLimit-(STEPSIZE-1))) { + reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn); + if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; } + pIn += LZ4_NbCommonBytes(diff); + return (unsigned)(pIn - pStart); + } + + if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; } + if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; } + if ((pIn compression run slower on incompressible data */ + + +/*-************************************ +* Local Structures and types +**************************************/ +typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t; + +/** + * This enum distinguishes several different modes of accessing previous + * content in the stream. + * + * - noDict : There is no preceding content. + * - withPrefix64k : Table entries up to ctx->dictSize before the current blob + * blob being compressed are valid and refer to the preceding + * content (of length ctx->dictSize), which is available + * contiguously preceding in memory the content currently + * being compressed. + * - usingExtDict : Like withPrefix64k, but the preceding content is somewhere + * else in memory, starting at ctx->dictionary with length + * ctx->dictSize. + * - usingDictCtx : Everything concerning the preceding content is + * in a separate context, pointed to by ctx->dictCtx. + * ctx->dictionary, ctx->dictSize, and table entries + * in the current context that refer to positions + * preceding the beginning of the current compression are + * ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx + * ->dictSize describe the location and size of the preceding + * content, and matches are found by looking in the ctx + * ->dictCtx->hashTable. + */ +typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive; +typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive; + + +/*-************************************ +* Local Utils +**************************************/ +int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; } +const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; } +int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); } +int LZ4_sizeofState(void) { return sizeof(LZ4_stream_t); } + + +/*-**************************************** +* Internal Definitions, used only in Tests +*******************************************/ + +int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize); + +int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, + int compressedSize, int maxOutputSize, + const void* dictStart, size_t dictSize); +int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest, + int compressedSize, int targetOutputSize, int dstCapacity, + const void* dictStart, size_t dictSize); + +/*-****************************** +* Compression functions +********************************/ +LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType) +{ + if (tableType == byU16) + return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1))); + else + return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG)); +} + +LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType) +{ + const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG; + if (LZ4_isLittleEndian()) { + const U64 prime5bytes = 889523592379ULL; + return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog)); + } else { + const U64 prime8bytes = 11400714785074694791ULL; + return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog)); + } +} + +LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType) +{ + if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType); + return LZ4_hash4(LZ4_read32(p), tableType); +} + +LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType) +{ + switch (tableType) + { + default: /* fallthrough */ + case clearedTable: { /* illegal! */ assert(0); return; } + case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; } + case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; } + case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; } + } +} + +LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType) +{ + switch (tableType) + { + default: /* fallthrough */ + case clearedTable: /* fallthrough */ + case byPtr: { /* illegal! */ assert(0); return; } + case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; } + case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; } + } +} + +LZ4_FORCE_INLINE void LZ4_putPositionOnHash(const BYTE* p, U32 h, + void* tableBase, tableType_t const tableType, + const BYTE* srcBase) +{ + switch (tableType) + { + case clearedTable: { /* illegal! */ assert(0); return; } + case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; } + case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; } + case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; } + } +} + +LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase) +{ + U32 const h = LZ4_hashPosition(p, tableType); + LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase); +} + +/* LZ4_getIndexOnHash() : + * Index of match position registered in hash table. + * hash position must be calculated by using base+index, or dictBase+index. + * Assumption 1 : only valid if tableType == byU32 or byU16. + * Assumption 2 : h is presumed valid (within limits of hash table) + */ +LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType) +{ + LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2); + if (tableType == byU32) { + const U32* const hashTable = (const U32*) tableBase; + assert(h < (1U << (LZ4_MEMORY_USAGE-2))); + return hashTable[h]; + } + if (tableType == byU16) { + const U16* const hashTable = (const U16*) tableBase; + assert(h < (1U << (LZ4_MEMORY_USAGE-1))); + return hashTable[h]; + } + assert(0); return 0; /* forbidden case */ +} + +static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType, const BYTE* srcBase) +{ + if (tableType == byPtr) { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; } + if (tableType == byU32) { const U32* const hashTable = (const U32*) tableBase; return hashTable[h] + srcBase; } + { const U16* const hashTable = (const U16*) tableBase; return hashTable[h] + srcBase; } /* default, to ensure a return */ +} + +LZ4_FORCE_INLINE const BYTE* +LZ4_getPosition(const BYTE* p, + const void* tableBase, tableType_t tableType, + const BYTE* srcBase) +{ + U32 const h = LZ4_hashPosition(p, tableType); + return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase); +} + +LZ4_FORCE_INLINE void +LZ4_prepareTable(LZ4_stream_t_internal* const cctx, + const int inputSize, + const tableType_t tableType) { + /* If the table hasn't been used, it's guaranteed to be zeroed out, and is + * therefore safe to use no matter what mode we're in. Otherwise, we figure + * out if it's safe to leave as is or whether it needs to be reset. + */ + if ((tableType_t)cctx->tableType != clearedTable) { + assert(inputSize >= 0); + if ((tableType_t)cctx->tableType != tableType + || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU) + || ((tableType == byU32) && cctx->currentOffset > 1 GB) + || tableType == byPtr + || inputSize >= 4 KB) + { + DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx); + MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE); + cctx->currentOffset = 0; + cctx->tableType = (U32)clearedTable; + } else { + DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)"); + } + } + + /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back, + * is faster than compressing without a gap. + * However, compressing with currentOffset == 0 is faster still, + * so we preserve that case. + */ + if (cctx->currentOffset != 0 && tableType == byU32) { + DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset"); + cctx->currentOffset += 64 KB; + } + + /* Finally, clear history */ + cctx->dictCtx = NULL; + cctx->dictionary = NULL; + cctx->dictSize = 0; +} + +/** LZ4_compress_generic() : + * inlined, to ensure branches are decided at compilation time. + * Presumed already validated at this stage: + * - source != NULL + * - inputSize > 0 + */ +LZ4_FORCE_INLINE int LZ4_compress_generic_validated( + LZ4_stream_t_internal* const cctx, + const char* const source, + char* const dest, + const int inputSize, + int* inputConsumed, /* only written when outputDirective == fillOutput */ + const int maxOutputSize, + const limitedOutput_directive outputDirective, + const tableType_t tableType, + const dict_directive dictDirective, + const dictIssue_directive dictIssue, + const int acceleration) +{ + int result; + const BYTE* ip = (const BYTE*) source; + + U32 const startIndex = cctx->currentOffset; + const BYTE* base = (const BYTE*) source - startIndex; + const BYTE* lowLimit; + + const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx; + const BYTE* const dictionary = + dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary; + const U32 dictSize = + dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize; + const U32 dictDelta = (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0; /* make indexes in dictCtx comparable with index in current context */ + + int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx); + U32 const prefixIdxLimit = startIndex - dictSize; /* used when dictDirective == dictSmall */ + const BYTE* const dictEnd = dictionary ? dictionary + dictSize : dictionary; + const BYTE* anchor = (const BYTE*) source; + const BYTE* const iend = ip + inputSize; + const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1; + const BYTE* const matchlimit = iend - LASTLITERALS; + + /* the dictCtx currentOffset is indexed on the start of the dictionary, + * while a dictionary in the current context precedes the currentOffset */ + const BYTE* dictBase = (dictionary == NULL) ? NULL : + (dictDirective == usingDictCtx) ? + dictionary + dictSize - dictCtx->currentOffset : + dictionary + dictSize - startIndex; + + BYTE* op = (BYTE*) dest; + BYTE* const olimit = op + maxOutputSize; + + U32 offset = 0; + U32 forwardH; + + DEBUGLOG(5, "LZ4_compress_generic_validated: srcSize=%i, tableType=%u", inputSize, tableType); + assert(ip != NULL); + /* If init conditions are not met, we don't have to mark stream + * as having dirty context, since no action was taken yet */ + if (outputDirective == fillOutput && maxOutputSize < 1) { return 0; } /* Impossible to store anything */ + if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) { return 0; } /* Size too large (not within 64K limit) */ + if (tableType==byPtr) assert(dictDirective==noDict); /* only supported use case with byPtr */ + assert(acceleration >= 1); + + lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0); + + /* Update context state */ + if (dictDirective == usingDictCtx) { + /* Subsequent linked blocks can't use the dictionary. */ + /* Instead, they use the block we just compressed. */ + cctx->dictCtx = NULL; + cctx->dictSize = (U32)inputSize; + } else { + cctx->dictSize += (U32)inputSize; + } + cctx->currentOffset += (U32)inputSize; + cctx->tableType = (U32)tableType; + + if (inputSizehashTable, tableType, base); + ip++; forwardH = LZ4_hashPosition(ip, tableType); + + /* Main Loop */ + for ( ; ; ) { + const BYTE* match; + BYTE* token; + const BYTE* filledIp; + + /* Find a match */ + if (tableType == byPtr) { + const BYTE* forwardIp = ip; + int step = 1; + int searchMatchNb = acceleration << LZ4_skipTrigger; + do { + U32 const h = forwardH; + ip = forwardIp; + forwardIp += step; + step = (searchMatchNb++ >> LZ4_skipTrigger); + + if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals; + assert(ip < mflimitPlusOne); + + match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base); + forwardH = LZ4_hashPosition(forwardIp, tableType); + LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base); + + } while ( (match+LZ4_DISTANCE_MAX < ip) + || (LZ4_read32(match) != LZ4_read32(ip)) ); + + } else { /* byU32, byU16 */ + + const BYTE* forwardIp = ip; + int step = 1; + int searchMatchNb = acceleration << LZ4_skipTrigger; + do { + U32 const h = forwardH; + U32 const current = (U32)(forwardIp - base); + U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType); + assert(matchIndex <= current); + assert(forwardIp - base < (ptrdiff_t)(2 GB - 1)); + ip = forwardIp; + forwardIp += step; + step = (searchMatchNb++ >> LZ4_skipTrigger); + + if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals; + assert(ip < mflimitPlusOne); + + if (dictDirective == usingDictCtx) { + if (matchIndex < startIndex) { + /* there was no match, try the dictionary */ + assert(tableType == byU32); + matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32); + match = dictBase + matchIndex; + matchIndex += dictDelta; /* make dictCtx index comparable with current context */ + lowLimit = dictionary; + } else { + match = base + matchIndex; + lowLimit = (const BYTE*)source; + } + } else if (dictDirective == usingExtDict) { + if (matchIndex < startIndex) { + DEBUGLOG(7, "extDict candidate: matchIndex=%5u < startIndex=%5u", matchIndex, startIndex); + assert(startIndex - matchIndex >= MINMATCH); + assert(dictBase); + match = dictBase + matchIndex; + lowLimit = dictionary; + } else { + match = base + matchIndex; + lowLimit = (const BYTE*)source; + } + } else { /* single continuous memory segment */ + match = base + matchIndex; + } + forwardH = LZ4_hashPosition(forwardIp, tableType); + LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType); + + DEBUGLOG(7, "candidate at pos=%u (offset=%u \n", matchIndex, current - matchIndex); + if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) { continue; } /* match outside of valid area */ + assert(matchIndex < current); + if ( ((tableType != byU16) || (LZ4_DISTANCE_MAX < LZ4_DISTANCE_ABSOLUTE_MAX)) + && (matchIndex+LZ4_DISTANCE_MAX < current)) { + continue; + } /* too far */ + assert((current - matchIndex) <= LZ4_DISTANCE_MAX); /* match now expected within distance */ + + if (LZ4_read32(match) == LZ4_read32(ip)) { + if (maybe_extMem) offset = current - matchIndex; + break; /* match found */ + } + + } while(1); + } + + /* Catch up */ + filledIp = ip; + while (((ip>anchor) & (match > lowLimit)) && (unlikely(ip[-1]==match[-1]))) { ip--; match--; } + + /* Encode Literals */ + { unsigned const litLength = (unsigned)(ip - anchor); + token = op++; + if ((outputDirective == limitedOutput) && /* Check output buffer overflow */ + (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)) ) { + return 0; /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */ + } + if ((outputDirective == fillOutput) && + (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) { + op--; + goto _last_literals; + } + if (litLength >= RUN_MASK) { + int len = (int)(litLength - RUN_MASK); + *token = (RUN_MASK<= 255 ; len-=255) *op++ = 255; + *op++ = (BYTE)len; + } + else *token = (BYTE)(litLength< olimit)) { + /* the match was too close to the end, rewind and go to last literals */ + op = token; + goto _last_literals; + } + + /* Encode Offset */ + if (maybe_extMem) { /* static test */ + DEBUGLOG(6, " with offset=%u (ext if > %i)", offset, (int)(ip - (const BYTE*)source)); + assert(offset <= LZ4_DISTANCE_MAX && offset > 0); + LZ4_writeLE16(op, (U16)offset); op+=2; + } else { + DEBUGLOG(6, " with offset=%u (same segment)", (U32)(ip - match)); + assert(ip-match <= LZ4_DISTANCE_MAX); + LZ4_writeLE16(op, (U16)(ip - match)); op+=2; + } + + /* Encode MatchLength */ + { unsigned matchCode; + + if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx) + && (lowLimit==dictionary) /* match within extDict */ ) { + const BYTE* limit = ip + (dictEnd-match); + assert(dictEnd > match); + if (limit > matchlimit) limit = matchlimit; + matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit); + ip += (size_t)matchCode + MINMATCH; + if (ip==limit) { + unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit); + matchCode += more; + ip += more; + } + DEBUGLOG(6, " with matchLength=%u starting in extDict", matchCode+MINMATCH); + } else { + matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit); + ip += (size_t)matchCode + MINMATCH; + DEBUGLOG(6, " with matchLength=%u", matchCode+MINMATCH); + } + + if ((outputDirective) && /* Check output buffer overflow */ + (unlikely(op + (1 + LASTLITERALS) + (matchCode+240)/255 > olimit)) ) { + if (outputDirective == fillOutput) { + /* Match description too long : reduce it */ + U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 1 - LASTLITERALS) * 255; + ip -= matchCode - newMatchCode; + assert(newMatchCode < matchCode); + matchCode = newMatchCode; + if (unlikely(ip <= filledIp)) { + /* We have already filled up to filledIp so if ip ends up less than filledIp + * we have positions in the hash table beyond the current position. This is + * a problem if we reuse the hash table. So we have to remove these positions + * from the hash table. + */ + const BYTE* ptr; + DEBUGLOG(5, "Clearing %u positions", (U32)(filledIp - ip)); + for (ptr = ip; ptr <= filledIp; ++ptr) { + U32 const h = LZ4_hashPosition(ptr, tableType); + LZ4_clearHash(h, cctx->hashTable, tableType); + } + } + } else { + assert(outputDirective == limitedOutput); + return 0; /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */ + } + } + if (matchCode >= ML_MASK) { + *token += ML_MASK; + matchCode -= ML_MASK; + LZ4_write32(op, 0xFFFFFFFF); + while (matchCode >= 4*255) { + op+=4; + LZ4_write32(op, 0xFFFFFFFF); + matchCode -= 4*255; + } + op += matchCode / 255; + *op++ = (BYTE)(matchCode % 255); + } else + *token += (BYTE)(matchCode); + } + /* Ensure we have enough space for the last literals. */ + assert(!(outputDirective == fillOutput && op + 1 + LASTLITERALS > olimit)); + + anchor = ip; + + /* Test end of chunk */ + if (ip >= mflimitPlusOne) break; + + /* Fill table */ + LZ4_putPosition(ip-2, cctx->hashTable, tableType, base); + + /* Test next position */ + if (tableType == byPtr) { + + match = LZ4_getPosition(ip, cctx->hashTable, tableType, base); + LZ4_putPosition(ip, cctx->hashTable, tableType, base); + if ( (match+LZ4_DISTANCE_MAX >= ip) + && (LZ4_read32(match) == LZ4_read32(ip)) ) + { token=op++; *token=0; goto _next_match; } + + } else { /* byU32, byU16 */ + + U32 const h = LZ4_hashPosition(ip, tableType); + U32 const current = (U32)(ip-base); + U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType); + assert(matchIndex < current); + if (dictDirective == usingDictCtx) { + if (matchIndex < startIndex) { + /* there was no match, try the dictionary */ + matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32); + match = dictBase + matchIndex; + lowLimit = dictionary; /* required for match length counter */ + matchIndex += dictDelta; + } else { + match = base + matchIndex; + lowLimit = (const BYTE*)source; /* required for match length counter */ + } + } else if (dictDirective==usingExtDict) { + if (matchIndex < startIndex) { + assert(dictBase); + match = dictBase + matchIndex; + lowLimit = dictionary; /* required for match length counter */ + } else { + match = base + matchIndex; + lowLimit = (const BYTE*)source; /* required for match length counter */ + } + } else { /* single memory segment */ + match = base + matchIndex; + } + LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType); + assert(matchIndex < current); + if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1) + && (((tableType==byU16) && (LZ4_DISTANCE_MAX == LZ4_DISTANCE_ABSOLUTE_MAX)) ? 1 : (matchIndex+LZ4_DISTANCE_MAX >= current)) + && (LZ4_read32(match) == LZ4_read32(ip)) ) { + token=op++; + *token=0; + if (maybe_extMem) offset = current - matchIndex; + DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i", + (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source)); + goto _next_match; + } + } + + /* Prepare next loop */ + forwardH = LZ4_hashPosition(++ip, tableType); + + } + +_last_literals: + /* Encode Last Literals */ + { size_t lastRun = (size_t)(iend - anchor); + if ( (outputDirective) && /* Check output buffer overflow */ + (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) { + if (outputDirective == fillOutput) { + /* adapt lastRun to fill 'dst' */ + assert(olimit >= op); + lastRun = (size_t)(olimit-op) - 1/*token*/; + lastRun -= (lastRun + 256 - RUN_MASK) / 256; /*additional length tokens*/ + } else { + assert(outputDirective == limitedOutput); + return 0; /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */ + } + } + DEBUGLOG(6, "Final literal run : %i literals", (int)lastRun); + if (lastRun >= RUN_MASK) { + size_t accumulator = lastRun - RUN_MASK; + *op++ = RUN_MASK << ML_BITS; + for(; accumulator >= 255 ; accumulator-=255) *op++ = 255; + *op++ = (BYTE) accumulator; + } else { + *op++ = (BYTE)(lastRun< 0); + DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, result); + return result; +} + +/** LZ4_compress_generic() : + * inlined, to ensure branches are decided at compilation time; + * takes care of src == (NULL, 0) + * and forward the rest to LZ4_compress_generic_validated */ +LZ4_FORCE_INLINE int LZ4_compress_generic( + LZ4_stream_t_internal* const cctx, + const char* const src, + char* const dst, + const int srcSize, + int *inputConsumed, /* only written when outputDirective == fillOutput */ + const int dstCapacity, + const limitedOutput_directive outputDirective, + const tableType_t tableType, + const dict_directive dictDirective, + const dictIssue_directive dictIssue, + const int acceleration) +{ + DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i", + srcSize, dstCapacity); + + if ((U32)srcSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; } /* Unsupported srcSize, too large (or negative) */ + if (srcSize == 0) { /* src == NULL supported if srcSize == 0 */ + if (outputDirective != notLimited && dstCapacity <= 0) return 0; /* no output, can't write anything */ + DEBUGLOG(5, "Generating an empty block"); + assert(outputDirective == notLimited || dstCapacity >= 1); + assert(dst != NULL); + dst[0] = 0; + if (outputDirective == fillOutput) { + assert (inputConsumed != NULL); + *inputConsumed = 0; + } + return 1; + } + assert(src != NULL); + + return LZ4_compress_generic_validated(cctx, src, dst, srcSize, + inputConsumed, /* only written into if outputDirective == fillOutput */ + dstCapacity, outputDirective, + tableType, dictDirective, dictIssue, acceleration); +} + + +int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration) +{ + LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse; + assert(ctx != NULL); + if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT; + if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX; + if (maxOutputSize >= LZ4_compressBound(inputSize)) { + if (inputSize < LZ4_64Klimit) { + return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration); + } else { + const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32; + return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration); + } + } else { + if (inputSize < LZ4_64Klimit) { + return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration); + } else { + const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32; + return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration); + } + } +} + +/** + * LZ4_compress_fast_extState_fastReset() : + * A variant of LZ4_compress_fast_extState(). + * + * Using this variant avoids an expensive initialization step. It is only safe + * to call if the state buffer is known to be correctly initialized already + * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of + * "correctly initialized"). + */ +int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration) +{ + LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse; + if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT; + if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX; + + if (dstCapacity >= LZ4_compressBound(srcSize)) { + if (srcSize < LZ4_64Klimit) { + const tableType_t tableType = byU16; + LZ4_prepareTable(ctx, srcSize, tableType); + if (ctx->currentOffset) { + return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration); + } else { + return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration); + } + } else { + const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32; + LZ4_prepareTable(ctx, srcSize, tableType); + return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration); + } + } else { + if (srcSize < LZ4_64Klimit) { + const tableType_t tableType = byU16; + LZ4_prepareTable(ctx, srcSize, tableType); + if (ctx->currentOffset) { + return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration); + } else { + return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration); + } + } else { + const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32; + LZ4_prepareTable(ctx, srcSize, tableType); + return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration); + } + } +} + + +int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration) +{ + int result; +#if (LZ4_HEAPMODE) + LZ4_stream_t* ctxPtr = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */ + if (ctxPtr == NULL) return 0; +#else + LZ4_stream_t ctx; + LZ4_stream_t* const ctxPtr = &ctx; +#endif + result = LZ4_compress_fast_extState(ctxPtr, source, dest, inputSize, maxOutputSize, acceleration); + +#if (LZ4_HEAPMODE) + FREEMEM(ctxPtr); +#endif + return result; +} + + +int LZ4_compress_default(const char* src, char* dst, int srcSize, int maxOutputSize) +{ + return LZ4_compress_fast(src, dst, srcSize, maxOutputSize, 1); +} + + +/* Note!: This function leaves the stream in an unclean/broken state! + * It is not safe to subsequently use the same state with a _fastReset() or + * _continue() call without resetting it. */ +static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize) +{ + void* const s = LZ4_initStream(state, sizeof (*state)); + assert(s != NULL); (void)s; + + if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) { /* compression success is guaranteed */ + return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1); + } else { + if (*srcSizePtr < LZ4_64Klimit) { + return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, 1); + } else { + tableType_t const addrMode = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32; + return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, 1); + } } +} + + +int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize) +{ +#if (LZ4_HEAPMODE) + LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */ + if (ctx == NULL) return 0; +#else + LZ4_stream_t ctxBody; + LZ4_stream_t* ctx = &ctxBody; +#endif + + int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize); + +#if (LZ4_HEAPMODE) + FREEMEM(ctx); +#endif + return result; +} + + + +/*-****************************** +* Streaming functions +********************************/ + +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +LZ4_stream_t* LZ4_createStream(void) +{ + LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t)); + LZ4_STATIC_ASSERT(sizeof(LZ4_stream_t) >= sizeof(LZ4_stream_t_internal)); + DEBUGLOG(4, "LZ4_createStream %p", lz4s); + if (lz4s == NULL) return NULL; + LZ4_initStream(lz4s, sizeof(*lz4s)); + return lz4s; +} +#endif + +static size_t LZ4_stream_t_alignment(void) +{ +#if LZ4_ALIGN_TEST + typedef struct { char c; LZ4_stream_t t; } t_a; + return sizeof(t_a) - sizeof(LZ4_stream_t); +#else + return 1; /* effectively disabled */ +#endif +} + +LZ4_stream_t* LZ4_initStream (void* buffer, size_t size) +{ + DEBUGLOG(5, "LZ4_initStream"); + if (buffer == NULL) { return NULL; } + if (size < sizeof(LZ4_stream_t)) { return NULL; } + if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL; + MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal)); + return (LZ4_stream_t*)buffer; +} + +/* resetStream is now deprecated, + * prefer initStream() which is more general */ +void LZ4_resetStream (LZ4_stream_t* LZ4_stream) +{ + DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream); + MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal)); +} + +void LZ4_resetStream_fast(LZ4_stream_t* ctx) { + LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32); +} + +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +int LZ4_freeStream (LZ4_stream_t* LZ4_stream) +{ + if (!LZ4_stream) return 0; /* support free on NULL */ + DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream); + FREEMEM(LZ4_stream); + return (0); +} +#endif + + +#define HASH_UNIT sizeof(reg_t) +int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize) +{ + LZ4_stream_t_internal* dict = &LZ4_dict->internal_donotuse; + const tableType_t tableType = byU32; + const BYTE* p = (const BYTE*)dictionary; + const BYTE* const dictEnd = p + dictSize; + const BYTE* base; + + DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict); + + /* It's necessary to reset the context, + * and not just continue it with prepareTable() + * to avoid any risk of generating overflowing matchIndex + * when compressing using this dictionary */ + LZ4_resetStream(LZ4_dict); + + /* We always increment the offset by 64 KB, since, if the dict is longer, + * we truncate it to the last 64k, and if it's shorter, we still want to + * advance by a whole window length so we can provide the guarantee that + * there are only valid offsets in the window, which allows an optimization + * in LZ4_compress_fast_continue() where it uses noDictIssue even when the + * dictionary isn't a full 64k. */ + dict->currentOffset += 64 KB; + + if (dictSize < (int)HASH_UNIT) { + return 0; + } + + if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB; + base = dictEnd - dict->currentOffset; + dict->dictionary = p; + dict->dictSize = (U32)(dictEnd - p); + dict->tableType = (U32)tableType; + + while (p <= dictEnd-HASH_UNIT) { + LZ4_putPosition(p, dict->hashTable, tableType, base); + p+=3; + } + + return (int)dict->dictSize; +} + +void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) +{ + const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL : + &(dictionaryStream->internal_donotuse); + + DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)", + workingStream, dictionaryStream, + dictCtx != NULL ? dictCtx->dictSize : 0); + + if (dictCtx != NULL) { + /* If the current offset is zero, we will never look in the + * external dictionary context, since there is no value a table + * entry can take that indicate a miss. In that case, we need + * to bump the offset to something non-zero. + */ + if (workingStream->internal_donotuse.currentOffset == 0) { + workingStream->internal_donotuse.currentOffset = 64 KB; + } + + /* Don't actually attach an empty dictionary. + */ + if (dictCtx->dictSize == 0) { + dictCtx = NULL; + } + } + workingStream->internal_donotuse.dictCtx = dictCtx; +} + + +static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize) +{ + assert(nextSize >= 0); + if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) { /* potential ptrdiff_t overflow (32-bits mode) */ + /* rescale hash table */ + U32 const delta = LZ4_dict->currentOffset - 64 KB; + const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize; + int i; + DEBUGLOG(4, "LZ4_renormDictT"); + for (i=0; ihashTable[i] < delta) LZ4_dict->hashTable[i]=0; + else LZ4_dict->hashTable[i] -= delta; + } + LZ4_dict->currentOffset = 64 KB; + if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB; + LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize; + } +} + + +int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream, + const char* source, char* dest, + int inputSize, int maxOutputSize, + int acceleration) +{ + const tableType_t tableType = byU32; + LZ4_stream_t_internal* const streamPtr = &LZ4_stream->internal_donotuse; + const char* dictEnd = streamPtr->dictSize ? (const char*)streamPtr->dictionary + streamPtr->dictSize : NULL; + + DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i, dictSize=%u)", inputSize, streamPtr->dictSize); + + LZ4_renormDictT(streamPtr, inputSize); /* fix index overflow */ + if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT; + if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX; + + /* invalidate tiny dictionaries */ + if ( (streamPtr->dictSize < 4) /* tiny dictionary : not enough for a hash */ + && (dictEnd != source) /* prefix mode */ + && (inputSize > 0) /* tolerance : don't lose history, in case next invocation would use prefix mode */ + && (streamPtr->dictCtx == NULL) /* usingDictCtx */ + ) { + DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary); + /* remove dictionary existence from history, to employ faster prefix mode */ + streamPtr->dictSize = 0; + streamPtr->dictionary = (const BYTE*)source; + dictEnd = source; + } + + /* Check overlapping input/dictionary space */ + { const char* const sourceEnd = source + inputSize; + if ((sourceEnd > (const char*)streamPtr->dictionary) && (sourceEnd < dictEnd)) { + streamPtr->dictSize = (U32)(dictEnd - sourceEnd); + if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB; + if (streamPtr->dictSize < 4) streamPtr->dictSize = 0; + streamPtr->dictionary = (const BYTE*)dictEnd - streamPtr->dictSize; + } + } + + /* prefix mode : source data follows dictionary */ + if (dictEnd == source) { + if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) + return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration); + else + return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration); + } + + /* external dictionary mode */ + { int result; + if (streamPtr->dictCtx) { + /* We depend here on the fact that dictCtx'es (produced by + * LZ4_loadDict) guarantee that their tables contain no references + * to offsets between dictCtx->currentOffset - 64 KB and + * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe + * to use noDictIssue even when the dict isn't a full 64 KB. + */ + if (inputSize > 4 KB) { + /* For compressing large blobs, it is faster to pay the setup + * cost to copy the dictionary's tables into the active context, + * so that the compression loop is only looking into one table. + */ + LZ4_memcpy(streamPtr, streamPtr->dictCtx, sizeof(*streamPtr)); + result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration); + } else { + result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration); + } + } else { /* small data <= 4 KB */ + if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) { + result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration); + } else { + result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration); + } + } + streamPtr->dictionary = (const BYTE*)source; + streamPtr->dictSize = (U32)inputSize; + return result; + } +} + + +/* Hidden debug function, to force-test external dictionary mode */ +int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize) +{ + LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse; + int result; + + LZ4_renormDictT(streamPtr, srcSize); + + if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) { + result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1); + } else { + result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1); + } + + streamPtr->dictionary = (const BYTE*)source; + streamPtr->dictSize = (U32)srcSize; + + return result; +} + + +/*! LZ4_saveDict() : + * If previously compressed data block is not guaranteed to remain available at its memory location, + * save it into a safer place (char* safeBuffer). + * Note : no need to call LZ4_loadDict() afterwards, dictionary is immediately usable, + * one can therefore call LZ4_compress_fast_continue() right after. + * @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error. + */ +int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize) +{ + LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse; + + DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer); + + if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */ + if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; } + + if (safeBuffer == NULL) assert(dictSize == 0); + if (dictSize > 0) { + const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize; + assert(dict->dictionary); + LZ4_memmove(safeBuffer, previousDictEnd - dictSize, (size_t)dictSize); + } + + dict->dictionary = (const BYTE*)safeBuffer; + dict->dictSize = (U32)dictSize; + + return dictSize; +} + + + +/*-******************************* + * Decompression functions + ********************************/ + +typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive; + +#undef MIN +#define MIN(a,b) ( (a) < (b) ? (a) : (b) ) + + +/* variant for decompress_unsafe() + * does not know end of input + * presumes input is well formed + * note : will consume at least one byte */ +size_t read_long_length_no_check(const BYTE** pp) +{ + size_t b, l = 0; + do { b = **pp; (*pp)++; l += b; } while (b==255); + DEBUGLOG(6, "read_long_length_no_check: +length=%zu using %zu input bytes", l, l/255 + 1) + return l; +} + +/* core decoder variant for LZ4_decompress_fast*() + * for legacy support only : these entry points are deprecated. + * - Presumes input is correctly formed (no defense vs malformed inputs) + * - Does not know input size (presume input buffer is "large enough") + * - Decompress a full block (only) + * @return : nb of bytes read from input. + * Note : this variant is not optimized for speed, just for maintenance. + * the goal is to remove support of decompress_fast*() variants by v2.0 +**/ +LZ4_FORCE_INLINE int +LZ4_decompress_unsafe_generic( + const BYTE* const istart, + BYTE* const ostart, + int decompressedSize, + + size_t prefixSize, + const BYTE* const dictStart, /* only if dict==usingExtDict */ + const size_t dictSize /* note: =0 if dictStart==NULL */ + ) +{ + const BYTE* ip = istart; + BYTE* op = (BYTE*)ostart; + BYTE* const oend = ostart + decompressedSize; + const BYTE* const prefixStart = ostart - prefixSize; + + DEBUGLOG(5, "LZ4_decompress_unsafe_generic"); + if (dictStart == NULL) assert(dictSize == 0); + + while (1) { + /* start new sequence */ + unsigned token = *ip++; + + /* literals */ + { size_t ll = token >> ML_BITS; + if (ll==15) { + /* long literal length */ + ll += read_long_length_no_check(&ip); + } + if ((size_t)(oend-op) < ll) return -1; /* output buffer overflow */ + LZ4_memmove(op, ip, ll); /* support in-place decompression */ + op += ll; + ip += ll; + if ((size_t)(oend-op) < MFLIMIT) { + if (op==oend) break; /* end of block */ + DEBUGLOG(5, "invalid: literals end at distance %zi from end of block", oend-op); + /* incorrect end of block : + * last match must start at least MFLIMIT==12 bytes before end of output block */ + return -1; + } } + + /* match */ + { size_t ml = token & 15; + size_t const offset = LZ4_readLE16(ip); + ip+=2; + + if (ml==15) { + /* long literal length */ + ml += read_long_length_no_check(&ip); + } + ml += MINMATCH; + + if ((size_t)(oend-op) < ml) return -1; /* output buffer overflow */ + + { const BYTE* match = op - offset; + + /* out of range */ + if (offset > (size_t)(op - prefixStart) + dictSize) { + DEBUGLOG(6, "offset out of range"); + return -1; + } + + /* check special case : extDict */ + if (offset > (size_t)(op - prefixStart)) { + /* extDict scenario */ + const BYTE* const dictEnd = dictStart + dictSize; + const BYTE* extMatch = dictEnd - (offset - (size_t)(op-prefixStart)); + size_t const extml = (size_t)(dictEnd - extMatch); + if (extml > ml) { + /* match entirely within extDict */ + LZ4_memmove(op, extMatch, ml); + op += ml; + ml = 0; + } else { + /* match split between extDict & prefix */ + LZ4_memmove(op, extMatch, extml); + op += extml; + ml -= extml; + } + match = prefixStart; + } + + /* match copy - slow variant, supporting overlap copy */ + { size_t u; + for (u=0; u= ipmax before start of loop. Returns initial_error if so. + * @error (output) - error code. Must be set to 0 before call. +**/ +typedef size_t Rvl_t; +static const Rvl_t rvl_error = (Rvl_t)(-1); +LZ4_FORCE_INLINE Rvl_t +read_variable_length(const BYTE** ip, const BYTE* ilimit, + int initial_check) +{ + Rvl_t s, length = 0; + assert(ip != NULL); + assert(*ip != NULL); + assert(ilimit != NULL); + if (initial_check && unlikely((*ip) >= ilimit)) { /* read limit reached */ + return rvl_error; + } + do { + s = **ip; + (*ip)++; + length += s; + if (unlikely((*ip) > ilimit)) { /* read limit reached */ + return rvl_error; + } + /* accumulator overflow detection (32-bit mode only) */ + if ((sizeof(length)<8) && unlikely(length > ((Rvl_t)(-1)/2)) ) { + return rvl_error; + } + } while (s==255); + + return length; +} + +/*! LZ4_decompress_generic() : + * This generic decompression function covers all use cases. + * It shall be instantiated several times, using different sets of directives. + * Note that it is important for performance that this function really get inlined, + * in order to remove useless branches during compilation optimization. + */ +LZ4_FORCE_INLINE int +LZ4_decompress_generic( + const char* const src, + char* const dst, + int srcSize, + int outputSize, /* If endOnInput==endOnInputSize, this value is `dstCapacity` */ + + earlyEnd_directive partialDecoding, /* full, partial */ + dict_directive dict, /* noDict, withPrefix64k, usingExtDict */ + const BYTE* const lowPrefix, /* always <= dst, == dst when no prefix */ + const BYTE* const dictStart, /* only if dict==usingExtDict */ + const size_t dictSize /* note : = 0 if noDict */ + ) +{ + if ((src == NULL) || (outputSize < 0)) { return -1; } + + { const BYTE* ip = (const BYTE*) src; + const BYTE* const iend = ip + srcSize; + + BYTE* op = (BYTE*) dst; + BYTE* const oend = op + outputSize; + BYTE* cpy; + + const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize; + + const int checkOffset = (dictSize < (int)(64 KB)); + + + /* Set up the "end" pointers for the shortcut. */ + const BYTE* const shortiend = iend - 14 /*maxLL*/ - 2 /*offset*/; + const BYTE* const shortoend = oend - 14 /*maxLL*/ - 18 /*maxML*/; + + const BYTE* match; + size_t offset; + unsigned token; + size_t length; + + + DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i, dstSize:%i)", srcSize, outputSize); + + /* Special cases */ + assert(lowPrefix <= op); + if (unlikely(outputSize==0)) { + /* Empty output buffer */ + if (partialDecoding) return 0; + return ((srcSize==1) && (*ip==0)) ? 0 : -1; + } + if (unlikely(srcSize==0)) { return -1; } + + /* LZ4_FAST_DEC_LOOP: + * designed for modern OoO performance cpus, + * where copying reliably 32-bytes is preferable to an unpredictable branch. + * note : fast loop may show a regression for some client arm chips. */ +#if LZ4_FAST_DEC_LOOP + if ((oend - op) < FASTLOOP_SAFE_DISTANCE) { + DEBUGLOG(6, "skip fast decode loop"); + goto safe_decode; + } + + /* Fast loop : decode sequences as long as output < oend-FASTLOOP_SAFE_DISTANCE */ + while (1) { + /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */ + assert(oend - op >= FASTLOOP_SAFE_DISTANCE); + assert(ip < iend); + token = *ip++; + length = token >> ML_BITS; /* literal length */ + + /* decode literal length */ + if (length == RUN_MASK) { + size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1); + if (addl == rvl_error) { goto _output_error; } + length += addl; + if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */ + if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */ + + /* copy literals */ + cpy = op+length; + LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH); + if ((cpy>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; } + LZ4_wildCopy32(op, ip, cpy); + ip += length; op = cpy; + } else { + cpy = op+length; + DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length); + /* We don't need to check oend, since we check it once for each loop below */ + if (ip > iend-(16 + 1/*max lit + offset + nextToken*/)) { goto safe_literal_copy; } + /* Literals can only be <= 14, but hope compilers optimize better when copy by a register size */ + LZ4_memcpy(op, ip, 16); + ip += length; op = cpy; + } + + /* get offset */ + offset = LZ4_readLE16(ip); ip+=2; + match = op - offset; + assert(match <= op); /* overflow check */ + + /* get matchlength */ + length = token & ML_MASK; + + if (length == ML_MASK) { + size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0); + if (addl == rvl_error) { goto _output_error; } + length += addl; + length += MINMATCH; + if (unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */ + if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */ + if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) { + goto safe_match_copy; + } + } else { + length += MINMATCH; + if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) { + goto safe_match_copy; + } + + /* Fastpath check: skip LZ4_wildCopy32 when true */ + if ((dict == withPrefix64k) || (match >= lowPrefix)) { + if (offset >= 8) { + assert(match >= lowPrefix); + assert(match <= op); + assert(op + 18 <= oend); + + LZ4_memcpy(op, match, 8); + LZ4_memcpy(op+8, match+8, 8); + LZ4_memcpy(op+16, match+16, 2); + op += length; + continue; + } } } + + if (checkOffset && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */ + /* match starting within external dictionary */ + if ((dict==usingExtDict) && (match < lowPrefix)) { + assert(dictEnd != NULL); + if (unlikely(op+length > oend-LASTLITERALS)) { + if (partialDecoding) { + DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd"); + length = MIN(length, (size_t)(oend-op)); + } else { + goto _output_error; /* end-of-block condition violated */ + } } + + if (length <= (size_t)(lowPrefix-match)) { + /* match fits entirely within external dictionary : just copy */ + LZ4_memmove(op, dictEnd - (lowPrefix-match), length); + op += length; + } else { + /* match stretches into both external dictionary and current block */ + size_t const copySize = (size_t)(lowPrefix - match); + size_t const restSize = length - copySize; + LZ4_memcpy(op, dictEnd - copySize, copySize); + op += copySize; + if (restSize > (size_t)(op - lowPrefix)) { /* overlap copy */ + BYTE* const endOfMatch = op + restSize; + const BYTE* copyFrom = lowPrefix; + while (op < endOfMatch) { *op++ = *copyFrom++; } + } else { + LZ4_memcpy(op, lowPrefix, restSize); + op += restSize; + } } + continue; + } + + /* copy match within block */ + cpy = op + length; + + assert((op <= oend) && (oend-op >= 32)); + if (unlikely(offset<16)) { + LZ4_memcpy_using_offset(op, match, cpy, offset); + } else { + LZ4_wildCopy32(op, match, cpy); + } + + op = cpy; /* wildcopy correction */ + } + safe_decode: +#endif + + /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */ + while (1) { + assert(ip < iend); + token = *ip++; + length = token >> ML_BITS; /* literal length */ + + /* A two-stage shortcut for the most common case: + * 1) If the literal length is 0..14, and there is enough space, + * enter the shortcut and copy 16 bytes on behalf of the literals + * (in the fast mode, only 8 bytes can be safely copied this way). + * 2) Further if the match length is 4..18, copy 18 bytes in a similar + * manner; but we ensure that there's enough space in the output for + * those 18 bytes earlier, upon entering the shortcut (in other words, + * there is a combined check for both stages). + */ + if ( (length != RUN_MASK) + /* strictly "less than" on input, to re-enter the loop with at least one byte */ + && likely((ip < shortiend) & (op <= shortoend)) ) { + /* Copy the literals */ + LZ4_memcpy(op, ip, 16); + op += length; ip += length; + + /* The second stage: prepare for match copying, decode full info. + * If it doesn't work out, the info won't be wasted. */ + length = token & ML_MASK; /* match length */ + offset = LZ4_readLE16(ip); ip += 2; + match = op - offset; + assert(match <= op); /* check overflow */ + + /* Do not deal with overlapping matches. */ + if ( (length != ML_MASK) + && (offset >= 8) + && (dict==withPrefix64k || match >= lowPrefix) ) { + /* Copy the match. */ + LZ4_memcpy(op + 0, match + 0, 8); + LZ4_memcpy(op + 8, match + 8, 8); + LZ4_memcpy(op +16, match +16, 2); + op += length + MINMATCH; + /* Both stages worked, load the next token. */ + continue; + } + + /* The second stage didn't work out, but the info is ready. + * Propel it right to the point of match copying. */ + goto _copy_match; + } + + /* decode literal length */ + if (length == RUN_MASK) { + size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1); + if (addl == rvl_error) { goto _output_error; } + length += addl; + if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */ + if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */ + } + + /* copy literals */ + cpy = op+length; +#if LZ4_FAST_DEC_LOOP + safe_literal_copy: +#endif + LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH); + if ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) { + /* We've either hit the input parsing restriction or the output parsing restriction. + * In the normal scenario, decoding a full block, it must be the last sequence, + * otherwise it's an error (invalid input or dimensions). + * In partialDecoding scenario, it's necessary to ensure there is no buffer overflow. + */ + if (partialDecoding) { + /* Since we are partial decoding we may be in this block because of the output parsing + * restriction, which is not valid since the output buffer is allowed to be undersized. + */ + DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end") + DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length); + DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op)); + DEBUGLOG(7, "partialDecoding: remaining space in srcBuffer : %i", (int)(iend - ip)); + /* Finishing in the middle of a literals segment, + * due to lack of input. + */ + if (ip+length > iend) { + length = (size_t)(iend-ip); + cpy = op + length; + } + /* Finishing in the middle of a literals segment, + * due to lack of output space. + */ + if (cpy > oend) { + cpy = oend; + assert(op<=oend); + length = (size_t)(oend-op); + } + } else { + /* We must be on the last sequence (or invalid) because of the parsing limitations + * so check that we exactly consume the input and don't overrun the output buffer. + */ + if ((ip+length != iend) || (cpy > oend)) { + DEBUGLOG(6, "should have been last run of literals") + DEBUGLOG(6, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend); + DEBUGLOG(6, "or cpy(%p) > oend(%p)", cpy, oend); + goto _output_error; + } + } + LZ4_memmove(op, ip, length); /* supports overlapping memory regions, for in-place decompression scenarios */ + ip += length; + op += length; + /* Necessarily EOF when !partialDecoding. + * When partialDecoding, it is EOF if we've either + * filled the output buffer or + * can't proceed with reading an offset for following match. + */ + if (!partialDecoding || (cpy == oend) || (ip >= (iend-2))) { + break; + } + } else { + LZ4_wildCopy8(op, ip, cpy); /* can overwrite up to 8 bytes beyond cpy */ + ip += length; op = cpy; + } + + /* get offset */ + offset = LZ4_readLE16(ip); ip+=2; + match = op - offset; + + /* get matchlength */ + length = token & ML_MASK; + + _copy_match: + if (length == ML_MASK) { + size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0); + if (addl == rvl_error) { goto _output_error; } + length += addl; + if (unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error; /* overflow detection */ + } + length += MINMATCH; + +#if LZ4_FAST_DEC_LOOP + safe_match_copy: +#endif + if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error; /* Error : offset outside buffers */ + /* match starting within external dictionary */ + if ((dict==usingExtDict) && (match < lowPrefix)) { + assert(dictEnd != NULL); + if (unlikely(op+length > oend-LASTLITERALS)) { + if (partialDecoding) length = MIN(length, (size_t)(oend-op)); + else goto _output_error; /* doesn't respect parsing restriction */ + } + + if (length <= (size_t)(lowPrefix-match)) { + /* match fits entirely within external dictionary : just copy */ + LZ4_memmove(op, dictEnd - (lowPrefix-match), length); + op += length; + } else { + /* match stretches into both external dictionary and current block */ + size_t const copySize = (size_t)(lowPrefix - match); + size_t const restSize = length - copySize; + LZ4_memcpy(op, dictEnd - copySize, copySize); + op += copySize; + if (restSize > (size_t)(op - lowPrefix)) { /* overlap copy */ + BYTE* const endOfMatch = op + restSize; + const BYTE* copyFrom = lowPrefix; + while (op < endOfMatch) *op++ = *copyFrom++; + } else { + LZ4_memcpy(op, lowPrefix, restSize); + op += restSize; + } } + continue; + } + assert(match >= lowPrefix); + + /* copy match within block */ + cpy = op + length; + + /* partialDecoding : may end anywhere within the block */ + assert(op<=oend); + if (partialDecoding && (cpy > oend-MATCH_SAFEGUARD_DISTANCE)) { + size_t const mlen = MIN(length, (size_t)(oend-op)); + const BYTE* const matchEnd = match + mlen; + BYTE* const copyEnd = op + mlen; + if (matchEnd > op) { /* overlap copy */ + while (op < copyEnd) { *op++ = *match++; } + } else { + LZ4_memcpy(op, match, mlen); + } + op = copyEnd; + if (op == oend) { break; } + continue; + } + + if (unlikely(offset<8)) { + LZ4_write32(op, 0); /* silence msan warning when offset==0 */ + op[0] = match[0]; + op[1] = match[1]; + op[2] = match[2]; + op[3] = match[3]; + match += inc32table[offset]; + LZ4_memcpy(op+4, match, 4); + match -= dec64table[offset]; + } else { + LZ4_memcpy(op, match, 8); + match += 8; + } + op += 8; + + if (unlikely(cpy > oend-MATCH_SAFEGUARD_DISTANCE)) { + BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH-1); + if (cpy > oend-LASTLITERALS) { goto _output_error; } /* Error : last LASTLITERALS bytes must be literals (uncompressed) */ + if (op < oCopyLimit) { + LZ4_wildCopy8(op, match, oCopyLimit); + match += oCopyLimit - op; + op = oCopyLimit; + } + while (op < cpy) { *op++ = *match++; } + } else { + LZ4_memcpy(op, match, 8); + if (length > 16) { LZ4_wildCopy8(op+8, match+8, cpy); } + } + op = cpy; /* wildcopy correction */ + } + + /* end of decoding */ + DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst)); + return (int) (((char*)op)-dst); /* Nb of output bytes decoded */ + + /* Overflow error detected */ + _output_error: + return (int) (-(((const char*)ip)-src))-1; + } +} + + +/*===== Instantiate the API decoding functions. =====*/ + +LZ4_FORCE_O2 +int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize) +{ + return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, + decode_full_block, noDict, + (BYTE*)dest, NULL, 0); +} + +LZ4_FORCE_O2 +int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, int targetOutputSize, int dstCapacity) +{ + dstCapacity = MIN(targetOutputSize, dstCapacity); + return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity, + partial_decode, + noDict, (BYTE*)dst, NULL, 0); +} + +LZ4_FORCE_O2 +int LZ4_decompress_fast(const char* source, char* dest, int originalSize) +{ + DEBUGLOG(5, "LZ4_decompress_fast"); + return LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + 0, NULL, 0); +} + +/*===== Instantiate a few more decoding cases, used more than once. =====*/ + +LZ4_FORCE_O2 /* Exported, an obsolete API function. */ +int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize) +{ + return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, + decode_full_block, withPrefix64k, + (BYTE*)dest - 64 KB, NULL, 0); +} + +LZ4_FORCE_O2 +static int LZ4_decompress_safe_partial_withPrefix64k(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity) +{ + dstCapacity = MIN(targetOutputSize, dstCapacity); + return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, + partial_decode, withPrefix64k, + (BYTE*)dest - 64 KB, NULL, 0); +} + +/* Another obsolete API function, paired with the previous one. */ +int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize) +{ + return LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + 64 KB, NULL, 0); +} + +LZ4_FORCE_O2 +static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize, + size_t prefixSize) +{ + return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, + decode_full_block, noDict, + (BYTE*)dest-prefixSize, NULL, 0); +} + +LZ4_FORCE_O2 +static int LZ4_decompress_safe_partial_withSmallPrefix(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, + size_t prefixSize) +{ + dstCapacity = MIN(targetOutputSize, dstCapacity); + return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, + partial_decode, noDict, + (BYTE*)dest-prefixSize, NULL, 0); +} + +LZ4_FORCE_O2 +int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, + int compressedSize, int maxOutputSize, + const void* dictStart, size_t dictSize) +{ + return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, + decode_full_block, usingExtDict, + (BYTE*)dest, (const BYTE*)dictStart, dictSize); +} + +LZ4_FORCE_O2 +int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest, + int compressedSize, int targetOutputSize, int dstCapacity, + const void* dictStart, size_t dictSize) +{ + dstCapacity = MIN(targetOutputSize, dstCapacity); + return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, + partial_decode, usingExtDict, + (BYTE*)dest, (const BYTE*)dictStart, dictSize); +} + +LZ4_FORCE_O2 +static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize, + const void* dictStart, size_t dictSize) +{ + return LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + 0, (const BYTE*)dictStart, dictSize); +} + +/* The "double dictionary" mode, for use with e.g. ring buffers: the first part + * of the dictionary is passed as prefix, and the second via dictStart + dictSize. + * These routines are used only once, in LZ4_decompress_*_continue(). + */ +LZ4_FORCE_INLINE +int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compressedSize, int maxOutputSize, + size_t prefixSize, const void* dictStart, size_t dictSize) +{ + return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, + decode_full_block, usingExtDict, + (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize); +} + +/*===== streaming decompression functions =====*/ + +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +LZ4_streamDecode_t* LZ4_createStreamDecode(void) +{ + LZ4_STATIC_ASSERT(sizeof(LZ4_streamDecode_t) >= sizeof(LZ4_streamDecode_t_internal)); + return (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t)); +} + +int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream) +{ + if (LZ4_stream == NULL) { return 0; } /* support free on NULL */ + FREEMEM(LZ4_stream); + return 0; +} +#endif + +/*! LZ4_setStreamDecode() : + * Use this function to instruct where to find the dictionary. + * This function is not necessary if previous data is still available where it was decoded. + * Loading a size of 0 is allowed (same effect as no dictionary). + * @return : 1 if OK, 0 if error + */ +int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize) +{ + LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse; + lz4sd->prefixSize = (size_t)dictSize; + if (dictSize) { + assert(dictionary != NULL); + lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize; + } else { + lz4sd->prefixEnd = (const BYTE*) dictionary; + } + lz4sd->externalDict = NULL; + lz4sd->extDictSize = 0; + return 1; +} + +/*! LZ4_decoderRingBufferSize() : + * when setting a ring buffer for streaming decompression (optional scenario), + * provides the minimum size of this ring buffer + * to be compatible with any source respecting maxBlockSize condition. + * Note : in a ring buffer scenario, + * blocks are presumed decompressed next to each other. + * When not enough space remains for next block (remainingSize < maxBlockSize), + * decoding resumes from beginning of ring buffer. + * @return : minimum ring buffer size, + * or 0 if there is an error (invalid maxBlockSize). + */ +int LZ4_decoderRingBufferSize(int maxBlockSize) +{ + if (maxBlockSize < 0) return 0; + if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0; + if (maxBlockSize < 16) maxBlockSize = 16; + return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize); +} + +/* +*_continue() : + These decoding functions allow decompression of multiple blocks in "streaming" mode. + Previously decoded blocks must still be available at the memory position where they were decoded. + If it's not possible, save the relevant part of decoded data into a safe buffer, + and indicate where it stands using LZ4_setStreamDecode() +*/ +LZ4_FORCE_O2 +int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize) +{ + LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse; + int result; + + if (lz4sd->prefixSize == 0) { + /* The first call, no dictionary yet. */ + assert(lz4sd->extDictSize == 0); + result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize); + if (result <= 0) return result; + lz4sd->prefixSize = (size_t)result; + lz4sd->prefixEnd = (BYTE*)dest + result; + } else if (lz4sd->prefixEnd == (BYTE*)dest) { + /* They're rolling the current segment. */ + if (lz4sd->prefixSize >= 64 KB - 1) + result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize); + else if (lz4sd->extDictSize == 0) + result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, + lz4sd->prefixSize); + else + result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize, + lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize); + if (result <= 0) return result; + lz4sd->prefixSize += (size_t)result; + lz4sd->prefixEnd += result; + } else { + /* The buffer wraps around, or they're switching to another buffer. */ + lz4sd->extDictSize = lz4sd->prefixSize; + lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; + result = LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, + lz4sd->externalDict, lz4sd->extDictSize); + if (result <= 0) return result; + lz4sd->prefixSize = (size_t)result; + lz4sd->prefixEnd = (BYTE*)dest + result; + } + + return result; +} + +LZ4_FORCE_O2 int +LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, + const char* source, char* dest, int originalSize) +{ + LZ4_streamDecode_t_internal* const lz4sd = + (assert(LZ4_streamDecode!=NULL), &LZ4_streamDecode->internal_donotuse); + int result; + + DEBUGLOG(5, "LZ4_decompress_fast_continue (toDecodeSize=%i)", originalSize); + assert(originalSize >= 0); + + if (lz4sd->prefixSize == 0) { + DEBUGLOG(5, "first invocation : no prefix nor extDict"); + assert(lz4sd->extDictSize == 0); + result = LZ4_decompress_fast(source, dest, originalSize); + if (result <= 0) return result; + lz4sd->prefixSize = (size_t)originalSize; + lz4sd->prefixEnd = (BYTE*)dest + originalSize; + } else if (lz4sd->prefixEnd == (BYTE*)dest) { + DEBUGLOG(5, "continue using existing prefix"); + result = LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + lz4sd->prefixSize, + lz4sd->externalDict, lz4sd->extDictSize); + if (result <= 0) return result; + lz4sd->prefixSize += (size_t)originalSize; + lz4sd->prefixEnd += originalSize; + } else { + DEBUGLOG(5, "prefix becomes extDict"); + lz4sd->extDictSize = lz4sd->prefixSize; + lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; + result = LZ4_decompress_fast_extDict(source, dest, originalSize, + lz4sd->externalDict, lz4sd->extDictSize); + if (result <= 0) return result; + lz4sd->prefixSize = (size_t)originalSize; + lz4sd->prefixEnd = (BYTE*)dest + originalSize; + } + + return result; +} + + +/* +Advanced decoding functions : +*_usingDict() : + These decoding functions work the same as "_continue" ones, + the dictionary must be explicitly provided within parameters +*/ + +int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize) +{ + if (dictSize==0) + return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize); + if (dictStart+dictSize == dest) { + if (dictSize >= 64 KB - 1) { + return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize); + } + assert(dictSize >= 0); + return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize); + } + assert(dictSize >= 0); + return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize); +} + +int LZ4_decompress_safe_partial_usingDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const char* dictStart, int dictSize) +{ + if (dictSize==0) + return LZ4_decompress_safe_partial(source, dest, compressedSize, targetOutputSize, dstCapacity); + if (dictStart+dictSize == dest) { + if (dictSize >= 64 KB - 1) { + return LZ4_decompress_safe_partial_withPrefix64k(source, dest, compressedSize, targetOutputSize, dstCapacity); + } + assert(dictSize >= 0); + return LZ4_decompress_safe_partial_withSmallPrefix(source, dest, compressedSize, targetOutputSize, dstCapacity, (size_t)dictSize); + } + assert(dictSize >= 0); + return LZ4_decompress_safe_partial_forceExtDict(source, dest, compressedSize, targetOutputSize, dstCapacity, dictStart, (size_t)dictSize); +} + +int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize) +{ + if (dictSize==0 || dictStart+dictSize == dest) + return LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + (size_t)dictSize, NULL, 0); + assert(dictSize >= 0); + return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize); +} + + +/*=************************************************* +* Obsolete Functions +***************************************************/ +/* obsolete compression functions */ +int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize) +{ + return LZ4_compress_default(source, dest, inputSize, maxOutputSize); +} +int LZ4_compress(const char* src, char* dest, int srcSize) +{ + return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize)); +} +int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize) +{ + return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1); +} +int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize) +{ + return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1); +} +int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity) +{ + return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1); +} +int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize) +{ + return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1); +} + +/* +These decompression functions are deprecated and should no longer be used. +They are only provided here for compatibility with older user programs. +- LZ4_uncompress is totally equivalent to LZ4_decompress_fast +- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe +*/ +int LZ4_uncompress (const char* source, char* dest, int outputSize) +{ + return LZ4_decompress_fast(source, dest, outputSize); +} +int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize) +{ + return LZ4_decompress_safe(source, dest, isize, maxOutputSize); +} + +/* Obsolete Streaming functions */ + +int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); } + +int LZ4_resetStreamState(void* state, char* inputBuffer) +{ + (void)inputBuffer; + LZ4_resetStream((LZ4_stream_t*)state); + return 0; +} + +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +void* LZ4_create (char* inputBuffer) +{ + (void)inputBuffer; + return LZ4_createStream(); +} +#endif + +char* LZ4_slideInputBuffer (void* state) +{ + /* avoid const char * -> char * conversion warning */ + return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary; +} + +#endif /* LZ4_COMMONDEFS_ONLY */ + +} diff --git a/Dependencies/tracy/common/tracy_lz4.hpp b/Dependencies/tracy/common/tracy_lz4.hpp new file mode 100644 index 000000000..672c2feb2 --- /dev/null +++ b/Dependencies/tracy/common/tracy_lz4.hpp @@ -0,0 +1,847 @@ +/* + * LZ4 - Fast LZ compression algorithm + * Header File + * Copyright (C) 2011-2020, Yann Collet. + + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 homepage : http://www.lz4.org + - LZ4 source repository : https://github.com/lz4/lz4 +*/ + +#ifndef TRACY_LZ4_H_2983827168210 +#define TRACY_LZ4_H_2983827168210 + +/* --- Dependency --- */ +#include /* size_t */ +#include + + +/** + Introduction + + LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core, + scalable with multi-cores CPU. It features an extremely fast decoder, with speed in + multiple GB/s per core, typically reaching RAM speed limits on multi-core systems. + + The LZ4 compression library provides in-memory compression and decompression functions. + It gives full buffer control to user. + Compression can be done in: + - a single step (described as Simple Functions) + - a single step, reusing a context (described in Advanced Functions) + - unbounded multiple steps (described as Streaming compression) + + lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md). + Decompressing such a compressed block requires additional metadata. + Exact metadata depends on exact decompression function. + For the typical case of LZ4_decompress_safe(), + metadata includes block's compressed size, and maximum bound of decompressed size. + Each application is free to encode and pass such metadata in whichever way it wants. + + lz4.h only handle blocks, it can not generate Frames. + + Blocks are different from Frames (doc/lz4_Frame_format.md). + Frames bundle both blocks and metadata in a specified manner. + Embedding metadata is required for compressed data to be self-contained and portable. + Frame format is delivered through a companion API, declared in lz4frame.h. + The `lz4` CLI can only manage frames. +*/ + +/*^*************************************************************** +* Export parameters +*****************************************************************/ +/* +* LZ4_DLL_EXPORT : +* Enable exporting of functions when building a Windows DLL +* LZ4LIB_VISIBILITY : +* Control library symbols visibility. +*/ +#ifndef LZ4LIB_VISIBILITY +# if defined(__GNUC__) && (__GNUC__ >= 4) +# define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default"))) +# else +# define LZ4LIB_VISIBILITY +# endif +#endif +#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1) +# define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY +#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1) +# define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/ +#else +# define LZ4LIB_API LZ4LIB_VISIBILITY +#endif + +/*! LZ4_FREESTANDING : + * When this macro is set to 1, it enables "freestanding mode" that is + * suitable for typical freestanding environment which doesn't support + * standard C library. + * + * - LZ4_FREESTANDING is a compile-time switch. + * - It requires the following macros to be defined: + * LZ4_memcpy, LZ4_memmove, LZ4_memset. + * - It only enables LZ4/HC functions which don't use heap. + * All LZ4F_* functions are not supported. + * - See tests/freestanding.c to check its basic setup. + */ +#if defined(LZ4_FREESTANDING) && (LZ4_FREESTANDING == 1) +# define LZ4_HEAPMODE 0 +# define LZ4HC_HEAPMODE 0 +# define LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION 1 +# if !defined(LZ4_memcpy) +# error "LZ4_FREESTANDING requires macro 'LZ4_memcpy'." +# endif +# if !defined(LZ4_memset) +# error "LZ4_FREESTANDING requires macro 'LZ4_memset'." +# endif +# if !defined(LZ4_memmove) +# error "LZ4_FREESTANDING requires macro 'LZ4_memmove'." +# endif +#elif ! defined(LZ4_FREESTANDING) +# define LZ4_FREESTANDING 0 +#endif + + +/*------ Version ------*/ +#define LZ4_VERSION_MAJOR 1 /* for breaking interface changes */ +#define LZ4_VERSION_MINOR 9 /* for new (non-breaking) interface capabilities */ +#define LZ4_VERSION_RELEASE 4 /* for tweaks, bug-fixes, or development */ + +#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE) + +#define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE +#define LZ4_QUOTE(str) #str +#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str) +#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION) /* requires v1.7.3+ */ + +namespace tracy +{ + +LZ4LIB_API int LZ4_versionNumber (void); /**< library version number; useful to check dll version; requires v1.3.0+ */ +LZ4LIB_API const char* LZ4_versionString (void); /**< library version string; useful to check dll version; requires v1.7.5+ */ + + +/*-************************************ +* Tuning parameter +**************************************/ +#define LZ4_MEMORY_USAGE_MIN 10 +#define LZ4_MEMORY_USAGE_DEFAULT 14 +#define LZ4_MEMORY_USAGE_MAX 20 + +/*! + * LZ4_MEMORY_USAGE : + * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; ) + * Increasing memory usage improves compression ratio, at the cost of speed. + * Reduced memory usage may improve speed at the cost of ratio, thanks to better cache locality. + * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache + */ +#ifndef LZ4_MEMORY_USAGE +# define LZ4_MEMORY_USAGE LZ4_MEMORY_USAGE_DEFAULT +#endif + +#if (LZ4_MEMORY_USAGE < LZ4_MEMORY_USAGE_MIN) +# error "LZ4_MEMORY_USAGE is too small !" +#endif + +#if (LZ4_MEMORY_USAGE > LZ4_MEMORY_USAGE_MAX) +# error "LZ4_MEMORY_USAGE is too large !" +#endif + +/*-************************************ +* Simple Functions +**************************************/ +/*! LZ4_compress_default() : + * Compresses 'srcSize' bytes from buffer 'src' + * into already allocated 'dst' buffer of size 'dstCapacity'. + * Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize). + * It also runs faster, so it's a recommended setting. + * If the function cannot compress 'src' into a more limited 'dst' budget, + * compression stops *immediately*, and the function result is zero. + * In which case, 'dst' content is undefined (invalid). + * srcSize : max supported value is LZ4_MAX_INPUT_SIZE. + * dstCapacity : size of buffer 'dst' (which must be already allocated) + * @return : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity) + * or 0 if compression fails + * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer). + */ +LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity); + +/*! LZ4_decompress_safe() : + * compressedSize : is the exact complete size of the compressed block. + * dstCapacity : is the size of destination buffer (which must be already allocated), presumed an upper bound of decompressed size. + * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity) + * If destination buffer is not large enough, decoding will stop and output an error code (negative value). + * If the source stream is detected malformed, the function will stop decoding and return a negative result. + * Note 1 : This function is protected against malicious data packets : + * it will never writes outside 'dst' buffer, nor read outside 'source' buffer, + * even if the compressed block is maliciously modified to order the decoder to do these actions. + * In such case, the decoder stops immediately, and considers the compressed block malformed. + * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them. + * The implementation is free to send / store / derive this information in whichever way is most beneficial. + * If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead. + */ +LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity); + + +/*-************************************ +* Advanced Functions +**************************************/ +#define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */ +#define LZ4_COMPRESSBOUND(isize) ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16) + +/*! LZ4_compressBound() : + Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible) + This function is primarily useful for memory allocation purposes (destination buffer size). + Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example). + Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize) + inputSize : max supported value is LZ4_MAX_INPUT_SIZE + return : maximum output size in a "worst case" scenario + or 0, if input size is incorrect (too large or negative) +*/ +LZ4LIB_API int LZ4_compressBound(int inputSize); + +/*! LZ4_compress_fast() : + Same as LZ4_compress_default(), but allows selection of "acceleration" factor. + The larger the acceleration value, the faster the algorithm, but also the lesser the compression. + It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed. + An acceleration value of "1" is the same as regular LZ4_compress_default() + Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c). + Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c). +*/ +LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); + + +/*! LZ4_compress_fast_extState() : + * Same as LZ4_compress_fast(), using an externally allocated memory space for its state. + * Use LZ4_sizeofState() to know how much memory must be allocated, + * and allocate it on 8-bytes boundaries (using `malloc()` typically). + * Then, provide this buffer as `void* state` to compression function. + */ +LZ4LIB_API int LZ4_sizeofState(void); +LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); + + +/*! LZ4_compress_destSize() : + * Reverse the logic : compresses as much data as possible from 'src' buffer + * into already allocated buffer 'dst', of size >= 'targetDestSize'. + * This function either compresses the entire 'src' content into 'dst' if it's large enough, + * or fill 'dst' buffer completely with as much data as possible from 'src'. + * note: acceleration parameter is fixed to "default". + * + * *srcSizePtr : will be modified to indicate how many bytes where read from 'src' to fill 'dst'. + * New value is necessarily <= input value. + * @return : Nb bytes written into 'dst' (necessarily <= targetDestSize) + * or 0 if compression fails. + * + * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed un v1.9.2+): + * the produced compressed content could, in specific circumstances, + * require to be decompressed into a destination buffer larger + * by at least 1 byte than the content to decompress. + * If an application uses `LZ4_compress_destSize()`, + * it's highly recommended to update liblz4 to v1.9.2 or better. + * If this can't be done or ensured, + * the receiving decompression function should provide + * a dstCapacity which is > decompressedSize, by at least 1 byte. + * See https://github.com/lz4/lz4/issues/859 for details + */ +LZ4LIB_API int LZ4_compress_destSize (const char* src, char* dst, int* srcSizePtr, int targetDstSize); + + +/*! LZ4_decompress_safe_partial() : + * Decompress an LZ4 compressed block, of size 'srcSize' at position 'src', + * into destination buffer 'dst' of size 'dstCapacity'. + * Up to 'targetOutputSize' bytes will be decoded. + * The function stops decoding on reaching this objective. + * This can be useful to boost performance + * whenever only the beginning of a block is required. + * + * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize) + * If source stream is detected malformed, function returns a negative result. + * + * Note 1 : @return can be < targetOutputSize, if compressed block contains less data. + * + * Note 2 : targetOutputSize must be <= dstCapacity + * + * Note 3 : this function effectively stops decoding on reaching targetOutputSize, + * so dstCapacity is kind of redundant. + * This is because in older versions of this function, + * decoding operation would still write complete sequences. + * Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize, + * it could write more bytes, though only up to dstCapacity. + * Some "margin" used to be required for this operation to work properly. + * Thankfully, this is no longer necessary. + * The function nonetheless keeps the same signature, in an effort to preserve API compatibility. + * + * Note 4 : If srcSize is the exact size of the block, + * then targetOutputSize can be any value, + * including larger than the block's decompressed size. + * The function will, at most, generate block's decompressed size. + * + * Note 5 : If srcSize is _larger_ than block's compressed size, + * then targetOutputSize **MUST** be <= block's decompressed size. + * Otherwise, *silent corruption will occur*. + */ +LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity); + + +/*-********************************************* +* Streaming Compression Functions +***********************************************/ +typedef union LZ4_stream_u LZ4_stream_t; /* incomplete type (defined later) */ + +/** + Note about RC_INVOKED + + - RC_INVOKED is predefined symbol of rc.exe (the resource compiler which is part of MSVC/Visual Studio). + https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros + + - Since rc.exe is a legacy compiler, it truncates long symbol (> 30 chars) + and reports warning "RC4011: identifier truncated". + + - To eliminate the warning, we surround long preprocessor symbol with + "#if !defined(RC_INVOKED) ... #endif" block that means + "skip this block when rc.exe is trying to read it". +*/ +#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +LZ4LIB_API LZ4_stream_t* LZ4_createStream(void); +LZ4LIB_API int LZ4_freeStream (LZ4_stream_t* streamPtr); +#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */ +#endif + +/*! LZ4_resetStream_fast() : v1.9.0+ + * Use this to prepare an LZ4_stream_t for a new chain of dependent blocks + * (e.g., LZ4_compress_fast_continue()). + * + * An LZ4_stream_t must be initialized once before usage. + * This is automatically done when created by LZ4_createStream(). + * However, should the LZ4_stream_t be simply declared on stack (for example), + * it's necessary to initialize it first, using LZ4_initStream(). + * + * After init, start any new stream with LZ4_resetStream_fast(). + * A same LZ4_stream_t can be re-used multiple times consecutively + * and compress multiple streams, + * provided that it starts each new stream with LZ4_resetStream_fast(). + * + * LZ4_resetStream_fast() is much faster than LZ4_initStream(), + * but is not compatible with memory regions containing garbage data. + * + * Note: it's only useful to call LZ4_resetStream_fast() + * in the context of streaming compression. + * The *extState* functions perform their own resets. + * Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive. + */ +LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr); + +/*! LZ4_loadDict() : + * Use this function to reference a static dictionary into LZ4_stream_t. + * The dictionary must remain available during compression. + * LZ4_loadDict() triggers a reset, so any previous data will be forgotten. + * The same dictionary will have to be loaded on decompression side for successful decoding. + * Dictionary are useful for better compression of small data (KB range). + * While LZ4 accept any input as dictionary, + * results are generally better when using Zstandard's Dictionary Builder. + * Loading a size of 0 is allowed, and is the same as reset. + * @return : loaded dictionary size, in bytes (necessarily <= 64 KB) + */ +LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize); + +/*! LZ4_compress_fast_continue() : + * Compress 'src' content using data from previously compressed blocks, for better compression ratio. + * 'dst' buffer must be already allocated. + * If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster. + * + * @return : size of compressed block + * or 0 if there is an error (typically, cannot fit into 'dst'). + * + * Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block. + * Each block has precise boundaries. + * Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata. + * It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together. + * + * Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory ! + * + * Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB. + * Make sure that buffers are separated, by at least one byte. + * This construction ensures that each block only depends on previous block. + * + * Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB. + * + * Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed. + */ +LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); + +/*! LZ4_saveDict() : + * If last 64KB data cannot be guaranteed to remain available at its current memory location, + * save it into a safer place (char* safeBuffer). + * This is schematically equivalent to a memcpy() followed by LZ4_loadDict(), + * but is much faster, because LZ4_saveDict() doesn't need to rebuild tables. + * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error. + */ +LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize); + + +/*-********************************************** +* Streaming Decompression Functions +* Bufferless synchronous API +************************************************/ +typedef union LZ4_streamDecode_u LZ4_streamDecode_t; /* tracking context */ + +/*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() : + * creation / destruction of streaming decompression tracking context. + * A tracking context can be re-used multiple times. + */ +#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void); +LZ4LIB_API int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream); +#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */ +#endif + +/*! LZ4_setStreamDecode() : + * An LZ4_streamDecode_t context can be allocated once and re-used multiple times. + * Use this function to start decompression of a new stream of blocks. + * A dictionary can optionally be set. Use NULL or size 0 for a reset order. + * Dictionary is presumed stable : it must remain accessible and unmodified during next decompression. + * @return : 1 if OK, 0 if error + */ +LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize); + +/*! LZ4_decoderRingBufferSize() : v1.8.2+ + * Note : in a ring buffer scenario (optional), + * blocks are presumed decompressed next to each other + * up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize), + * at which stage it resumes from beginning of ring buffer. + * When setting such a ring buffer for streaming decompression, + * provides the minimum size of this ring buffer + * to be compatible with any source respecting maxBlockSize condition. + * @return : minimum ring buffer size, + * or 0 if there is an error (invalid maxBlockSize). + */ +LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize); +#define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize)) /* for static allocation; maxBlockSize presumed valid */ + +/*! LZ4_decompress_*_continue() : + * These decoding functions allow decompression of consecutive blocks in "streaming" mode. + * A block is an unsplittable entity, it must be presented entirely to a decompression function. + * Decompression functions only accepts one block at a time. + * The last 64KB of previously decoded data *must* remain available and unmodified at the memory position where they were decoded. + * If less than 64KB of data has been decoded, all the data must be present. + * + * Special : if decompression side sets a ring buffer, it must respect one of the following conditions : + * - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize). + * maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes. + * In which case, encoding and decoding buffers do not need to be synchronized. + * Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize. + * - Synchronized mode : + * Decompression buffer size is _exactly_ the same as compression buffer size, + * and follows exactly same update rule (block boundaries at same positions), + * and decoding function is provided with exact decompressed size of each block (exception for last block of the stream), + * _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB). + * - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes. + * In which case, encoding and decoding buffers do not need to be synchronized, + * and encoding ring buffer can have any size, including small ones ( < 64 KB). + * + * Whenever these conditions are not possible, + * save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression, + * then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block. +*/ +LZ4LIB_API int +LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, + const char* src, char* dst, + int srcSize, int dstCapacity); + + +/*! LZ4_decompress_*_usingDict() : + * These decoding functions work the same as + * a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue() + * They are stand-alone, and don't need an LZ4_streamDecode_t structure. + * Dictionary is presumed stable : it must remain accessible and unmodified during decompression. + * Performance tip : Decompression speed can be substantially increased + * when dst == dictStart + dictSize. + */ +LZ4LIB_API int +LZ4_decompress_safe_usingDict(const char* src, char* dst, + int srcSize, int dstCapacity, + const char* dictStart, int dictSize); + +LZ4LIB_API int +LZ4_decompress_safe_partial_usingDict(const char* src, char* dst, + int compressedSize, + int targetOutputSize, int maxOutputSize, + const char* dictStart, int dictSize); + +} + +#endif /* LZ4_H_2983827168210 */ + + +/*^************************************* + * !!!!!! STATIC LINKING ONLY !!!!!! + ***************************************/ + +/*-**************************************************************************** + * Experimental section + * + * Symbols declared in this section must be considered unstable. Their + * signatures or semantics may change, or they may be removed altogether in the + * future. They are therefore only safe to depend on when the caller is + * statically linked against the library. + * + * To protect against unsafe usage, not only are the declarations guarded, + * the definitions are hidden by default + * when building LZ4 as a shared/dynamic library. + * + * In order to access these declarations, + * define LZ4_STATIC_LINKING_ONLY in your application + * before including LZ4's headers. + * + * In order to make their implementations accessible dynamically, you must + * define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library. + ******************************************************************************/ + +#ifdef LZ4_STATIC_LINKING_ONLY + +#ifndef TRACY_LZ4_STATIC_3504398509 +#define TRACY_LZ4_STATIC_3504398509 + +#ifdef LZ4_PUBLISH_STATIC_FUNCTIONS +#define LZ4LIB_STATIC_API LZ4LIB_API +#else +#define LZ4LIB_STATIC_API +#endif + +namespace tracy +{ + +/*! LZ4_compress_fast_extState_fastReset() : + * A variant of LZ4_compress_fast_extState(). + * + * Using this variant avoids an expensive initialization step. + * It is only safe to call if the state buffer is known to be correctly initialized already + * (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized"). + * From a high level, the difference is that + * this function initializes the provided state with a call to something like LZ4_resetStream_fast() + * while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream(). + */ +LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); + +/*! LZ4_attach_dictionary() : + * This is an experimental API that allows + * efficient use of a static dictionary many times. + * + * Rather than re-loading the dictionary buffer into a working context before + * each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a + * working LZ4_stream_t, this function introduces a no-copy setup mechanism, + * in which the working stream references the dictionary stream in-place. + * + * Several assumptions are made about the state of the dictionary stream. + * Currently, only streams which have been prepared by LZ4_loadDict() should + * be expected to work. + * + * Alternatively, the provided dictionaryStream may be NULL, + * in which case any existing dictionary stream is unset. + * + * If a dictionary is provided, it replaces any pre-existing stream history. + * The dictionary contents are the only history that can be referenced and + * logically immediately precede the data compressed in the first subsequent + * compression call. + * + * The dictionary will only remain attached to the working stream through the + * first compression call, at the end of which it is cleared. The dictionary + * stream (and source buffer) must remain in-place / accessible / unchanged + * through the completion of the first compression call on the stream. + */ +LZ4LIB_STATIC_API void +LZ4_attach_dictionary(LZ4_stream_t* workingStream, + const LZ4_stream_t* dictionaryStream); + + +/*! In-place compression and decompression + * + * It's possible to have input and output sharing the same buffer, + * for highly constrained memory environments. + * In both cases, it requires input to lay at the end of the buffer, + * and decompression to start at beginning of the buffer. + * Buffer size must feature some margin, hence be larger than final size. + * + * |<------------------------buffer--------------------------------->| + * |<-----------compressed data--------->| + * |<-----------decompressed size------------------>| + * |<----margin---->| + * + * This technique is more useful for decompression, + * since decompressed size is typically larger, + * and margin is short. + * + * In-place decompression will work inside any buffer + * which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize). + * This presumes that decompressedSize > compressedSize. + * Otherwise, it means compression actually expanded data, + * and it would be more efficient to store such data with a flag indicating it's not compressed. + * This can happen when data is not compressible (already compressed, or encrypted). + * + * For in-place compression, margin is larger, as it must be able to cope with both + * history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX, + * and data expansion, which can happen when input is not compressible. + * As a consequence, buffer size requirements are much higher, + * and memory savings offered by in-place compression are more limited. + * + * There are ways to limit this cost for compression : + * - Reduce history size, by modifying LZ4_DISTANCE_MAX. + * Note that it is a compile-time constant, so all compressions will apply this limit. + * Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX, + * so it's a reasonable trick when inputs are known to be small. + * - Require the compressor to deliver a "maximum compressed size". + * This is the `dstCapacity` parameter in `LZ4_compress*()`. + * When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail, + * in which case, the return code will be 0 (zero). + * The caller must be ready for these cases to happen, + * and typically design a backup scheme to send data uncompressed. + * The combination of both techniques can significantly reduce + * the amount of margin required for in-place compression. + * + * In-place compression can work in any buffer + * which size is >= (maxCompressedSize) + * with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success. + * LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX, + * so it's possible to reduce memory requirements by playing with them. + */ + +#define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize) (((compressedSize) >> 8) + 32) +#define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize) ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize)) /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */ + +#ifndef LZ4_DISTANCE_MAX /* history window size; can be user-defined at compile time */ +# define LZ4_DISTANCE_MAX 65535 /* set to maximum value by default */ +#endif + +#define LZ4_COMPRESS_INPLACE_MARGIN (LZ4_DISTANCE_MAX + 32) /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */ +#define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize) ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN) /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */ + +} + +#endif /* LZ4_STATIC_3504398509 */ +#endif /* LZ4_STATIC_LINKING_ONLY */ + + + +#ifndef TRACY_LZ4_H_98237428734687 +#define TRACY_LZ4_H_98237428734687 + +namespace tracy +{ + +/*-************************************************************ + * Private Definitions + ************************************************************** + * Do not use these definitions directly. + * They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`. + * Accessing members will expose user code to API and/or ABI break in future versions of the library. + **************************************************************/ +#define LZ4_HASHLOG (LZ4_MEMORY_USAGE-2) +#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE) +#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG) /* required as macro for static allocation */ + +#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) + typedef int8_t LZ4_i8; + typedef uint8_t LZ4_byte; + typedef uint16_t LZ4_u16; + typedef uint32_t LZ4_u32; +#else + typedef signed char LZ4_i8; + typedef unsigned char LZ4_byte; + typedef unsigned short LZ4_u16; + typedef unsigned int LZ4_u32; +#endif + +/*! LZ4_stream_t : + * Never ever use below internal definitions directly ! + * These definitions are not API/ABI safe, and may change in future versions. + * If you need static allocation, declare or allocate an LZ4_stream_t object. +**/ + +typedef struct LZ4_stream_t_internal LZ4_stream_t_internal; +struct LZ4_stream_t_internal { + LZ4_u32 hashTable[LZ4_HASH_SIZE_U32]; + const LZ4_byte* dictionary; + const LZ4_stream_t_internal* dictCtx; + LZ4_u32 currentOffset; + LZ4_u32 tableType; + LZ4_u32 dictSize; + /* Implicit padding to ensure structure is aligned */ +}; + +#define LZ4_STREAM_MINSIZE ((1UL << LZ4_MEMORY_USAGE) + 32) /* static size, for inter-version compatibility */ +union LZ4_stream_u { + char minStateSize[LZ4_STREAM_MINSIZE]; + LZ4_stream_t_internal internal_donotuse; +}; /* previously typedef'd to LZ4_stream_t */ + + +/*! LZ4_initStream() : v1.9.0+ + * An LZ4_stream_t structure must be initialized at least once. + * This is automatically done when invoking LZ4_createStream(), + * but it's not when the structure is simply declared on stack (for example). + * + * Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t. + * It can also initialize any arbitrary buffer of sufficient size, + * and will @return a pointer of proper type upon initialization. + * + * Note : initialization fails if size and alignment conditions are not respected. + * In which case, the function will @return NULL. + * Note2: An LZ4_stream_t structure guarantees correct alignment and size. + * Note3: Before v1.9.0, use LZ4_resetStream() instead +**/ +LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* buffer, size_t size); + + +/*! LZ4_streamDecode_t : + * Never ever use below internal definitions directly ! + * These definitions are not API/ABI safe, and may change in future versions. + * If you need static allocation, declare or allocate an LZ4_streamDecode_t object. +**/ +typedef struct { + const LZ4_byte* externalDict; + const LZ4_byte* prefixEnd; + size_t extDictSize; + size_t prefixSize; +} LZ4_streamDecode_t_internal; + +#define LZ4_STREAMDECODE_MINSIZE 32 +union LZ4_streamDecode_u { + char minStateSize[LZ4_STREAMDECODE_MINSIZE]; + LZ4_streamDecode_t_internal internal_donotuse; +} ; /* previously typedef'd to LZ4_streamDecode_t */ + + + +/*-************************************ +* Obsolete Functions +**************************************/ + +/*! Deprecation warnings + * + * Deprecated functions make the compiler generate a warning when invoked. + * This is meant to invite users to update their source code. + * Should deprecation warnings be a problem, it is generally possible to disable them, + * typically with -Wno-deprecated-declarations for gcc + * or _CRT_SECURE_NO_WARNINGS in Visual. + * + * Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS + * before including the header file. + */ +#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS +# define LZ4_DEPRECATED(message) /* disable deprecation warnings */ +#else +# if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */ +# define LZ4_DEPRECATED(message) [[deprecated(message)]] +# elif defined(_MSC_VER) +# define LZ4_DEPRECATED(message) __declspec(deprecated(message)) +# elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45)) +# define LZ4_DEPRECATED(message) __attribute__((deprecated(message))) +# elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31) +# define LZ4_DEPRECATED(message) __attribute__((deprecated)) +# else +# pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler") +# define LZ4_DEPRECATED(message) /* disabled */ +# endif +#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */ + +/*! Obsolete compression functions (since v1.7.3) */ +LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress (const char* src, char* dest, int srcSize); +LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress_limitedOutput (const char* src, char* dest, int srcSize, int maxOutputSize); +LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState (void* state, const char* source, char* dest, int inputSize); +LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize); +LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize); +LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize); + +/*! Obsolete decompression functions (since v1.8.0) */ +LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize); +LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); + +/* Obsolete streaming functions (since v1.7.0) + * degraded functionality; do not use! + * + * In order to perform streaming compression, these functions depended on data + * that is no longer tracked in the state. They have been preserved as well as + * possible: using them will still produce a correct output. However, they don't + * actually retain any history between compression calls. The compression ratio + * achieved will therefore be no better than compressing each chunk + * independently. + */ +LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer); +LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int LZ4_sizeofStreamState(void); +LZ4_DEPRECATED("Use LZ4_resetStream() instead") LZ4LIB_API int LZ4_resetStreamState(void* state, char* inputBuffer); +LZ4_DEPRECATED("Use LZ4_saveDict() instead") LZ4LIB_API char* LZ4_slideInputBuffer (void* state); + +/*! Obsolete streaming decoding functions (since v1.7.0) */ +LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize); +LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize); + +/*! Obsolete LZ4_decompress_fast variants (since v1.9.0) : + * These functions used to be faster than LZ4_decompress_safe(), + * but this is no longer the case. They are now slower. + * This is because LZ4_decompress_fast() doesn't know the input size, + * and therefore must progress more cautiously into the input buffer to not read beyond the end of block. + * On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability. + * As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated. + * + * The last remaining LZ4_decompress_fast() specificity is that + * it can decompress a block without knowing its compressed size. + * Such functionality can be achieved in a more secure manner + * by employing LZ4_decompress_safe_partial(). + * + * Parameters: + * originalSize : is the uncompressed size to regenerate. + * `dst` must be already allocated, its size must be >= 'originalSize' bytes. + * @return : number of bytes read from source buffer (== compressed size). + * The function expects to finish at block's end exactly. + * If the source stream is detected malformed, the function stops decoding and returns a negative result. + * note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer. + * However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds. + * Also, since match offsets are not validated, match reads from 'src' may underflow too. + * These issues never happen if input (compressed) data is correct. + * But they may happen if input data is invalid (error or intentional tampering). + * As a consequence, use these functions in trusted environments with trusted data **only**. + */ +LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe() instead") +LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize); +LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_continue() instead") +LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize); +LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_usingDict() instead") +LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize); + +/*! LZ4_resetStream() : + * An LZ4_stream_t structure must be initialized at least once. + * This is done with LZ4_initStream(), or LZ4_resetStream(). + * Consider switching to LZ4_initStream(), + * invoking LZ4_resetStream() will trigger deprecation warnings in the future. + */ +LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr); + +} + +#endif /* LZ4_H_98237428734687 */ diff --git a/Dependencies/tracy/common/tracy_lz4hc.cpp b/Dependencies/tracy/common/tracy_lz4hc.cpp new file mode 100644 index 000000000..eec7239e0 --- /dev/null +++ b/Dependencies/tracy/common/tracy_lz4hc.cpp @@ -0,0 +1,1636 @@ +/* + LZ4 HC - High Compression Mode of LZ4 + Copyright (C) 2011-2020, Yann Collet. + + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 source repository : https://github.com/lz4/lz4 + - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c +*/ +/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */ + + +/* ************************************* +* Tuning Parameter +***************************************/ + +/*! HEAPMODE : + * Select how default compression function will allocate workplace memory, + * in stack (0:fastest), or in heap (1:requires malloc()). + * Since workplace is rather large, heap mode is recommended. +**/ +#ifndef LZ4HC_HEAPMODE +# define LZ4HC_HEAPMODE 1 +#endif + + +/*=== Dependency ===*/ +#define LZ4_HC_STATIC_LINKING_ONLY +#include "tracy_lz4hc.hpp" + + +/*=== Common definitions ===*/ +#if defined(__GNUC__) +# pragma GCC diagnostic ignored "-Wunused-function" +#endif +#if defined (__clang__) +# pragma clang diagnostic ignored "-Wunused-function" +#endif + +#define LZ4_COMMONDEFS_ONLY +#ifndef LZ4_SRC_INCLUDED +#include "tracy_lz4.cpp" /* LZ4_count, constants, mem */ +#endif + + +/*=== Enums ===*/ +typedef enum { noDictCtx, usingDictCtxHc } dictCtx_directive; + + +/*=== Constants ===*/ +#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH) +#define LZ4_OPT_NUM (1<<12) + + +/*=== Macros ===*/ +#define MIN(a,b) ( (a) < (b) ? (a) : (b) ) +#define MAX(a,b) ( (a) > (b) ? (a) : (b) ) +#define HASH_FUNCTION(i) (((i) * 2654435761U) >> ((MINMATCH*8)-LZ4HC_HASH_LOG)) +#define DELTANEXTMAXD(p) chainTable[(p) & LZ4HC_MAXD_MASK] /* flexible, LZ4HC_MAXD dependent */ +#define DELTANEXTU16(table, pos) table[(U16)(pos)] /* faster */ +/* Make fields passed to, and updated by LZ4HC_encodeSequence explicit */ +#define UPDATABLE(ip, op, anchor) &ip, &op, &anchor + +namespace tracy +{ + +static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)); } + + +/************************************** +* HC Compression +**************************************/ +static void LZ4HC_clearTables (LZ4HC_CCtx_internal* hc4) +{ + MEM_INIT(hc4->hashTable, 0, sizeof(hc4->hashTable)); + MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable)); +} + +static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start) +{ + size_t const bufferSize = (size_t)(hc4->end - hc4->prefixStart); + size_t newStartingOffset = bufferSize + hc4->dictLimit; + assert(newStartingOffset >= bufferSize); /* check overflow */ + if (newStartingOffset > 1 GB) { + LZ4HC_clearTables(hc4); + newStartingOffset = 0; + } + newStartingOffset += 64 KB; + hc4->nextToUpdate = (U32)newStartingOffset; + hc4->prefixStart = start; + hc4->end = start; + hc4->dictStart = start; + hc4->dictLimit = (U32)newStartingOffset; + hc4->lowLimit = (U32)newStartingOffset; +} + + +/* Update chains up to ip (excluded) */ +LZ4_FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip) +{ + U16* const chainTable = hc4->chainTable; + U32* const hashTable = hc4->hashTable; + const BYTE* const prefixPtr = hc4->prefixStart; + U32 const prefixIdx = hc4->dictLimit; + U32 const target = (U32)(ip - prefixPtr) + prefixIdx; + U32 idx = hc4->nextToUpdate; + assert(ip >= prefixPtr); + assert(target >= prefixIdx); + + while (idx < target) { + U32 const h = LZ4HC_hashPtr(prefixPtr+idx-prefixIdx); + size_t delta = idx - hashTable[h]; + if (delta>LZ4_DISTANCE_MAX) delta = LZ4_DISTANCE_MAX; + DELTANEXTU16(chainTable, idx) = (U16)delta; + hashTable[h] = idx; + idx++; + } + + hc4->nextToUpdate = target; +} + +/** LZ4HC_countBack() : + * @return : negative value, nb of common bytes before ip/match */ +LZ4_FORCE_INLINE +int LZ4HC_countBack(const BYTE* const ip, const BYTE* const match, + const BYTE* const iMin, const BYTE* const mMin) +{ + int back = 0; + int const min = (int)MAX(iMin - ip, mMin - match); + assert(min <= 0); + assert(ip >= iMin); assert((size_t)(ip-iMin) < (1U<<31)); + assert(match >= mMin); assert((size_t)(match - mMin) < (1U<<31)); + while ( (back > min) + && (ip[back-1] == match[back-1]) ) + back--; + return back; +} + +#if defined(_MSC_VER) +# define LZ4HC_rotl32(x,r) _rotl(x,r) +#else +# define LZ4HC_rotl32(x,r) ((x << r) | (x >> (32 - r))) +#endif + + +static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern) +{ + size_t const bitsToRotate = (rotate & (sizeof(pattern) - 1)) << 3; + if (bitsToRotate == 0) return pattern; + return LZ4HC_rotl32(pattern, (int)bitsToRotate); +} + +/* LZ4HC_countPattern() : + * pattern32 must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!) */ +static unsigned +LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32) +{ + const BYTE* const iStart = ip; + reg_t const pattern = (sizeof(pattern)==8) ? + (reg_t)pattern32 + (((reg_t)pattern32) << (sizeof(pattern)*4)) : pattern32; + + while (likely(ip < iEnd-(sizeof(pattern)-1))) { + reg_t const diff = LZ4_read_ARCH(ip) ^ pattern; + if (!diff) { ip+=sizeof(pattern); continue; } + ip += LZ4_NbCommonBytes(diff); + return (unsigned)(ip - iStart); + } + + if (LZ4_isLittleEndian()) { + reg_t patternByte = pattern; + while ((ip>= 8; + } + } else { /* big endian */ + U32 bitOffset = (sizeof(pattern)*8) - 8; + while (ip < iEnd) { + BYTE const byte = (BYTE)(pattern >> bitOffset); + if (*ip != byte) break; + ip ++; bitOffset -= 8; + } } + + return (unsigned)(ip - iStart); +} + +/* LZ4HC_reverseCountPattern() : + * pattern must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!) + * read using natural platform endianness */ +static unsigned +LZ4HC_reverseCountPattern(const BYTE* ip, const BYTE* const iLow, U32 pattern) +{ + const BYTE* const iStart = ip; + + while (likely(ip >= iLow+4)) { + if (LZ4_read32(ip-4) != pattern) break; + ip -= 4; + } + { const BYTE* bytePtr = (const BYTE*)(&pattern) + 3; /* works for any endianness */ + while (likely(ip>iLow)) { + if (ip[-1] != *bytePtr) break; + ip--; bytePtr--; + } } + return (unsigned)(iStart - ip); +} + +/* LZ4HC_protectDictEnd() : + * Checks if the match is in the last 3 bytes of the dictionary, so reading the + * 4 byte MINMATCH would overflow. + * @returns true if the match index is okay. + */ +static int LZ4HC_protectDictEnd(U32 const dictLimit, U32 const matchIndex) +{ + return ((U32)((dictLimit - 1) - matchIndex) >= 3); +} + +typedef enum { rep_untested, rep_not, rep_confirmed } repeat_state_e; +typedef enum { favorCompressionRatio=0, favorDecompressionSpeed } HCfavor_e; + +LZ4_FORCE_INLINE int +LZ4HC_InsertAndGetWiderMatch ( + LZ4HC_CCtx_internal* const hc4, + const BYTE* const ip, + const BYTE* const iLowLimit, const BYTE* const iHighLimit, + int longest, + const BYTE** matchpos, + const BYTE** startpos, + const int maxNbAttempts, + const int patternAnalysis, const int chainSwap, + const dictCtx_directive dict, + const HCfavor_e favorDecSpeed) +{ + U16* const chainTable = hc4->chainTable; + U32* const HashTable = hc4->hashTable; + const LZ4HC_CCtx_internal * const dictCtx = hc4->dictCtx; + const BYTE* const prefixPtr = hc4->prefixStart; + const U32 prefixIdx = hc4->dictLimit; + const U32 ipIndex = (U32)(ip - prefixPtr) + prefixIdx; + const int withinStartDistance = (hc4->lowLimit + (LZ4_DISTANCE_MAX + 1) > ipIndex); + const U32 lowestMatchIndex = (withinStartDistance) ? hc4->lowLimit : ipIndex - LZ4_DISTANCE_MAX; + const BYTE* const dictStart = hc4->dictStart; + const U32 dictIdx = hc4->lowLimit; + const BYTE* const dictEnd = dictStart + prefixIdx - dictIdx; + int const lookBackLength = (int)(ip-iLowLimit); + int nbAttempts = maxNbAttempts; + U32 matchChainPos = 0; + U32 const pattern = LZ4_read32(ip); + U32 matchIndex; + repeat_state_e repeat = rep_untested; + size_t srcPatternLength = 0; + + DEBUGLOG(7, "LZ4HC_InsertAndGetWiderMatch"); + /* First Match */ + LZ4HC_Insert(hc4, ip); + matchIndex = HashTable[LZ4HC_hashPtr(ip)]; + DEBUGLOG(7, "First match at index %u / %u (lowestMatchIndex)", + matchIndex, lowestMatchIndex); + + while ((matchIndex>=lowestMatchIndex) && (nbAttempts>0)) { + int matchLength=0; + nbAttempts--; + assert(matchIndex < ipIndex); + if (favorDecSpeed && (ipIndex - matchIndex < 8)) { + /* do nothing */ + } else if (matchIndex >= prefixIdx) { /* within current Prefix */ + const BYTE* const matchPtr = prefixPtr + matchIndex - prefixIdx; + assert(matchPtr < ip); + assert(longest >= 1); + if (LZ4_read16(iLowLimit + longest - 1) == LZ4_read16(matchPtr - lookBackLength + longest - 1)) { + if (LZ4_read32(matchPtr) == pattern) { + int const back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, prefixPtr) : 0; + matchLength = MINMATCH + (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, iHighLimit); + matchLength -= back; + if (matchLength > longest) { + longest = matchLength; + *matchpos = matchPtr + back; + *startpos = ip + back; + } } } + } else { /* lowestMatchIndex <= matchIndex < dictLimit */ + const BYTE* const matchPtr = dictStart + (matchIndex - dictIdx); + assert(matchIndex >= dictIdx); + if ( likely(matchIndex <= prefixIdx - 4) + && (LZ4_read32(matchPtr) == pattern) ) { + int back = 0; + const BYTE* vLimit = ip + (prefixIdx - matchIndex); + if (vLimit > iHighLimit) vLimit = iHighLimit; + matchLength = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH; + if ((ip+matchLength == vLimit) && (vLimit < iHighLimit)) + matchLength += LZ4_count(ip+matchLength, prefixPtr, iHighLimit); + back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictStart) : 0; + matchLength -= back; + if (matchLength > longest) { + longest = matchLength; + *matchpos = prefixPtr - prefixIdx + matchIndex + back; /* virtual pos, relative to ip, to retrieve offset */ + *startpos = ip + back; + } } } + + if (chainSwap && matchLength==longest) { /* better match => select a better chain */ + assert(lookBackLength==0); /* search forward only */ + if (matchIndex + (U32)longest <= ipIndex) { + int const kTrigger = 4; + U32 distanceToNextMatch = 1; + int const end = longest - MINMATCH + 1; + int step = 1; + int accel = 1 << kTrigger; + int pos; + for (pos = 0; pos < end; pos += step) { + U32 const candidateDist = DELTANEXTU16(chainTable, matchIndex + (U32)pos); + step = (accel++ >> kTrigger); + if (candidateDist > distanceToNextMatch) { + distanceToNextMatch = candidateDist; + matchChainPos = (U32)pos; + accel = 1 << kTrigger; + } } + if (distanceToNextMatch > 1) { + if (distanceToNextMatch > matchIndex) break; /* avoid overflow */ + matchIndex -= distanceToNextMatch; + continue; + } } } + + { U32 const distNextMatch = DELTANEXTU16(chainTable, matchIndex); + if (patternAnalysis && distNextMatch==1 && matchChainPos==0) { + U32 const matchCandidateIdx = matchIndex-1; + /* may be a repeated pattern */ + if (repeat == rep_untested) { + if ( ((pattern & 0xFFFF) == (pattern >> 16)) + & ((pattern & 0xFF) == (pattern >> 24)) ) { + repeat = rep_confirmed; + srcPatternLength = LZ4HC_countPattern(ip+sizeof(pattern), iHighLimit, pattern) + sizeof(pattern); + } else { + repeat = rep_not; + } } + if ( (repeat == rep_confirmed) && (matchCandidateIdx >= lowestMatchIndex) + && LZ4HC_protectDictEnd(prefixIdx, matchCandidateIdx) ) { + const int extDict = matchCandidateIdx < prefixIdx; + const BYTE* const matchPtr = (extDict ? dictStart - dictIdx : prefixPtr - prefixIdx) + matchCandidateIdx; + if (LZ4_read32(matchPtr) == pattern) { /* good candidate */ + const BYTE* const iLimit = extDict ? dictEnd : iHighLimit; + size_t forwardPatternLength = LZ4HC_countPattern(matchPtr+sizeof(pattern), iLimit, pattern) + sizeof(pattern); + if (extDict && matchPtr + forwardPatternLength == iLimit) { + U32 const rotatedPattern = LZ4HC_rotatePattern(forwardPatternLength, pattern); + forwardPatternLength += LZ4HC_countPattern(prefixPtr, iHighLimit, rotatedPattern); + } + { const BYTE* const lowestMatchPtr = extDict ? dictStart : prefixPtr; + size_t backLength = LZ4HC_reverseCountPattern(matchPtr, lowestMatchPtr, pattern); + size_t currentSegmentLength; + if (!extDict + && matchPtr - backLength == prefixPtr + && dictIdx < prefixIdx) { + U32 const rotatedPattern = LZ4HC_rotatePattern((U32)(-(int)backLength), pattern); + backLength += LZ4HC_reverseCountPattern(dictEnd, dictStart, rotatedPattern); + } + /* Limit backLength not go further than lowestMatchIndex */ + backLength = matchCandidateIdx - MAX(matchCandidateIdx - (U32)backLength, lowestMatchIndex); + assert(matchCandidateIdx - backLength >= lowestMatchIndex); + currentSegmentLength = backLength + forwardPatternLength; + /* Adjust to end of pattern if the source pattern fits, otherwise the beginning of the pattern */ + if ( (currentSegmentLength >= srcPatternLength) /* current pattern segment large enough to contain full srcPatternLength */ + && (forwardPatternLength <= srcPatternLength) ) { /* haven't reached this position yet */ + U32 const newMatchIndex = matchCandidateIdx + (U32)forwardPatternLength - (U32)srcPatternLength; /* best position, full pattern, might be followed by more match */ + if (LZ4HC_protectDictEnd(prefixIdx, newMatchIndex)) + matchIndex = newMatchIndex; + else { + /* Can only happen if started in the prefix */ + assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict); + matchIndex = prefixIdx; + } + } else { + U32 const newMatchIndex = matchCandidateIdx - (U32)backLength; /* farthest position in current segment, will find a match of length currentSegmentLength + maybe some back */ + if (!LZ4HC_protectDictEnd(prefixIdx, newMatchIndex)) { + assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict); + matchIndex = prefixIdx; + } else { + matchIndex = newMatchIndex; + if (lookBackLength==0) { /* no back possible */ + size_t const maxML = MIN(currentSegmentLength, srcPatternLength); + if ((size_t)longest < maxML) { + assert(prefixPtr - prefixIdx + matchIndex != ip); + if ((size_t)(ip - prefixPtr) + prefixIdx - matchIndex > LZ4_DISTANCE_MAX) break; + assert(maxML < 2 GB); + longest = (int)maxML; + *matchpos = prefixPtr - prefixIdx + matchIndex; /* virtual pos, relative to ip, to retrieve offset */ + *startpos = ip; + } + { U32 const distToNextPattern = DELTANEXTU16(chainTable, matchIndex); + if (distToNextPattern > matchIndex) break; /* avoid overflow */ + matchIndex -= distToNextPattern; + } } } } } + continue; + } } + } } /* PA optimization */ + + /* follow current chain */ + matchIndex -= DELTANEXTU16(chainTable, matchIndex + matchChainPos); + + } /* while ((matchIndex>=lowestMatchIndex) && (nbAttempts)) */ + + if ( dict == usingDictCtxHc + && nbAttempts > 0 + && ipIndex - lowestMatchIndex < LZ4_DISTANCE_MAX) { + size_t const dictEndOffset = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit; + U32 dictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)]; + assert(dictEndOffset <= 1 GB); + matchIndex = dictMatchIndex + lowestMatchIndex - (U32)dictEndOffset; + while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) { + const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + dictMatchIndex; + + if (LZ4_read32(matchPtr) == pattern) { + int mlt; + int back = 0; + const BYTE* vLimit = ip + (dictEndOffset - dictMatchIndex); + if (vLimit > iHighLimit) vLimit = iHighLimit; + mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH; + back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->prefixStart) : 0; + mlt -= back; + if (mlt > longest) { + longest = mlt; + *matchpos = prefixPtr - prefixIdx + matchIndex + back; + *startpos = ip + back; + } } + + { U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, dictMatchIndex); + dictMatchIndex -= nextOffset; + matchIndex -= nextOffset; + } } } + + return longest; +} + +LZ4_FORCE_INLINE int +LZ4HC_InsertAndFindBestMatch(LZ4HC_CCtx_internal* const hc4, /* Index table will be updated */ + const BYTE* const ip, const BYTE* const iLimit, + const BYTE** matchpos, + const int maxNbAttempts, + const int patternAnalysis, + const dictCtx_directive dict) +{ + const BYTE* uselessPtr = ip; + /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos), + * but this won't be the case here, as we define iLowLimit==ip, + * so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */ + return LZ4HC_InsertAndGetWiderMatch(hc4, ip, ip, iLimit, MINMATCH-1, matchpos, &uselessPtr, maxNbAttempts, patternAnalysis, 0 /*chainSwap*/, dict, favorCompressionRatio); +} + +/* LZ4HC_encodeSequence() : + * @return : 0 if ok, + * 1 if buffer issue detected */ +LZ4_FORCE_INLINE int LZ4HC_encodeSequence ( + const BYTE** _ip, + BYTE** _op, + const BYTE** _anchor, + int matchLength, + const BYTE* const match, + limitedOutput_directive limit, + BYTE* oend) +{ +#define ip (*_ip) +#define op (*_op) +#define anchor (*_anchor) + + size_t length; + BYTE* const token = op++; + +#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 6) + static const BYTE* start = NULL; + static U32 totalCost = 0; + U32 const pos = (start==NULL) ? 0 : (U32)(anchor - start); + U32 const ll = (U32)(ip - anchor); + U32 const llAdd = (ll>=15) ? ((ll-15) / 255) + 1 : 0; + U32 const mlAdd = (matchLength>=19) ? ((matchLength-19) / 255) + 1 : 0; + U32 const cost = 1 + llAdd + ll + 2 + mlAdd; + if (start==NULL) start = anchor; /* only works for single segment */ + /* g_debuglog_enable = (pos >= 2228) & (pos <= 2262); */ + DEBUGLOG(6, "pos:%7u -- literals:%4u, match:%4i, offset:%5u, cost:%4u + %5u", + pos, + (U32)(ip - anchor), matchLength, (U32)(ip-match), + cost, totalCost); + totalCost += cost; +#endif + + /* Encode Literal length */ + length = (size_t)(ip - anchor); + LZ4_STATIC_ASSERT(notLimited == 0); + /* Check output limit */ + if (limit && ((op + (length / 255) + length + (2 + 1 + LASTLITERALS)) > oend)) { + DEBUGLOG(6, "Not enough room to write %i literals (%i bytes remaining)", + (int)length, (int)(oend - op)); + return 1; + } + if (length >= RUN_MASK) { + size_t len = length - RUN_MASK; + *token = (RUN_MASK << ML_BITS); + for(; len >= 255 ; len -= 255) *op++ = 255; + *op++ = (BYTE)len; + } else { + *token = (BYTE)(length << ML_BITS); + } + + /* Copy Literals */ + LZ4_wildCopy8(op, anchor, op + length); + op += length; + + /* Encode Offset */ + assert( (ip - match) <= LZ4_DISTANCE_MAX ); /* note : consider providing offset as a value, rather than as a pointer difference */ + LZ4_writeLE16(op, (U16)(ip - match)); op += 2; + + /* Encode MatchLength */ + assert(matchLength >= MINMATCH); + length = (size_t)matchLength - MINMATCH; + if (limit && (op + (length / 255) + (1 + LASTLITERALS) > oend)) { + DEBUGLOG(6, "Not enough room to write match length"); + return 1; /* Check output limit */ + } + if (length >= ML_MASK) { + *token += ML_MASK; + length -= ML_MASK; + for(; length >= 510 ; length -= 510) { *op++ = 255; *op++ = 255; } + if (length >= 255) { length -= 255; *op++ = 255; } + *op++ = (BYTE)length; + } else { + *token += (BYTE)(length); + } + + /* Prepare next loop */ + ip += matchLength; + anchor = ip; + + return 0; +} +#undef ip +#undef op +#undef anchor + +LZ4_FORCE_INLINE int LZ4HC_compress_hashChain ( + LZ4HC_CCtx_internal* const ctx, + const char* const source, + char* const dest, + int* srcSizePtr, + int const maxOutputSize, + int maxNbAttempts, + const limitedOutput_directive limit, + const dictCtx_directive dict + ) +{ + const int inputSize = *srcSizePtr; + const int patternAnalysis = (maxNbAttempts > 128); /* levels 9+ */ + + const BYTE* ip = (const BYTE*) source; + const BYTE* anchor = ip; + const BYTE* const iend = ip + inputSize; + const BYTE* const mflimit = iend - MFLIMIT; + const BYTE* const matchlimit = (iend - LASTLITERALS); + + BYTE* optr = (BYTE*) dest; + BYTE* op = (BYTE*) dest; + BYTE* oend = op + maxOutputSize; + + int ml0, ml, ml2, ml3; + const BYTE* start0; + const BYTE* ref0; + const BYTE* ref = NULL; + const BYTE* start2 = NULL; + const BYTE* ref2 = NULL; + const BYTE* start3 = NULL; + const BYTE* ref3 = NULL; + + /* init */ + *srcSizePtr = 0; + if (limit == fillOutput) oend -= LASTLITERALS; /* Hack for support LZ4 format restriction */ + if (inputSize < LZ4_minLength) goto _last_literals; /* Input too small, no compression (all literals) */ + + /* Main Loop */ + while (ip <= mflimit) { + ml = LZ4HC_InsertAndFindBestMatch(ctx, ip, matchlimit, &ref, maxNbAttempts, patternAnalysis, dict); + if (ml encode ML1 */ + optr = op; + if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow; + continue; + } + + if (start0 < ip) { /* first match was skipped at least once */ + if (start2 < ip + ml0) { /* squeezing ML1 between ML0(original ML1) and ML2 */ + ip = start0; ref = ref0; ml = ml0; /* restore initial ML1 */ + } } + + /* Here, start0==ip */ + if ((start2 - ip) < 3) { /* First Match too small : removed */ + ml = ml2; + ip = start2; + ref =ref2; + goto _Search2; + } + +_Search3: + /* At this stage, we have : + * ml2 > ml1, and + * ip1+3 <= ip2 (usually < ip1+ml1) */ + if ((start2 - ip) < OPTIMAL_ML) { + int correction; + int new_ml = ml; + if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML; + if (ip+new_ml > start2 + ml2 - MINMATCH) new_ml = (int)(start2 - ip) + ml2 - MINMATCH; + correction = new_ml - (int)(start2 - ip); + if (correction > 0) { + start2 += correction; + ref2 += correction; + ml2 -= correction; + } + } + /* Now, we have start2 = ip+new_ml, with new_ml = min(ml, OPTIMAL_ML=18) */ + + if (start2 + ml2 <= mflimit) { + ml3 = LZ4HC_InsertAndGetWiderMatch(ctx, + start2 + ml2 - 3, start2, matchlimit, ml2, &ref3, &start3, + maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio); + } else { + ml3 = ml2; + } + + if (ml3 == ml2) { /* No better match => encode ML1 and ML2 */ + /* ip & ref are known; Now for ml */ + if (start2 < ip+ml) ml = (int)(start2 - ip); + /* Now, encode 2 sequences */ + optr = op; + if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow; + ip = start2; + optr = op; + if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml2, ref2, limit, oend)) { + ml = ml2; + ref = ref2; + goto _dest_overflow; + } + continue; + } + + if (start3 < ip+ml+3) { /* Not enough space for match 2 : remove it */ + if (start3 >= (ip+ml)) { /* can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 */ + if (start2 < ip+ml) { + int correction = (int)(ip+ml - start2); + start2 += correction; + ref2 += correction; + ml2 -= correction; + if (ml2 < MINMATCH) { + start2 = start3; + ref2 = ref3; + ml2 = ml3; + } + } + + optr = op; + if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow; + ip = start3; + ref = ref3; + ml = ml3; + + start0 = start2; + ref0 = ref2; + ml0 = ml2; + goto _Search2; + } + + start2 = start3; + ref2 = ref3; + ml2 = ml3; + goto _Search3; + } + + /* + * OK, now we have 3 ascending matches; + * let's write the first one ML1. + * ip & ref are known; Now decide ml. + */ + if (start2 < ip+ml) { + if ((start2 - ip) < OPTIMAL_ML) { + int correction; + if (ml > OPTIMAL_ML) ml = OPTIMAL_ML; + if (ip + ml > start2 + ml2 - MINMATCH) ml = (int)(start2 - ip) + ml2 - MINMATCH; + correction = ml - (int)(start2 - ip); + if (correction > 0) { + start2 += correction; + ref2 += correction; + ml2 -= correction; + } + } else { + ml = (int)(start2 - ip); + } + } + optr = op; + if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow; + + /* ML2 becomes ML1 */ + ip = start2; ref = ref2; ml = ml2; + + /* ML3 becomes ML2 */ + start2 = start3; ref2 = ref3; ml2 = ml3; + + /* let's find a new ML3 */ + goto _Search3; + } + +_last_literals: + /* Encode Last Literals */ + { size_t lastRunSize = (size_t)(iend - anchor); /* literals */ + size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255; + size_t const totalSize = 1 + llAdd + lastRunSize; + if (limit == fillOutput) oend += LASTLITERALS; /* restore correct value */ + if (limit && (op + totalSize > oend)) { + if (limit == limitedOutput) return 0; + /* adapt lastRunSize to fill 'dest' */ + lastRunSize = (size_t)(oend - op) - 1 /*token*/; + llAdd = (lastRunSize + 256 - RUN_MASK) / 256; + lastRunSize -= llAdd; + } + DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize); + ip = anchor + lastRunSize; /* can be != iend if limit==fillOutput */ + + if (lastRunSize >= RUN_MASK) { + size_t accumulator = lastRunSize - RUN_MASK; + *op++ = (RUN_MASK << ML_BITS); + for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255; + *op++ = (BYTE) accumulator; + } else { + *op++ = (BYTE)(lastRunSize << ML_BITS); + } + LZ4_memcpy(op, anchor, lastRunSize); + op += lastRunSize; + } + + /* End */ + *srcSizePtr = (int) (((const char*)ip) - source); + return (int) (((char*)op)-dest); + +_dest_overflow: + if (limit == fillOutput) { + /* Assumption : ip, anchor, ml and ref must be set correctly */ + size_t const ll = (size_t)(ip - anchor); + size_t const ll_addbytes = (ll + 240) / 255; + size_t const ll_totalCost = 1 + ll_addbytes + ll; + BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */ + DEBUGLOG(6, "Last sequence overflowing"); + op = optr; /* restore correct out pointer */ + if (op + ll_totalCost <= maxLitPos) { + /* ll validated; now adjust match length */ + size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost)); + size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255); + assert(maxMlSize < INT_MAX); assert(ml >= 0); + if ((size_t)ml > maxMlSize) ml = (int)maxMlSize; + if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + ml >= MFLIMIT) { + LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, notLimited, oend); + } } + goto _last_literals; + } + /* compression failed */ + return 0; +} + + +static int LZ4HC_compress_optimal( LZ4HC_CCtx_internal* ctx, + const char* const source, char* dst, + int* srcSizePtr, int dstCapacity, + int const nbSearches, size_t sufficient_len, + const limitedOutput_directive limit, int const fullUpdate, + const dictCtx_directive dict, + const HCfavor_e favorDecSpeed); + + +LZ4_FORCE_INLINE int LZ4HC_compress_generic_internal ( + LZ4HC_CCtx_internal* const ctx, + const char* const src, + char* const dst, + int* const srcSizePtr, + int const dstCapacity, + int cLevel, + const limitedOutput_directive limit, + const dictCtx_directive dict + ) +{ + typedef enum { lz4hc, lz4opt } lz4hc_strat_e; + typedef struct { + lz4hc_strat_e strat; + int nbSearches; + U32 targetLength; + } cParams_t; + static const cParams_t clTable[LZ4HC_CLEVEL_MAX+1] = { + { lz4hc, 2, 16 }, /* 0, unused */ + { lz4hc, 2, 16 }, /* 1, unused */ + { lz4hc, 2, 16 }, /* 2, unused */ + { lz4hc, 4, 16 }, /* 3 */ + { lz4hc, 8, 16 }, /* 4 */ + { lz4hc, 16, 16 }, /* 5 */ + { lz4hc, 32, 16 }, /* 6 */ + { lz4hc, 64, 16 }, /* 7 */ + { lz4hc, 128, 16 }, /* 8 */ + { lz4hc, 256, 16 }, /* 9 */ + { lz4opt, 96, 64 }, /*10==LZ4HC_CLEVEL_OPT_MIN*/ + { lz4opt, 512,128 }, /*11 */ + { lz4opt,16384,LZ4_OPT_NUM }, /* 12==LZ4HC_CLEVEL_MAX */ + }; + + DEBUGLOG(4, "LZ4HC_compress_generic(ctx=%p, src=%p, srcSize=%d, limit=%d)", + ctx, src, *srcSizePtr, limit); + + if (limit == fillOutput && dstCapacity < 1) return 0; /* Impossible to store anything */ + if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0; /* Unsupported input size (too large or negative) */ + + ctx->end += *srcSizePtr; + if (cLevel < 1) cLevel = LZ4HC_CLEVEL_DEFAULT; /* note : convention is different from lz4frame, maybe something to review */ + cLevel = MIN(LZ4HC_CLEVEL_MAX, cLevel); + { cParams_t const cParam = clTable[cLevel]; + HCfavor_e const favor = ctx->favorDecSpeed ? favorDecompressionSpeed : favorCompressionRatio; + int result; + + if (cParam.strat == lz4hc) { + result = LZ4HC_compress_hashChain(ctx, + src, dst, srcSizePtr, dstCapacity, + cParam.nbSearches, limit, dict); + } else { + assert(cParam.strat == lz4opt); + result = LZ4HC_compress_optimal(ctx, + src, dst, srcSizePtr, dstCapacity, + cParam.nbSearches, cParam.targetLength, limit, + cLevel == LZ4HC_CLEVEL_MAX, /* ultra mode */ + dict, favor); + } + if (result <= 0) ctx->dirty = 1; + return result; + } +} + +static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock); + +static int +LZ4HC_compress_generic_noDictCtx ( + LZ4HC_CCtx_internal* const ctx, + const char* const src, + char* const dst, + int* const srcSizePtr, + int const dstCapacity, + int cLevel, + limitedOutput_directive limit + ) +{ + assert(ctx->dictCtx == NULL); + return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, noDictCtx); +} + +static int +LZ4HC_compress_generic_dictCtx ( + LZ4HC_CCtx_internal* const ctx, + const char* const src, + char* const dst, + int* const srcSizePtr, + int const dstCapacity, + int cLevel, + limitedOutput_directive limit + ) +{ + const size_t position = (size_t)(ctx->end - ctx->prefixStart) + (ctx->dictLimit - ctx->lowLimit); + assert(ctx->dictCtx != NULL); + if (position >= 64 KB) { + ctx->dictCtx = NULL; + return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit); + } else if (position == 0 && *srcSizePtr > 4 KB) { + LZ4_memcpy(ctx, ctx->dictCtx, sizeof(LZ4HC_CCtx_internal)); + LZ4HC_setExternalDict(ctx, (const BYTE *)src); + ctx->compressionLevel = (short)cLevel; + return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit); + } else { + return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, usingDictCtxHc); + } +} + +static int +LZ4HC_compress_generic ( + LZ4HC_CCtx_internal* const ctx, + const char* const src, + char* const dst, + int* const srcSizePtr, + int const dstCapacity, + int cLevel, + limitedOutput_directive limit + ) +{ + if (ctx->dictCtx == NULL) { + return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit); + } else { + return LZ4HC_compress_generic_dictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit); + } +} + + +int LZ4_sizeofStateHC(void) { return (int)sizeof(LZ4_streamHC_t); } + +static size_t LZ4_streamHC_t_alignment(void) +{ +#if LZ4_ALIGN_TEST + typedef struct { char c; LZ4_streamHC_t t; } t_a; + return sizeof(t_a) - sizeof(LZ4_streamHC_t); +#else + return 1; /* effectively disabled */ +#endif +} + +/* state is presumed correctly initialized, + * in which case its size and alignment have already been validate */ +int LZ4_compress_HC_extStateHC_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel) +{ + LZ4HC_CCtx_internal* const ctx = &((LZ4_streamHC_t*)state)->internal_donotuse; + if (!LZ4_isAligned(state, LZ4_streamHC_t_alignment())) return 0; + LZ4_resetStreamHC_fast((LZ4_streamHC_t*)state, compressionLevel); + LZ4HC_init_internal (ctx, (const BYTE*)src); + if (dstCapacity < LZ4_compressBound(srcSize)) + return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, limitedOutput); + else + return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, notLimited); +} + +int LZ4_compress_HC_extStateHC (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel) +{ + LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx)); + if (ctx==NULL) return 0; /* init failure */ + return LZ4_compress_HC_extStateHC_fastReset(state, src, dst, srcSize, dstCapacity, compressionLevel); +} + +int LZ4_compress_HC(const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel) +{ + int cSize; +#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1 + LZ4_streamHC_t* const statePtr = (LZ4_streamHC_t*)ALLOC(sizeof(LZ4_streamHC_t)); + if (statePtr==NULL) return 0; +#else + LZ4_streamHC_t state; + LZ4_streamHC_t* const statePtr = &state; +#endif + cSize = LZ4_compress_HC_extStateHC(statePtr, src, dst, srcSize, dstCapacity, compressionLevel); +#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1 + FREEMEM(statePtr); +#endif + return cSize; +} + +/* state is presumed sized correctly (>= sizeof(LZ4_streamHC_t)) */ +int LZ4_compress_HC_destSize(void* state, const char* source, char* dest, int* sourceSizePtr, int targetDestSize, int cLevel) +{ + LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx)); + if (ctx==NULL) return 0; /* init failure */ + LZ4HC_init_internal(&ctx->internal_donotuse, (const BYTE*) source); + LZ4_setCompressionLevel(ctx, cLevel); + return LZ4HC_compress_generic(&ctx->internal_donotuse, source, dest, sourceSizePtr, targetDestSize, cLevel, fillOutput); +} + + + +/************************************** +* Streaming Functions +**************************************/ +/* allocation */ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +LZ4_streamHC_t* LZ4_createStreamHC(void) +{ + LZ4_streamHC_t* const state = + (LZ4_streamHC_t*)ALLOC_AND_ZERO(sizeof(LZ4_streamHC_t)); + if (state == NULL) return NULL; + LZ4_setCompressionLevel(state, LZ4HC_CLEVEL_DEFAULT); + return state; +} + +int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr) +{ + DEBUGLOG(4, "LZ4_freeStreamHC(%p)", LZ4_streamHCPtr); + if (!LZ4_streamHCPtr) return 0; /* support free on NULL */ + FREEMEM(LZ4_streamHCPtr); + return 0; +} +#endif + + +LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size) +{ + LZ4_streamHC_t* const LZ4_streamHCPtr = (LZ4_streamHC_t*)buffer; + DEBUGLOG(4, "LZ4_initStreamHC(%p, %u)", buffer, (unsigned)size); + /* check conditions */ + if (buffer == NULL) return NULL; + if (size < sizeof(LZ4_streamHC_t)) return NULL; + if (!LZ4_isAligned(buffer, LZ4_streamHC_t_alignment())) return NULL; + /* init */ + { LZ4HC_CCtx_internal* const hcstate = &(LZ4_streamHCPtr->internal_donotuse); + MEM_INIT(hcstate, 0, sizeof(*hcstate)); } + LZ4_setCompressionLevel(LZ4_streamHCPtr, LZ4HC_CLEVEL_DEFAULT); + return LZ4_streamHCPtr; +} + +/* just a stub */ +void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel) +{ + LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr)); + LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel); +} + +void LZ4_resetStreamHC_fast (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel) +{ + DEBUGLOG(4, "LZ4_resetStreamHC_fast(%p, %d)", LZ4_streamHCPtr, compressionLevel); + if (LZ4_streamHCPtr->internal_donotuse.dirty) { + LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr)); + } else { + /* preserve end - prefixStart : can trigger clearTable's threshold */ + if (LZ4_streamHCPtr->internal_donotuse.end != NULL) { + LZ4_streamHCPtr->internal_donotuse.end -= (uptrval)LZ4_streamHCPtr->internal_donotuse.prefixStart; + } else { + assert(LZ4_streamHCPtr->internal_donotuse.prefixStart == NULL); + } + LZ4_streamHCPtr->internal_donotuse.prefixStart = NULL; + LZ4_streamHCPtr->internal_donotuse.dictCtx = NULL; + } + LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel); +} + +void LZ4_setCompressionLevel(LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel) +{ + DEBUGLOG(5, "LZ4_setCompressionLevel(%p, %d)", LZ4_streamHCPtr, compressionLevel); + if (compressionLevel < 1) compressionLevel = LZ4HC_CLEVEL_DEFAULT; + if (compressionLevel > LZ4HC_CLEVEL_MAX) compressionLevel = LZ4HC_CLEVEL_MAX; + LZ4_streamHCPtr->internal_donotuse.compressionLevel = (short)compressionLevel; +} + +void LZ4_favorDecompressionSpeed(LZ4_streamHC_t* LZ4_streamHCPtr, int favor) +{ + LZ4_streamHCPtr->internal_donotuse.favorDecSpeed = (favor!=0); +} + +/* LZ4_loadDictHC() : + * LZ4_streamHCPtr is presumed properly initialized */ +int LZ4_loadDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, + const char* dictionary, int dictSize) +{ + LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse; + DEBUGLOG(4, "LZ4_loadDictHC(ctx:%p, dict:%p, dictSize:%d)", LZ4_streamHCPtr, dictionary, dictSize); + assert(LZ4_streamHCPtr != NULL); + if (dictSize > 64 KB) { + dictionary += (size_t)dictSize - 64 KB; + dictSize = 64 KB; + } + /* need a full initialization, there are bad side-effects when using resetFast() */ + { int const cLevel = ctxPtr->compressionLevel; + LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr)); + LZ4_setCompressionLevel(LZ4_streamHCPtr, cLevel); + } + LZ4HC_init_internal (ctxPtr, (const BYTE*)dictionary); + ctxPtr->end = (const BYTE*)dictionary + dictSize; + if (dictSize >= 4) LZ4HC_Insert (ctxPtr, ctxPtr->end-3); + return dictSize; +} + +void LZ4_attach_HC_dictionary(LZ4_streamHC_t *working_stream, const LZ4_streamHC_t *dictionary_stream) { + working_stream->internal_donotuse.dictCtx = dictionary_stream != NULL ? &(dictionary_stream->internal_donotuse) : NULL; +} + +/* compression */ + +static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock) +{ + DEBUGLOG(4, "LZ4HC_setExternalDict(%p, %p)", ctxPtr, newBlock); + if (ctxPtr->end >= ctxPtr->prefixStart + 4) + LZ4HC_Insert (ctxPtr, ctxPtr->end-3); /* Referencing remaining dictionary content */ + + /* Only one memory segment for extDict, so any previous extDict is lost at this stage */ + ctxPtr->lowLimit = ctxPtr->dictLimit; + ctxPtr->dictStart = ctxPtr->prefixStart; + ctxPtr->dictLimit += (U32)(ctxPtr->end - ctxPtr->prefixStart); + ctxPtr->prefixStart = newBlock; + ctxPtr->end = newBlock; + ctxPtr->nextToUpdate = ctxPtr->dictLimit; /* match referencing will resume from there */ + + /* cannot reference an extDict and a dictCtx at the same time */ + ctxPtr->dictCtx = NULL; +} + +static int +LZ4_compressHC_continue_generic (LZ4_streamHC_t* LZ4_streamHCPtr, + const char* src, char* dst, + int* srcSizePtr, int dstCapacity, + limitedOutput_directive limit) +{ + LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse; + DEBUGLOG(5, "LZ4_compressHC_continue_generic(ctx=%p, src=%p, srcSize=%d, limit=%d)", + LZ4_streamHCPtr, src, *srcSizePtr, limit); + assert(ctxPtr != NULL); + /* auto-init if forgotten */ + if (ctxPtr->prefixStart == NULL) LZ4HC_init_internal (ctxPtr, (const BYTE*) src); + + /* Check overflow */ + if ((size_t)(ctxPtr->end - ctxPtr->prefixStart) + ctxPtr->dictLimit > 2 GB) { + size_t dictSize = (size_t)(ctxPtr->end - ctxPtr->prefixStart); + if (dictSize > 64 KB) dictSize = 64 KB; + LZ4_loadDictHC(LZ4_streamHCPtr, (const char*)(ctxPtr->end) - dictSize, (int)dictSize); + } + + /* Check if blocks follow each other */ + if ((const BYTE*)src != ctxPtr->end) + LZ4HC_setExternalDict(ctxPtr, (const BYTE*)src); + + /* Check overlapping input/dictionary space */ + { const BYTE* sourceEnd = (const BYTE*) src + *srcSizePtr; + const BYTE* const dictBegin = ctxPtr->dictStart; + const BYTE* const dictEnd = ctxPtr->dictStart + (ctxPtr->dictLimit - ctxPtr->lowLimit); + if ((sourceEnd > dictBegin) && ((const BYTE*)src < dictEnd)) { + if (sourceEnd > dictEnd) sourceEnd = dictEnd; + ctxPtr->lowLimit += (U32)(sourceEnd - ctxPtr->dictStart); + ctxPtr->dictStart += (U32)(sourceEnd - ctxPtr->dictStart); + if (ctxPtr->dictLimit - ctxPtr->lowLimit < 4) { + ctxPtr->lowLimit = ctxPtr->dictLimit; + ctxPtr->dictStart = ctxPtr->prefixStart; + } } } + + return LZ4HC_compress_generic (ctxPtr, src, dst, srcSizePtr, dstCapacity, ctxPtr->compressionLevel, limit); +} + +int LZ4_compress_HC_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int srcSize, int dstCapacity) +{ + if (dstCapacity < LZ4_compressBound(srcSize)) + return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, limitedOutput); + else + return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, notLimited); +} + +int LZ4_compress_HC_continue_destSize (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int* srcSizePtr, int targetDestSize) +{ + return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, src, dst, srcSizePtr, targetDestSize, fillOutput); +} + + + +/* LZ4_saveDictHC : + * save history content + * into a user-provided buffer + * which is then used to continue compression + */ +int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictSize) +{ + LZ4HC_CCtx_internal* const streamPtr = &LZ4_streamHCPtr->internal_donotuse; + int const prefixSize = (int)(streamPtr->end - streamPtr->prefixStart); + DEBUGLOG(5, "LZ4_saveDictHC(%p, %p, %d)", LZ4_streamHCPtr, safeBuffer, dictSize); + assert(prefixSize >= 0); + if (dictSize > 64 KB) dictSize = 64 KB; + if (dictSize < 4) dictSize = 0; + if (dictSize > prefixSize) dictSize = prefixSize; + if (safeBuffer == NULL) assert(dictSize == 0); + if (dictSize > 0) + LZ4_memmove(safeBuffer, streamPtr->end - dictSize, dictSize); + { U32 const endIndex = (U32)(streamPtr->end - streamPtr->prefixStart) + streamPtr->dictLimit; + streamPtr->end = (const BYTE*)safeBuffer + dictSize; + streamPtr->prefixStart = streamPtr->end - dictSize; + streamPtr->dictLimit = endIndex - (U32)dictSize; + streamPtr->lowLimit = endIndex - (U32)dictSize; + streamPtr->dictStart = streamPtr->prefixStart; + if (streamPtr->nextToUpdate < streamPtr->dictLimit) + streamPtr->nextToUpdate = streamPtr->dictLimit; + } + return dictSize; +} + + +/*************************************************** +* Deprecated Functions +***************************************************/ + +/* These functions currently generate deprecation warnings */ + +/* Wrappers for deprecated compression functions */ +int LZ4_compressHC(const char* src, char* dst, int srcSize) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), 0); } +int LZ4_compressHC_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, 0); } +int LZ4_compressHC2(const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); } +int LZ4_compressHC2_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize, int cLevel) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, cLevel); } +int LZ4_compressHC_withStateHC (void* state, const char* src, char* dst, int srcSize) { return LZ4_compress_HC_extStateHC (state, src, dst, srcSize, LZ4_compressBound(srcSize), 0); } +int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC_extStateHC (state, src, dst, srcSize, maxDstSize, 0); } +int LZ4_compressHC2_withStateHC (void* state, const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC_extStateHC(state, src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); } +int LZ4_compressHC2_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize, int cLevel) { return LZ4_compress_HC_extStateHC(state, src, dst, srcSize, maxDstSize, cLevel); } +int LZ4_compressHC_continue (LZ4_streamHC_t* ctx, const char* src, char* dst, int srcSize) { return LZ4_compress_HC_continue (ctx, src, dst, srcSize, LZ4_compressBound(srcSize)); } +int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* ctx, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC_continue (ctx, src, dst, srcSize, maxDstSize); } + + +/* Deprecated streaming functions */ +int LZ4_sizeofStreamStateHC(void) { return sizeof(LZ4_streamHC_t); } + +/* state is presumed correctly sized, aka >= sizeof(LZ4_streamHC_t) + * @return : 0 on success, !=0 if error */ +int LZ4_resetStreamStateHC(void* state, char* inputBuffer) +{ + LZ4_streamHC_t* const hc4 = LZ4_initStreamHC(state, sizeof(*hc4)); + if (hc4 == NULL) return 1; /* init failed */ + LZ4HC_init_internal (&hc4->internal_donotuse, (const BYTE*)inputBuffer); + return 0; +} + +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +void* LZ4_createHC (const char* inputBuffer) +{ + LZ4_streamHC_t* const hc4 = LZ4_createStreamHC(); + if (hc4 == NULL) return NULL; /* not enough memory */ + LZ4HC_init_internal (&hc4->internal_donotuse, (const BYTE*)inputBuffer); + return hc4; +} + +int LZ4_freeHC (void* LZ4HC_Data) +{ + if (!LZ4HC_Data) return 0; /* support free on NULL */ + FREEMEM(LZ4HC_Data); + return 0; +} +#endif + +int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int cLevel) +{ + return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, 0, cLevel, notLimited); +} + +int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int dstCapacity, int cLevel) +{ + return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, dstCapacity, cLevel, limitedOutput); +} + +char* LZ4_slideInputBufferHC(void* LZ4HC_Data) +{ + LZ4_streamHC_t* const ctx = (LZ4_streamHC_t*)LZ4HC_Data; + const BYTE* bufferStart = ctx->internal_donotuse.prefixStart - ctx->internal_donotuse.dictLimit + ctx->internal_donotuse.lowLimit; + LZ4_resetStreamHC_fast(ctx, ctx->internal_donotuse.compressionLevel); + /* avoid const char * -> char * conversion warning :( */ + return (char*)(uptrval)bufferStart; +} + + +/* ================================================ + * LZ4 Optimal parser (levels [LZ4HC_CLEVEL_OPT_MIN - LZ4HC_CLEVEL_MAX]) + * ===============================================*/ +typedef struct { + int price; + int off; + int mlen; + int litlen; +} LZ4HC_optimal_t; + +/* price in bytes */ +LZ4_FORCE_INLINE int LZ4HC_literalsPrice(int const litlen) +{ + int price = litlen; + assert(litlen >= 0); + if (litlen >= (int)RUN_MASK) + price += 1 + ((litlen-(int)RUN_MASK) / 255); + return price; +} + + +/* requires mlen >= MINMATCH */ +LZ4_FORCE_INLINE int LZ4HC_sequencePrice(int litlen, int mlen) +{ + int price = 1 + 2 ; /* token + 16-bit offset */ + assert(litlen >= 0); + assert(mlen >= MINMATCH); + + price += LZ4HC_literalsPrice(litlen); + + if (mlen >= (int)(ML_MASK+MINMATCH)) + price += 1 + ((mlen-(int)(ML_MASK+MINMATCH)) / 255); + + return price; +} + + +typedef struct { + int off; + int len; +} LZ4HC_match_t; + +LZ4_FORCE_INLINE LZ4HC_match_t +LZ4HC_FindLongerMatch(LZ4HC_CCtx_internal* const ctx, + const BYTE* ip, const BYTE* const iHighLimit, + int minLen, int nbSearches, + const dictCtx_directive dict, + const HCfavor_e favorDecSpeed) +{ + LZ4HC_match_t match = { 0 , 0 }; + const BYTE* matchPtr = NULL; + /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos), + * but this won't be the case here, as we define iLowLimit==ip, + * so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */ + int matchLength = LZ4HC_InsertAndGetWiderMatch(ctx, ip, ip, iHighLimit, minLen, &matchPtr, &ip, nbSearches, 1 /*patternAnalysis*/, 1 /*chainSwap*/, dict, favorDecSpeed); + if (matchLength <= minLen) return match; + if (favorDecSpeed) { + if ((matchLength>18) & (matchLength<=36)) matchLength=18; /* favor shortcut */ + } + match.len = matchLength; + match.off = (int)(ip-matchPtr); + return match; +} + + +static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx, + const char* const source, + char* dst, + int* srcSizePtr, + int dstCapacity, + int const nbSearches, + size_t sufficient_len, + const limitedOutput_directive limit, + int const fullUpdate, + const dictCtx_directive dict, + const HCfavor_e favorDecSpeed) +{ + int retval = 0; +#define TRAILING_LITERALS 3 +#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1 + LZ4HC_optimal_t* const opt = (LZ4HC_optimal_t*)ALLOC(sizeof(LZ4HC_optimal_t) * (LZ4_OPT_NUM + TRAILING_LITERALS)); +#else + LZ4HC_optimal_t opt[LZ4_OPT_NUM + TRAILING_LITERALS]; /* ~64 KB, which is a bit large for stack... */ +#endif + + const BYTE* ip = (const BYTE*) source; + const BYTE* anchor = ip; + const BYTE* const iend = ip + *srcSizePtr; + const BYTE* const mflimit = iend - MFLIMIT; + const BYTE* const matchlimit = iend - LASTLITERALS; + BYTE* op = (BYTE*) dst; + BYTE* opSaved = (BYTE*) dst; + BYTE* oend = op + dstCapacity; + int ovml = MINMATCH; /* overflow - last sequence */ + const BYTE* ovref = NULL; + + /* init */ +#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1 + if (opt == NULL) goto _return_label; +#endif + DEBUGLOG(5, "LZ4HC_compress_optimal(dst=%p, dstCapa=%u)", dst, (unsigned)dstCapacity); + *srcSizePtr = 0; + if (limit == fillOutput) oend -= LASTLITERALS; /* Hack for support LZ4 format restriction */ + if (sufficient_len >= LZ4_OPT_NUM) sufficient_len = LZ4_OPT_NUM-1; + + /* Main Loop */ + while (ip <= mflimit) { + int const llen = (int)(ip - anchor); + int best_mlen, best_off; + int cur, last_match_pos = 0; + + LZ4HC_match_t const firstMatch = LZ4HC_FindLongerMatch(ctx, ip, matchlimit, MINMATCH-1, nbSearches, dict, favorDecSpeed); + if (firstMatch.len==0) { ip++; continue; } + + if ((size_t)firstMatch.len > sufficient_len) { + /* good enough solution : immediate encoding */ + int const firstML = firstMatch.len; + const BYTE* const matchPos = ip - firstMatch.off; + opSaved = op; + if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), firstML, matchPos, limit, oend) ) { /* updates ip, op and anchor */ + ovml = firstML; + ovref = matchPos; + goto _dest_overflow; + } + continue; + } + + /* set prices for first positions (literals) */ + { int rPos; + for (rPos = 0 ; rPos < MINMATCH ; rPos++) { + int const cost = LZ4HC_literalsPrice(llen + rPos); + opt[rPos].mlen = 1; + opt[rPos].off = 0; + opt[rPos].litlen = llen + rPos; + opt[rPos].price = cost; + DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup", + rPos, cost, opt[rPos].litlen); + } } + /* set prices using initial match */ + { int mlen = MINMATCH; + int const matchML = firstMatch.len; /* necessarily < sufficient_len < LZ4_OPT_NUM */ + int const offset = firstMatch.off; + assert(matchML < LZ4_OPT_NUM); + for ( ; mlen <= matchML ; mlen++) { + int const cost = LZ4HC_sequencePrice(llen, mlen); + opt[mlen].mlen = mlen; + opt[mlen].off = offset; + opt[mlen].litlen = llen; + opt[mlen].price = cost; + DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i) -- initial setup", + mlen, cost, mlen); + } } + last_match_pos = firstMatch.len; + { int addLit; + for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) { + opt[last_match_pos+addLit].mlen = 1; /* literal */ + opt[last_match_pos+addLit].off = 0; + opt[last_match_pos+addLit].litlen = addLit; + opt[last_match_pos+addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit); + DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup", + last_match_pos+addLit, opt[last_match_pos+addLit].price, addLit); + } } + + /* check further positions */ + for (cur = 1; cur < last_match_pos; cur++) { + const BYTE* const curPtr = ip + cur; + LZ4HC_match_t newMatch; + + if (curPtr > mflimit) break; + DEBUGLOG(7, "rPos:%u[%u] vs [%u]%u", + cur, opt[cur].price, opt[cur+1].price, cur+1); + if (fullUpdate) { + /* not useful to search here if next position has same (or lower) cost */ + if ( (opt[cur+1].price <= opt[cur].price) + /* in some cases, next position has same cost, but cost rises sharply after, so a small match would still be beneficial */ + && (opt[cur+MINMATCH].price < opt[cur].price + 3/*min seq price*/) ) + continue; + } else { + /* not useful to search here if next position has same (or lower) cost */ + if (opt[cur+1].price <= opt[cur].price) continue; + } + + DEBUGLOG(7, "search at rPos:%u", cur); + if (fullUpdate) + newMatch = LZ4HC_FindLongerMatch(ctx, curPtr, matchlimit, MINMATCH-1, nbSearches, dict, favorDecSpeed); + else + /* only test matches of minimum length; slightly faster, but misses a few bytes */ + newMatch = LZ4HC_FindLongerMatch(ctx, curPtr, matchlimit, last_match_pos - cur, nbSearches, dict, favorDecSpeed); + if (!newMatch.len) continue; + + if ( ((size_t)newMatch.len > sufficient_len) + || (newMatch.len + cur >= LZ4_OPT_NUM) ) { + /* immediate encoding */ + best_mlen = newMatch.len; + best_off = newMatch.off; + last_match_pos = cur + 1; + goto encode; + } + + /* before match : set price with literals at beginning */ + { int const baseLitlen = opt[cur].litlen; + int litlen; + for (litlen = 1; litlen < MINMATCH; litlen++) { + int const price = opt[cur].price - LZ4HC_literalsPrice(baseLitlen) + LZ4HC_literalsPrice(baseLitlen+litlen); + int const pos = cur + litlen; + if (price < opt[pos].price) { + opt[pos].mlen = 1; /* literal */ + opt[pos].off = 0; + opt[pos].litlen = baseLitlen+litlen; + opt[pos].price = price; + DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)", + pos, price, opt[pos].litlen); + } } } + + /* set prices using match at position = cur */ + { int const matchML = newMatch.len; + int ml = MINMATCH; + + assert(cur + newMatch.len < LZ4_OPT_NUM); + for ( ; ml <= matchML ; ml++) { + int const pos = cur + ml; + int const offset = newMatch.off; + int price; + int ll; + DEBUGLOG(7, "testing price rPos %i (last_match_pos=%i)", + pos, last_match_pos); + if (opt[cur].mlen == 1) { + ll = opt[cur].litlen; + price = ((cur > ll) ? opt[cur - ll].price : 0) + + LZ4HC_sequencePrice(ll, ml); + } else { + ll = 0; + price = opt[cur].price + LZ4HC_sequencePrice(0, ml); + } + + assert((U32)favorDecSpeed <= 1); + if (pos > last_match_pos+TRAILING_LITERALS + || price <= opt[pos].price - (int)favorDecSpeed) { + DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i)", + pos, price, ml); + assert(pos < LZ4_OPT_NUM); + if ( (ml == matchML) /* last pos of last match */ + && (last_match_pos < pos) ) + last_match_pos = pos; + opt[pos].mlen = ml; + opt[pos].off = offset; + opt[pos].litlen = ll; + opt[pos].price = price; + } } } + /* complete following positions with literals */ + { int addLit; + for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) { + opt[last_match_pos+addLit].mlen = 1; /* literal */ + opt[last_match_pos+addLit].off = 0; + opt[last_match_pos+addLit].litlen = addLit; + opt[last_match_pos+addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit); + DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)", last_match_pos+addLit, opt[last_match_pos+addLit].price, addLit); + } } + } /* for (cur = 1; cur <= last_match_pos; cur++) */ + + assert(last_match_pos < LZ4_OPT_NUM + TRAILING_LITERALS); + best_mlen = opt[last_match_pos].mlen; + best_off = opt[last_match_pos].off; + cur = last_match_pos - best_mlen; + +encode: /* cur, last_match_pos, best_mlen, best_off must be set */ + assert(cur < LZ4_OPT_NUM); + assert(last_match_pos >= 1); /* == 1 when only one candidate */ + DEBUGLOG(6, "reverse traversal, looking for shortest path (last_match_pos=%i)", last_match_pos); + { int candidate_pos = cur; + int selected_matchLength = best_mlen; + int selected_offset = best_off; + while (1) { /* from end to beginning */ + int const next_matchLength = opt[candidate_pos].mlen; /* can be 1, means literal */ + int const next_offset = opt[candidate_pos].off; + DEBUGLOG(7, "pos %i: sequence length %i", candidate_pos, selected_matchLength); + opt[candidate_pos].mlen = selected_matchLength; + opt[candidate_pos].off = selected_offset; + selected_matchLength = next_matchLength; + selected_offset = next_offset; + if (next_matchLength > candidate_pos) break; /* last match elected, first match to encode */ + assert(next_matchLength > 0); /* can be 1, means literal */ + candidate_pos -= next_matchLength; + } } + + /* encode all recorded sequences in order */ + { int rPos = 0; /* relative position (to ip) */ + while (rPos < last_match_pos) { + int const ml = opt[rPos].mlen; + int const offset = opt[rPos].off; + if (ml == 1) { ip++; rPos++; continue; } /* literal; note: can end up with several literals, in which case, skip them */ + rPos += ml; + assert(ml >= MINMATCH); + assert((offset >= 1) && (offset <= LZ4_DISTANCE_MAX)); + opSaved = op; + if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ip - offset, limit, oend) ) { /* updates ip, op and anchor */ + ovml = ml; + ovref = ip - offset; + goto _dest_overflow; + } } } + } /* while (ip <= mflimit) */ + +_last_literals: + /* Encode Last Literals */ + { size_t lastRunSize = (size_t)(iend - anchor); /* literals */ + size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255; + size_t const totalSize = 1 + llAdd + lastRunSize; + if (limit == fillOutput) oend += LASTLITERALS; /* restore correct value */ + if (limit && (op + totalSize > oend)) { + if (limit == limitedOutput) { /* Check output limit */ + retval = 0; + goto _return_label; + } + /* adapt lastRunSize to fill 'dst' */ + lastRunSize = (size_t)(oend - op) - 1 /*token*/; + llAdd = (lastRunSize + 256 - RUN_MASK) / 256; + lastRunSize -= llAdd; + } + DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize); + ip = anchor + lastRunSize; /* can be != iend if limit==fillOutput */ + + if (lastRunSize >= RUN_MASK) { + size_t accumulator = lastRunSize - RUN_MASK; + *op++ = (RUN_MASK << ML_BITS); + for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255; + *op++ = (BYTE) accumulator; + } else { + *op++ = (BYTE)(lastRunSize << ML_BITS); + } + LZ4_memcpy(op, anchor, lastRunSize); + op += lastRunSize; + } + + /* End */ + *srcSizePtr = (int) (((const char*)ip) - source); + retval = (int) ((char*)op-dst); + goto _return_label; + +_dest_overflow: +if (limit == fillOutput) { + /* Assumption : ip, anchor, ovml and ovref must be set correctly */ + size_t const ll = (size_t)(ip - anchor); + size_t const ll_addbytes = (ll + 240) / 255; + size_t const ll_totalCost = 1 + ll_addbytes + ll; + BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */ + DEBUGLOG(6, "Last sequence overflowing (only %i bytes remaining)", (int)(oend-1-opSaved)); + op = opSaved; /* restore correct out pointer */ + if (op + ll_totalCost <= maxLitPos) { + /* ll validated; now adjust match length */ + size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost)); + size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255); + assert(maxMlSize < INT_MAX); assert(ovml >= 0); + if ((size_t)ovml > maxMlSize) ovml = (int)maxMlSize; + if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + ovml >= MFLIMIT) { + DEBUGLOG(6, "Space to end : %i + ml (%i)", (int)((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1), ovml); + DEBUGLOG(6, "Before : ip = %p, anchor = %p", ip, anchor); + LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ovml, ovref, notLimited, oend); + DEBUGLOG(6, "After : ip = %p, anchor = %p", ip, anchor); + } } + goto _last_literals; +} +_return_label: +#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1 + FREEMEM(opt); +#endif + return retval; +} + +} diff --git a/Dependencies/tracy/common/tracy_lz4hc.hpp b/Dependencies/tracy/common/tracy_lz4hc.hpp new file mode 100644 index 000000000..460cbae7f --- /dev/null +++ b/Dependencies/tracy/common/tracy_lz4hc.hpp @@ -0,0 +1,405 @@ +/* + LZ4 HC - High Compression Mode of LZ4 + Header File + Copyright (C) 2011-2020, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - LZ4 source repository : https://github.com/lz4/lz4 + - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c +*/ +#ifndef TRACY_LZ4_HC_H_19834876238432 +#define TRACY_LZ4_HC_H_19834876238432 + +/* --- Dependency --- */ +/* note : lz4hc requires lz4.h/lz4.c for compilation */ +#include "tracy_lz4.hpp" /* stddef, LZ4LIB_API, LZ4_DEPRECATED */ + + +/* --- Useful constants --- */ +#define LZ4HC_CLEVEL_MIN 3 +#define LZ4HC_CLEVEL_DEFAULT 9 +#define LZ4HC_CLEVEL_OPT_MIN 10 +#define LZ4HC_CLEVEL_MAX 12 + +namespace tracy +{ + +/*-************************************ + * Block Compression + **************************************/ +/*! LZ4_compress_HC() : + * Compress data from `src` into `dst`, using the powerful but slower "HC" algorithm. + * `dst` must be already allocated. + * Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)` (see "lz4.h") + * Max supported `srcSize` value is LZ4_MAX_INPUT_SIZE (see "lz4.h") + * `compressionLevel` : any value between 1 and LZ4HC_CLEVEL_MAX will work. + * Values > LZ4HC_CLEVEL_MAX behave the same as LZ4HC_CLEVEL_MAX. + * @return : the number of bytes written into 'dst' + * or 0 if compression fails. + */ +LZ4LIB_API int LZ4_compress_HC (const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel); + + +/* Note : + * Decompression functions are provided within "lz4.h" (BSD license) + */ + + +/*! LZ4_compress_HC_extStateHC() : + * Same as LZ4_compress_HC(), but using an externally allocated memory segment for `state`. + * `state` size is provided by LZ4_sizeofStateHC(). + * Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() should do properly). + */ +LZ4LIB_API int LZ4_sizeofStateHC(void); +LZ4LIB_API int LZ4_compress_HC_extStateHC(void* stateHC, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel); + + +/*! LZ4_compress_HC_destSize() : v1.9.0+ + * Will compress as much data as possible from `src` + * to fit into `targetDstSize` budget. + * Result is provided in 2 parts : + * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize) + * or 0 if compression fails. + * `srcSizePtr` : on success, *srcSizePtr is updated to indicate how much bytes were read from `src` + */ +LZ4LIB_API int LZ4_compress_HC_destSize(void* stateHC, + const char* src, char* dst, + int* srcSizePtr, int targetDstSize, + int compressionLevel); + + +/*-************************************ + * Streaming Compression + * Bufferless synchronous API + **************************************/ + typedef union LZ4_streamHC_u LZ4_streamHC_t; /* incomplete type (defined later) */ + +/*! LZ4_createStreamHC() and LZ4_freeStreamHC() : + * These functions create and release memory for LZ4 HC streaming state. + * Newly created states are automatically initialized. + * A same state can be used multiple times consecutively, + * starting with LZ4_resetStreamHC_fast() to start a new stream of blocks. + */ +LZ4LIB_API LZ4_streamHC_t* LZ4_createStreamHC(void); +LZ4LIB_API int LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr); + +/* + These functions compress data in successive blocks of any size, + using previous blocks as dictionary, to improve compression ratio. + One key assumption is that previous blocks (up to 64 KB) remain read-accessible while compressing next blocks. + There is an exception for ring buffers, which can be smaller than 64 KB. + Ring-buffer scenario is automatically detected and handled within LZ4_compress_HC_continue(). + + Before starting compression, state must be allocated and properly initialized. + LZ4_createStreamHC() does both, though compression level is set to LZ4HC_CLEVEL_DEFAULT. + + Selecting the compression level can be done with LZ4_resetStreamHC_fast() (starts a new stream) + or LZ4_setCompressionLevel() (anytime, between blocks in the same stream) (experimental). + LZ4_resetStreamHC_fast() only works on states which have been properly initialized at least once, + which is automatically the case when state is created using LZ4_createStreamHC(). + + After reset, a first "fictional block" can be designated as initial dictionary, + using LZ4_loadDictHC() (Optional). + + Invoke LZ4_compress_HC_continue() to compress each successive block. + The number of blocks is unlimited. + Previous input blocks, including initial dictionary when present, + must remain accessible and unmodified during compression. + + It's allowed to update compression level anytime between blocks, + using LZ4_setCompressionLevel() (experimental). + + 'dst' buffer should be sized to handle worst case scenarios + (see LZ4_compressBound(), it ensures compression success). + In case of failure, the API does not guarantee recovery, + so the state _must_ be reset. + To ensure compression success + whenever `dst` buffer size cannot be made >= LZ4_compressBound(), + consider using LZ4_compress_HC_continue_destSize(). + + Whenever previous input blocks can't be preserved unmodified in-place during compression of next blocks, + it's possible to copy the last blocks into a more stable memory space, using LZ4_saveDictHC(). + Return value of LZ4_saveDictHC() is the size of dictionary effectively saved into 'safeBuffer' (<= 64 KB) + + After completing a streaming compression, + it's possible to start a new stream of blocks, using the same LZ4_streamHC_t state, + just by resetting it, using LZ4_resetStreamHC_fast(). +*/ + +LZ4LIB_API void LZ4_resetStreamHC_fast(LZ4_streamHC_t* streamHCPtr, int compressionLevel); /* v1.9.0+ */ +LZ4LIB_API int LZ4_loadDictHC (LZ4_streamHC_t* streamHCPtr, const char* dictionary, int dictSize); + +LZ4LIB_API int LZ4_compress_HC_continue (LZ4_streamHC_t* streamHCPtr, + const char* src, char* dst, + int srcSize, int maxDstSize); + +/*! LZ4_compress_HC_continue_destSize() : v1.9.0+ + * Similar to LZ4_compress_HC_continue(), + * but will read as much data as possible from `src` + * to fit into `targetDstSize` budget. + * Result is provided into 2 parts : + * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize) + * or 0 if compression fails. + * `srcSizePtr` : on success, *srcSizePtr will be updated to indicate how much bytes were read from `src`. + * Note that this function may not consume the entire input. + */ +LZ4LIB_API int LZ4_compress_HC_continue_destSize(LZ4_streamHC_t* LZ4_streamHCPtr, + const char* src, char* dst, + int* srcSizePtr, int targetDstSize); + +LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSize); + + + +/*^********************************************** + * !!!!!! STATIC LINKING ONLY !!!!!! + ***********************************************/ + +/*-****************************************************************** + * PRIVATE DEFINITIONS : + * Do not use these definitions directly. + * They are merely exposed to allow static allocation of `LZ4_streamHC_t`. + * Declare an `LZ4_streamHC_t` directly, rather than any type below. + * Even then, only do so in the context of static linking, as definitions may change between versions. + ********************************************************************/ + +#define LZ4HC_DICTIONARY_LOGSIZE 16 +#define LZ4HC_MAXD (1<= LZ4HC_CLEVEL_OPT_MIN. + */ +LZ4LIB_STATIC_API void LZ4_favorDecompressionSpeed( + LZ4_streamHC_t* LZ4_streamHCPtr, int favor); + +/*! LZ4_resetStreamHC_fast() : v1.9.0+ + * When an LZ4_streamHC_t is known to be in a internally coherent state, + * it can often be prepared for a new compression with almost no work, only + * sometimes falling back to the full, expensive reset that is always required + * when the stream is in an indeterminate state (i.e., the reset performed by + * LZ4_resetStreamHC()). + * + * LZ4_streamHCs are guaranteed to be in a valid state when: + * - returned from LZ4_createStreamHC() + * - reset by LZ4_resetStreamHC() + * - memset(stream, 0, sizeof(LZ4_streamHC_t)) + * - the stream was in a valid state and was reset by LZ4_resetStreamHC_fast() + * - the stream was in a valid state and was then used in any compression call + * that returned success + * - the stream was in an indeterminate state and was used in a compression + * call that fully reset the state (LZ4_compress_HC_extStateHC()) and that + * returned success + * + * Note: + * A stream that was last used in a compression call that returned an error + * may be passed to this function. However, it will be fully reset, which will + * clear any existing history and settings from the context. + */ +LZ4LIB_STATIC_API void LZ4_resetStreamHC_fast( + LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel); + +/*! LZ4_compress_HC_extStateHC_fastReset() : + * A variant of LZ4_compress_HC_extStateHC(). + * + * Using this variant avoids an expensive initialization step. It is only safe + * to call if the state buffer is known to be correctly initialized already + * (see above comment on LZ4_resetStreamHC_fast() for a definition of + * "correctly initialized"). From a high level, the difference is that this + * function initializes the provided state with a call to + * LZ4_resetStreamHC_fast() while LZ4_compress_HC_extStateHC() starts with a + * call to LZ4_resetStreamHC(). + */ +LZ4LIB_STATIC_API int LZ4_compress_HC_extStateHC_fastReset ( + void* state, + const char* src, char* dst, + int srcSize, int dstCapacity, + int compressionLevel); + +/*! LZ4_attach_HC_dictionary() : + * This is an experimental API that allows for the efficient use of a + * static dictionary many times. + * + * Rather than re-loading the dictionary buffer into a working context before + * each compression, or copying a pre-loaded dictionary's LZ4_streamHC_t into a + * working LZ4_streamHC_t, this function introduces a no-copy setup mechanism, + * in which the working stream references the dictionary stream in-place. + * + * Several assumptions are made about the state of the dictionary stream. + * Currently, only streams which have been prepared by LZ4_loadDictHC() should + * be expected to work. + * + * Alternatively, the provided dictionary stream pointer may be NULL, in which + * case any existing dictionary stream is unset. + * + * A dictionary should only be attached to a stream without any history (i.e., + * a stream that has just been reset). + * + * The dictionary will remain attached to the working stream only for the + * current stream session. Calls to LZ4_resetStreamHC(_fast) will remove the + * dictionary context association from the working stream. The dictionary + * stream (and source buffer) must remain in-place / accessible / unchanged + * through the lifetime of the stream session. + */ +LZ4LIB_STATIC_API void LZ4_attach_HC_dictionary( + LZ4_streamHC_t *working_stream, + const LZ4_streamHC_t *dictionary_stream); + +} + +#endif /* LZ4_HC_SLO_098092834 */ +#endif /* LZ4_HC_STATIC_LINKING_ONLY */ diff --git a/Dependencies/tracy/premake5.lua b/Dependencies/tracy/premake5.lua new file mode 100644 index 000000000..15d64c2d1 --- /dev/null +++ b/Dependencies/tracy/premake5.lua @@ -0,0 +1,16 @@ +project "tracy" + kind "StaticLib" + language "C++" + cppdialect "C++20" + files { "**.h", "**.hpp", "**.cpp", "**.lua" } + targetdir (outputdir .. "%{cfg.buildcfg}/%{prj.name}") + objdir (objoutdir .. "%{cfg.buildcfg}/%{prj.name}") + characterset ("MBCS") + + filter { "configurations:Debug" } + defines { "DEBUG" } + symbols "On" + + filter { "configurations:Release" } + defines { "NDEBUG" } + optimize "On" diff --git a/Dependencies/tracy/tracy/Tracy.hpp b/Dependencies/tracy/tracy/Tracy.hpp new file mode 100644 index 000000000..e75d02ce9 --- /dev/null +++ b/Dependencies/tracy/tracy/Tracy.hpp @@ -0,0 +1,300 @@ +#ifndef __TRACY_HPP__ +#define __TRACY_HPP__ + +#include "../common/TracyColor.hpp" +#include "../common/TracySystem.hpp" + +#ifndef TracyFunction +# define TracyFunction __FUNCTION__ +#endif + +#ifndef TracyFile +# define TracyFile __FILE__ +#endif + +#ifndef TracyLine +# define TracyLine __LINE__ +#endif + +#ifndef TRACY_ENABLE + +#define TracyNoop + +#define ZoneNamed(x,y) +#define ZoneNamedN(x,y,z) +#define ZoneNamedC(x,y,z) +#define ZoneNamedNC(x,y,z,w) + +#define ZoneTransient(x,y) +#define ZoneTransientN(x,y,z) + +#define ZoneScoped +#define ZoneScopedN(x) +#define ZoneScopedC(x) +#define ZoneScopedNC(x,y) + +#define ZoneText(x,y) +#define ZoneTextV(x,y,z) +#define ZoneTextF(x,...) +#define ZoneTextVF(x,y,...) +#define ZoneName(x,y) +#define ZoneNameV(x,y,z) +#define ZoneNameF(x,...) +#define ZoneNameVF(x,y,...) +#define ZoneColor(x) +#define ZoneColorV(x,y) +#define ZoneValue(x) +#define ZoneValueV(x,y) +#define ZoneIsActive false +#define ZoneIsActiveV(x) false + +#define FrameMark +#define FrameMarkNamed(x) +#define FrameMarkStart(x) +#define FrameMarkEnd(x) + +#define FrameImage(x,y,z,w,a) + +#define TracyLockable( type, varname ) type varname +#define TracyLockableN( type, varname, desc ) type varname +#define TracySharedLockable( type, varname ) type varname +#define TracySharedLockableN( type, varname, desc ) type varname +#define LockableBase( type ) type +#define SharedLockableBase( type ) type +#define LockMark(x) (void)x +#define LockableName(x,y,z) + +#define TracyPlot(x,y) +#define TracyPlotConfig(x,y,z,w,a) + +#define TracyMessage(x,y) +#define TracyMessageL(x) +#define TracyMessageC(x,y,z) +#define TracyMessageLC(x,y) +#define TracyAppInfo(x,y) + +#define TracyAlloc(x,y) +#define TracyFree(x) +#define TracySecureAlloc(x,y) +#define TracySecureFree(x) + +#define TracyAllocN(x,y,z) +#define TracyFreeN(x,y) +#define TracySecureAllocN(x,y,z) +#define TracySecureFreeN(x,y) + +#define ZoneNamedS(x,y,z) +#define ZoneNamedNS(x,y,z,w) +#define ZoneNamedCS(x,y,z,w) +#define ZoneNamedNCS(x,y,z,w,a) + +#define ZoneTransientS(x,y,z) +#define ZoneTransientNS(x,y,z,w) + +#define ZoneScopedS(x) +#define ZoneScopedNS(x,y) +#define ZoneScopedCS(x,y) +#define ZoneScopedNCS(x,y,z) + +#define TracyAllocS(x,y,z) +#define TracyFreeS(x,y) +#define TracySecureAllocS(x,y,z) +#define TracySecureFreeS(x,y) + +#define TracyAllocNS(x,y,z,w) +#define TracyFreeNS(x,y,z) +#define TracySecureAllocNS(x,y,z,w) +#define TracySecureFreeNS(x,y,z) + +#define TracyMessageS(x,y,z) +#define TracyMessageLS(x,y) +#define TracyMessageCS(x,y,z,w) +#define TracyMessageLCS(x,y,z) + +#define TracySourceCallbackRegister(x,y) +#define TracyParameterRegister(x,y) +#define TracyParameterSetup(x,y,z,w) +#define TracyIsConnected false +#define TracyIsStarted false +#define TracySetProgramName(x) + +#define TracyFiberEnter(x) +#define TracyFiberEnterHint(x,y) +#define TracyFiberLeave + +#else + +#include + +#include "../client/TracyLock.hpp" +#include "../client/TracyProfiler.hpp" +#include "../client/TracyScoped.hpp" + +#define TracyNoop tracy::ProfilerAvailable() + +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define ZoneNamed( varname, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), TRACY_CALLSTACK, active ) +# define ZoneNamedN( varname, name, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), TRACY_CALLSTACK, active ) +# define ZoneNamedC( varname, color, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), TRACY_CALLSTACK, active ) +# define ZoneNamedNC( varname, name, color, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), TRACY_CALLSTACK, active ) + +# define ZoneTransient( varname, active ) tracy::ScopedZone varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), nullptr, 0, TRACY_CALLSTACK, active ) +# define ZoneTransientN( varname, name, active ) tracy::ScopedZone varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), TRACY_CALLSTACK, active ) +# define ZoneTransientNC( varname, name, color, active ) tracy::ScopedZone varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), color, TRACY_CALLSTACK, active ) +#else +# define ZoneNamed( varname, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), active ) +# define ZoneNamedN( varname, name, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), active ) +# define ZoneNamedC( varname, color, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), active ) +# define ZoneNamedNC( varname, name, color, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), active ) + +# define ZoneTransient( varname, active ) tracy::ScopedZone varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), nullptr, 0, active ) +# define ZoneTransientN( varname, name, active ) tracy::ScopedZone varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), active ) +# define ZoneTransientNC( varname, name, color, active ) tracy::ScopedZone varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), color, active ) +#endif + +#define ZoneScoped ZoneNamed( ___tracy_scoped_zone, true ) +#define ZoneScopedN( name ) ZoneNamedN( ___tracy_scoped_zone, name, true ) +#define ZoneScopedC( color ) ZoneNamedC( ___tracy_scoped_zone, color, true ) +#define ZoneScopedNC( name, color ) ZoneNamedNC( ___tracy_scoped_zone, name, color, true ) + +#define ZoneText( txt, size ) ___tracy_scoped_zone.Text( txt, size ) +#define ZoneTextV( varname, txt, size ) varname.Text( txt, size ) +#define ZoneTextF( fmt, ... ) ___tracy_scoped_zone.TextFmt( fmt, ##__VA_ARGS__ ) +#define ZoneTextVF( varname, fmt, ... ) varname.TextFmt( fmt, ##__VA_ARGS__ ) +#define ZoneName( txt, size ) ___tracy_scoped_zone.Name( txt, size ) +#define ZoneNameV( varname, txt, size ) varname.Name( txt, size ) +#define ZoneNameF( fmt, ... ) ___tracy_scoped_zone.NameFmt( fmt, ##__VA_ARGS__ ) +#define ZoneNameVF( varname, fmt, ... ) varname.NameFmt( fmt, ##__VA_ARGS__ ) +#define ZoneColor( color ) ___tracy_scoped_zone.Color( color ) +#define ZoneColorV( varname, color ) varname.Color( color ) +#define ZoneValue( value ) ___tracy_scoped_zone.Value( value ) +#define ZoneValueV( varname, value ) varname.Value( value ) +#define ZoneIsActive ___tracy_scoped_zone.IsActive() +#define ZoneIsActiveV( varname ) varname.IsActive() + +#define FrameMark tracy::Profiler::SendFrameMark( nullptr ) +#define FrameMarkNamed( name ) tracy::Profiler::SendFrameMark( name ) +#define FrameMarkStart( name ) tracy::Profiler::SendFrameMark( name, tracy::QueueType::FrameMarkMsgStart ) +#define FrameMarkEnd( name ) tracy::Profiler::SendFrameMark( name, tracy::QueueType::FrameMarkMsgEnd ) + +#define FrameImage( image, width, height, offset, flip ) tracy::Profiler::SendFrameImage( image, width, height, offset, flip ) + +#define TracyLockable( type, varname ) tracy::Lockable varname { [] () -> const tracy::SourceLocationData* { static constexpr tracy::SourceLocationData srcloc { nullptr, #type " " #varname, TracyFile, TracyLine, 0 }; return &srcloc; }() } +#define TracyLockableN( type, varname, desc ) tracy::Lockable varname { [] () -> const tracy::SourceLocationData* { static constexpr tracy::SourceLocationData srcloc { nullptr, desc, TracyFile, TracyLine, 0 }; return &srcloc; }() } +#define TracySharedLockable( type, varname ) tracy::SharedLockable varname { [] () -> const tracy::SourceLocationData* { static constexpr tracy::SourceLocationData srcloc { nullptr, #type " " #varname, TracyFile, TracyLine, 0 }; return &srcloc; }() } +#define TracySharedLockableN( type, varname, desc ) tracy::SharedLockable varname { [] () -> const tracy::SourceLocationData* { static constexpr tracy::SourceLocationData srcloc { nullptr, desc, TracyFile, TracyLine, 0 }; return &srcloc; }() } +#define LockableBase( type ) tracy::Lockable +#define SharedLockableBase( type ) tracy::SharedLockable +#define LockMark( varname ) static constexpr tracy::SourceLocationData __tracy_lock_location_##varname { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; varname.Mark( &__tracy_lock_location_##varname ) +#define LockableName( varname, txt, size ) varname.CustomName( txt, size ) + +#define TracyPlot( name, val ) tracy::Profiler::PlotData( name, val ) +#define TracyPlotConfig( name, type, step, fill, color ) tracy::Profiler::ConfigurePlot( name, type, step, fill, color ) + +#define TracyAppInfo( txt, size ) tracy::Profiler::MessageAppInfo( txt, size ) + +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define TracyMessage( txt, size ) tracy::Profiler::Message( txt, size, TRACY_CALLSTACK ) +# define TracyMessageL( txt ) tracy::Profiler::Message( txt, TRACY_CALLSTACK ) +# define TracyMessageC( txt, size, color ) tracy::Profiler::MessageColor( txt, size, color, TRACY_CALLSTACK ) +# define TracyMessageLC( txt, color ) tracy::Profiler::MessageColor( txt, color, TRACY_CALLSTACK ) + +# define TracyAlloc( ptr, size ) tracy::Profiler::MemAllocCallstack( ptr, size, TRACY_CALLSTACK, false ) +# define TracyFree( ptr ) tracy::Profiler::MemFreeCallstack( ptr, TRACY_CALLSTACK, false ) +# define TracySecureAlloc( ptr, size ) tracy::Profiler::MemAllocCallstack( ptr, size, TRACY_CALLSTACK, true ) +# define TracySecureFree( ptr ) tracy::Profiler::MemFreeCallstack( ptr, TRACY_CALLSTACK, true ) + +# define TracyAllocN( ptr, size, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, TRACY_CALLSTACK, false, name ) +# define TracyFreeN( ptr, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, TRACY_CALLSTACK, false, name ) +# define TracySecureAllocN( ptr, size, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, TRACY_CALLSTACK, true, name ) +# define TracySecureFreeN( ptr, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, TRACY_CALLSTACK, true, name ) +#else +# define TracyMessage( txt, size ) tracy::Profiler::Message( txt, size, 0 ) +# define TracyMessageL( txt ) tracy::Profiler::Message( txt, 0 ) +# define TracyMessageC( txt, size, color ) tracy::Profiler::MessageColor( txt, size, color, 0 ) +# define TracyMessageLC( txt, color ) tracy::Profiler::MessageColor( txt, color, 0 ) + +# define TracyAlloc( ptr, size ) tracy::Profiler::MemAlloc( ptr, size, false ) +# define TracyFree( ptr ) tracy::Profiler::MemFree( ptr, false ) +# define TracySecureAlloc( ptr, size ) tracy::Profiler::MemAlloc( ptr, size, true ) +# define TracySecureFree( ptr ) tracy::Profiler::MemFree( ptr, true ) + +# define TracyAllocN( ptr, size, name ) tracy::Profiler::MemAllocNamed( ptr, size, false, name ) +# define TracyFreeN( ptr, name ) tracy::Profiler::MemFreeNamed( ptr, false, name ) +# define TracySecureAllocN( ptr, size, name ) tracy::Profiler::MemAllocNamed( ptr, size, true, name ) +# define TracySecureFreeN( ptr, name ) tracy::Profiler::MemFreeNamed( ptr, true, name ) +#endif + +#ifdef TRACY_HAS_CALLSTACK +# define ZoneNamedS( varname, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), depth, active ) +# define ZoneNamedNS( varname, name, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), depth, active ) +# define ZoneNamedCS( varname, color, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), depth, active ) +# define ZoneNamedNCS( varname, name, color, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), depth, active ) + +# define ZoneTransientS( varname, depth, active ) tracy::ScopedZone varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), nullptr, 0, depth, active ) +# define ZoneTransientNS( varname, name, depth, active ) tracy::ScopedZone varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), depth, active ) + +# define ZoneScopedS( depth ) ZoneNamedS( ___tracy_scoped_zone, depth, true ) +# define ZoneScopedNS( name, depth ) ZoneNamedNS( ___tracy_scoped_zone, name, depth, true ) +# define ZoneScopedCS( color, depth ) ZoneNamedCS( ___tracy_scoped_zone, color, depth, true ) +# define ZoneScopedNCS( name, color, depth ) ZoneNamedNCS( ___tracy_scoped_zone, name, color, depth, true ) + +# define TracyAllocS( ptr, size, depth ) tracy::Profiler::MemAllocCallstack( ptr, size, depth, false ) +# define TracyFreeS( ptr, depth ) tracy::Profiler::MemFreeCallstack( ptr, depth, false ) +# define TracySecureAllocS( ptr, size, depth ) tracy::Profiler::MemAllocCallstack( ptr, size, depth, true ) +# define TracySecureFreeS( ptr, depth ) tracy::Profiler::MemFreeCallstack( ptr, depth, true ) + +# define TracyAllocNS( ptr, size, depth, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, false, name ) +# define TracyFreeNS( ptr, depth, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, depth, false, name ) +# define TracySecureAllocNS( ptr, size, depth, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, true, name ) +# define TracySecureFreeNS( ptr, depth, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, depth, true, name ) + +# define TracyMessageS( txt, size, depth ) tracy::Profiler::Message( txt, size, depth ) +# define TracyMessageLS( txt, depth ) tracy::Profiler::Message( txt, depth ) +# define TracyMessageCS( txt, size, color, depth ) tracy::Profiler::MessageColor( txt, size, color, depth ) +# define TracyMessageLCS( txt, color, depth ) tracy::Profiler::MessageColor( txt, color, depth ) +#else +# define ZoneNamedS( varname, depth, active ) ZoneNamed( varname, active ) +# define ZoneNamedNS( varname, name, depth, active ) ZoneNamedN( varname, name, active ) +# define ZoneNamedCS( varname, color, depth, active ) ZoneNamedC( varname, color, active ) +# define ZoneNamedNCS( varname, name, color, depth, active ) ZoneNamedNC( varname, name, color, active ) + +# define ZoneTransientS( varname, depth, active ) ZoneTransient( varname, active ) +# define ZoneTransientNS( varname, name, depth, active ) ZoneTransientN( varname, name, active ) + +# define ZoneScopedS( depth ) ZoneScoped +# define ZoneScopedNS( name, depth ) ZoneScopedN( name ) +# define ZoneScopedCS( color, depth ) ZoneScopedC( color ) +# define ZoneScopedNCS( name, color, depth ) ZoneScopedNC( name, color ) + +# define TracyAllocS( ptr, size, depth ) TracyAlloc( ptr, size ) +# define TracyFreeS( ptr, depth ) TracyFree( ptr ) +# define TracySecureAllocS( ptr, size, depth ) TracySecureAlloc( ptr, size ) +# define TracySecureFreeS( ptr, depth ) TracySecureFree( ptr ) + +# define TracyAllocNS( ptr, size, depth, name ) TracyAllocN( ptr, size, name ) +# define TracyFreeNS( ptr, depth, name ) TracyFreeN( ptr, name ) +# define TracySecureAllocNS( ptr, size, depth, name ) TracySecureAllocN( ptr, size, name ) +# define TracySecureFreeNS( ptr, depth, name ) TracySecureFreeN( ptr, name ) + +# define TracyMessageS( txt, size, depth ) TracyMessage( txt, size ) +# define TracyMessageLS( txt, depth ) TracyMessageL( txt ) +# define TracyMessageCS( txt, size, color, depth ) TracyMessageC( txt, size, color ) +# define TracyMessageLCS( txt, color, depth ) TracyMessageLC( txt, color ) +#endif + +#define TracySourceCallbackRegister( cb, data ) tracy::Profiler::SourceCallbackRegister( cb, data ) +#define TracyParameterRegister( cb, data ) tracy::Profiler::ParameterRegister( cb, data ) +#define TracyParameterSetup( idx, name, isBool, val ) tracy::Profiler::ParameterSetup( idx, name, isBool, val ) +#define TracyIsConnected tracy::GetProfiler().IsConnected() +#define TracySetProgramName( name ) tracy::GetProfiler().SetProgramName( name ); + +#ifdef TRACY_FIBERS +# define TracyFiberEnter( fiber ) tracy::Profiler::EnterFiber( fiber, 0 ) +# define TracyFiberEnterHint( fiber, groupHint ) tracy::Profiler::EnterFiber( fiber, groupHint ) +# define TracyFiberLeave tracy::Profiler::LeaveFiber() +#endif + +#endif + +#endif diff --git a/Dependencies/tracy/tracy/TracyC.h b/Dependencies/tracy/tracy/TracyC.h new file mode 100644 index 000000000..8b447beb5 --- /dev/null +++ b/Dependencies/tracy/tracy/TracyC.h @@ -0,0 +1,417 @@ +#ifndef __TRACYC_HPP__ +#define __TRACYC_HPP__ + +#include +#include + +#include "../client/TracyCallstack.h" +#include "../common/TracyApi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum TracyPlotFormatEnum +{ + TracyPlotFormatNumber, + TracyPlotFormatMemory, + TracyPlotFormatPercentage, + TracyPlotFormatWatt +}; + +TRACY_API void ___tracy_set_thread_name( const char* name ); + +#define TracyCSetThreadName( name ) ___tracy_set_thread_name( name ); + +#ifndef TracyFunction +# define TracyFunction __FUNCTION__ +#endif + +#ifndef TracyFile +# define TracyFile __FILE__ +#endif + +#ifndef TracyLine +# define TracyLine __LINE__ +#endif + +#ifndef TRACY_ENABLE + +typedef const void* TracyCZoneCtx; + +typedef const void* TracyCLockCtx; + +#define TracyCZone(c,x) +#define TracyCZoneN(c,x,y) +#define TracyCZoneC(c,x,y) +#define TracyCZoneNC(c,x,y,z) +#define TracyCZoneEnd(c) +#define TracyCZoneText(c,x,y) +#define TracyCZoneName(c,x,y) +#define TracyCZoneColor(c,x) +#define TracyCZoneValue(c,x) + +#define TracyCAlloc(x,y) +#define TracyCFree(x) +#define TracyCSecureAlloc(x,y) +#define TracyCSecureFree(x) + +#define TracyCAllocN(x,y,z) +#define TracyCFreeN(x,y) +#define TracyCSecureAllocN(x,y,z) +#define TracyCSecureFreeN(x,y) + +#define TracyCFrameMark +#define TracyCFrameMarkNamed(x) +#define TracyCFrameMarkStart(x) +#define TracyCFrameMarkEnd(x) +#define TracyCFrameImage(x,y,z,w,a) + +#define TracyCPlot(x,y) +#define TracyCPlotF(x,y) +#define TracyCPlotI(x,y) +#define TracyCPlotConfig(x,y,z,w,a) + +#define TracyCMessage(x,y) +#define TracyCMessageL(x) +#define TracyCMessageC(x,y,z) +#define TracyCMessageLC(x,y) +#define TracyCAppInfo(x,y) + +#define TracyCZoneS(x,y,z) +#define TracyCZoneNS(x,y,z,w) +#define TracyCZoneCS(x,y,z,w) +#define TracyCZoneNCS(x,y,z,w,a) + +#define TracyCAllocS(x,y,z) +#define TracyCFreeS(x,y) +#define TracyCSecureAllocS(x,y,z) +#define TracyCSecureFreeS(x,y) + +#define TracyCAllocNS(x,y,z,w) +#define TracyCFreeNS(x,y,z) +#define TracyCSecureAllocNS(x,y,z,w) +#define TracyCSecureFreeNS(x,y,z) + +#define TracyCMessageS(x,y,z) +#define TracyCMessageLS(x,y) +#define TracyCMessageCS(x,y,z,w) +#define TracyCMessageLCS(x,y,z) + +#define TracyCLockCtx(l) +#define TracyCLockAnnounce(l) +#define TracyCLockTerminate(l) +#define TracyCLockBeforeLock(l) +#define TracyCLockAfterLock(l) +#define TracyCLockAfterUnlock(l) +#define TracyCLockAfterTryLock(l,x) +#define TracyCLockMark(l) +#define TracyCLockCustomName(l,x,y) + +#define TracyCIsConnected 0 +#define TracyCIsStarted 0 + +#ifdef TRACY_FIBERS +# define TracyCFiberEnter(fiber) +# define TracyCFiberLeave +#endif + +#else + +#ifndef TracyConcat +# define TracyConcat(x,y) TracyConcatIndirect(x,y) +#endif +#ifndef TracyConcatIndirect +# define TracyConcatIndirect(x,y) x##y +#endif + +struct ___tracy_source_location_data +{ + const char* name; + const char* function; + const char* file; + uint32_t line; + uint32_t color; +}; + +struct ___tracy_c_zone_context +{ + uint32_t id; + int active; +}; + +struct ___tracy_gpu_time_data +{ + int64_t gpuTime; + uint16_t queryId; + uint8_t context; +}; + +struct ___tracy_gpu_zone_begin_data { + uint64_t srcloc; + uint16_t queryId; + uint8_t context; +}; + +struct ___tracy_gpu_zone_begin_callstack_data { + uint64_t srcloc; + int depth; + uint16_t queryId; + uint8_t context; +}; + +struct ___tracy_gpu_zone_end_data { + uint16_t queryId; + uint8_t context; +}; + +struct ___tracy_gpu_new_context_data { + int64_t gpuTime; + float period; + uint8_t context; + uint8_t flags; + uint8_t type; +}; + +struct ___tracy_gpu_context_name_data { + uint8_t context; + const char* name; + uint16_t len; +}; + +struct ___tracy_gpu_calibration_data { + int64_t gpuTime; + int64_t cpuDelta; + uint8_t context; +}; + +struct ___tracy_gpu_time_sync_data { + int64_t gpuTime; + uint8_t context; +}; + +struct __tracy_lockable_context_data; + +// Some containers don't support storing const types. +// This struct, as visible to user, is immutable, so treat it as if const was declared here. +typedef /*const*/ struct ___tracy_c_zone_context TracyCZoneCtx; + +typedef struct __tracy_lockable_context_data* TracyCLockCtx; + +#ifdef TRACY_MANUAL_LIFETIME +TRACY_API void ___tracy_startup_profiler(void); +TRACY_API void ___tracy_shutdown_profiler(void); +TRACY_API int ___tracy_profiler_started(void); + +# define TracyCIsStarted ___tracy_profiler_started() +#else +# define TracyCIsStarted 1 +#endif + +TRACY_API uint64_t ___tracy_alloc_srcloc( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, uint32_t color ); +TRACY_API uint64_t ___tracy_alloc_srcloc_name( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, uint32_t color ); + +TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin( const struct ___tracy_source_location_data* srcloc, int active ); +TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_callstack( const struct ___tracy_source_location_data* srcloc, int depth, int active ); +TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_alloc( uint64_t srcloc, int active ); +TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_alloc_callstack( uint64_t srcloc, int depth, int active ); +TRACY_API void ___tracy_emit_zone_end( TracyCZoneCtx ctx ); +TRACY_API void ___tracy_emit_zone_text( TracyCZoneCtx ctx, const char* txt, size_t size ); +TRACY_API void ___tracy_emit_zone_name( TracyCZoneCtx ctx, const char* txt, size_t size ); +TRACY_API void ___tracy_emit_zone_color( TracyCZoneCtx ctx, uint32_t color ); +TRACY_API void ___tracy_emit_zone_value( TracyCZoneCtx ctx, uint64_t value ); + +TRACY_API void ___tracy_emit_gpu_zone_begin( const struct ___tracy_gpu_zone_begin_data ); +TRACY_API void ___tracy_emit_gpu_zone_begin_callstack( const struct ___tracy_gpu_zone_begin_callstack_data ); +TRACY_API void ___tracy_emit_gpu_zone_begin_alloc( const struct ___tracy_gpu_zone_begin_data ); +TRACY_API void ___tracy_emit_gpu_zone_begin_alloc_callstack( const struct ___tracy_gpu_zone_begin_callstack_data ); +TRACY_API void ___tracy_emit_gpu_zone_end( const struct ___tracy_gpu_zone_end_data data ); +TRACY_API void ___tracy_emit_gpu_time( const struct ___tracy_gpu_time_data ); +TRACY_API void ___tracy_emit_gpu_new_context( const struct ___tracy_gpu_new_context_data ); +TRACY_API void ___tracy_emit_gpu_context_name( const struct ___tracy_gpu_context_name_data ); +TRACY_API void ___tracy_emit_gpu_calibration( const struct ___tracy_gpu_calibration_data ); +TRACY_API void ___tracy_emit_gpu_time_sync( const struct ___tracy_gpu_time_sync_data ); + +TRACY_API void ___tracy_emit_gpu_zone_begin_serial( const struct ___tracy_gpu_zone_begin_data ); +TRACY_API void ___tracy_emit_gpu_zone_begin_callstack_serial( const struct ___tracy_gpu_zone_begin_callstack_data ); +TRACY_API void ___tracy_emit_gpu_zone_begin_alloc_serial( const struct ___tracy_gpu_zone_begin_data ); +TRACY_API void ___tracy_emit_gpu_zone_begin_alloc_callstack_serial( const struct ___tracy_gpu_zone_begin_callstack_data ); +TRACY_API void ___tracy_emit_gpu_zone_end_serial( const struct ___tracy_gpu_zone_end_data data ); +TRACY_API void ___tracy_emit_gpu_time_serial( const struct ___tracy_gpu_time_data ); +TRACY_API void ___tracy_emit_gpu_new_context_serial( const struct ___tracy_gpu_new_context_data ); +TRACY_API void ___tracy_emit_gpu_context_name_serial( const struct ___tracy_gpu_context_name_data ); +TRACY_API void ___tracy_emit_gpu_calibration_serial( const struct ___tracy_gpu_calibration_data ); +TRACY_API void ___tracy_emit_gpu_time_sync_serial( const struct ___tracy_gpu_time_sync_data ); + +TRACY_API int ___tracy_connected(void); + +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define TracyCZone( ctx, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, 0 }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), TRACY_CALLSTACK, active ); +# define TracyCZoneN( ctx, name, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { name, __func__, TracyFile, (uint32_t)TracyLine, 0 }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), TRACY_CALLSTACK, active ); +# define TracyCZoneC( ctx, color, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, color }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), TRACY_CALLSTACK, active ); +# define TracyCZoneNC( ctx, name, color, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { name, __func__, TracyFile, (uint32_t)TracyLine, color }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), TRACY_CALLSTACK, active ); +#else +# define TracyCZone( ctx, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, 0 }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin( &TracyConcat(__tracy_source_location,TracyLine), active ); +# define TracyCZoneN( ctx, name, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { name, __func__, TracyFile, (uint32_t)TracyLine, 0 }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin( &TracyConcat(__tracy_source_location,TracyLine), active ); +# define TracyCZoneC( ctx, color, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, color }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin( &TracyConcat(__tracy_source_location,TracyLine), active ); +# define TracyCZoneNC( ctx, name, color, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { name, __func__, TracyFile, (uint32_t)TracyLine, color }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin( &TracyConcat(__tracy_source_location,TracyLine), active ); +#endif + +#define TracyCZoneEnd( ctx ) ___tracy_emit_zone_end( ctx ); + +#define TracyCZoneText( ctx, txt, size ) ___tracy_emit_zone_text( ctx, txt, size ); +#define TracyCZoneName( ctx, txt, size ) ___tracy_emit_zone_name( ctx, txt, size ); +#define TracyCZoneColor( ctx, color ) ___tracy_emit_zone_color( ctx, color ); +#define TracyCZoneValue( ctx, value ) ___tracy_emit_zone_value( ctx, value ); + + +TRACY_API void ___tracy_emit_memory_alloc( const void* ptr, size_t size, int secure ); +TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int depth, int secure ); +TRACY_API void ___tracy_emit_memory_free( const void* ptr, int secure ); +TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int depth, int secure ); +TRACY_API void ___tracy_emit_memory_alloc_named( const void* ptr, size_t size, int secure, const char* name ); +TRACY_API void ___tracy_emit_memory_alloc_callstack_named( const void* ptr, size_t size, int depth, int secure, const char* name ); +TRACY_API void ___tracy_emit_memory_free_named( const void* ptr, int secure, const char* name ); +TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int depth, int secure, const char* name ); + +TRACY_API void ___tracy_emit_message( const char* txt, size_t size, int callstack ); +TRACY_API void ___tracy_emit_messageL( const char* txt, int callstack ); +TRACY_API void ___tracy_emit_messageC( const char* txt, size_t size, uint32_t color, int callstack ); +TRACY_API void ___tracy_emit_messageLC( const char* txt, uint32_t color, int callstack ); + +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define TracyCAlloc( ptr, size ) ___tracy_emit_memory_alloc_callstack( ptr, size, TRACY_CALLSTACK, 0 ) +# define TracyCFree( ptr ) ___tracy_emit_memory_free_callstack( ptr, TRACY_CALLSTACK, 0 ) +# define TracyCSecureAlloc( ptr, size ) ___tracy_emit_memory_alloc_callstack( ptr, size, TRACY_CALLSTACK, 1 ) +# define TracyCSecureFree( ptr ) ___tracy_emit_memory_free_callstack( ptr, TRACY_CALLSTACK, 1 ) + +# define TracyCAllocN( ptr, size, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, TRACY_CALLSTACK, 0, name ) +# define TracyCFreeN( ptr, name ) ___tracy_emit_memory_free_callstack_named( ptr, TRACY_CALLSTACK, 0, name ) +# define TracyCSecureAllocN( ptr, size, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, TRACY_CALLSTACK, 1, name ) +# define TracyCSecureFreeN( ptr, name ) ___tracy_emit_memory_free_callstack_named( ptr, TRACY_CALLSTACK, 1, name ) + +# define TracyCMessage( txt, size ) ___tracy_emit_message( txt, size, TRACY_CALLSTACK ); +# define TracyCMessageL( txt ) ___tracy_emit_messageL( txt, TRACY_CALLSTACK ); +# define TracyCMessageC( txt, size, color ) ___tracy_emit_messageC( txt, size, color, TRACY_CALLSTACK ); +# define TracyCMessageLC( txt, color ) ___tracy_emit_messageLC( txt, color, TRACY_CALLSTACK ); +#else +# define TracyCAlloc( ptr, size ) ___tracy_emit_memory_alloc( ptr, size, 0 ); +# define TracyCFree( ptr ) ___tracy_emit_memory_free( ptr, 0 ); +# define TracyCSecureAlloc( ptr, size ) ___tracy_emit_memory_alloc( ptr, size, 1 ); +# define TracyCSecureFree( ptr ) ___tracy_emit_memory_free( ptr, 1 ); + +# define TracyCAllocN( ptr, size, name ) ___tracy_emit_memory_alloc_named( ptr, size, 0, name ); +# define TracyCFreeN( ptr, name ) ___tracy_emit_memory_free_named( ptr, 0, name ); +# define TracyCSecureAllocN( ptr, size, name ) ___tracy_emit_memory_alloc_named( ptr, size, 1, name ); +# define TracyCSecureFreeN( ptr, name ) ___tracy_emit_memory_free_named( ptr, 1, name ); + +# define TracyCMessage( txt, size ) ___tracy_emit_message( txt, size, 0 ); +# define TracyCMessageL( txt ) ___tracy_emit_messageL( txt, 0 ); +# define TracyCMessageC( txt, size, color ) ___tracy_emit_messageC( txt, size, color, 0 ); +# define TracyCMessageLC( txt, color ) ___tracy_emit_messageLC( txt, color, 0 ); +#endif + + +TRACY_API void ___tracy_emit_frame_mark( const char* name ); +TRACY_API void ___tracy_emit_frame_mark_start( const char* name ); +TRACY_API void ___tracy_emit_frame_mark_end( const char* name ); +TRACY_API void ___tracy_emit_frame_image( const void* image, uint16_t w, uint16_t h, uint8_t offset, int flip ); + +#define TracyCFrameMark ___tracy_emit_frame_mark( 0 ); +#define TracyCFrameMarkNamed( name ) ___tracy_emit_frame_mark( name ); +#define TracyCFrameMarkStart( name ) ___tracy_emit_frame_mark_start( name ); +#define TracyCFrameMarkEnd( name ) ___tracy_emit_frame_mark_end( name ); +#define TracyCFrameImage( image, width, height, offset, flip ) ___tracy_emit_frame_image( image, width, height, offset, flip ); + + +TRACY_API void ___tracy_emit_plot( const char* name, double val ); +TRACY_API void ___tracy_emit_plot_float( const char* name, float val ); +TRACY_API void ___tracy_emit_plot_int( const char* name, int64_t val ); +TRACY_API void ___tracy_emit_plot_config( const char* name, int type, int step, int fill, uint32_t color ); +TRACY_API void ___tracy_emit_message_appinfo( const char* txt, size_t size ); + +#define TracyCPlot( name, val ) ___tracy_emit_plot( name, val ); +#define TracyCPlotF( name, val ) ___tracy_emit_plot_float( name, val ); +#define TracyCPlotI( name, val ) ___tracy_emit_plot_int( name, val ); +#define TracyCPlotConfig( name, type, step, fill, color ) ___tracy_emit_plot_config( name, type, step, fill, color ); +#define TracyCAppInfo( txt, size ) ___tracy_emit_message_appinfo( txt, size ); + + +#ifdef TRACY_HAS_CALLSTACK +# define TracyCZoneS( ctx, depth, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, 0 }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), depth, active ); +# define TracyCZoneNS( ctx, name, depth, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { name, __func__, TracyFile, (uint32_t)TracyLine, 0 }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), depth, active ); +# define TracyCZoneCS( ctx, color, depth, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, color }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), depth, active ); +# define TracyCZoneNCS( ctx, name, color, depth, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { name, __func__, TracyFile, (uint32_t)TracyLine, color }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), depth, active ); + +# define TracyCAllocS( ptr, size, depth ) ___tracy_emit_memory_alloc_callstack( ptr, size, depth, 0 ) +# define TracyCFreeS( ptr, depth ) ___tracy_emit_memory_free_callstack( ptr, depth, 0 ) +# define TracyCSecureAllocS( ptr, size, depth ) ___tracy_emit_memory_alloc_callstack( ptr, size, depth, 1 ) +# define TracyCSecureFreeS( ptr, depth ) ___tracy_emit_memory_free_callstack( ptr, depth, 1 ) + +# define TracyCAllocNS( ptr, size, depth, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, depth, 0, name ) +# define TracyCFreeNS( ptr, depth, name ) ___tracy_emit_memory_free_callstack_named( ptr, depth, 0, name ) +# define TracyCSecureAllocNS( ptr, size, depth, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, depth, 1, name ) +# define TracyCSecureFreeNS( ptr, depth, name ) ___tracy_emit_memory_free_callstack_named( ptr, depth, 1, name ) + +# define TracyCMessageS( txt, size, depth ) ___tracy_emit_message( txt, size, depth ); +# define TracyCMessageLS( txt, depth ) ___tracy_emit_messageL( txt, depth ); +# define TracyCMessageCS( txt, size, color, depth ) ___tracy_emit_messageC( txt, size, color, depth ); +# define TracyCMessageLCS( txt, color, depth ) ___tracy_emit_messageLC( txt, color, depth ); +#else +# define TracyCZoneS( ctx, depth, active ) TracyCZone( ctx, active ) +# define TracyCZoneNS( ctx, name, depth, active ) TracyCZoneN( ctx, name, active ) +# define TracyCZoneCS( ctx, color, depth, active ) TracyCZoneC( ctx, color, active ) +# define TracyCZoneNCS( ctx, name, color, depth, active ) TracyCZoneNC( ctx, name, color, active ) + +# define TracyCAllocS( ptr, size, depth ) TracyCAlloc( ptr, size ) +# define TracyCFreeS( ptr, depth ) TracyCFree( ptr ) +# define TracyCSecureAllocS( ptr, size, depth ) TracyCSecureAlloc( ptr, size ) +# define TracyCSecureFreeS( ptr, depth ) TracyCSecureFree( ptr ) + +# define TracyCAllocNS( ptr, size, depth, name ) TracyCAllocN( ptr, size, name ) +# define TracyCFreeNS( ptr, depth, name ) TracyCFreeN( ptr, name ) +# define TracyCSecureAllocNS( ptr, size, depth, name ) TracyCSecureAllocN( ptr, size, name ) +# define TracyCSecureFreeNS( ptr, depth, name ) TracyCSecureFreeN( ptr, name ) + +# define TracyCMessageS( txt, size, depth ) TracyCMessage( txt, size ) +# define TracyCMessageLS( txt, depth ) TracyCMessageL( txt ) +# define TracyCMessageCS( txt, size, color, depth ) TracyCMessageC( txt, size, color ) +# define TracyCMessageLCS( txt, color, depth ) TracyCMessageLC( txt, color ) +#endif + + +TRACY_API struct __tracy_lockable_context_data* ___tracy_announce_lockable_ctx( const struct ___tracy_source_location_data* srcloc ); +TRACY_API void ___tracy_terminate_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); +TRACY_API int ___tracy_before_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); +TRACY_API void ___tracy_after_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); +TRACY_API void ___tracy_after_unlock_lockable_ctx( struct __tracy_lockable_context_data* lockdata ); +TRACY_API void ___tracy_after_try_lock_lockable_ctx( struct __tracy_lockable_context_data* lockdata, int acquired ); +TRACY_API void ___tracy_mark_lockable_ctx( struct __tracy_lockable_context_data* lockdata, const struct ___tracy_source_location_data* srcloc ); +TRACY_API void ___tracy_custom_name_lockable_ctx( struct __tracy_lockable_context_data* lockdata, const char* name, size_t nameSz ); + +#define TracyCLockAnnounce( lock ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, 0 }; lock = ___tracy_announce_lockable_ctx( &TracyConcat(__tracy_source_location,TracyLine) ); +#define TracyCLockTerminate( lock ) ___tracy_terminate_lockable_ctx( lock ); +#define TracyCLockBeforeLock( lock ) ___tracy_before_lock_lockable_ctx( lock ); +#define TracyCLockAfterLock( lock ) ___tracy_after_lock_lockable_ctx( lock ); +#define TracyCLockAfterUnlock( lock ) ___tracy_after_unlock_lockable_ctx( lock ); +#define TracyCLockAfterTryLock( lock, acquired ) ___tracy_after_try_lock_lockable_ctx( lock, acquired ); +#define TracyCLockMark( lock ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, 0 }; ___tracy_mark_lockable_ctx( lock, &TracyConcat(__tracy_source_location,TracyLine) ); +#define TracyCLockCustomName( lock, name, nameSz ) ___tracy_custom_name_lockable_ctx( lock, name, nameSz ); + +#define TracyCIsConnected ___tracy_connected() + +#ifdef TRACY_FIBERS +TRACY_API void ___tracy_fiber_enter( const char* fiber ); +TRACY_API void ___tracy_fiber_leave( void ); + +# define TracyCFiberEnter( fiber ) ___tracy_fiber_enter( fiber ); +# define TracyCFiberLeave ___tracy_fiber_leave(); +#endif + +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Dependencies/tracy/tracy/TracyD3D11.hpp b/Dependencies/tracy/tracy/TracyD3D11.hpp new file mode 100644 index 000000000..3ed151bff --- /dev/null +++ b/Dependencies/tracy/tracy/TracyD3D11.hpp @@ -0,0 +1,446 @@ +#ifndef __TRACYD3D11_HPP__ +#define __TRACYD3D11_HPP__ + +#ifndef TRACY_ENABLE + +#define TracyD3D11Context(device,queue) nullptr +#define TracyD3D11Destroy(ctx) +#define TracyD3D11ContextName(ctx, name, size) + +#define TracyD3D11NewFrame(ctx) + +#define TracyD3D11Zone(ctx, name) +#define TracyD3D11ZoneC(ctx, name, color) +#define TracyD3D11NamedZone(ctx, varname, name, active) +#define TracyD3D11NamedZoneC(ctx, varname, name, color, active) +#define TracyD3D11ZoneTransient(ctx, varname, name, active) + +#define TracyD3D11ZoneS(ctx, name, depth) +#define TracyD3D11ZoneCS(ctx, name, color, depth) +#define TracyD3D11NamedZoneS(ctx, varname, name, depth, active) +#define TracyD3D11NamedZoneCS(ctx, varname, name, color, depth, active) +#define TracyD3D11ZoneTransientS(ctx, varname, name, depth, active) + +#define TracyD3D11Collect(ctx) + +namespace tracy +{ +class D3D11ZoneScope {}; +} + +using TracyD3D11Ctx = void*; + +#else + +#include +#include +#include + +#include "Tracy.hpp" +#include "../client/TracyProfiler.hpp" +#include "../client/TracyCallstack.hpp" +#include "../common/TracyYield.hpp" + +#include + +#define TracyD3D11Panic(msg, ...) do { assert(false && "TracyD3D11: " msg); TracyMessageLC("TracyD3D11: " msg, tracy::Color::Red4); __VA_ARGS__; } while(false); + +namespace tracy +{ + +class D3D11Ctx +{ + friend class D3D11ZoneScope; + + static constexpr uint32_t MaxQueries = 64 * 1024; + + enum CollectMode { POLL, BLOCK }; + +public: + D3D11Ctx( ID3D11Device* device, ID3D11DeviceContext* devicectx ) + { + // TODO: consider calling ID3D11Device::GetImmediateContext() instead of passing it as an argument + m_device = device; + device->AddRef(); + m_immediateDevCtx = devicectx; + devicectx->AddRef(); + + { + D3D11_QUERY_DESC desc = { }; + desc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT; + if (FAILED(m_device->CreateQuery(&desc, &m_disjointQuery))) + { + TracyD3D11Panic("unable to create disjoint timestamp query.", return); + } + } + + for (ID3D11Query*& query : m_queries) + { + D3D11_QUERY_DESC desc = { }; + desc.Query = D3D11_QUERY_TIMESTAMP; + if (FAILED(m_device->CreateQuery(&desc, &query))) + { + TracyD3D11Panic("unable to create timestamp query.", return); + } + } + + // Calibrate CPU and GPU timestamps + int64_t tcpu = 0; + int64_t tgpu = 0; + for (int attempts = 0; attempts < 50; attempts++) + { + m_immediateDevCtx->Begin(m_disjointQuery); + m_immediateDevCtx->End(m_queries[0]); + m_immediateDevCtx->End(m_disjointQuery); + + int64_t tcpu0 = Profiler::GetTime(); + WaitForQuery(m_disjointQuery); + int64_t tcpu1 = Profiler::GetTime(); + + D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjoint = { }; + if (m_immediateDevCtx->GetData(m_disjointQuery, &disjoint, sizeof(disjoint), 0) != S_OK) + { + TracyMessageLC("TracyD3D11: unable to query GPU timestamp; retrying...", tracy::Color::Tomato); + continue; + } + + if (disjoint.Disjoint) + continue; + + UINT64 timestamp = 0; + if (m_immediateDevCtx->GetData(m_queries[0], ×tamp, sizeof(timestamp), 0) != S_OK) + continue; // this should never happen, since the enclosing disjoint query succeeded + + tcpu = tcpu0 + (tcpu1 - tcpu0) * 1 / 2; + tgpu = timestamp * (1000000000 / disjoint.Frequency); + break; + } + + // ready to roll + m_contextId = GetGpuCtxCounter().fetch_add(1); + m_immediateDevCtx->Begin(m_disjointQuery); + m_previousCheckpoint = m_nextCheckpoint = 0; + + auto* item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuNewContext ); + MemWrite( &item->gpuNewContext.cpuTime, tcpu ); + MemWrite( &item->gpuNewContext.gpuTime, tgpu ); + MemWrite( &item->gpuNewContext.thread, uint32_t(0) ); // #TODO: why not GetThreadHandle()? + MemWrite( &item->gpuNewContext.period, 1.0f ); + MemWrite( &item->gpuNewContext.context, m_contextId); + MemWrite( &item->gpuNewContext.flags, uint8_t(0) ); + MemWrite( &item->gpuNewContext.type, GpuContextType::Direct3D11 ); + +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + + Profiler::QueueSerialFinish(); + } + + ~D3D11Ctx() + { + // collect all pending timestamps before destroying everything + do + { + Collect(BLOCK); + } while (m_previousCheckpoint != m_queryCounter); + + for (ID3D11Query* query : m_queries) + { + query->Release(); + } + m_immediateDevCtx->End(m_disjointQuery); + m_disjointQuery->Release(); + m_immediateDevCtx->Release(); + m_device->Release(); + } + + void Name( const char* name, uint16_t len ) + { + auto ptr = (char*)tracy_malloc( len ); + memcpy( ptr, name, len ); + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuContextName ); + MemWrite( &item->gpuContextNameFat.context, m_contextId ); + MemWrite( &item->gpuContextNameFat.ptr, (uint64_t)ptr ); + MemWrite( &item->gpuContextNameFat.size, len ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + + void Collect(CollectMode mode = POLL) + { + ZoneScopedC( Color::Red4 ); + +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) + { + m_previousCheckpoint = m_nextCheckpoint = m_queryCounter; + return; + } +#endif + + if (m_previousCheckpoint == m_nextCheckpoint) + { + uintptr_t nextCheckpoint = m_queryCounter; + if (nextCheckpoint == m_nextCheckpoint) + { + return; + } + m_nextCheckpoint = nextCheckpoint; + m_immediateDevCtx->End(m_disjointQuery); + } + + if (mode == CollectMode::BLOCK) + { + WaitForQuery(m_disjointQuery); + } + + D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjoint = { }; + if (m_immediateDevCtx->GetData(m_disjointQuery, &disjoint, sizeof(disjoint), D3D11_ASYNC_GETDATA_DONOTFLUSH) != S_OK) + { + return; + } + + if (disjoint.Disjoint == TRUE) + { + m_previousCheckpoint = m_nextCheckpoint; + TracyD3D11Panic("disjoint timestamps detected; dropping."); + return; + } + + auto begin = m_previousCheckpoint; + auto end = m_nextCheckpoint; + for (auto i = begin; i != end; ++i) + { + uint32_t k = RingIndex(i); + UINT64 timestamp = 0; + if (m_immediateDevCtx->GetData(m_queries[k], ×tamp, sizeof(timestamp), 0) != S_OK) + { + TracyD3D11Panic("timestamp expected to be ready, but it was not!"); + break; + } + timestamp *= (1000000000ull / disjoint.Frequency); + auto* item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuTime); + MemWrite(&item->gpuTime.gpuTime, static_cast(timestamp)); + MemWrite(&item->gpuTime.queryId, static_cast(k)); + MemWrite(&item->gpuTime.context, m_contextId); + Profiler::QueueSerialFinish(); + } + + // disjoint timestamp queries should only be invoked once per frame or less + // https://learn.microsoft.com/en-us/windows/win32/api/d3d11/ne-d3d11-d3d11_query + m_immediateDevCtx->Begin(m_disjointQuery); + m_previousCheckpoint = m_nextCheckpoint; + } + +private: + tracy_force_inline uint32_t RingIndex(uintptr_t index) + { + index %= MaxQueries; + return static_cast(index); + } + + tracy_force_inline uint32_t RingCount(uintptr_t begin, uintptr_t end) + { + // wrap-around safe: all unsigned + uintptr_t count = end - begin; + return static_cast(count); + } + + tracy_force_inline uint32_t NextQueryId() + { + auto id = m_queryCounter++; + if (RingCount(m_previousCheckpoint, id) >= MaxQueries) + { + TracyD3D11Panic("too many pending timestamp queries."); + // #TODO: return some sentinel value; ideally a "hidden" query index + } + return RingIndex(id); + } + + tracy_force_inline ID3D11Query* GetQueryObjectFromId(uint32_t id) + { + return m_queries[id]; + } + + tracy_force_inline void WaitForQuery(ID3D11Query* query) + { + m_immediateDevCtx->Flush(); + while (m_immediateDevCtx->GetData(query, nullptr, 0, 0) != S_OK) + YieldThread(); // busy-wait :-( attempt to reduce power usage with _mm_pause() & friends... + } + + tracy_force_inline uint8_t GetContextId() const + { + return m_contextId; + } + + ID3D11Device* m_device = nullptr; + ID3D11DeviceContext* m_immediateDevCtx = nullptr; + + ID3D11Query* m_queries[MaxQueries]; + ID3D11Query* m_disjointQuery = nullptr; + + uint8_t m_contextId = 255; // NOTE: apparently, 255 means invalid id; is this documented anywhere? + + uintptr_t m_queryCounter = 0; + + uintptr_t m_previousCheckpoint = 0; + uintptr_t m_nextCheckpoint = 0; +}; + +class D3D11ZoneScope +{ +public: + tracy_force_inline D3D11ZoneScope( D3D11Ctx* ctx, const SourceLocationData* srcloc, bool active ) + : D3D11ZoneScope(ctx, active) + { + if( !m_active ) return; + + auto* item = Profiler::QueueSerial(); + WriteQueueItem(item, QueueType::GpuZoneBeginSerial, reinterpret_cast(srcloc)); + } + + tracy_force_inline D3D11ZoneScope( D3D11Ctx* ctx, const SourceLocationData* srcloc, int depth, bool active ) + : D3D11ZoneScope(ctx, active) + { + if( !m_active ) return; + + auto* item = Profiler::QueueSerialCallstack(Callstack(depth)); + WriteQueueItem(item, QueueType::GpuZoneBeginCallstackSerial, reinterpret_cast(srcloc)); + } + + tracy_force_inline D3D11ZoneScope(D3D11Ctx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, bool active) + : D3D11ZoneScope(ctx, active) + { + if( !m_active ) return; + + const auto sourceLocation = Profiler::AllocSourceLocation(line, source, sourceSz, function, functionSz, name, nameSz); + + auto* item = Profiler::QueueSerial(); + WriteQueueItem(item, QueueType::GpuZoneBeginAllocSrcLocSerial, sourceLocation); + } + + tracy_force_inline D3D11ZoneScope(D3D11Ctx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, int depth, bool active) + : D3D11ZoneScope(ctx, active) + { + if( !m_active ) return; + + const auto sourceLocation = Profiler::AllocSourceLocation(line, source, sourceSz, function, functionSz, name, nameSz); + + auto* item = Profiler::QueueSerialCallstack(Callstack(depth)); + WriteQueueItem(item, QueueType::GpuZoneBeginAllocSrcLocCallstackSerial, sourceLocation); + } + + tracy_force_inline ~D3D11ZoneScope() + { + if( !m_active ) return; + + const auto queryId = m_ctx->NextQueryId(); + m_ctx->m_immediateDevCtx->End(m_ctx->GetQueryObjectFromId(queryId)); + + auto* item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuZoneEndSerial ); + MemWrite( &item->gpuZoneEnd.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneEnd.thread, GetThreadHandle() ); + MemWrite( &item->gpuZoneEnd.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneEnd.context, m_ctx->GetContextId() ); + Profiler::QueueSerialFinish(); + } + +private: + tracy_force_inline D3D11ZoneScope( D3D11Ctx* ctx, bool active ) +#ifdef TRACY_ON_DEMAND + : m_active( active && GetProfiler().IsConnected() ) +#else + : m_active( active ) +#endif + { + if( !m_active ) return; + m_ctx = ctx; + } + + void WriteQueueItem(tracy::QueueItem* item, tracy::QueueType queueItemType, uint64_t sourceLocation) + { + const auto queryId = m_ctx->NextQueryId(); + m_ctx->m_immediateDevCtx->End(m_ctx->GetQueryObjectFromId(queryId)); + + MemWrite( &item->hdr.type, queueItemType); + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneBegin.srcloc, sourceLocation ); + MemWrite( &item->gpuZoneBegin.thread, GetThreadHandle() ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, m_ctx->GetContextId() ); + Profiler::QueueSerialFinish(); + } + + const bool m_active; + + D3D11Ctx* m_ctx; +}; + +static inline D3D11Ctx* CreateD3D11Context( ID3D11Device* device, ID3D11DeviceContext* devicectx ) +{ + auto ctx = (D3D11Ctx*)tracy_malloc( sizeof( D3D11Ctx ) ); + new(ctx) D3D11Ctx( device, devicectx ); + return ctx; +} + +static inline void DestroyD3D11Context( D3D11Ctx* ctx ) +{ + ctx->~D3D11Ctx(); + tracy_free( ctx ); +} +} + +#undef TracyD3D11Panic + +using TracyD3D11Ctx = tracy::D3D11Ctx*; + +#define TracyD3D11Context( device, devicectx ) tracy::CreateD3D11Context( device, devicectx ); +#define TracyD3D11Destroy(ctx) tracy::DestroyD3D11Context(ctx); +#define TracyD3D11ContextName(ctx, name, size) ctx->Name(name, size); + +#define TracyD3D11UnnamedZone ___tracy_gpu_d3d11_zone +#define TracyD3D11SrcLocSymbol TracyConcat(__tracy_gpu_d3d11_source_location,TracyLine) +#define TracyD3D11SrcLocObject(name, color) static constexpr tracy::SourceLocationData TracyD3D11SrcLocSymbol { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; + +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define TracyD3D11Zone( ctx, name ) TracyD3D11NamedZoneS( ctx, TracyD3D11UnnamedZone, name, TRACY_CALLSTACK, true ) +# define TracyD3D11ZoneC( ctx, name, color ) TracyD3D11NamedZoneCS( ctx, TracyD3D11UnnamedZone, name, color, TRACY_CALLSTACK, true ) +# define TracyD3D11NamedZone( ctx, varname, name, active ) TracyD3D11SrcLocObject(name, 0); tracy::D3D11ZoneScope varname( ctx, &TracyD3D11SrcLocSymbol, TRACY_CALLSTACK, active ); +# define TracyD3D11NamedZoneC( ctx, varname, name, color, active ) TracyD3D11SrcLocObject(name, color); tracy::D3D11ZoneScope varname( ctx, &TracyD3D11SrcLocSymbol, TRACY_CALLSTACK, active ); +# define TracyD3D11ZoneTransient(ctx, varname, name, active) TracyD3D11ZoneTransientS(ctx, varname, cmdList, name, TRACY_CALLSTACK, active) +#else +# define TracyD3D11Zone( ctx, name ) TracyD3D11NamedZone( ctx, TracyD3D11UnnamedZone, name, true ) +# define TracyD3D11ZoneC( ctx, name, color ) TracyD3D11NamedZoneC( ctx, TracyD3D11UnnamedZone, name, color, true ) +# define TracyD3D11NamedZone( ctx, varname, name, active ) TracyD3D11SrcLocObject(name, 0); tracy::D3D11ZoneScope varname( ctx, &TracyD3D11SrcLocSymbol, active ); +# define TracyD3D11NamedZoneC( ctx, varname, name, color, active ) TracyD3D11SrcLocObject(name, color); tracy::D3D11ZoneScope varname( ctx, &TracyD3D11SrcLocSymbol, active ); +# define TracyD3D11ZoneTransient(ctx, varname, name, active) tracy::D3D11ZoneScope varname{ ctx, TracyLine, TracyFile, strlen(TracyFile), TracyFunction, strlen(TracyFunction), name, strlen(name), active }; +#endif + +#ifdef TRACY_HAS_CALLSTACK +# define TracyD3D11ZoneS( ctx, name, depth ) TracyD3D11NamedZoneS( ctx, TracyD3D11UnnamedZone, name, depth, true ) +# define TracyD3D11ZoneCS( ctx, name, color, depth ) TracyD3D11NamedZoneCS( ctx, TracyD3D11UnnamedZone, name, color, depth, true ) +# define TracyD3D11NamedZoneS( ctx, varname, name, depth, active ) TracyD3D11SrcLocObject(name, 0); tracy::D3D11ZoneScope varname( ctx, &TracyD3D11SrcLocSymbol, depth, active ); +# define TracyD3D11NamedZoneCS( ctx, varname, name, color, depth, active ) TracyD3D11SrcLocObject(name, color); tracy::D3D11ZoneScope varname( ctx, &TracyD3D11SrcLocSymbol, depth, active ); +# define TracyD3D11ZoneTransientS(ctx, varname, name, depth, active) tracy::D3D11ZoneScope varname{ ctx, TracyLine, TracyFile, strlen(TracyFile), TracyFunction, strlen(TracyFunction), name, strlen(name), depth, active }; +#else +# define TracyD3D11ZoneS( ctx, name, depth, active ) TracyD3D11Zone( ctx, name ) +# define TracyD3D11ZoneCS( ctx, name, color, depth, active ) TracyD3D11ZoneC( name, color ) +# define TracyD3D11NamedZoneS( ctx, varname, name, depth, active ) TracyD3D11NamedZone( ctx, varname, name, active ) +# define TracyD3D11NamedZoneCS( ctx, varname, name, color, depth, active ) TracyD3D11NamedZoneC( ctx, varname, name, color, active ) +# define TracyD3D11ZoneTransientS(ctx, varname, name, depth, active) TracyD3D11ZoneTransient(ctx, varname, name, active) +#endif + +#define TracyD3D11Collect( ctx ) ctx->Collect(); + +#endif + +#endif diff --git a/Dependencies/tracy/tracy/TracyD3D12.hpp b/Dependencies/tracy/tracy/TracyD3D12.hpp new file mode 100644 index 000000000..41567937e --- /dev/null +++ b/Dependencies/tracy/tracy/TracyD3D12.hpp @@ -0,0 +1,500 @@ +#ifndef __TRACYD3D12_HPP__ +#define __TRACYD3D12_HPP__ + +#ifndef TRACY_ENABLE + +#define TracyD3D12Context(device, queue) nullptr +#define TracyD3D12Destroy(ctx) +#define TracyD3D12ContextName(ctx, name, size) + +#define TracyD3D12NewFrame(ctx) + +#define TracyD3D12Zone(ctx, cmdList, name) +#define TracyD3D12ZoneC(ctx, cmdList, name, color) +#define TracyD3D12NamedZone(ctx, varname, cmdList, name, active) +#define TracyD3D12NamedZoneC(ctx, varname, cmdList, name, color, active) +#define TracyD3D12ZoneTransient(ctx, varname, cmdList, name, active) + +#define TracyD3D12ZoneS(ctx, cmdList, name, depth) +#define TracyD3D12ZoneCS(ctx, cmdList, name, color, depth) +#define TracyD3D12NamedZoneS(ctx, varname, cmdList, name, depth, active) +#define TracyD3D12NamedZoneCS(ctx, varname, cmdList, name, color, depth, active) +#define TracyD3D12ZoneTransientS(ctx, varname, cmdList, name, depth, active) + +#define TracyD3D12Collect(ctx) + +namespace tracy +{ + class D3D12ZoneScope {}; +} + +using TracyD3D12Ctx = void*; + +#else + +#include "Tracy.hpp" +#include "../client/TracyProfiler.hpp" +#include "../client/TracyCallstack.hpp" + +#include +#include +#include +#include +#include + +#define TracyD3D12Panic(msg, ...) do { assert(false && "TracyD3D12: " msg); TracyMessageLC("TracyD3D12: " msg, tracy::Color::Red4); __VA_ARGS__; } while(false); + +namespace tracy +{ + + struct D3D12QueryPayload + { + uint32_t m_queryIdStart = 0; + uint32_t m_queryCount = 0; + }; + + // Command queue context. + class D3D12QueueCtx + { + friend class D3D12ZoneScope; + + ID3D12Device* m_device = nullptr; + ID3D12CommandQueue* m_queue = nullptr; + uint8_t m_contextId = 255; // TODO: apparently, 255 means "invalid id"; is this documented somewhere? + ID3D12QueryHeap* m_queryHeap = nullptr; + ID3D12Resource* m_readbackBuffer = nullptr; + + // In-progress payload. + uint32_t m_queryLimit = 0; + std::atomic m_queryCounter = 0; + uint32_t m_previousQueryCounter = 0; + + uint32_t m_activePayload = 0; + ID3D12Fence* m_payloadFence = nullptr; + std::queue m_payloadQueue; + + UINT64 m_prevCalibrationTicksCPU = 0; + + void RecalibrateClocks() + { + UINT64 cpuTimestamp; + UINT64 gpuTimestamp; + if (FAILED(m_queue->GetClockCalibration(&gpuTimestamp, &cpuTimestamp))) + { + TracyD3D12Panic("failed to obtain queue clock calibration counters.", return); + } + + int64_t cpuDeltaTicks = cpuTimestamp - m_prevCalibrationTicksCPU; + if (cpuDeltaTicks > 0) + { + static const int64_t nanosecodsPerTick = int64_t(1000000000) / GetFrequencyQpc(); + int64_t cpuDeltaNS = cpuDeltaTicks * nanosecodsPerTick; + // Save the device cpu timestamp, not the Tracy profiler timestamp: + m_prevCalibrationTicksCPU = cpuTimestamp; + + cpuTimestamp = Profiler::GetTime(); + + auto* item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuCalibration); + MemWrite(&item->gpuCalibration.gpuTime, gpuTimestamp); + MemWrite(&item->gpuCalibration.cpuTime, cpuTimestamp); + MemWrite(&item->gpuCalibration.cpuDelta, cpuDeltaNS); + MemWrite(&item->gpuCalibration.context, GetId()); + SubmitQueueItem(item); + } + } + + tracy_force_inline void SubmitQueueItem(tracy::QueueItem* item) + { +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem(*item); +#endif + Profiler::QueueSerialFinish(); + } + + public: + D3D12QueueCtx(ID3D12Device* device, ID3D12CommandQueue* queue) + : m_device(device) + , m_queue(queue) + { + // Verify we support timestamp queries on this queue. + + if (queue->GetDesc().Type == D3D12_COMMAND_LIST_TYPE_COPY) + { + D3D12_FEATURE_DATA_D3D12_OPTIONS3 featureData{}; + + HRESULT hr = device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &featureData, sizeof(featureData)); + if (FAILED(hr) || (featureData.CopyQueueTimestampQueriesSupported == FALSE)) + { + TracyD3D12Panic("Platform does not support profiling of copy queues.", return); + } + } + + static constexpr uint32_t MaxQueries = 64 * 1024; // Must be even, because queries are (begin, end) pairs + m_queryLimit = MaxQueries; + + D3D12_QUERY_HEAP_DESC heapDesc{}; + heapDesc.Type = queue->GetDesc().Type == D3D12_COMMAND_LIST_TYPE_COPY ? D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP : D3D12_QUERY_HEAP_TYPE_TIMESTAMP; + heapDesc.Count = m_queryLimit; + heapDesc.NodeMask = 0; // #TODO: Support multiple adapters. + + while (FAILED(device->CreateQueryHeap(&heapDesc, IID_PPV_ARGS(&m_queryHeap)))) + { + m_queryLimit /= 2; + heapDesc.Count = m_queryLimit; + } + + // Create a readback buffer, which will be used as a destination for the query data. + + D3D12_RESOURCE_DESC readbackBufferDesc{}; + readbackBufferDesc.Alignment = 0; + readbackBufferDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; + readbackBufferDesc.Width = m_queryLimit * sizeof(uint64_t); + readbackBufferDesc.Height = 1; + readbackBufferDesc.DepthOrArraySize = 1; + readbackBufferDesc.Format = DXGI_FORMAT_UNKNOWN; + readbackBufferDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; // Buffers are always row major. + readbackBufferDesc.MipLevels = 1; + readbackBufferDesc.SampleDesc.Count = 1; + readbackBufferDesc.SampleDesc.Quality = 0; + readbackBufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE; + + D3D12_HEAP_PROPERTIES readbackHeapProps{}; + readbackHeapProps.Type = D3D12_HEAP_TYPE_READBACK; + readbackHeapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; + readbackHeapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; + readbackHeapProps.CreationNodeMask = 0; + readbackHeapProps.VisibleNodeMask = 0; // #TODO: Support multiple adapters. + + if (FAILED(device->CreateCommittedResource(&readbackHeapProps, D3D12_HEAP_FLAG_NONE, &readbackBufferDesc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_readbackBuffer)))) + { + TracyD3D12Panic("Failed to create query readback buffer.", return); + } + + if (FAILED(device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_payloadFence)))) + { + TracyD3D12Panic("Failed to create payload fence.", return); + } + + float period = [queue]() + { + uint64_t timestampFrequency; + if (FAILED(queue->GetTimestampFrequency(×tampFrequency))) + { + return 0.0f; + } + return static_cast( 1E+09 / static_cast(timestampFrequency) ); + }(); + + if (period == 0.0f) + { + TracyD3D12Panic("Failed to get timestamp frequency.", return); + } + + uint64_t cpuTimestamp; + uint64_t gpuTimestamp; + if (FAILED(queue->GetClockCalibration(&gpuTimestamp, &cpuTimestamp))) + { + TracyD3D12Panic("Failed to get queue clock calibration.", return); + } + + // Save the device cpu timestamp, not the profiler's timestamp. + m_prevCalibrationTicksCPU = cpuTimestamp; + + cpuTimestamp = Profiler::GetTime(); + + // all checked: ready to roll + m_contextId = GetGpuCtxCounter().fetch_add(1); + + auto* item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuNewContext); + MemWrite(&item->gpuNewContext.cpuTime, cpuTimestamp); + MemWrite(&item->gpuNewContext.gpuTime, gpuTimestamp); + MemWrite(&item->gpuNewContext.thread, decltype(item->gpuNewContext.thread)(0)); // #TODO: why 0 instead of GetThreadHandle()? + MemWrite(&item->gpuNewContext.period, period); + MemWrite(&item->gpuNewContext.context, GetId()); + MemWrite(&item->gpuNewContext.flags, GpuContextCalibration); + MemWrite(&item->gpuNewContext.type, GpuContextType::Direct3D12); + SubmitQueueItem(item); + } + + ~D3D12QueueCtx() + { + ZoneScopedC(Color::Red4); + // collect all pending timestamps + while (m_payloadFence->GetCompletedValue() != m_activePayload) + /* busy-wait ... */; + Collect(); + m_payloadFence->Release(); + m_readbackBuffer->Release(); + m_queryHeap->Release(); + } + + + void NewFrame() + { + uint32_t queryCounter = m_queryCounter.exchange(0); + m_payloadQueue.emplace(D3D12QueryPayload{ m_previousQueryCounter, queryCounter }); + m_previousQueryCounter += queryCounter; + + if (m_previousQueryCounter >= m_queryLimit) + { + m_previousQueryCounter -= m_queryLimit; + } + + m_queue->Signal(m_payloadFence, ++m_activePayload); + } + + void Name( const char* name, uint16_t len ) + { + auto ptr = (char*)tracy_malloc( len ); + memcpy( ptr, name, len ); + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuContextName ); + MemWrite( &item->gpuContextNameFat.context, GetId()); + MemWrite( &item->gpuContextNameFat.ptr, (uint64_t)ptr ); + MemWrite( &item->gpuContextNameFat.size, len ); + SubmitQueueItem(item); + } + + void Collect() + { + ZoneScopedC(Color::Red4); + +#ifdef TRACY_ON_DEMAND + if (!GetProfiler().IsConnected()) + { + m_queryCounter = 0; + + return; + } +#endif + + // Find out what payloads are available. + const auto newestReadyPayload = m_payloadFence->GetCompletedValue(); + const auto payloadCount = m_payloadQueue.size() - (m_activePayload - newestReadyPayload); + + if (!payloadCount) + { + return; // No payloads are available yet, exit out. + } + + D3D12_RANGE mapRange{ 0, m_queryLimit * sizeof(uint64_t) }; + + // Map the readback buffer so we can fetch the query data from the GPU. + void* readbackBufferMapping = nullptr; + + if (FAILED(m_readbackBuffer->Map(0, &mapRange, &readbackBufferMapping))) + { + TracyD3D12Panic("Failed to map readback buffer.", return); + } + + auto* timestampData = static_cast(readbackBufferMapping); + + for (uint32_t i = 0; i < payloadCount; ++i) + { + const auto& payload = m_payloadQueue.front(); + + for (uint32_t j = 0; j < payload.m_queryCount; ++j) + { + const auto counter = (payload.m_queryIdStart + j) % m_queryLimit; + const auto timestamp = timestampData[counter]; + const auto queryId = counter; + + auto* item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuTime); + MemWrite(&item->gpuTime.gpuTime, timestamp); + MemWrite(&item->gpuTime.queryId, static_cast(queryId)); + MemWrite(&item->gpuTime.context, GetId()); + + Profiler::QueueSerialFinish(); + } + + m_payloadQueue.pop(); + } + + m_readbackBuffer->Unmap(0, nullptr); + + // Recalibrate to account for drift. + RecalibrateClocks(); + } + + private: + tracy_force_inline uint32_t NextQueryId() + { + uint32_t queryCounter = m_queryCounter.fetch_add(2); + if (queryCounter >= m_queryLimit) + { + TracyD3D12Panic("Submitted too many GPU queries! Consider increasing MaxQueries."); + // #TODO: consider returning an invalid id or sentinel value here + } + + const uint32_t id = (m_previousQueryCounter + queryCounter) % m_queryLimit; + + return id; + } + + tracy_force_inline uint8_t GetId() const + { + return m_contextId; + } + }; + + class D3D12ZoneScope + { + const bool m_active; + D3D12QueueCtx* m_ctx = nullptr; + ID3D12GraphicsCommandList* m_cmdList = nullptr; + uint32_t m_queryId = 0; // Used for tracking in nested zones. + + tracy_force_inline void WriteQueueItem(QueueItem* item, QueueType type, uint64_t srcLocation) + { + MemWrite(&item->hdr.type, type); + MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime()); + MemWrite(&item->gpuZoneBegin.srcloc, srcLocation); + MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle()); + MemWrite(&item->gpuZoneBegin.queryId, static_cast(m_queryId)); + MemWrite(&item->gpuZoneBegin.context, m_ctx->GetId()); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, ID3D12GraphicsCommandList* cmdList, bool active) +#ifdef TRACY_ON_DEMAND + : m_active(active&& GetProfiler().IsConnected()) +#else + : m_active(active) +#endif + { + if (!m_active) return; + + m_ctx = ctx; + m_cmdList = cmdList; + + m_queryId = m_ctx->NextQueryId(); + m_cmdList->EndQuery(m_ctx->m_queryHeap, D3D12_QUERY_TYPE_TIMESTAMP, m_queryId); + } + + public: + tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, ID3D12GraphicsCommandList* cmdList, const SourceLocationData* srcLocation, bool active) + : D3D12ZoneScope(ctx, cmdList, active) + { + if (!m_active) return; + + auto* item = Profiler::QueueSerial(); + WriteQueueItem(item, QueueType::GpuZoneBeginSerial, reinterpret_cast(srcLocation)); + } + + tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, ID3D12GraphicsCommandList* cmdList, const SourceLocationData* srcLocation, int depth, bool active) + : D3D12ZoneScope(ctx, cmdList, active) + { + if (!m_active) return; + + auto* item = Profiler::QueueSerialCallstack(Callstack(depth)); + WriteQueueItem(item, QueueType::GpuZoneBeginCallstackSerial, reinterpret_cast(srcLocation)); + } + + tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, ID3D12GraphicsCommandList* cmdList, bool active) + : D3D12ZoneScope(ctx, cmdList, active) + { + if (!m_active) return; + + const auto sourceLocation = Profiler::AllocSourceLocation(line, source, sourceSz, function, functionSz, name, nameSz); + + auto* item = Profiler::QueueSerial(); + WriteQueueItem(item, QueueType::GpuZoneBeginAllocSrcLocSerial, sourceLocation); + } + + tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, ID3D12GraphicsCommandList* cmdList, int depth, bool active) + : D3D12ZoneScope(ctx, cmdList, active) + { + if (!m_active) return; + + const auto sourceLocation = Profiler::AllocSourceLocation(line, source, sourceSz, function, functionSz, name, nameSz); + + auto* item = Profiler::QueueSerialCallstack(Callstack(depth)); + WriteQueueItem(item, QueueType::GpuZoneBeginAllocSrcLocCallstackSerial, sourceLocation); + } + + tracy_force_inline ~D3D12ZoneScope() + { + if (!m_active) return; + + const auto queryId = m_queryId + 1; // Our end query slot is immediately after the begin slot. + m_cmdList->EndQuery(m_ctx->m_queryHeap, D3D12_QUERY_TYPE_TIMESTAMP, queryId); + + auto* item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuZoneEndSerial); + MemWrite(&item->gpuZoneEnd.cpuTime, Profiler::GetTime()); + MemWrite(&item->gpuZoneEnd.thread, GetThreadHandle()); + MemWrite(&item->gpuZoneEnd.queryId, static_cast(queryId)); + MemWrite(&item->gpuZoneEnd.context, m_ctx->GetId()); + Profiler::QueueSerialFinish(); + + m_cmdList->ResolveQueryData(m_ctx->m_queryHeap, D3D12_QUERY_TYPE_TIMESTAMP, m_queryId, 2, m_ctx->m_readbackBuffer, m_queryId * sizeof(uint64_t)); + } + }; + + static inline D3D12QueueCtx* CreateD3D12Context(ID3D12Device* device, ID3D12CommandQueue* queue) + { + auto* ctx = static_cast(tracy_malloc(sizeof(D3D12QueueCtx))); + new (ctx) D3D12QueueCtx{ device, queue }; + + return ctx; + } + + static inline void DestroyD3D12Context(D3D12QueueCtx* ctx) + { + ctx->~D3D12QueueCtx(); + tracy_free(ctx); + } + +} + +#undef TracyD3D12Panic + +using TracyD3D12Ctx = tracy::D3D12QueueCtx*; + +#define TracyD3D12Context(device, queue) tracy::CreateD3D12Context(device, queue); +#define TracyD3D12Destroy(ctx) tracy::DestroyD3D12Context(ctx); +#define TracyD3D12ContextName(ctx, name, size) ctx->Name(name, size); + +#define TracyD3D12NewFrame(ctx) ctx->NewFrame(); + +#define TracyD3D12UnnamedZone ___tracy_gpu_d3d12_zone +#define TracyD3D12SrcLocSymbol TracyConcat(__tracy_d3d12_source_location,TracyLine) +#define TracyD3D12SrcLocObject(name, color) static constexpr tracy::SourceLocationData TracyD3D12SrcLocSymbol { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; + +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define TracyD3D12Zone(ctx, cmdList, name) TracyD3D12NamedZoneS(ctx, TracyD3D12UnnamedZone, cmdList, name, TRACY_CALLSTACK, true) +# define TracyD3D12ZoneC(ctx, cmdList, name, color) TracyD3D12NamedZoneCS(ctx, TracyD3D12UnnamedZone, cmdList, name, color, TRACY_CALLSTACK, true) +# define TracyD3D12NamedZone(ctx, varname, cmdList, name, active) TracyD3D12SrcLocObject(name, 0); tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyD3D12SrcLocSymbol, TRACY_CALLSTACK, active }; +# define TracyD3D12NamedZoneC(ctx, varname, cmdList, name, color, active) TracyD3D12SrcLocObject(name, color); tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyD3D12SrcLocSymbol, TRACY_CALLSTACK, active }; +# define TracyD3D12ZoneTransient(ctx, varname, cmdList, name, active) TracyD3D12ZoneTransientS(ctx, varname, cmdList, name, TRACY_CALLSTACK, active) +#else +# define TracyD3D12Zone(ctx, cmdList, name) TracyD3D12NamedZone(ctx, TracyD3D12UnnamedZone, cmdList, name, true) +# define TracyD3D12ZoneC(ctx, cmdList, name, color) TracyD3D12NamedZoneC(ctx, TracyD3D12UnnamedZone, cmdList, name, color, true) +# define TracyD3D12NamedZone(ctx, varname, cmdList, name, active) TracyD3D12SrcLocObject(name, 0); tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyD3D12SrcLocSymbol, active }; +# define TracyD3D12NamedZoneC(ctx, varname, cmdList, name, color, active) TracyD3D12SrcLocObject(name, color); tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyD3D12SrcLocSymbol, active }; +# define TracyD3D12ZoneTransient(ctx, varname, cmdList, name, active) tracy::D3D12ZoneScope varname{ ctx, TracyLine, TracyFile, strlen(TracyFile), TracyFunction, strlen(TracyFunction), name, strlen(name), cmdList, active }; +#endif + +#ifdef TRACY_HAS_CALLSTACK +# define TracyD3D12ZoneS(ctx, cmdList, name, depth) TracyD3D12NamedZoneS(ctx, TracyD3D12UnnamedZone, cmdList, name, depth, true) +# define TracyD3D12ZoneCS(ctx, cmdList, name, color, depth) TracyD3D12NamedZoneCS(ctx, TracyD3D12UnnamedZone, cmdList, name, color, depth, true) +# define TracyD3D12NamedZoneS(ctx, varname, cmdList, name, depth, active) TracyD3D12SrcLocObject(name, 0); tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyD3D12SrcLocSymbol, depth, active }; +# define TracyD3D12NamedZoneCS(ctx, varname, cmdList, name, color, depth, active) TracyD3D12SrcLocObject(name, color); tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyD3D12SrcLocSymbol, depth, active }; +# define TracyD3D12ZoneTransientS(ctx, varname, cmdList, name, depth, active) tracy::D3D12ZoneScope varname{ ctx, TracyLine, TracyFile, strlen(TracyFile), TracyFunction, strlen(TracyFunction), name, strlen(name), cmdList, depth, active }; +#else +# define TracyD3D12ZoneS(ctx, cmdList, name, depth) TracyD3D12Zone(ctx, cmdList, name) +# define TracyD3D12ZoneCS(ctx, cmdList, name, color, depth) TracyD3D12Zone(ctx, cmdList, name, color) +# define TracyD3D12NamedZoneS(ctx, varname, cmdList, name, depth, active) TracyD3D12NamedZone(ctx, varname, cmdList, name, active) +# define TracyD3D12NamedZoneCS(ctx, varname, cmdList, name, color, depth, active) TracyD3D12NamedZoneC(ctx, varname, cmdList, name, color, active) +# define TracyD3D12ZoneTransientS(ctx, varname, cmdList, name, depth, active) TracyD3D12ZoneTransient(ctx, varname, cmdList, name, active) +#endif + +#define TracyD3D12Collect(ctx) ctx->Collect(); + +#endif + +#endif diff --git a/Dependencies/tracy/tracy/TracyLua.hpp b/Dependencies/tracy/tracy/TracyLua.hpp new file mode 100644 index 000000000..51dead51f --- /dev/null +++ b/Dependencies/tracy/tracy/TracyLua.hpp @@ -0,0 +1,446 @@ +#ifndef __TRACYLUA_HPP__ +#define __TRACYLUA_HPP__ + +// Include this file after you include lua headers. + +#ifndef TRACY_ENABLE + +#include + +namespace tracy +{ + +namespace detail +{ +static inline int noop( lua_State* L ) { return 0; } +} + +static inline void LuaRegister( lua_State* L ) +{ + lua_newtable( L ); + lua_pushcfunction( L, detail::noop ); + lua_setfield( L, -2, "ZoneBegin" ); + lua_pushcfunction( L, detail::noop ); + lua_setfield( L, -2, "ZoneBeginN" ); + lua_pushcfunction( L, detail::noop ); + lua_setfield( L, -2, "ZoneBeginS" ); + lua_pushcfunction( L, detail::noop ); + lua_setfield( L, -2, "ZoneBeginNS" ); + lua_pushcfunction( L, detail::noop ); + lua_setfield( L, -2, "ZoneEnd" ); + lua_pushcfunction( L, detail::noop ); + lua_setfield( L, -2, "ZoneText" ); + lua_pushcfunction( L, detail::noop ); + lua_setfield( L, -2, "ZoneName" ); + lua_pushcfunction( L, detail::noop ); + lua_setfield( L, -2, "Message" ); + lua_setglobal( L, "tracy" ); +} + +static inline char* FindEnd( char* ptr ) +{ + unsigned int cnt = 1; + while( cnt != 0 ) + { + if( *ptr == '(' ) cnt++; + else if( *ptr == ')' ) cnt--; + ptr++; + } + return ptr; +} + +static inline void LuaRemove( char* script ) +{ + while( *script ) + { + if( strncmp( script, "tracy.", 6 ) == 0 ) + { + if( strncmp( script + 6, "Zone", 4 ) == 0 ) + { + if( strncmp( script + 10, "End()", 5 ) == 0 ) + { + memset( script, ' ', 15 ); + script += 15; + } + else if( strncmp( script + 10, "Begin()", 7 ) == 0 ) + { + memset( script, ' ', 17 ); + script += 17; + } + else if( strncmp( script + 10, "Text(", 5 ) == 0 ) + { + auto end = FindEnd( script + 15 ); + memset( script, ' ', end - script ); + script = end; + } + else if( strncmp( script + 10, "Name(", 5 ) == 0 ) + { + auto end = FindEnd( script + 15 ); + memset( script, ' ', end - script ); + script = end; + } + else if( strncmp( script + 10, "BeginN(", 7 ) == 0 ) + { + auto end = FindEnd( script + 17 ); + memset( script, ' ', end - script ); + script = end; + } + else if( strncmp( script + 10, "BeginS(", 7 ) == 0 ) + { + auto end = FindEnd( script + 17 ); + memset( script, ' ', end - script ); + script = end; + } + else if( strncmp( script + 10, "BeginNS(", 8 ) == 0 ) + { + auto end = FindEnd( script + 18 ); + memset( script, ' ', end - script ); + script = end; + } + else + { + script += 10; + } + } + else if( strncmp( script + 6, "Message(", 8 ) == 0 ) + { + auto end = FindEnd( script + 14 ); + memset( script, ' ', end - script ); + script = end; + } + else + { + script += 6; + } + } + else + { + script++; + } + } +} + +} + +#else + +#include +#include + +#include "../common/TracyColor.hpp" +#include "../common/TracyAlign.hpp" +#include "../common/TracyForceInline.hpp" +#include "../common/TracySystem.hpp" +#include "../client/TracyProfiler.hpp" + +namespace tracy +{ + +#ifdef TRACY_ON_DEMAND +TRACY_API LuaZoneState& GetLuaZoneState(); +#endif + +namespace detail +{ + +#ifdef TRACY_HAS_CALLSTACK +static tracy_force_inline void SendLuaCallstack( lua_State* L, uint32_t depth ) +{ + assert( depth <= 64 ); + lua_Debug dbg[64]; + const char* func[64]; + uint32_t fsz[64]; + uint32_t ssz[64]; + + uint8_t cnt; + uint16_t spaceNeeded = sizeof( cnt ); + for( cnt=0; cnt::max)() ); + memcpy( dst, fsz+i, 2 ); dst += 2; + memcpy( dst, func[i], fsz[i] ); dst += fsz[i]; + assert( ssz[i] <= (std::numeric_limits::max)() ); + memcpy( dst, ssz+i, 2 ); dst += 2; + memcpy( dst, dbg[i].source, ssz[i] ), dst += ssz[i]; + } + assert( dst - ptr == spaceNeeded + 2 ); + + TracyQueuePrepare( QueueType::CallstackAlloc ); + MemWrite( &item->callstackAllocFat.ptr, (uint64_t)ptr ); + MemWrite( &item->callstackAllocFat.nativePtr, (uint64_t)Callstack( depth ) ); + TracyQueueCommit( callstackAllocFatThread ); +} + +static inline void LuaShortenSrc( char* dst, const char* src ) +{ + size_t l = std::min( (size_t)255, strlen( src ) ); + memcpy( dst, src, l ); + dst[l] = 0; +} + +static inline int LuaZoneBeginS( lua_State* L ) +{ +#ifdef TRACY_ON_DEMAND + const auto zoneCnt = GetLuaZoneState().counter++; + if( zoneCnt != 0 && !GetLuaZoneState().active ) return 0; + GetLuaZoneState().active = GetProfiler().IsConnected(); + if( !GetLuaZoneState().active ) return 0; +#endif + +#ifdef TRACY_CALLSTACK + const uint32_t depth = TRACY_CALLSTACK; +#else + const auto depth = uint32_t( lua_tointeger( L, 1 ) ); +#endif + SendLuaCallstack( L, depth ); + + lua_Debug dbg; + lua_getstack( L, 1, &dbg ); + lua_getinfo( L, "Snl", &dbg ); + char src[256]; + LuaShortenSrc( src, dbg.source ); + const auto srcloc = Profiler::AllocSourceLocation( dbg.currentline, src, dbg.name ? dbg.name : dbg.short_src ); + + TracyQueuePrepare( QueueType::ZoneBeginAllocSrcLocCallstack ); + MemWrite( &item->zoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, srcloc ); + TracyQueueCommit( zoneBeginThread ); + + return 0; +} + +static inline int LuaZoneBeginNS( lua_State* L ) +{ +#ifdef TRACY_ON_DEMAND + const auto zoneCnt = GetLuaZoneState().counter++; + if( zoneCnt != 0 && !GetLuaZoneState().active ) return 0; + GetLuaZoneState().active = GetProfiler().IsConnected(); + if( !GetLuaZoneState().active ) return 0; +#endif + +#ifdef TRACY_CALLSTACK + const uint32_t depth = TRACY_CALLSTACK; +#else + const auto depth = uint32_t( lua_tointeger( L, 2 ) ); +#endif + SendLuaCallstack( L, depth ); + + lua_Debug dbg; + lua_getstack( L, 1, &dbg ); + lua_getinfo( L, "Snl", &dbg ); + size_t nsz; + char src[256]; + LuaShortenSrc( src, dbg.source ); + const auto name = lua_tolstring( L, 1, &nsz ); + const auto srcloc = Profiler::AllocSourceLocation( dbg.currentline, src, dbg.name ? dbg.name : dbg.short_src, name, nsz ); + + TracyQueuePrepare( QueueType::ZoneBeginAllocSrcLocCallstack ); + MemWrite( &item->zoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, srcloc ); + TracyQueueCommit( zoneBeginThread ); + + return 0; +} +#endif + +static inline int LuaZoneBegin( lua_State* L ) +{ +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK + return LuaZoneBeginS( L ); +#else +#ifdef TRACY_ON_DEMAND + const auto zoneCnt = GetLuaZoneState().counter++; + if( zoneCnt != 0 && !GetLuaZoneState().active ) return 0; + GetLuaZoneState().active = GetProfiler().IsConnected(); + if( !GetLuaZoneState().active ) return 0; +#endif + + lua_Debug dbg; + lua_getstack( L, 1, &dbg ); + lua_getinfo( L, "Snl", &dbg ); + char src[256]; + LuaShortenSrc( src, dbg.source ); + const auto srcloc = Profiler::AllocSourceLocation( dbg.currentline, src, dbg.name ? dbg.name : dbg.short_src ); + + TracyQueuePrepare( QueueType::ZoneBeginAllocSrcLoc ); + MemWrite( &item->zoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, srcloc ); + TracyQueueCommit( zoneBeginThread ); + return 0; +#endif +} + +static inline int LuaZoneBeginN( lua_State* L ) +{ +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK + return LuaZoneBeginNS( L ); +#else +#ifdef TRACY_ON_DEMAND + const auto zoneCnt = GetLuaZoneState().counter++; + if( zoneCnt != 0 && !GetLuaZoneState().active ) return 0; + GetLuaZoneState().active = GetProfiler().IsConnected(); + if( !GetLuaZoneState().active ) return 0; +#endif + + lua_Debug dbg; + lua_getstack( L, 1, &dbg ); + lua_getinfo( L, "Snl", &dbg ); + size_t nsz; + char src[256]; + LuaShortenSrc( src, dbg.source ); + const auto name = lua_tolstring( L, 1, &nsz ); + const auto srcloc = Profiler::AllocSourceLocation( dbg.currentline, src, dbg.name ? dbg.name : dbg.short_src, name, nsz ); + + TracyQueuePrepare( QueueType::ZoneBeginAllocSrcLoc ); + MemWrite( &item->zoneBegin.time, Profiler::GetTime() ); + MemWrite( &item->zoneBegin.srcloc, srcloc ); + TracyQueueCommit( zoneBeginThread ); + return 0; +#endif +} + +static inline int LuaZoneEnd( lua_State* L ) +{ +#ifdef TRACY_ON_DEMAND + assert( GetLuaZoneState().counter != 0 ); + GetLuaZoneState().counter--; + if( !GetLuaZoneState().active ) return 0; + if( !GetProfiler().IsConnected() ) + { + GetLuaZoneState().active = false; + return 0; + } +#endif + + TracyQueuePrepare( QueueType::ZoneEnd ); + MemWrite( &item->zoneEnd.time, Profiler::GetTime() ); + TracyQueueCommit( zoneEndThread ); + return 0; +} + +static inline int LuaZoneText( lua_State* L ) +{ +#ifdef TRACY_ON_DEMAND + if( !GetLuaZoneState().active ) return 0; + if( !GetProfiler().IsConnected() ) + { + GetLuaZoneState().active = false; + return 0; + } +#endif + + auto txt = lua_tostring( L, 1 ); + const auto size = strlen( txt ); + assert( size < (std::numeric_limits::max)() ); + + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, txt, size ); + + TracyQueuePrepare( QueueType::ZoneText ); + MemWrite( &item->zoneTextFat.text, (uint64_t)ptr ); + MemWrite( &item->zoneTextFat.size, (uint16_t)size ); + TracyQueueCommit( zoneTextFatThread ); + return 0; +} + +static inline int LuaZoneName( lua_State* L ) +{ +#ifdef TRACY_ON_DEMAND + if( !GetLuaZoneState().active ) return 0; + if( !GetProfiler().IsConnected() ) + { + GetLuaZoneState().active = false; + return 0; + } +#endif + + auto txt = lua_tostring( L, 1 ); + const auto size = strlen( txt ); + assert( size < (std::numeric_limits::max)() ); + + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, txt, size ); + + TracyQueuePrepare( QueueType::ZoneName ); + MemWrite( &item->zoneTextFat.text, (uint64_t)ptr ); + MemWrite( &item->zoneTextFat.size, (uint16_t)size ); + TracyQueueCommit( zoneTextFatThread ); + return 0; +} + +static inline int LuaMessage( lua_State* L ) +{ +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) return 0; +#endif + + auto txt = lua_tostring( L, 1 ); + const auto size = strlen( txt ); + assert( size < (std::numeric_limits::max)() ); + + auto ptr = (char*)tracy_malloc( size ); + memcpy( ptr, txt, size ); + + TracyQueuePrepare( QueueType::Message ); + MemWrite( &item->messageFat.time, Profiler::GetTime() ); + MemWrite( &item->messageFat.text, (uint64_t)ptr ); + MemWrite( &item->messageFat.size, (uint16_t)size ); + TracyQueueCommit( messageFatThread ); + return 0; +} + +} + +static inline void LuaRegister( lua_State* L ) +{ + lua_newtable( L ); + lua_pushcfunction( L, detail::LuaZoneBegin ); + lua_setfield( L, -2, "ZoneBegin" ); + lua_pushcfunction( L, detail::LuaZoneBeginN ); + lua_setfield( L, -2, "ZoneBeginN" ); +#ifdef TRACY_HAS_CALLSTACK + lua_pushcfunction( L, detail::LuaZoneBeginS ); + lua_setfield( L, -2, "ZoneBeginS" ); + lua_pushcfunction( L, detail::LuaZoneBeginNS ); + lua_setfield( L, -2, "ZoneBeginNS" ); +#else + lua_pushcfunction( L, detail::LuaZoneBegin ); + lua_setfield( L, -2, "ZoneBeginS" ); + lua_pushcfunction( L, detail::LuaZoneBeginN ); + lua_setfield( L, -2, "ZoneBeginNS" ); +#endif + lua_pushcfunction( L, detail::LuaZoneEnd ); + lua_setfield( L, -2, "ZoneEnd" ); + lua_pushcfunction( L, detail::LuaZoneText ); + lua_setfield( L, -2, "ZoneText" ); + lua_pushcfunction( L, detail::LuaZoneName ); + lua_setfield( L, -2, "ZoneName" ); + lua_pushcfunction( L, detail::LuaMessage ); + lua_setfield( L, -2, "Message" ); + lua_setglobal( L, "tracy" ); +} + +static inline void LuaRemove( char* script ) {} + +} + +#endif + +#endif diff --git a/Dependencies/tracy/tracy/TracyOpenCL.hpp b/Dependencies/tracy/tracy/TracyOpenCL.hpp new file mode 100644 index 000000000..20d0a7cab --- /dev/null +++ b/Dependencies/tracy/tracy/TracyOpenCL.hpp @@ -0,0 +1,414 @@ +#ifndef __TRACYOPENCL_HPP__ +#define __TRACYOPENCL_HPP__ + +#if !defined TRACY_ENABLE + +#define TracyCLContext(c, x) nullptr +#define TracyCLDestroy(c) +#define TracyCLContextName(c, x, y) + +#define TracyCLNamedZone(c, x, y, z) +#define TracyCLNamedZoneC(c, x, y, z, w) +#define TracyCLZone(c, x) +#define TracyCLZoneC(c, x, y) +#define TracyCLZoneTransient(c,x,y,z) + +#define TracyCLNamedZoneS(c, x, y, z, w) +#define TracyCLNamedZoneCS(c, x, y, z, w, v) +#define TracyCLZoneS(c, x, y) +#define TracyCLZoneCS(c, x, y, z) +#define TracyCLZoneTransientS(c,x,y,z,w) + +#define TracyCLNamedZoneSetEvent(x, e) +#define TracyCLZoneSetEvent(e) + +#define TracyCLCollect(c) + +namespace tracy +{ + class OpenCLCtxScope {}; +} + +using TracyCLCtx = void*; + +#else + +#include + +#include +#include +#include + +#include "Tracy.hpp" +#include "../client/TracyCallstack.hpp" +#include "../client/TracyProfiler.hpp" +#include "../common/TracyAlloc.hpp" + +#define TRACY_CL_TO_STRING_INDIRECT(T) #T +#define TRACY_CL_TO_STRING(T) TRACY_CL_TO_STRING_INDIRECT(T) +#define TRACY_CL_ASSERT(p) if(!(p)) { \ + TracyMessageL( "TRACY_CL_ASSERT failed on " TracyFile ":" TRACY_CL_TO_STRING(TracyLine) ); \ + assert(false && "TRACY_CL_ASSERT failed"); \ +} +#define TRACY_CL_CHECK_ERROR(err) if(err != CL_SUCCESS) { \ + std::ostringstream oss; \ + oss << "TRACY_CL_CHECK_ERROR failed on " << TracyFile << ":" << TracyLine \ + << ": error code " << err; \ + auto msg = oss.str(); \ + TracyMessage(msg.data(), msg.size()); \ + assert(false && "TRACY_CL_CHECK_ERROR failed"); \ +} + +namespace tracy { + + enum class EventPhase : uint8_t + { + Begin, + End + }; + + struct EventInfo + { + cl_event event; + EventPhase phase; + }; + + class OpenCLCtx + { + public: + enum { QueryCount = 64 * 1024 }; + + OpenCLCtx(cl_context context, cl_device_id device) + : m_contextId(GetGpuCtxCounter().fetch_add(1, std::memory_order_relaxed)) + , m_head(0) + , m_tail(0) + { + int64_t tcpu, tgpu; + TRACY_CL_ASSERT(m_contextId != 255); + + cl_int err = CL_SUCCESS; + cl_command_queue queue = clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, &err); + TRACY_CL_CHECK_ERROR(err) + uint32_t dummyValue = 42; + cl_mem dummyBuffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(uint32_t), nullptr, &err); + TRACY_CL_CHECK_ERROR(err) + cl_event writeBufferEvent; + TRACY_CL_CHECK_ERROR(clEnqueueWriteBuffer(queue, dummyBuffer, CL_FALSE, 0, sizeof(uint32_t), &dummyValue, 0, nullptr, &writeBufferEvent)); + TRACY_CL_CHECK_ERROR(clWaitForEvents(1, &writeBufferEvent)); + + tcpu = Profiler::GetTime(); + + cl_int eventStatus; + TRACY_CL_CHECK_ERROR(clGetEventInfo(writeBufferEvent, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(cl_int), &eventStatus, nullptr)); + TRACY_CL_ASSERT(eventStatus == CL_COMPLETE); + TRACY_CL_CHECK_ERROR(clGetEventProfilingInfo(writeBufferEvent, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &tgpu, nullptr)); + TRACY_CL_CHECK_ERROR(clReleaseEvent(writeBufferEvent)); + TRACY_CL_CHECK_ERROR(clReleaseMemObject(dummyBuffer)); + TRACY_CL_CHECK_ERROR(clReleaseCommandQueue(queue)); + + auto item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuNewContext); + MemWrite(&item->gpuNewContext.cpuTime, tcpu); + MemWrite(&item->gpuNewContext.gpuTime, tgpu); + memset(&item->gpuNewContext.thread, 0, sizeof(item->gpuNewContext.thread)); + MemWrite(&item->gpuNewContext.period, 1.0f); + MemWrite(&item->gpuNewContext.type, GpuContextType::OpenCL); + MemWrite(&item->gpuNewContext.context, (uint8_t) m_contextId); + MemWrite(&item->gpuNewContext.flags, (uint8_t)0); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem(*item); +#endif + Profiler::QueueSerialFinish(); + } + + void Name( const char* name, uint16_t len ) + { + auto ptr = (char*)tracy_malloc( len ); + memcpy( ptr, name, len ); + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuContextName ); + MemWrite( &item->gpuContextNameFat.context, (uint8_t)m_contextId ); + MemWrite( &item->gpuContextNameFat.ptr, (uint64_t)ptr ); + MemWrite( &item->gpuContextNameFat.size, len ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + + void Collect() + { + ZoneScopedC(Color::Red4); + + if (m_tail == m_head) return; + +#ifdef TRACY_ON_DEMAND + if (!GetProfiler().IsConnected()) + { + m_head = m_tail = 0; + } +#endif + + for (; m_tail != m_head; m_tail = (m_tail + 1) % QueryCount) + { + EventInfo eventInfo = GetQuery(m_tail); + cl_int eventStatus; + cl_int err = clGetEventInfo(eventInfo.event, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(cl_int), &eventStatus, nullptr); + if (err != CL_SUCCESS) + { + std::ostringstream oss; + oss << "clGetEventInfo falied with error code " << err << ", on event " << eventInfo.event << ", skipping..."; + auto msg = oss.str(); + TracyMessage(msg.data(), msg.size()); + if (eventInfo.event == nullptr) { + TracyMessageL("A TracyCLZone must be paird with a TracyCLZoneSetEvent, check your code!"); + } + assert(false && "clGetEventInfo failed, maybe a TracyCLZone is not paired with TracyCLZoneSetEvent"); + continue; + } + if (eventStatus != CL_COMPLETE) return; + + cl_int eventInfoQuery = (eventInfo.phase == EventPhase::Begin) + ? CL_PROFILING_COMMAND_START + : CL_PROFILING_COMMAND_END; + + cl_ulong eventTimeStamp = 0; + err = clGetEventProfilingInfo(eventInfo.event, eventInfoQuery, sizeof(cl_ulong), &eventTimeStamp, nullptr); + if (err == CL_PROFILING_INFO_NOT_AVAILABLE) + { + TracyMessageL("command queue is not created with CL_QUEUE_PROFILING_ENABLE flag, check your code!"); + assert(false && "command queue is not created with CL_QUEUE_PROFILING_ENABLE flag"); + } + else + TRACY_CL_CHECK_ERROR(err); + + TRACY_CL_ASSERT(eventTimeStamp != 0); + + auto item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuTime); + MemWrite(&item->gpuTime.gpuTime, (int64_t)eventTimeStamp); + MemWrite(&item->gpuTime.queryId, (uint16_t)m_tail); + MemWrite(&item->gpuTime.context, m_contextId); + Profiler::QueueSerialFinish(); + + if (eventInfo.phase == EventPhase::End) + { + // Done with the event, so release it + TRACY_CL_CHECK_ERROR(clReleaseEvent(eventInfo.event)); + } + } + } + + tracy_force_inline uint8_t GetId() const + { + return m_contextId; + } + + tracy_force_inline unsigned int NextQueryId(EventInfo eventInfo) + { + const auto id = m_head; + m_head = (m_head + 1) % QueryCount; + TRACY_CL_ASSERT(m_head != m_tail); + m_query[id] = eventInfo; + return id; + } + + tracy_force_inline EventInfo& GetQuery(unsigned int id) + { + TRACY_CL_ASSERT(id < QueryCount); + return m_query[id]; + } + + private: + + unsigned int m_contextId; + + EventInfo m_query[QueryCount]; + unsigned int m_head; // index at which a new event should be inserted + unsigned int m_tail; // oldest event + + }; + + class OpenCLCtxScope { + public: + tracy_force_inline OpenCLCtxScope(OpenCLCtx* ctx, const SourceLocationData* srcLoc, bool is_active) +#ifdef TRACY_ON_DEMAND + : m_active(is_active&& GetProfiler().IsConnected()) +#else + : m_active(is_active) +#endif + , m_ctx(ctx) + , m_event(nullptr) + { + if (!m_active) return; + + m_beginQueryId = ctx->NextQueryId(EventInfo{ nullptr, EventPhase::Begin }); + + auto item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuZoneBeginSerial); + MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime()); + MemWrite(&item->gpuZoneBegin.srcloc, (uint64_t)srcLoc); + MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle()); + MemWrite(&item->gpuZoneBegin.queryId, (uint16_t)m_beginQueryId); + MemWrite(&item->gpuZoneBegin.context, ctx->GetId()); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline OpenCLCtxScope(OpenCLCtx* ctx, const SourceLocationData* srcLoc, int depth, bool is_active) +#ifdef TRACY_ON_DEMAND + : m_active(is_active&& GetProfiler().IsConnected()) +#else + : m_active(is_active) +#endif + , m_ctx(ctx) + , m_event(nullptr) + { + if (!m_active) return; + + m_beginQueryId = ctx->NextQueryId(EventInfo{ nullptr, EventPhase::Begin }); + + GetProfiler().SendCallstack(depth); + + auto item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuZoneBeginCallstackSerial); + MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime()); + MemWrite(&item->gpuZoneBegin.srcloc, (uint64_t)srcLoc); + MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle()); + MemWrite(&item->gpuZoneBegin.queryId, (uint16_t)m_beginQueryId); + MemWrite(&item->gpuZoneBegin.context, ctx->GetId()); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline OpenCLCtxScope(OpenCLCtx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, bool is_active) +#ifdef TRACY_ON_DEMAND + : m_active(is_active && GetProfiler().IsConnected()) +#else + : m_active(is_active) +#endif + , m_ctx(ctx) + , m_event(nullptr) + { + if (!m_active) return; + + m_beginQueryId = ctx->NextQueryId(EventInfo{ nullptr, EventPhase::Begin }); + + const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz ); + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuZoneBeginAllocSrcLocSerial ); + MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime()); + MemWrite(&item->gpuZoneBegin.srcloc, srcloc); + MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle()); + MemWrite(&item->gpuZoneBegin.queryId, (uint16_t)m_beginQueryId); + MemWrite(&item->gpuZoneBegin.context, ctx->GetId()); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline OpenCLCtxScope(OpenCLCtx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, int depth, bool is_active) +#ifdef TRACY_ON_DEMAND + : m_active(is_active && GetProfiler().IsConnected()) +#else + : m_active(is_active) +#endif + , m_ctx(ctx) + , m_event(nullptr) + { + if (!m_active) return; + + m_beginQueryId = ctx->NextQueryId(EventInfo{ nullptr, EventPhase::Begin }); + + const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz ); + auto item = Profiler::QueueSerialCallstack( Callstack( depth ) ); + MemWrite(&item->hdr.type, QueueType::GpuZoneBeginAllocSrcLocCallstackSerial); + MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime()); + MemWrite(&item->gpuZoneBegin.srcloc, srcloc); + MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle()); + MemWrite(&item->gpuZoneBegin.queryId, (uint16_t)m_beginQueryId); + MemWrite(&item->gpuZoneBegin.context, ctx->GetId()); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline void SetEvent(cl_event event) + { + if (!m_active) return; + m_event = event; + TRACY_CL_CHECK_ERROR(clRetainEvent(m_event)); + m_ctx->GetQuery(m_beginQueryId).event = m_event; + } + + tracy_force_inline ~OpenCLCtxScope() + { + if (!m_active) return; + const auto queryId = m_ctx->NextQueryId(EventInfo{ m_event, EventPhase::End }); + + auto item = Profiler::QueueSerial(); + MemWrite(&item->hdr.type, QueueType::GpuZoneEndSerial); + MemWrite(&item->gpuZoneEnd.cpuTime, Profiler::GetTime()); + MemWrite(&item->gpuZoneEnd.thread, GetThreadHandle()); + MemWrite(&item->gpuZoneEnd.queryId, (uint16_t)queryId); + MemWrite(&item->gpuZoneEnd.context, m_ctx->GetId()); + Profiler::QueueSerialFinish(); + } + + const bool m_active; + OpenCLCtx* m_ctx; + cl_event m_event; + unsigned int m_beginQueryId; + }; + + static inline OpenCLCtx* CreateCLContext(cl_context context, cl_device_id device) + { + auto ctx = (OpenCLCtx*)tracy_malloc(sizeof(OpenCLCtx)); + new (ctx) OpenCLCtx(context, device); + return ctx; + } + + static inline void DestroyCLContext(OpenCLCtx* ctx) + { + ctx->~OpenCLCtx(); + tracy_free(ctx); + } + +} // namespace tracy + +using TracyCLCtx = tracy::OpenCLCtx*; + +#define TracyCLContext(ctx, device) tracy::CreateCLContext(ctx, device); +#define TracyCLDestroy(ctx) tracy::DestroyCLContext(ctx); +#define TracyCLContextName(ctx, name, size) ctx->Name(name, size); +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define TracyCLNamedZone(ctx, varname, name, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::OpenCLCtxScope varname(ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), TRACY_CALLSTACK, active ); +# define TracyCLNamedZoneC(ctx, varname, name, color, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::OpenCLCtxScope varname(ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), TRACY_CALLSTACK, active ); +# define TracyCLZone(ctx, name) TracyCLNamedZoneS(ctx, __tracy_gpu_zone, name, TRACY_CALLSTACK, true) +# define TracyCLZoneC(ctx, name, color) TracyCLNamedZoneCS(ctx, __tracy_gpu_zone, name, color, TRACY_CALLSTACK, true) +# define TracyCLZoneTransient( ctx, varname, name, active ) tracy::OpenCLCtxScope varname( ctx, TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), TRACY_CALLSTACK, active ); +#else +# define TracyCLNamedZone(ctx, varname, name, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine){ name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::OpenCLCtxScope varname(ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), active); +# define TracyCLNamedZoneC(ctx, varname, name, color, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine){ name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::OpenCLCtxScope varname(ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), active); +# define TracyCLZone(ctx, name) TracyCLNamedZone(ctx, __tracy_gpu_zone, name, true) +# define TracyCLZoneC(ctx, name, color) TracyCLNamedZoneC(ctx, __tracy_gpu_zone, name, color, true ) +# define TracyCLZoneTransient( ctx, varname, name, active ) tracy::OpenCLCtxScope varname( ctx, TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), active ); +#endif + +#ifdef TRACY_HAS_CALLSTACK +# define TracyCLNamedZoneS(ctx, varname, name, depth, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine){ name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::OpenCLCtxScope varname(ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), depth, active); +# define TracyCLNamedZoneCS(ctx, varname, name, color, depth, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine){ name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::OpenCLCtxScope varname(ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), depth, active); +# define TracyCLZoneS(ctx, name, depth) TracyCLNamedZoneS(ctx, __tracy_gpu_zone, name, depth, true) +# define TracyCLZoneCS(ctx, name, color, depth) TracyCLNamedZoneCS(ctx, __tracy_gpu_zone, name, color, depth, true) +# define TracyCLZoneTransientS( ctx, varname, name, depth, active ) tracy::OpenCLCtxScope varname( ctx, TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), depth, active ); +#else +# define TracyCLNamedZoneS(ctx, varname, name, depth, active) TracyCLNamedZone(ctx, varname, name, active) +# define TracyCLNamedZoneCS(ctx, varname, name, color, depth, active) TracyCLNamedZoneC(ctx, varname, name, color, active) +# define TracyCLZoneS(ctx, name, depth) TracyCLZone(ctx, name) +# define TracyCLZoneCS(ctx, name, color, depth) TracyCLZoneC(ctx, name, color) +# define TracyCLZoneTransientS( ctx, varname, name, depth, active ) TracyCLZoneTransient( ctx, varname, name, active ) +#endif + +#define TracyCLNamedZoneSetEvent(varname, event) varname.SetEvent(event) +#define TracyCLZoneSetEvent(event) __tracy_gpu_zone.SetEvent(event) + +#define TracyCLCollect(ctx) ctx->Collect() + +#endif + +#endif diff --git a/Dependencies/tracy/tracy/TracyOpenGL.hpp b/Dependencies/tracy/tracy/TracyOpenGL.hpp new file mode 100644 index 000000000..3bdadccee --- /dev/null +++ b/Dependencies/tracy/tracy/TracyOpenGL.hpp @@ -0,0 +1,325 @@ +#ifndef __TRACYOPENGL_HPP__ +#define __TRACYOPENGL_HPP__ + +#if !defined TRACY_ENABLE || defined __APPLE__ + +#define TracyGpuContext +#define TracyGpuContextName(x,y) +#define TracyGpuNamedZone(x,y,z) +#define TracyGpuNamedZoneC(x,y,z,w) +#define TracyGpuZone(x) +#define TracyGpuZoneC(x,y) +#define TracyGpuZoneTransient(x,y,z) +#define TracyGpuCollect + +#define TracyGpuNamedZoneS(x,y,z,w) +#define TracyGpuNamedZoneCS(x,y,z,w,a) +#define TracyGpuZoneS(x,y) +#define TracyGpuZoneCS(x,y,z) +#define TracyGpuZoneTransientS(x,y,z,w) + +namespace tracy +{ +struct SourceLocationData; +class GpuCtxScope +{ +public: + GpuCtxScope( const SourceLocationData*, bool ) {} + GpuCtxScope( const SourceLocationData*, int, bool ) {} +}; +} + +#else + +#include +#include +#include + +#include "Tracy.hpp" +#include "../client/TracyProfiler.hpp" +#include "../client/TracyCallstack.hpp" +#include "../common/TracyAlign.hpp" +#include "../common/TracyAlloc.hpp" + +#if !defined GL_TIMESTAMP && defined GL_TIMESTAMP_EXT +# define GL_TIMESTAMP GL_TIMESTAMP_EXT +# define GL_QUERY_COUNTER_BITS GL_QUERY_COUNTER_BITS_EXT +# define glGetQueryObjectiv glGetQueryObjectivEXT +# define glGetQueryObjectui64v glGetQueryObjectui64vEXT +# define glQueryCounter glQueryCounterEXT +#endif + +#define TracyGpuContext tracy::GetGpuCtx().ptr = (tracy::GpuCtx*)tracy::tracy_malloc( sizeof( tracy::GpuCtx ) ); new(tracy::GetGpuCtx().ptr) tracy::GpuCtx; +#define TracyGpuContextName( name, size ) tracy::GetGpuCtx().ptr->Name( name, size ); +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define TracyGpuNamedZone( varname, name, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::GpuCtxScope varname( &TracyConcat(__tracy_gpu_source_location,TracyLine), TRACY_CALLSTACK, active ); +# define TracyGpuNamedZoneC( varname, name, color, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::GpuCtxScope varname( &TracyConcat(__tracy_gpu_source_location,TracyLine), TRACY_CALLSTACK, active ); +# define TracyGpuZone( name ) TracyGpuNamedZoneS( ___tracy_gpu_zone, name, TRACY_CALLSTACK, true ) +# define TracyGpuZoneC( name, color ) TracyGpuNamedZoneCS( ___tracy_gpu_zone, name, color, TRACY_CALLSTACK, true ) +# define TracyGpuZoneTransient( varname, name, active ) tracy::GpuCtxScope varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), TRACY_CALLSTACK, active ); +#else +# define TracyGpuNamedZone( varname, name, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::GpuCtxScope varname( &TracyConcat(__tracy_gpu_source_location,TracyLine), active ); +# define TracyGpuNamedZoneC( varname, name, color, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::GpuCtxScope varname( &TracyConcat(__tracy_gpu_source_location,TracyLine), active ); +# define TracyGpuZone( name ) TracyGpuNamedZone( ___tracy_gpu_zone, name, true ) +# define TracyGpuZoneC( name, color ) TracyGpuNamedZoneC( ___tracy_gpu_zone, name, color, true ) +# define TracyGpuZoneTransient( varname, name, active ) tracy::GpuCtxScope varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), active ); +#endif +#define TracyGpuCollect tracy::GetGpuCtx().ptr->Collect(); + +#ifdef TRACY_HAS_CALLSTACK +# define TracyGpuNamedZoneS( varname, name, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::GpuCtxScope varname( &TracyConcat(__tracy_gpu_source_location,TracyLine), depth, active ); +# define TracyGpuNamedZoneCS( varname, name, color, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::GpuCtxScope varname( &TracyConcat(__tracy_gpu_source_location,TracyLine), depth, active ); +# define TracyGpuZoneS( name, depth ) TracyGpuNamedZoneS( ___tracy_gpu_zone, name, depth, true ) +# define TracyGpuZoneCS( name, color, depth ) TracyGpuNamedZoneCS( ___tracy_gpu_zone, name, color, depth, true ) +# define TracyGpuZoneTransientS( varname, name, depth, active ) tracy::GpuCtxScope varname( TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), depth, active ); +#else +# define TracyGpuNamedZoneS( varname, name, depth, active ) TracyGpuNamedZone( varname, name, active ) +# define TracyGpuNamedZoneCS( varname, name, color, depth, active ) TracyGpuNamedZoneC( varname, name, color, active ) +# define TracyGpuZoneS( name, depth ) TracyGpuZone( name ) +# define TracyGpuZoneCS( name, color, depth ) TracyGpuZoneC( name, color ) +# define TracyGpuZoneTransientS( varname, name, depth, active ) TracyGpuZoneTransient( varname, name, active ) +#endif + +namespace tracy +{ + +class GpuCtx +{ + friend class GpuCtxScope; + + enum { QueryCount = 64 * 1024 }; + +public: + GpuCtx() + : m_context( GetGpuCtxCounter().fetch_add( 1, std::memory_order_relaxed ) ) + , m_head( 0 ) + , m_tail( 0 ) + { + assert( m_context != 255 ); + + glGenQueries( QueryCount, m_query ); + + int64_t tgpu; + glGetInteger64v( GL_TIMESTAMP, &tgpu ); + int64_t tcpu = Profiler::GetTime(); + + GLint bits; + glGetQueryiv( GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, &bits ); + + const float period = 1.f; + const auto thread = GetThreadHandle(); + TracyLfqPrepare( QueueType::GpuNewContext ); + MemWrite( &item->gpuNewContext.cpuTime, tcpu ); + MemWrite( &item->gpuNewContext.gpuTime, tgpu ); + MemWrite( &item->gpuNewContext.thread, thread ); + MemWrite( &item->gpuNewContext.period, period ); + MemWrite( &item->gpuNewContext.context, m_context ); + MemWrite( &item->gpuNewContext.flags, uint8_t( 0 ) ); + MemWrite( &item->gpuNewContext.type, GpuContextType::OpenGl ); + +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + + TracyLfqCommit; + } + + void Name( const char* name, uint16_t len ) + { + auto ptr = (char*)tracy_malloc( len ); + memcpy( ptr, name, len ); + + TracyLfqPrepare( QueueType::GpuContextName ); + MemWrite( &item->gpuContextNameFat.context, m_context ); + MemWrite( &item->gpuContextNameFat.ptr, (uint64_t)ptr ); + MemWrite( &item->gpuContextNameFat.size, len ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + TracyLfqCommit; + } + + void Collect() + { + ZoneScopedC( Color::Red4 ); + + if( m_tail == m_head ) return; + +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) + { + m_head = m_tail = 0; + return; + } +#endif + + while( m_tail != m_head ) + { + GLint available; + glGetQueryObjectiv( m_query[m_tail], GL_QUERY_RESULT_AVAILABLE, &available ); + if( !available ) return; + + uint64_t time; + glGetQueryObjectui64v( m_query[m_tail], GL_QUERY_RESULT, &time ); + + TracyLfqPrepare( QueueType::GpuTime ); + MemWrite( &item->gpuTime.gpuTime, (int64_t)time ); + MemWrite( &item->gpuTime.queryId, (uint16_t)m_tail ); + MemWrite( &item->gpuTime.context, m_context ); + TracyLfqCommit; + + m_tail = ( m_tail + 1 ) % QueryCount; + } + } + +private: + tracy_force_inline unsigned int NextQueryId() + { + const auto id = m_head; + m_head = ( m_head + 1 ) % QueryCount; + assert( m_head != m_tail ); + return id; + } + + tracy_force_inline unsigned int TranslateOpenGlQueryId( unsigned int id ) + { + return m_query[id]; + } + + tracy_force_inline uint8_t GetId() const + { + return m_context; + } + + unsigned int m_query[QueryCount]; + uint8_t m_context; + + unsigned int m_head; + unsigned int m_tail; +}; + +class GpuCtxScope +{ +public: + tracy_force_inline GpuCtxScope( const SourceLocationData* srcloc, bool is_active ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; + + const auto queryId = GetGpuCtx().ptr->NextQueryId(); + glQueryCounter( GetGpuCtx().ptr->TranslateOpenGlQueryId( queryId ), GL_TIMESTAMP ); + + TracyLfqPrepare( QueueType::GpuZoneBegin ); + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + memset( &item->gpuZoneBegin.thread, 0, sizeof( item->gpuZoneBegin.thread ) ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, GetGpuCtx().ptr->GetId() ); + MemWrite( &item->gpuZoneBegin.srcloc, (uint64_t)srcloc ); + TracyLfqCommit; + } + + tracy_force_inline GpuCtxScope( const SourceLocationData* srcloc, int depth, bool is_active ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; + + const auto queryId = GetGpuCtx().ptr->NextQueryId(); + glQueryCounter( GetGpuCtx().ptr->TranslateOpenGlQueryId( queryId ), GL_TIMESTAMP ); + +#ifdef TRACY_FIBERS + TracyLfqPrepare( QueueType::GpuZoneBegin ); + memset( &item->gpuZoneBegin.thread, 0, sizeof( item->gpuZoneBegin.thread ) ); +#else + GetProfiler().SendCallstack( depth ); + TracyLfqPrepare( QueueType::GpuZoneBeginCallstack ); + MemWrite( &item->gpuZoneBegin.thread, GetThreadHandle() ); +#endif + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, GetGpuCtx().ptr->GetId() ); + MemWrite( &item->gpuZoneBegin.srcloc, (uint64_t)srcloc ); + TracyLfqCommit; + } + + tracy_force_inline GpuCtxScope( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, bool is_active ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; + + const auto queryId = GetGpuCtx().ptr->NextQueryId(); + glQueryCounter( GetGpuCtx().ptr->TranslateOpenGlQueryId( queryId ), GL_TIMESTAMP ); + + TracyLfqPrepare( QueueType::GpuZoneBeginAllocSrcLoc ); + const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz ); + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + memset( &item->gpuZoneBegin.thread, 0, sizeof( item->gpuZoneBegin.thread ) ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, GetGpuCtx().ptr->GetId() ); + MemWrite( &item->gpuZoneBegin.srcloc, (uint64_t)srcloc ); + TracyLfqCommit; + } + + tracy_force_inline GpuCtxScope( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, int depth, bool is_active ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; + + const auto queryId = GetGpuCtx().ptr->NextQueryId(); + glQueryCounter( GetGpuCtx().ptr->TranslateOpenGlQueryId( queryId ), GL_TIMESTAMP ); + +#ifdef TRACY_FIBERS + TracyLfqPrepare( QueueType::GpuZoneBeginAllocSrcLoc ); + memset( &item->gpuZoneBegin.thread, 0, sizeof( item->gpuZoneBegin.thread ) ); +#else + GetProfiler().SendCallstack( depth ); + TracyLfqPrepare( QueueType::GpuZoneBeginAllocSrcLocCallstack ); + MemWrite( &item->gpuZoneBegin.thread, GetThreadHandle() ); +#endif + const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz ); + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, GetGpuCtx().ptr->GetId() ); + MemWrite( &item->gpuZoneBegin.srcloc, (uint64_t)srcloc ); + TracyLfqCommit; + } + + tracy_force_inline ~GpuCtxScope() + { + if( !m_active ) return; + + const auto queryId = GetGpuCtx().ptr->NextQueryId(); + glQueryCounter( GetGpuCtx().ptr->TranslateOpenGlQueryId( queryId ), GL_TIMESTAMP ); + + TracyLfqPrepare( QueueType::GpuZoneEnd ); + MemWrite( &item->gpuZoneEnd.cpuTime, Profiler::GetTime() ); + memset( &item->gpuZoneEnd.thread, 0, sizeof( item->gpuZoneEnd.thread ) ); + MemWrite( &item->gpuZoneEnd.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneEnd.context, GetGpuCtx().ptr->GetId() ); + TracyLfqCommit; + } + +private: + const bool m_active; +}; + +} + +#endif + +#endif diff --git a/Dependencies/tracy/tracy/TracyVulkan.hpp b/Dependencies/tracy/tracy/TracyVulkan.hpp new file mode 100644 index 000000000..c34b71852 --- /dev/null +++ b/Dependencies/tracy/tracy/TracyVulkan.hpp @@ -0,0 +1,723 @@ +#ifndef __TRACYVULKAN_HPP__ +#define __TRACYVULKAN_HPP__ + +#if !defined TRACY_ENABLE + +#define TracyVkContext(x,y,z,w) nullptr +#define TracyVkContextCalibrated(x,y,z,w,a,b) nullptr +#if defined VK_EXT_host_query_reset +#define TracyVkContextHostCalibrated(x,y,z,w,a) nullptr +#endif +#define TracyVkDestroy(x) +#define TracyVkContextName(c,x,y) +#define TracyVkNamedZone(c,x,y,z,w) +#define TracyVkNamedZoneC(c,x,y,z,w,a) +#define TracyVkZone(c,x,y) +#define TracyVkZoneC(c,x,y,z) +#define TracyVkZoneTransient(c,x,y,z,w) +#define TracyVkCollect(c,x) + +#define TracyVkNamedZoneS(c,x,y,z,w,a) +#define TracyVkNamedZoneCS(c,x,y,z,w,v,a) +#define TracyVkZoneS(c,x,y,z) +#define TracyVkZoneCS(c,x,y,z,w) +#define TracyVkZoneTransientS(c,x,y,z,w,a) + +namespace tracy +{ +class VkCtxScope {}; +} + +using TracyVkCtx = void*; + +#else + +#if !defined VK_NULL_HANDLE +# error "You must include Vulkan headers before including TracyVulkan.hpp" +#endif + +#include +#include +#include "Tracy.hpp" +#include "../client/TracyProfiler.hpp" +#include "../client/TracyCallstack.hpp" + +#include + +namespace tracy +{ + +#if defined TRACY_VK_USE_SYMBOL_TABLE +#define LoadVkDeviceCoreSymbols(Operation) \ + Operation(vkBeginCommandBuffer) \ + Operation(vkCmdResetQueryPool) \ + Operation(vkCmdWriteTimestamp) \ + Operation(vkCreateQueryPool) \ + Operation(vkDestroyQueryPool) \ + Operation(vkEndCommandBuffer) \ + Operation(vkGetQueryPoolResults) \ + Operation(vkQueueSubmit) \ + Operation(vkQueueWaitIdle) \ + Operation(vkResetQueryPool) + +#define LoadVkDeviceExtensionSymbols(Operation) \ + Operation(vkGetCalibratedTimestampsEXT) + +#define LoadVkInstanceExtensionSymbols(Operation) \ + Operation(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) + +#define LoadVkInstanceCoreSymbols(Operation) \ + Operation(vkGetPhysicalDeviceProperties) + +struct VkSymbolTable +{ +#define MAKE_PFN(name) PFN_##name name; + LoadVkDeviceCoreSymbols(MAKE_PFN) + LoadVkDeviceExtensionSymbols(MAKE_PFN) + LoadVkInstanceExtensionSymbols(MAKE_PFN) + LoadVkInstanceCoreSymbols(MAKE_PFN) +#undef MAKE_PFN +}; + +#define VK_FUNCTION_WRAPPER(callSignature) m_symbols.callSignature +#define CONTEXT_VK_FUNCTION_WRAPPER(callSignature) m_ctx->m_symbols.callSignature +#else +#define VK_FUNCTION_WRAPPER(callSignature) callSignature +#define CONTEXT_VK_FUNCTION_WRAPPER(callSignature) callSignature +#endif + +class VkCtx +{ + friend class VkCtxScope; + + enum { QueryCount = 64 * 1024 }; + +public: +#if defined TRACY_VK_USE_SYMBOL_TABLE + VkCtx( VkInstance instance, VkPhysicalDevice physdev, VkDevice device, VkQueue queue, VkCommandBuffer cmdbuf, PFN_vkGetInstanceProcAddr instanceProcAddr, PFN_vkGetDeviceProcAddr deviceProcAddr, bool calibrated ) +#else + VkCtx( VkPhysicalDevice physdev, VkDevice device, VkQueue queue, VkCommandBuffer cmdbuf, PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT) +#endif + : m_device( device ) + , m_timeDomain( VK_TIME_DOMAIN_DEVICE_EXT ) + , m_context( GetGpuCtxCounter().fetch_add( 1, std::memory_order_relaxed ) ) + , m_head( 0 ) + , m_tail( 0 ) + , m_oldCnt( 0 ) + , m_queryCount( QueryCount ) +#if !defined TRACY_VK_USE_SYMBOL_TABLE + , m_vkGetCalibratedTimestampsEXT( vkGetCalibratedTimestampsEXT ) +#endif + { + assert( m_context != 255 ); + +#if defined TRACY_VK_USE_SYMBOL_TABLE + PopulateSymbolTable(instance, instanceProcAddr, deviceProcAddr); + if ( calibrated ) + { + m_vkGetCalibratedTimestampsEXT = m_symbols.vkGetCalibratedTimestampsEXT; + } + +#endif + + if( VK_FUNCTION_WRAPPER( vkGetPhysicalDeviceCalibrateableTimeDomainsEXT ) && m_vkGetCalibratedTimestampsEXT ) + { + FindAvailableTimeDomains( physdev, VK_FUNCTION_WRAPPER( vkGetPhysicalDeviceCalibrateableTimeDomainsEXT ) ); + } + + CreateQueryPool(); + + VkCommandBufferBeginInfo beginInfo = {}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + + VkSubmitInfo submitInfo = {}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &cmdbuf; + + VK_FUNCTION_WRAPPER( vkBeginCommandBuffer( cmdbuf, &beginInfo ) ); + VK_FUNCTION_WRAPPER( vkCmdResetQueryPool( cmdbuf, m_query, 0, m_queryCount ) ); + VK_FUNCTION_WRAPPER( vkEndCommandBuffer( cmdbuf ) ); + VK_FUNCTION_WRAPPER( vkQueueSubmit( queue, 1, &submitInfo, VK_NULL_HANDLE ) ); + VK_FUNCTION_WRAPPER( vkQueueWaitIdle( queue ) ); + + int64_t tcpu, tgpu; + if( m_timeDomain == VK_TIME_DOMAIN_DEVICE_EXT ) + { + VK_FUNCTION_WRAPPER( vkBeginCommandBuffer( cmdbuf, &beginInfo ) ); + VK_FUNCTION_WRAPPER( vkCmdWriteTimestamp( cmdbuf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, m_query, 0 ) ); + VK_FUNCTION_WRAPPER( vkEndCommandBuffer( cmdbuf ) ); + VK_FUNCTION_WRAPPER( vkQueueSubmit( queue, 1, &submitInfo, VK_NULL_HANDLE ) ); + VK_FUNCTION_WRAPPER( vkQueueWaitIdle( queue ) ); + + tcpu = Profiler::GetTime(); + VK_FUNCTION_WRAPPER( vkGetQueryPoolResults( device, m_query, 0, 1, sizeof( tgpu ), &tgpu, sizeof( tgpu ), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT ) ); + + VK_FUNCTION_WRAPPER( vkBeginCommandBuffer( cmdbuf, &beginInfo ) ); + VK_FUNCTION_WRAPPER( vkCmdResetQueryPool( cmdbuf, m_query, 0, 1 ) ); + VK_FUNCTION_WRAPPER( vkEndCommandBuffer( cmdbuf ) ); + VK_FUNCTION_WRAPPER( vkQueueSubmit( queue, 1, &submitInfo, VK_NULL_HANDLE ) ); + VK_FUNCTION_WRAPPER( vkQueueWaitIdle( queue ) ); + } + else + { + FindCalibratedTimestampDeviation(); + Calibrate( device, m_prevCalibration, tgpu ); + tcpu = Profiler::GetTime(); + } + + WriteInitialItem( physdev, tcpu, tgpu ); + + m_res = (int64_t*)tracy_malloc( sizeof( int64_t ) * m_queryCount ); + } + +#if defined VK_EXT_host_query_reset + /** + * This alternative constructor does not use command buffers and instead uses functionality from + * VK_EXT_host_query_reset (core with 1.2 and non-optional) and VK_EXT_calibrated_timestamps. This requires + * the physical device to have another time domain apart from DEVICE to be calibrateable. + */ +#if defined TRACY_VK_USE_SYMBOL_TABLE + VkCtx( VkInstance instance, VkPhysicalDevice physdev, VkDevice device, PFN_vkGetInstanceProcAddr instanceProcAddr, PFN_vkGetDeviceProcAddr deviceProcAddr ) +#else + VkCtx( VkPhysicalDevice physdev, VkDevice device, PFN_vkResetQueryPoolEXT vkResetQueryPool, PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT ) +#endif + : m_device( device ) + , m_timeDomain( VK_TIME_DOMAIN_DEVICE_EXT ) + , m_context( GetGpuCtxCounter().fetch_add(1, std::memory_order_relaxed) ) + , m_head( 0 ) + , m_tail( 0 ) + , m_oldCnt( 0 ) + , m_queryCount( QueryCount ) +#if !defined TRACY_VK_USE_SYMBOL_TABLE + , m_vkGetCalibratedTimestampsEXT( vkGetCalibratedTimestampsEXT ) +#endif + { + assert( m_context != 255); + +#if defined TRACY_VK_USE_SYMBOL_TABLE + PopulateSymbolTable(instance, instanceProcAddr, deviceProcAddr); + m_vkGetCalibratedTimestampsEXT = m_symbols.vkGetCalibratedTimestampsEXT; +#endif + + assert( VK_FUNCTION_WRAPPER( vkResetQueryPool ) != nullptr ); + assert( VK_FUNCTION_WRAPPER( vkGetPhysicalDeviceCalibrateableTimeDomainsEXT ) != nullptr ); + assert( VK_FUNCTION_WRAPPER( vkGetCalibratedTimestampsEXT ) != nullptr ); + + FindAvailableTimeDomains( physdev, VK_FUNCTION_WRAPPER( vkGetPhysicalDeviceCalibrateableTimeDomainsEXT ) ); + + // We require a host time domain to be available to properly calibrate. + FindCalibratedTimestampDeviation(); + int64_t tgpu; + Calibrate( device, m_prevCalibration, tgpu ); + int64_t tcpu = Profiler::GetTime(); + + CreateQueryPool(); + VK_FUNCTION_WRAPPER( vkResetQueryPool( device, m_query, 0, m_queryCount ) ); + + WriteInitialItem( physdev, tcpu, tgpu ); + + // We need the buffer to be twice as large for availability values + size_t resSize = sizeof( int64_t ) * m_queryCount * 2; + m_res = (int64_t*)tracy_malloc( resSize ); + } +#endif + + ~VkCtx() + { + tracy_free( m_res ); + VK_FUNCTION_WRAPPER( vkDestroyQueryPool( m_device, m_query, nullptr ) ); + } + + void Name( const char* name, uint16_t len ) + { + auto ptr = (char*)tracy_malloc( len ); + memcpy( ptr, name, len ); + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuContextName ); + MemWrite( &item->gpuContextNameFat.context, m_context ); + MemWrite( &item->gpuContextNameFat.ptr, (uint64_t)ptr ); + MemWrite( &item->gpuContextNameFat.size, len ); +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + + void Collect( VkCommandBuffer cmdbuf ) + { + ZoneScopedC( Color::Red4 ); + + const uint64_t head = m_head.load(std::memory_order_relaxed); + if( m_tail == head ) return; + +#ifdef TRACY_ON_DEMAND + if( !GetProfiler().IsConnected() ) + { + VK_FUNCTION_WRAPPER( vkCmdResetQueryPool( cmdbuf, m_query, 0, m_queryCount ) ); + m_tail = head; + m_oldCnt = 0; + int64_t tgpu; + if( m_timeDomain != VK_TIME_DOMAIN_DEVICE_EXT ) Calibrate( m_device, m_prevCalibration, tgpu ); + return; + } +#endif + assert( head > m_tail ); + + const unsigned int wrappedTail = (unsigned int)( m_tail % m_queryCount ); + + unsigned int cnt; + if( m_oldCnt != 0 ) + { + cnt = m_oldCnt; + m_oldCnt = 0; + } + else + { + cnt = (unsigned int)( head - m_tail ); + assert( cnt <= m_queryCount ); + if( wrappedTail + cnt > m_queryCount ) + { + cnt = m_queryCount - wrappedTail; + } + } + + + VK_FUNCTION_WRAPPER( vkGetQueryPoolResults( m_device, m_query, wrappedTail, cnt, sizeof( int64_t ) * m_queryCount * 2, m_res, sizeof( int64_t ) * 2, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT ) ); + + for( unsigned int idx=0; idxhdr.type, QueueType::GpuTime ); + MemWrite( &item->gpuTime.gpuTime, m_res[idx * 2] ); + MemWrite( &item->gpuTime.queryId, uint16_t( wrappedTail + idx ) ); + MemWrite( &item->gpuTime.context, m_context ); + Profiler::QueueSerialFinish(); + } + + if( m_timeDomain != VK_TIME_DOMAIN_DEVICE_EXT ) + { + int64_t tgpu, tcpu; + Calibrate( m_device, tcpu, tgpu ); + const auto refCpu = Profiler::GetTime(); + const auto delta = tcpu - m_prevCalibration; + if( delta > 0 ) + { + m_prevCalibration = tcpu; + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuCalibration ); + MemWrite( &item->gpuCalibration.gpuTime, tgpu ); + MemWrite( &item->gpuCalibration.cpuTime, refCpu ); + MemWrite( &item->gpuCalibration.cpuDelta, delta ); + MemWrite( &item->gpuCalibration.context, m_context ); + Profiler::QueueSerialFinish(); + } + } + + VK_FUNCTION_WRAPPER( vkCmdResetQueryPool( cmdbuf, m_query, wrappedTail, cnt ) ); + + m_tail += cnt; + } + + tracy_force_inline unsigned int NextQueryId() + { + const uint64_t id = m_head.fetch_add(1, std::memory_order_relaxed); + return id % m_queryCount; + } + + tracy_force_inline uint8_t GetId() const + { + return m_context; + } + + tracy_force_inline VkQueryPool GetQueryPool() const + { + return m_query; + } + +private: + tracy_force_inline void Calibrate( VkDevice device, int64_t& tCpu, int64_t& tGpu ) + { + assert( m_timeDomain != VK_TIME_DOMAIN_DEVICE_EXT ); + VkCalibratedTimestampInfoEXT spec[2] = { + { VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, nullptr, VK_TIME_DOMAIN_DEVICE_EXT }, + { VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, nullptr, m_timeDomain }, + }; + uint64_t ts[2]; + uint64_t deviation; + do + { + m_vkGetCalibratedTimestampsEXT( device, 2, spec, ts, &deviation ); + } + while( deviation > m_deviation ); + +#if defined _WIN32 + tGpu = ts[0]; + tCpu = ts[1] * m_qpcToNs; +#elif defined __linux__ && defined CLOCK_MONOTONIC_RAW + tGpu = ts[0]; + tCpu = ts[1]; +#else + assert( false ); +#endif + } + + tracy_force_inline void CreateQueryPool() + { + VkQueryPoolCreateInfo poolInfo = {}; + poolInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; + poolInfo.queryCount = m_queryCount; + poolInfo.queryType = VK_QUERY_TYPE_TIMESTAMP; + while ( VK_FUNCTION_WRAPPER( vkCreateQueryPool( m_device, &poolInfo, nullptr, &m_query ) != VK_SUCCESS ) ) + { + m_queryCount /= 2; + poolInfo.queryCount = m_queryCount; + } + } + + tracy_force_inline void FindAvailableTimeDomains( VkPhysicalDevice physicalDevice, PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT ) + { + uint32_t num; + _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, &num, nullptr ); + if(num > 4) num = 4; + VkTimeDomainEXT data[4]; + _vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, &num, data ); + VkTimeDomainEXT supportedDomain = (VkTimeDomainEXT)-1; +#if defined _WIN32 + supportedDomain = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT; +#elif defined __linux__ && defined CLOCK_MONOTONIC_RAW + supportedDomain = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT; +#endif + for( uint32_t i=0; i deviation[i] ) { + minDeviation = deviation[i]; + } + } + m_deviation = minDeviation * 3 / 2; + +#if defined _WIN32 + m_qpcToNs = int64_t( 1000000000. / GetFrequencyQpc() ); +#endif + } + + tracy_force_inline void WriteInitialItem( VkPhysicalDevice physdev, int64_t tcpu, int64_t tgpu ) + { + uint8_t flags = 0; + if( m_timeDomain != VK_TIME_DOMAIN_DEVICE_EXT ) flags |= GpuContextCalibration; + + VkPhysicalDeviceProperties prop; + VK_FUNCTION_WRAPPER( vkGetPhysicalDeviceProperties( physdev, &prop ) ); + const float period = prop.limits.timestampPeriod; + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuNewContext ); + MemWrite( &item->gpuNewContext.cpuTime, tcpu ); + MemWrite( &item->gpuNewContext.gpuTime, tgpu ); + memset( &item->gpuNewContext.thread, 0, sizeof( item->gpuNewContext.thread ) ); + MemWrite( &item->gpuNewContext.period, period ); + MemWrite( &item->gpuNewContext.context, m_context ); + MemWrite( &item->gpuNewContext.flags, flags ); + MemWrite( &item->gpuNewContext.type, GpuContextType::Vulkan ); + +#ifdef TRACY_ON_DEMAND + GetProfiler().DeferItem( *item ); +#endif + Profiler::QueueSerialFinish(); + } + +#if defined TRACY_VK_USE_SYMBOL_TABLE + void PopulateSymbolTable( VkInstance instance, PFN_vkGetInstanceProcAddr instanceProcAddr, PFN_vkGetDeviceProcAddr deviceProcAddr ) + { +#define VK_GET_DEVICE_SYMBOL( name ) \ + (PFN_##name)deviceProcAddr( m_device, #name ); +#define VK_LOAD_DEVICE_SYMBOL( name ) \ + m_symbols.name = VK_GET_DEVICE_SYMBOL( name ); +#define VK_GET_INSTANCE_SYMBOL( name ) \ + (PFN_##name)instanceProcAddr( instance, #name ); +#define VK_LOAD_INSTANCE_SYMBOL( name ) \ + m_symbols.name = VK_GET_INSTANCE_SYMBOL( name ); + + LoadVkDeviceCoreSymbols( VK_LOAD_DEVICE_SYMBOL ) + LoadVkDeviceExtensionSymbols( VK_LOAD_DEVICE_SYMBOL ) + LoadVkInstanceExtensionSymbols( VK_LOAD_INSTANCE_SYMBOL ) + LoadVkInstanceCoreSymbols( VK_LOAD_INSTANCE_SYMBOL ) +#undef VK_GET_DEVICE_SYMBOL +#undef VK_LOAD_DEVICE_SYMBOL +#undef VK_GET_INSTANCE_SYMBOL +#undef VK_LOAD_INSTANCE_SYMBOL + } +#endif + + VkDevice m_device; + VkQueryPool m_query; + VkTimeDomainEXT m_timeDomain; +#if defined TRACY_VK_USE_SYMBOL_TABLE + VkSymbolTable m_symbols; +#endif + uint64_t m_deviation; +#ifdef _WIN32 + int64_t m_qpcToNs; +#endif + int64_t m_prevCalibration; + uint8_t m_context; + + std::atomic m_head; + uint64_t m_tail; + unsigned int m_oldCnt; + unsigned int m_queryCount; + + int64_t* m_res; + + PFN_vkGetCalibratedTimestampsEXT m_vkGetCalibratedTimestampsEXT; +}; + +class VkCtxScope +{ +public: + tracy_force_inline VkCtxScope( VkCtx* ctx, const SourceLocationData* srcloc, VkCommandBuffer cmdbuf, bool is_active ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; + m_cmdbuf = cmdbuf; + m_ctx = ctx; + + const auto queryId = ctx->NextQueryId(); + CONTEXT_VK_FUNCTION_WRAPPER( vkCmdWriteTimestamp( cmdbuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, ctx->m_query, queryId ) ); + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuZoneBeginSerial ); + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneBegin.srcloc, (uint64_t)srcloc ); + MemWrite( &item->gpuZoneBegin.thread, GetThreadHandle() ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, ctx->GetId() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline VkCtxScope( VkCtx* ctx, const SourceLocationData* srcloc, VkCommandBuffer cmdbuf, int depth, bool is_active ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; + m_cmdbuf = cmdbuf; + m_ctx = ctx; + + const auto queryId = ctx->NextQueryId(); + CONTEXT_VK_FUNCTION_WRAPPER( vkCmdWriteTimestamp( cmdbuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, ctx->m_query, queryId ) ); + + auto item = Profiler::QueueSerialCallstack( Callstack( depth ) ); + MemWrite( &item->hdr.type, QueueType::GpuZoneBeginCallstackSerial ); + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneBegin.srcloc, (uint64_t)srcloc ); + MemWrite( &item->gpuZoneBegin.thread, GetThreadHandle() ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, ctx->GetId() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline VkCtxScope( VkCtx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, VkCommandBuffer cmdbuf, bool is_active ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; + m_cmdbuf = cmdbuf; + m_ctx = ctx; + + const auto queryId = ctx->NextQueryId(); + CONTEXT_VK_FUNCTION_WRAPPER( vkCmdWriteTimestamp( cmdbuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, ctx->m_query, queryId ) ); + + const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz ); + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuZoneBeginAllocSrcLocSerial ); + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneBegin.srcloc, srcloc ); + MemWrite( &item->gpuZoneBegin.thread, GetThreadHandle() ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, ctx->GetId() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline VkCtxScope( VkCtx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, VkCommandBuffer cmdbuf, int depth, bool is_active ) +#ifdef TRACY_ON_DEMAND + : m_active( is_active && GetProfiler().IsConnected() ) +#else + : m_active( is_active ) +#endif + { + if( !m_active ) return; + m_cmdbuf = cmdbuf; + m_ctx = ctx; + + const auto queryId = ctx->NextQueryId(); + CONTEXT_VK_FUNCTION_WRAPPER( vkCmdWriteTimestamp( cmdbuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, ctx->m_query, queryId ) ); + + const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz ); + auto item = Profiler::QueueSerialCallstack( Callstack( depth ) ); + MemWrite( &item->hdr.type, QueueType::GpuZoneBeginAllocSrcLocCallstackSerial ); + MemWrite( &item->gpuZoneBegin.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneBegin.srcloc, srcloc ); + MemWrite( &item->gpuZoneBegin.thread, GetThreadHandle() ); + MemWrite( &item->gpuZoneBegin.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneBegin.context, ctx->GetId() ); + Profiler::QueueSerialFinish(); + } + + tracy_force_inline ~VkCtxScope() + { + if( !m_active ) return; + + const auto queryId = m_ctx->NextQueryId(); + CONTEXT_VK_FUNCTION_WRAPPER( vkCmdWriteTimestamp( m_cmdbuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, m_ctx->m_query, queryId ) ); + + auto item = Profiler::QueueSerial(); + MemWrite( &item->hdr.type, QueueType::GpuZoneEndSerial ); + MemWrite( &item->gpuZoneEnd.cpuTime, Profiler::GetTime() ); + MemWrite( &item->gpuZoneEnd.thread, GetThreadHandle() ); + MemWrite( &item->gpuZoneEnd.queryId, uint16_t( queryId ) ); + MemWrite( &item->gpuZoneEnd.context, m_ctx->GetId() ); + Profiler::QueueSerialFinish(); + } + +private: + const bool m_active; + + VkCommandBuffer m_cmdbuf; + VkCtx* m_ctx; +}; + +#if defined TRACY_VK_USE_SYMBOL_TABLE +static inline VkCtx* CreateVkContext( VkInstance instance, VkPhysicalDevice physdev, VkDevice device, VkQueue queue, VkCommandBuffer cmdbuf, PFN_vkGetInstanceProcAddr instanceProcAddr, PFN_vkGetDeviceProcAddr getDeviceProcAddr, bool calibrated = false ) +#else +static inline VkCtx* CreateVkContext( VkPhysicalDevice physdev, VkDevice device, VkQueue queue, VkCommandBuffer cmdbuf, PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT gpdctd, PFN_vkGetCalibratedTimestampsEXT gct ) +#endif +{ + auto ctx = (VkCtx*)tracy_malloc( sizeof( VkCtx ) ); +#if defined TRACY_VK_USE_SYMBOL_TABLE + new(ctx) VkCtx( instance, physdev, device, queue, cmdbuf, instanceProcAddr, getDeviceProcAddr, calibrated ); +#else + new(ctx) VkCtx( physdev, device, queue, cmdbuf, gpdctd, gct ); +#endif + return ctx; +} + +#if defined VK_EXT_host_query_reset +#if defined TRACY_VK_USE_SYMBOL_TABLE +static inline VkCtx* CreateVkContext( VkInstance instance, VkPhysicalDevice physdev, VkDevice device, PFN_vkGetInstanceProcAddr instanceProcAddr, PFN_vkGetDeviceProcAddr getDeviceProcAddr ) +#else +static inline VkCtx* CreateVkContext( VkPhysicalDevice physdev, VkDevice device, PFN_vkResetQueryPoolEXT qpreset, PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT gpdctd, PFN_vkGetCalibratedTimestampsEXT gct ) +#endif +{ + auto ctx = (VkCtx*)tracy_malloc( sizeof( VkCtx ) ); +#if defined TRACY_VK_USE_SYMBOL_TABLE + new(ctx) VkCtx( instance, physdev, device, instanceProcAddr, getDeviceProcAddr ); +#else + new(ctx) VkCtx( physdev, device, qpreset, gpdctd, gct ); +#endif + return ctx; +} +#endif + +static inline void DestroyVkContext( VkCtx* ctx ) +{ + ctx->~VkCtx(); + tracy_free( ctx ); +} + +} + +using TracyVkCtx = tracy::VkCtx*; + +#if defined TRACY_VK_USE_SYMBOL_TABLE +#define TracyVkContext( instance, physdev, device, queue, cmdbuf, instanceProcAddr, deviceProcAddr ) tracy::CreateVkContext( instance, physdev, device, queue, cmdbuf, instanceProcAddr, deviceProcAddr ); +#else +#define TracyVkContext( physdev, device, queue, cmdbuf ) tracy::CreateVkContext( physdev, device, queue, cmdbuf, nullptr, nullptr ); +#endif +#if defined TRACY_VK_USE_SYMBOL_TABLE +#define TracyVkContextCalibrated( instance, physdev, device, queue, cmdbuf, instanceProcAddr, deviceProcAddr ) tracy::CreateVkContext( instance, physdev, device, queue, cmdbuf, instanceProcAddr, deviceProcAddr, true ); +#else +#define TracyVkContextCalibrated( physdev, device, queue, cmdbuf, gpdctd, gct ) tracy::CreateVkContext( physdev, device, queue, cmdbuf, gpdctd, gct ); +#endif +#if defined VK_EXT_host_query_reset +#if defined TRACY_VK_USE_SYMBOL_TABLE +#define TracyVkContextHostCalibrated( instance, physdev, device, instanceProcAddr, deviceProcAddr ) tracy::CreateVkContext( instance, physdev, device, instanceProcAddr, deviceProcAddr ); +#else +#define TracyVkContextHostCalibrated( physdev, device, qpreset, gpdctd, gct ) tracy::CreateVkContext( physdev, device, qpreset, gpdctd, gct ); +#endif +#endif +#define TracyVkDestroy( ctx ) tracy::DestroyVkContext( ctx ); +#define TracyVkContextName( ctx, name, size ) ctx->Name( name, size ); +#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK +# define TracyVkNamedZone( ctx, varname, cmdbuf, name, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::VkCtxScope varname( ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), cmdbuf, TRACY_CALLSTACK, active ); +# define TracyVkNamedZoneC( ctx, varname, cmdbuf, name, color, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::VkCtxScope varname( ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), cmdbuf, TRACY_CALLSTACK, active ); +# define TracyVkZone( ctx, cmdbuf, name ) TracyVkNamedZoneS( ctx, ___tracy_gpu_zone, cmdbuf, name, TRACY_CALLSTACK, true ) +# define TracyVkZoneC( ctx, cmdbuf, name, color ) TracyVkNamedZoneCS( ctx, ___tracy_gpu_zone, cmdbuf, name, color, TRACY_CALLSTACK, true ) +# define TracyVkZoneTransient( ctx, varname, cmdbuf, name, active ) TracyVkZoneTransientS( ctx, varname, cmdbuf, name, TRACY_CALLSTACK, active ) +#else +# define TracyVkNamedZone( ctx, varname, cmdbuf, name, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::VkCtxScope varname( ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), cmdbuf, active ); +# define TracyVkNamedZoneC( ctx, varname, cmdbuf, name, color, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::VkCtxScope varname( ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), cmdbuf, active ); +# define TracyVkZone( ctx, cmdbuf, name ) TracyVkNamedZone( ctx, ___tracy_gpu_zone, cmdbuf, name, true ) +# define TracyVkZoneC( ctx, cmdbuf, name, color ) TracyVkNamedZoneC( ctx, ___tracy_gpu_zone, cmdbuf, name, color, true ) +# define TracyVkZoneTransient( ctx, varname, cmdbuf, name, active ) tracy::VkCtxScope varname( ctx, TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), cmdbuf, active ); +#endif +#define TracyVkCollect( ctx, cmdbuf ) ctx->Collect( cmdbuf ); + +#ifdef TRACY_HAS_CALLSTACK +# define TracyVkNamedZoneS( ctx, varname, cmdbuf, name, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::VkCtxScope varname( ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), cmdbuf, depth, active ); +# define TracyVkNamedZoneCS( ctx, varname, cmdbuf, name, color, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, color }; tracy::VkCtxScope varname( ctx, &TracyConcat(__tracy_gpu_source_location,TracyLine), cmdbuf, depth, active ); +# define TracyVkZoneS( ctx, cmdbuf, name, depth ) TracyVkNamedZoneS( ctx, ___tracy_gpu_zone, cmdbuf, name, depth, true ) +# define TracyVkZoneCS( ctx, cmdbuf, name, color, depth ) TracyVkNamedZoneCS( ctx, ___tracy_gpu_zone, cmdbuf, name, color, depth, true ) +# define TracyVkZoneTransientS( ctx, varname, cmdbuf, name, depth, active ) tracy::VkCtxScope varname( ctx, TracyLine, TracyFile, strlen( TracyFile ), TracyFunction, strlen( TracyFunction ), name, strlen( name ), cmdbuf, depth, active ); +#else +# define TracyVkNamedZoneS( ctx, varname, cmdbuf, name, depth, active ) TracyVkNamedZone( ctx, varname, cmdbuf, name, active ) +# define TracyVkNamedZoneCS( ctx, varname, cmdbuf, name, color, depth, active ) TracyVkNamedZoneC( ctx, varname, cmdbuf, name, color, active ) +# define TracyVkZoneS( ctx, cmdbuf, name, depth ) TracyVkZone( ctx, cmdbuf, name ) +# define TracyVkZoneCS( ctx, cmdbuf, name, color, depth ) TracyVkZoneC( ctx, cmdbuf, name, color ) +# define TracyVkZoneTransientS( ctx, varname, cmdbuf, name, depth, active ) TracyVkZoneTransient( ctx, varname, cmdbuf, name, active ) +#endif + +#endif + +#endif diff --git a/Sources/Overload/OvCore/premake5.lua b/Sources/Overload/OvCore/premake5.lua index 211b56364..773a68bb1 100644 --- a/Sources/Overload/OvCore/premake5.lua +++ b/Sources/Overload/OvCore/premake5.lua @@ -4,7 +4,7 @@ project "OvCore" cppdialect "C++20" files { "**.h", "**.inl", "**.cpp", "**.lua" } includedirs { - dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", + dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", dependdir .. "tracy", "%{wks.location}/OvAnalytics/include", "%{wks.location}/OvAudio/include", "%{wks.location}/OvDebug/include", "%{wks.location}/OvMaths/include", "%{wks.location}/OvPhysics/include", "%{wks.location}/OvRendering/include", "%{wks.location}/OvTools/include", "%{wks.location}/OvUI/include", "%{wks.location}/OvWindowing/include", "include" diff --git a/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp b/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp index e48ac90de..f259c7d9e 100644 --- a/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp @@ -4,6 +4,8 @@ * @licence: MIT */ +#include + #include #include #include @@ -53,6 +55,8 @@ OvTools::Utils::OptRef F void OvCore::Rendering::PostProcessRenderPass::Draw(OvRendering::Data::PipelineState p_pso) { + ZoneScopedN("PostProcessRenderPass::Draw"); + auto& sceneDescriptor = m_renderer.GetDescriptor(); auto& scene = sceneDescriptor.scene; diff --git a/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp b/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp index f4be66f50..cdbfa2464 100644 --- a/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp @@ -4,6 +4,8 @@ * @licence: MIT */ +#include + #include #include @@ -61,6 +63,8 @@ class OpaqueRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { + ZoneScopedN("OpaqueRenderPass::Draw"); + PrepareStencilBuffer(p_pso); auto& sceneContent = m_renderer.GetDescriptor(); @@ -81,6 +85,8 @@ class TransparentRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { + ZoneScopedN("TransparentRenderPass::Draw"); + PrepareStencilBuffer(p_pso); auto& sceneContent = m_renderer.GetDescriptor(); @@ -101,6 +107,8 @@ class UIRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { + ZoneScopedN("UIRenderPass::Draw"); + PrepareStencilBuffer(p_pso); auto& sceneContent = m_renderer.GetDescriptor(); @@ -146,6 +154,8 @@ OvRendering::Features::LightingRenderFeature::LightSet FindActiveLights(const Ov void OvCore::Rendering::SceneRenderer::BeginFrame(const OvRendering::Data::FrameDescriptor& p_frameDescriptor) { + ZoneScopedN("SceneRenderer::BeginFrame"); + OVASSERT(HasDescriptor(), "Cannot find SceneDescriptor attached to this renderer"); auto& sceneDescriptor = GetDescriptor(); @@ -188,6 +198,8 @@ void OvCore::Rendering::SceneRenderer::DrawModelWithSingleMaterial(OvRendering:: OvCore::Rendering::SceneRenderer::AllDrawables OvCore::Rendering::SceneRenderer::ParseScene() { + ZoneScopedN("SceneRenderer::ParseScene"); + using namespace OvCore::ECS::Components; OpaqueDrawables opaques; @@ -239,6 +251,7 @@ OvCore::Rendering::SceneRenderer::AllDrawables OvCore::Rendering::SceneRenderer: if (frustum) { + ZoneScopedN("SceneRenderer::"); PROFILER_SPY("Frustum Culling"); meshes = frustum.value().GetMeshesInFrustum(*model, modelBoundingSphere, transform, cullingOptions); } diff --git a/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp b/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp index f751861c0..52af10de2 100644 --- a/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp @@ -4,6 +4,8 @@ * @licence: MIT */ +#include + #include #include @@ -223,83 +225,97 @@ bool OvCore::Scripting::LuaScriptEngineBase::IsOk() const template<> void OvCore::Scripting::LuaScriptEngineBase::OnAwake(OvCore::ECS::Components::Behaviour& p_target) { + ZoneScopedN("LuaScriptEngine::OnAwake"); ExecuteLuaFunction(p_target, "OnAwake"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnStart(OvCore::ECS::Components::Behaviour& p_target) { + ZoneScopedN("LuaScriptEngine::OnStart"); ExecuteLuaFunction(p_target, "OnStart"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnEnable(OvCore::ECS::Components::Behaviour& p_target) { + ZoneScopedN("LuaScriptEngine::OnEnable"); ExecuteLuaFunction(p_target, "OnEnable"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnDisable(OvCore::ECS::Components::Behaviour& p_target) { + ZoneScopedN("LuaScriptEngine::OnDisable"); ExecuteLuaFunction(p_target, "OnDisable"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnDestroy(OvCore::ECS::Components::Behaviour& p_target) { + ZoneScopedN("LuaScriptEngine::OnDestroy"); ExecuteLuaFunction(p_target, "OnDestroy"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnUpdate(OvCore::ECS::Components::Behaviour& p_target, float p_deltaTime) { + ZoneScopedN("LuaScriptEngine::OnUpdate"); ExecuteLuaFunction(p_target, "OnUpdate", p_deltaTime); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnFixedUpdate(OvCore::ECS::Components::Behaviour& p_target, float p_deltaTime) { + ZoneScopedN("LuaScriptEngine::OnFixedUpdate"); ExecuteLuaFunction(p_target, "OnFixedUpdate", p_deltaTime); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnLateUpdate(OvCore::ECS::Components::Behaviour& p_target, float p_deltaTime) { + ZoneScopedN("LuaScriptEngine::OnLateUpdate"); ExecuteLuaFunction(p_target, "OnLateUpdate", p_deltaTime); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnCollisionEnter(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { + ZoneScopedN("LuaScriptEngine::OnCollisionEnter"); ExecuteLuaFunction(p_target, "OnCollisionEnter", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnCollisionStay(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { + ZoneScopedN("LuaScriptEngine::OnCollisionStay"); ExecuteLuaFunction(p_target, "OnCollisionStay", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnCollisionExit(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { + ZoneScopedN("LuaScriptEngine::OnCollisionExit"); ExecuteLuaFunction(p_target, "OnCollisionExit", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnTriggerEnter(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { + ZoneScopedN("LuaScriptEngine::OnTriggerEnter"); ExecuteLuaFunction(p_target, "OnTriggerEnter", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnTriggerStay(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { + ZoneScopedN("LuaScriptEngine::OnTriggerStay"); ExecuteLuaFunction(p_target, "OnTriggerStay", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnTriggerExit(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { + ZoneScopedN("LuaScriptEngine::OnTriggerExit"); ExecuteLuaFunction(p_target, "OnTriggerExit", p_otherObject); } diff --git a/Sources/Overload/OvEditor/premake5.lua b/Sources/Overload/OvEditor/premake5.lua index 9ef651103..85a7b9083 100644 --- a/Sources/Overload/OvEditor/premake5.lua +++ b/Sources/Overload/OvEditor/premake5.lua @@ -3,7 +3,7 @@ project "OvEditor" cppdialect "C++20" files { "**.h", "**.inl","**.cpp", "**.lua", "**.rc", "**.ini" } includedirs { - dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", + dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", dependdir .. "tracy", "%{wks.location}/OvAnalytics/include", "%{wks.location}/OvAudio/include", "%{wks.location}/OvCore/include", "%{wks.location}/OvDebug/include", "%{wks.location}/OvMaths/include", "%{wks.location}/OvPhysics/include", "%{wks.location}/OvRendering/include", "%{wks.location}/OvTools/include", "%{wks.location}/OvUI/include", "%{wks.location}/OvWindowing/include", @@ -12,10 +12,10 @@ project "OvEditor" libdirs { dependdir .. "glfw/lib", dependdir .. "bullet3/lib/%{cfg.buildcfg}", dependdir .. "lua/lib", dependdir .. "glew/lib", dependdir .. "irrKlang/lib", dependdir .. "assimp/lib" } links { - "assimp-vc143-mt.lib", "Bullet3Collision.lib", "Bullet3Common.lib", "Bullet3Dynamics.lib", "Bullet3Geometry.lib", "BulletCollision.lib", "BulletDynamics.lib", "BulletSoftBody.lib", "LinearMath.lib", "glew32.lib", "glfw3dll.lib", "irrKlang.lib", "liblua53.lib", "opengl32.lib", - "ImGui", "tinyxml2", + "assimp-vc143-mt.lib", "Bullet3Collision.lib", "Bullet3Common.lib", "Bullet3Dynamics.lib", "Bullet3Geometry.lib", "BulletCollision.lib", "BulletDynamics.lib", "BulletSoftBody.lib", "LinearMath.lib", "glew32.lib", "glfw3dll.lib", "irrKlang.lib", "liblua53.lib", "opengl32.lib", "dbghelp.lib", + "ImGui", "tinyxml2", "tracy", "OvAnalytics", "OvAudio", "OvCore", "OvDebug", "OvMaths", "OvPhysics", "OvRendering", "OvTools", "OvUI", "OvWindowing" - } + } targetdir (outputdir .. "%{cfg.buildcfg}/%{prj.name}") objdir (objoutdir .. "%{cfg.buildcfg}/%{prj.name}") diff --git a/Sources/Overload/OvEditor/src/OvEditor/Core/Application.cpp b/Sources/Overload/OvEditor/src/OvEditor/Core/Application.cpp index 48756ceb9..a9e02f18a 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Core/Application.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Core/Application.cpp @@ -4,9 +4,11 @@ * @licence: MIT */ -#include +#include + +#include -#include "OvEditor/Core/Application.h" +#include OvEditor::Core::Application::Application(const std::string& p_projectPath, const std::string& p_projectName) : m_context(p_projectPath, p_projectName), @@ -29,6 +31,7 @@ void OvEditor::Core::Application::Run() m_editor.PostUpdate(); clock.Update(); + FrameMark; } } diff --git a/Sources/Overload/OvGame/premake5.lua b/Sources/Overload/OvGame/premake5.lua index f134bd7c5..097810499 100644 --- a/Sources/Overload/OvGame/premake5.lua +++ b/Sources/Overload/OvGame/premake5.lua @@ -3,7 +3,7 @@ project "OvGame" cppdialect "C++20" files { "**.h", "**.inl", "**.cpp", "**.lua", "**.rc" } includedirs { - dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", + dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", dependdir .. "tracy", "%{wks.location}/OvAnalytics/include", "%{wks.location}/OvAudio/include", "%{wks.location}/OvCore/include", "%{wks.location}/OvDebug/include", "%{wks.location}/OvMaths/include", "%{wks.location}/OvPhysics/include", "%{wks.location}/OvRendering/include", "%{wks.location}/OvTools/include", "%{wks.location}/OvUI/include", "%{wks.location}/OvWindowing/include", @@ -13,7 +13,7 @@ project "OvGame" libdirs { dependdir .. "glfw/lib", dependdir .. "bullet3/lib/%{cfg.buildcfg}", dependdir .. "lua/lib", dependdir .. "glew/lib", dependdir .. "assimp/lib", dependdir .. "irrKlang/lib" } links { "assimp-vc143-mt.lib", "Bullet3Collision.lib", "Bullet3Common.lib", "Bullet3Dynamics.lib", "Bullet3Geometry.lib", "BulletCollision.lib", "BulletDynamics.lib", "BulletSoftBody.lib", "LinearMath.lib", "glew32.lib", "glfw3dll.lib", "irrKlang.lib", "liblua53.lib", "opengl32.lib", - "ImGui", "tinyxml2", + "ImGui", "tinyxml2", "tracy", "OvAnalytics", "OvAudio", "OvCore", "OvDebug", "OvMaths", "OvPhysics", "OvRendering", "OvTools", "OvUI", "OvWindowing" } diff --git a/Sources/Overload/OvGame/src/OvGame/Core/Application.cpp b/Sources/Overload/OvGame/src/OvGame/Core/Application.cpp index ea4a6a7c4..d32a89caf 100644 --- a/Sources/Overload/OvGame/src/OvGame/Core/Application.cpp +++ b/Sources/Overload/OvGame/src/OvGame/Core/Application.cpp @@ -4,6 +4,8 @@ * @licence: MIT */ +#include + #include #include "OvGame/Core/Application.h" @@ -29,6 +31,7 @@ void OvGame::Core::Application::Run() m_game.PostUpdate(); clock.Update(); + FrameMark; } } diff --git a/Sources/Overload/OvRendering/premake5.lua b/Sources/Overload/OvRendering/premake5.lua index 22041234c..07f0379da 100644 --- a/Sources/Overload/OvRendering/premake5.lua +++ b/Sources/Overload/OvRendering/premake5.lua @@ -4,7 +4,7 @@ project "OvRendering" cppdialect "C++20" files { "**.h", "**.inl", "**.cpp", "**.lua" } includedirs { - dependdir .. "glew/include", dependdir .. "stb_image/include", dependdir .. "assimp/include", + dependdir .. "glew/include", dependdir .. "stb_image/include", dependdir .. "assimp/include", dependdir .. "tracy", "%{wks.location}/OvDebug/include", "%{wks.location}/OvMaths/include", "%{wks.location}/OvTools/include", "include" } diff --git a/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp b/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp index 353e6eb5c..b0083be18 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp @@ -6,6 +6,8 @@ #include +#include + #include "OvRendering/Core/ABaseRenderer.h" #include "OvRendering/Resources/Loaders/TextureLoader.h" #include @@ -46,6 +48,8 @@ OvRendering::Core::ABaseRenderer::~ABaseRenderer() void OvRendering::Core::ABaseRenderer::BeginFrame(const Data::FrameDescriptor& p_frameDescriptor) { + ZoneScopedN("ABaseRenderer::BeginFrame"); + OVASSERT(!s_isDrawing, "Cannot call BeginFrame() when previous frame hasn't finished."); OVASSERT(p_frameDescriptor.IsValid(), "Invalid FrameDescriptor!"); @@ -74,6 +78,8 @@ void OvRendering::Core::ABaseRenderer::BeginFrame(const Data::FrameDescriptor& p void OvRendering::Core::ABaseRenderer::EndFrame() { + ZoneScopedN("ABaseRenderer::EndFrame"); + OVASSERT(s_isDrawing, "Cannot call EndFrame() before calling BeginFrame()"); if (m_frameDescriptor.outputBuffer) @@ -113,6 +119,8 @@ void OvRendering::Core::ABaseRenderer::Clear( const OvMaths::FVector4& p_color ) { + ZoneScopedN("ABaseRenderer::Clear"); + m_driver.Clear(p_colorBuffer, p_depthBuffer, p_stencilBuffer, p_color); } @@ -124,6 +132,8 @@ void OvRendering::Core::ABaseRenderer::Blit( OvRendering::Settings::EBlitFlags p_flags ) { + ZoneScopedN("ABaseRenderer::Blit"); + OVASSERT(m_unitQuad != nullptr, "Invalid unit quad mesh, cannot blit!"); auto [srcWidth, srcHeight] = p_src.GetSize(); @@ -175,6 +185,8 @@ void OvRendering::Core::ABaseRenderer::DrawEntity( const Entities::Drawable& p_drawable ) { + ZoneScopedN("ABaseRenderer::DrawEntity"); + auto material = p_drawable.material; auto mesh = p_drawable.mesh; diff --git a/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp b/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp index 12b1e6dc1..4643993fa 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp @@ -6,6 +6,8 @@ #include +#include + #include "OvRendering/Core/CompositeRenderer.h" OvRendering::Core::CompositeRenderer::CompositeRenderer(Context::Driver& p_driver) @@ -36,6 +38,8 @@ void OvRendering::Core::CompositeRenderer::BeginFrame(const Data::FrameDescripto void OvRendering::Core::CompositeRenderer::DrawFrame() { + ZoneScopedN("CompositeRenderer::DrawFrame"); + auto pso = CreatePipelineState(); for (const auto& [_, pass] : m_passes) @@ -52,6 +56,8 @@ void OvRendering::Core::CompositeRenderer::DrawFrame() void OvRendering::Core::CompositeRenderer::EndFrame() { + ZoneScopedN("CompositeRenderer::EndFrame"); + for (const auto& [_, pass] : m_passes) { if (pass.second->IsEnabled()) @@ -77,6 +83,8 @@ void OvRendering::Core::CompositeRenderer::DrawEntity( const Entities::Drawable& p_drawable ) { + ZoneScopedN("CompositeRenderer::DrawEntity"); + for (const auto& [_, feature] : m_features) { if (feature->IsEnabled()) diff --git a/Sources/Overload/premake5.lua b/Sources/Overload/premake5.lua index a000ac68e..4456edb14 100644 --- a/Sources/Overload/premake5.lua +++ b/Sources/Overload/premake5.lua @@ -16,7 +16,15 @@ workspace "Overload" configurations { "Debug", "Release" } platforms { "x64" } startproject "OvEditor" - defines { "LUA_SCRIPTING", "GRAPHICS_API_OPENGL", "OVERLOAD_VERSION=\"" .. version .. "\"" } + defines { + "LUA_SCRIPTING", + "GRAPHICS_API_OPENGL", + "OVERLOAD_VERSION=\"" .. version .. "\"", + "TRACY_ENABLE" + } + + -- Disable "Hot Reload": Doesn't work with Tracy. + editandcontinue "Off" outputdir = "%{wks.location}/../../Bin/" objoutdir = "%{wks.location}/../../Bin-Int/" @@ -27,6 +35,7 @@ resdir = "%{wks.location}/../../Resources/" group "Dependencies" include "../../Dependencies/ImGui" include "../../Dependencies/tinyxml2" + include "../../Dependencies/tracy" group "" group "Dependencies/Prebuilt" From 5746ba2ed7c0eccb81ad0b681eb047b7a083319c Mon Sep 17 00:00:00 2001 From: Adrien GIVRY Date: Fri, 4 Apr 2025 00:50:18 -0400 Subject: [PATCH 02/11] Added support for GPU profiling --- .../Rendering/PostProcessRenderPass.cpp | 5 ++- .../src/OvCore/Rendering/SceneRenderer.cpp | 37 +++++++++------- .../src/OvCore/Rendering/ShadowRenderPass.cpp | 13 +++--- .../OvCore/src/OvCore/SceneSystem/Scene.cpp | 5 +++ .../OvCore/Scripting/Lua/LuaScriptEngine.cpp | 14 ------ .../OvEditor/src/OvEditor/Core/Editor.cpp | 3 +- .../OvEditor/Rendering/DebugSceneRenderer.cpp | 44 +++++++++++-------- .../src/OvEditor/Rendering/GridRenderPass.cpp | 14 +++--- .../OvEditor/Rendering/PickingRenderPass.cpp | 4 ++ Sources/Overload/OvGame/premake5.lua | 2 +- .../Overload/OvGame/src/OvGame/Core/Game.cpp | 1 + .../include/OvRendering/Context/Driver.h | 5 +++ .../include/OvRendering/HAL/Common/TBackend.h | 6 +++ .../include/OvRendering/HAL/Profiling.h | 14 ++++++ .../src/OvRendering/Context/Driver.cpp | 5 +++ .../src/OvRendering/Core/ABaseRenderer.cpp | 11 +++-- .../OvRendering/Core/CompositeRenderer.cpp | 14 ++++-- .../src/OvRendering/Data/Material.cpp | 4 ++ .../src/OvRendering/HAL/None/NoneBackend.cpp | 4 ++ .../src/OvRendering/HAL/OpenGL/GLBackend.cpp | 12 ++++- 20 files changed, 143 insertions(+), 74 deletions(-) create mode 100644 Sources/Overload/OvRendering/include/OvRendering/HAL/Profiling.h diff --git a/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp b/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp index f259c7d9e..efcf14b6c 100644 --- a/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp @@ -12,6 +12,8 @@ #include #include #include + +#include #include OvCore::Rendering::PostProcessRenderPass::PostProcessRenderPass(OvRendering::Core::CompositeRenderer& p_renderer) : @@ -55,7 +57,8 @@ OvTools::Utils::OptRef F void OvCore::Rendering::PostProcessRenderPass::Draw(OvRendering::Data::PipelineState p_pso) { - ZoneScopedN("PostProcessRenderPass::Draw"); + ZoneScoped; + OvGpuZone("PostProcessRenderPass"); auto& sceneDescriptor = m_renderer.GetDescriptor(); auto& scene = sceneDescriptor.scene; diff --git a/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp b/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp index cdbfa2464..403b854b6 100644 --- a/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp @@ -8,21 +8,22 @@ #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + #include #include +#include #include -#include "OvCore/Rendering/SceneRenderer.h" -#include "OvCore/Rendering/EngineBufferRenderFeature.h" -#include "OvCore/Rendering/EngineDrawableDescriptor.h" -#include "OvCore/Rendering/ShadowRenderFeature.h" -#include "OvCore/Rendering/ShadowRenderPass.h" -#include "OvCore/Rendering/PostProcessRenderPass.h" -#include "OvCore/ECS/Components/CModelRenderer.h" -#include "OvCore/ECS/Components/CMaterialRenderer.h" -#include "OvCore/Global/ServiceLocator.h" -#include "OvCore/ResourceManagement/ShaderManager.h" - struct SceneRenderPassDescriptor { OvCore::Rendering::SceneRenderer::AllDrawables drawables; @@ -63,7 +64,8 @@ class OpaqueRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - ZoneScopedN("OpaqueRenderPass::Draw"); + ZoneScoped; + OvGpuZone("OpaqueRenderPass"); PrepareStencilBuffer(p_pso); @@ -85,7 +87,8 @@ class TransparentRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - ZoneScopedN("TransparentRenderPass::Draw"); + ZoneScoped; + OvGpuZone("TransparentRenderPass"); PrepareStencilBuffer(p_pso); @@ -107,7 +110,8 @@ class UIRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - ZoneScopedN("UIRenderPass::Draw"); + ZoneScoped; + OvGpuZone("UIRenderPass"); PrepareStencilBuffer(p_pso); @@ -154,7 +158,7 @@ OvRendering::Features::LightingRenderFeature::LightSet FindActiveLights(const Ov void OvCore::Rendering::SceneRenderer::BeginFrame(const OvRendering::Data::FrameDescriptor& p_frameDescriptor) { - ZoneScopedN("SceneRenderer::BeginFrame"); + ZoneScoped; OVASSERT(HasDescriptor(), "Cannot find SceneDescriptor attached to this renderer"); @@ -198,7 +202,7 @@ void OvCore::Rendering::SceneRenderer::DrawModelWithSingleMaterial(OvRendering:: OvCore::Rendering::SceneRenderer::AllDrawables OvCore::Rendering::SceneRenderer::ParseScene() { - ZoneScopedN("SceneRenderer::ParseScene"); + ZoneScoped; using namespace OvCore::ECS::Components; @@ -251,7 +255,6 @@ OvCore::Rendering::SceneRenderer::AllDrawables OvCore::Rendering::SceneRenderer: if (frustum) { - ZoneScopedN("SceneRenderer::"); PROFILER_SPY("Frustum Culling"); meshes = frustum.value().GetMeshesInFrustum(*model, modelBoundingSphere, transform, cullingOptions); } diff --git a/Sources/Overload/OvCore/src/OvCore/Rendering/ShadowRenderPass.cpp b/Sources/Overload/OvCore/src/OvCore/Rendering/ShadowRenderPass.cpp index f1e79e41f..669f2356a 100644 --- a/Sources/Overload/OvCore/src/OvCore/Rendering/ShadowRenderPass.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Rendering/ShadowRenderPass.cpp @@ -4,14 +4,15 @@ * @licence: MIT */ -#include "OvCore/Rendering/ShadowRenderPass.h" - #include -#include +#include #include -#include +#include +#include #include -#include + +#include +#include constexpr uint8_t kMaxShadowMaps = 1; @@ -28,6 +29,8 @@ OvCore::Rendering::ShadowRenderPass::ShadowRenderPass(OvRendering::Core::Composi void OvCore::Rendering::ShadowRenderPass::Draw(OvRendering::Data::PipelineState p_pso) { + OvGpuZone("ShadowRenderPass"); + using namespace OvCore::Rendering; OVASSERT(m_renderer.HasDescriptor(), "Cannot find SceneDescriptor attached to this renderer"); diff --git a/Sources/Overload/OvCore/src/OvCore/SceneSystem/Scene.cpp b/Sources/Overload/OvCore/src/OvCore/SceneSystem/Scene.cpp index 3041fd80d..af3a2c799 100644 --- a/Sources/Overload/OvCore/src/OvCore/SceneSystem/Scene.cpp +++ b/Sources/Overload/OvCore/src/OvCore/SceneSystem/Scene.cpp @@ -7,6 +7,8 @@ #include #include +#include + #include #include #include @@ -64,18 +66,21 @@ bool OvCore::SceneSystem::Scene::IsPlaying() const void OvCore::SceneSystem::Scene::Update(float p_deltaTime) { + ZoneScoped; auto actors = m_actors; std::for_each(actors.begin(), actors.end(), std::bind(std::mem_fn(&ECS::Actor::OnUpdate), std::placeholders::_1, p_deltaTime)); } void OvCore::SceneSystem::Scene::FixedUpdate(float p_deltaTime) { + ZoneScoped; auto actors = m_actors; std::for_each(actors.begin(), actors.end(), std::bind(std::mem_fn(&ECS::Actor::OnFixedUpdate), std::placeholders::_1, p_deltaTime)); } void OvCore::SceneSystem::Scene::LateUpdate(float p_deltaTime) { + ZoneScoped; auto actors = m_actors; std::for_each(actors.begin(), actors.end(), std::bind(std::mem_fn(&ECS::Actor::OnLateUpdate), std::placeholders::_1, p_deltaTime)); } diff --git a/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp b/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp index 52af10de2..651835e79 100644 --- a/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp @@ -225,97 +225,83 @@ bool OvCore::Scripting::LuaScriptEngineBase::IsOk() const template<> void OvCore::Scripting::LuaScriptEngineBase::OnAwake(OvCore::ECS::Components::Behaviour& p_target) { - ZoneScopedN("LuaScriptEngine::OnAwake"); ExecuteLuaFunction(p_target, "OnAwake"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnStart(OvCore::ECS::Components::Behaviour& p_target) { - ZoneScopedN("LuaScriptEngine::OnStart"); ExecuteLuaFunction(p_target, "OnStart"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnEnable(OvCore::ECS::Components::Behaviour& p_target) { - ZoneScopedN("LuaScriptEngine::OnEnable"); ExecuteLuaFunction(p_target, "OnEnable"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnDisable(OvCore::ECS::Components::Behaviour& p_target) { - ZoneScopedN("LuaScriptEngine::OnDisable"); ExecuteLuaFunction(p_target, "OnDisable"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnDestroy(OvCore::ECS::Components::Behaviour& p_target) { - ZoneScopedN("LuaScriptEngine::OnDestroy"); ExecuteLuaFunction(p_target, "OnDestroy"); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnUpdate(OvCore::ECS::Components::Behaviour& p_target, float p_deltaTime) { - ZoneScopedN("LuaScriptEngine::OnUpdate"); ExecuteLuaFunction(p_target, "OnUpdate", p_deltaTime); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnFixedUpdate(OvCore::ECS::Components::Behaviour& p_target, float p_deltaTime) { - ZoneScopedN("LuaScriptEngine::OnFixedUpdate"); ExecuteLuaFunction(p_target, "OnFixedUpdate", p_deltaTime); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnLateUpdate(OvCore::ECS::Components::Behaviour& p_target, float p_deltaTime) { - ZoneScopedN("LuaScriptEngine::OnLateUpdate"); ExecuteLuaFunction(p_target, "OnLateUpdate", p_deltaTime); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnCollisionEnter(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { - ZoneScopedN("LuaScriptEngine::OnCollisionEnter"); ExecuteLuaFunction(p_target, "OnCollisionEnter", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnCollisionStay(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { - ZoneScopedN("LuaScriptEngine::OnCollisionStay"); ExecuteLuaFunction(p_target, "OnCollisionStay", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnCollisionExit(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { - ZoneScopedN("LuaScriptEngine::OnCollisionExit"); ExecuteLuaFunction(p_target, "OnCollisionExit", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnTriggerEnter(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { - ZoneScopedN("LuaScriptEngine::OnTriggerEnter"); ExecuteLuaFunction(p_target, "OnTriggerEnter", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnTriggerStay(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { - ZoneScopedN("LuaScriptEngine::OnTriggerStay"); ExecuteLuaFunction(p_target, "OnTriggerStay", p_otherObject); } template<> void OvCore::Scripting::LuaScriptEngineBase::OnTriggerExit(OvCore::ECS::Components::Behaviour& p_target, OvCore::ECS::Components::CPhysicalObject& p_otherObject) { - ZoneScopedN("LuaScriptEngine::OnTriggerExit"); ExecuteLuaFunction(p_target, "OnTriggerExit", p_otherObject); } diff --git a/Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp b/Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp index 19ec816a7..c048d11b9 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp @@ -267,5 +267,6 @@ void OvEditor::Core::Editor::PostUpdate() m_context.window->SwapBuffers(); m_context.inputManager->ClearEvents(); + m_context.driver->NotifyFrameFinished(); ++m_elapsedFrames; -} \ No newline at end of file +} diff --git a/Sources/Overload/OvEditor/src/OvEditor/Rendering/DebugSceneRenderer.cpp b/Sources/Overload/OvEditor/src/OvEditor/Rendering/DebugSceneRenderer.cpp index dcffe27dd..88922a438 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Rendering/DebugSceneRenderer.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Rendering/DebugSceneRenderer.cpp @@ -4,35 +4,35 @@ * @licence: MIT */ +#include + #include +#include +#include #include -#include #include -#include +#include #include -#include #include #include -#include -#include - -#include - #include -#include "OvEditor/Rendering/DebugModelRenderFeature.h" -#include "OvEditor/Rendering/DebugSceneRenderer.h" -#include "OvEditor/Rendering/GridRenderPass.h" -#include "OvEditor/Rendering/OutlineRenderFeature.h" -#include "OvEditor/Rendering/GizmoRenderFeature.h" -#include "OvEditor/Rendering/PickingRenderPass.h" -#include "OvEditor/Core/EditorResources.h" -#include "OvEditor/Panels/AView.h" -#include "OvEditor/Panels/GameView.h" -#include "OvEditor/Settings/EditorSettings.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include -#include "OvEditor/Core/EditorActions.h" +#include +#include +#include using namespace OvMaths; using namespace OvRendering::Resources; @@ -85,6 +85,8 @@ class DebugCamerasRenderPass : public OvRendering::Core::ARenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { + OvGpuZone("DebugCamerasRenderPass"); + auto& sceneDescriptor = m_renderer.GetDescriptor(); for (auto camera : sceneDescriptor.scene.GetFastAccessComponents().cameras) @@ -121,6 +123,8 @@ class DebugLightsRenderPass : public OvRendering::Core::ARenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { + OvGpuZone("DebugLightsRenderPass"); + auto& sceneDescriptor = m_renderer.GetDescriptor(); m_lightMaterial.Set("u_Scale", OvEditor::Settings::EditorSettings::LightBillboardScale * 0.1f); @@ -169,6 +173,8 @@ class DebugActorRenderPass : public OvRendering::Core::ARenderPass virtual void Draw(OvRendering::Data::PipelineState p_pso) override { + OvGpuZone("DebugActorRenderPass"); + auto& debugSceneDescriptor = m_renderer.GetDescriptor(); if (debugSceneDescriptor.selectedActor) diff --git a/Sources/Overload/OvEditor/src/OvEditor/Rendering/GridRenderPass.cpp b/Sources/Overload/OvEditor/src/OvEditor/Rendering/GridRenderPass.cpp index 48185bf40..a1e9e9b70 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Rendering/GridRenderPass.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Rendering/GridRenderPass.cpp @@ -4,14 +4,16 @@ * @licence: MIT */ -#include #include -#include "OvEditor/Rendering/DebugModelRenderFeature.h" -#include "OvEditor/Core/EditorResources.h" -#include "OvEditor/Core/EditorActions.h" -#include "OvEditor/Rendering/GridRenderPass.h" +#include +#include +#include +#include + +#include +#include OvEditor::Rendering::GridRenderPass::GridRenderPass(OvRendering::Core::CompositeRenderer& p_renderer) : OvRendering::Core::ARenderPass(p_renderer) @@ -26,6 +28,8 @@ OvEditor::Rendering::GridRenderPass::GridRenderPass(OvRendering::Core::Composite void OvEditor::Rendering::GridRenderPass::Draw(OvRendering::Data::PipelineState p_pso) { + OvGpuZone("GridRenderPass"); + OVASSERT(m_renderer.HasDescriptor(), "Cannot find GridDescriptor attached to this renderer"); OVASSERT(m_renderer.HasFeature(), "Cannot find DebugShapeRenderFeature attached to this renderer"); OVASSERT(m_renderer.HasFeature(), "Cannot find DebugModelRenderFeature attached to this renderer"); diff --git a/Sources/Overload/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp b/Sources/Overload/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp index 40b81b1c1..db134a9f9 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp @@ -14,6 +14,8 @@ #include #include +#include + OvEditor::Rendering::PickingRenderPass::PickingRenderPass(OvRendering::Core::CompositeRenderer& p_renderer) : OvRendering::Core::ARenderPass(p_renderer), m_actorPickingFramebuffer("ActorPicking") @@ -79,6 +81,8 @@ void OvEditor::Rendering::PickingRenderPass::Draw(OvRendering::Data::PipelineSta { // TODO: Make sure we only renderer when the view is hovered and not being resized + OvGpuZone("PickingRenderPass"); + using namespace OvCore::Rendering; OVASSERT(m_renderer.HasDescriptor(), "Cannot find SceneDescriptor attached to this renderer"); diff --git a/Sources/Overload/OvGame/premake5.lua b/Sources/Overload/OvGame/premake5.lua index 097810499..331fc7cf8 100644 --- a/Sources/Overload/OvGame/premake5.lua +++ b/Sources/Overload/OvGame/premake5.lua @@ -12,7 +12,7 @@ project "OvGame" libdirs { dependdir .. "glfw/lib", dependdir .. "bullet3/lib/%{cfg.buildcfg}", dependdir .. "lua/lib", dependdir .. "glew/lib", dependdir .. "assimp/lib", dependdir .. "irrKlang/lib" } links { - "assimp-vc143-mt.lib", "Bullet3Collision.lib", "Bullet3Common.lib", "Bullet3Dynamics.lib", "Bullet3Geometry.lib", "BulletCollision.lib", "BulletDynamics.lib", "BulletSoftBody.lib", "LinearMath.lib", "glew32.lib", "glfw3dll.lib", "irrKlang.lib", "liblua53.lib", "opengl32.lib", + "assimp-vc143-mt.lib", "Bullet3Collision.lib", "Bullet3Common.lib", "Bullet3Dynamics.lib", "Bullet3Geometry.lib", "BulletCollision.lib", "BulletDynamics.lib", "BulletSoftBody.lib", "LinearMath.lib", "glew32.lib", "glfw3dll.lib", "irrKlang.lib", "liblua53.lib", "opengl32.lib", "dbghelp.lib", "ImGui", "tinyxml2", "tracy", "OvAnalytics", "OvAudio", "OvCore", "OvDebug", "OvMaths", "OvPhysics", "OvRendering", "OvTools", "OvUI", "OvWindowing" } diff --git a/Sources/Overload/OvGame/src/OvGame/Core/Game.cpp b/Sources/Overload/OvGame/src/OvGame/Core/Game.cpp index 32254019c..b75052761 100644 --- a/Sources/Overload/OvGame/src/OvGame/Core/Game.cpp +++ b/Sources/Overload/OvGame/src/OvGame/Core/Game.cpp @@ -151,4 +151,5 @@ void OvGame::Core::Game::PostUpdate() #endif m_context.window->SwapBuffers(); m_context.inputManager->ClearEvents(); + m_context.driver->NotifyFrameFinished(); } \ No newline at end of file diff --git a/Sources/Overload/OvRendering/include/OvRendering/Context/Driver.h b/Sources/Overload/OvRendering/include/OvRendering/Context/Driver.h index 271be0beb..409dad737 100644 --- a/Sources/Overload/OvRendering/include/OvRendering/Context/Driver.h +++ b/Sources/Overload/OvRendering/include/OvRendering/Context/Driver.h @@ -45,6 +45,11 @@ namespace OvRendering::Context */ ~Driver(); + /** + * Notifies the driver that the frame is finished + */ + void NotifyFrameFinished(); + /** * Set the viewport * @param p_x diff --git a/Sources/Overload/OvRendering/include/OvRendering/HAL/Common/TBackend.h b/Sources/Overload/OvRendering/include/OvRendering/HAL/Common/TBackend.h index c41b2c1cf..85f930f21 100644 --- a/Sources/Overload/OvRendering/include/OvRendering/HAL/Common/TBackend.h +++ b/Sources/Overload/OvRendering/include/OvRendering/HAL/Common/TBackend.h @@ -35,6 +35,12 @@ namespace OvRendering::HAL */ std::optional Init(bool p_debug); + /** + * Notifies the backend that the current frame is finished. + * This can be used for synchronization purposes, profiling, etc. + */ + void NotifyFrameFinished(); + /** * Clears the specified buffers. * @param p_colorBuffer Clears the color buffer if true. diff --git a/Sources/Overload/OvRendering/include/OvRendering/HAL/Profiling.h b/Sources/Overload/OvRendering/include/OvRendering/HAL/Profiling.h new file mode 100644 index 000000000..c4ff467e6 --- /dev/null +++ b/Sources/Overload/OvRendering/include/OvRendering/HAL/Profiling.h @@ -0,0 +1,14 @@ +/** +* @project: Overload +* @author: Overload Tech. +* @licence: MIT +*/ + +#pragma once + +#if defined(GRAPHICS_API_OPENGL) +#include +#define OvGpuZone(...) TracyGpuZone(__VA_ARGS__) +#else +#define OvGpuZone(...) (void)0 +#endif // defined(GRAPHICS_API_OPENGL) diff --git a/Sources/Overload/OvRendering/src/OvRendering/Context/Driver.cpp b/Sources/Overload/OvRendering/src/OvRendering/Context/Driver.cpp index 516b60d78..372cdaa5b 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Context/Driver.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Context/Driver.cpp @@ -46,6 +46,11 @@ OvRendering::Context::Driver::~Driver() { } +void OvRendering::Context::Driver::NotifyFrameFinished() +{ + m_gfxBackend->NotifyFrameFinished(); +} + void OvRendering::Context::Driver::SetViewport(uint32_t p_x, uint32_t p_y, uint32_t p_width, uint32_t p_height) { m_gfxBackend->SetViewport(p_x, p_y, p_width, p_height); diff --git a/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp b/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp index b0083be18..bca9d841d 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp @@ -48,7 +48,7 @@ OvRendering::Core::ABaseRenderer::~ABaseRenderer() void OvRendering::Core::ABaseRenderer::BeginFrame(const Data::FrameDescriptor& p_frameDescriptor) { - ZoneScopedN("ABaseRenderer::BeginFrame"); + ZoneScoped; OVASSERT(!s_isDrawing, "Cannot call BeginFrame() when previous frame hasn't finished."); OVASSERT(p_frameDescriptor.IsValid(), "Invalid FrameDescriptor!"); @@ -78,7 +78,7 @@ void OvRendering::Core::ABaseRenderer::BeginFrame(const Data::FrameDescriptor& p void OvRendering::Core::ABaseRenderer::EndFrame() { - ZoneScopedN("ABaseRenderer::EndFrame"); + ZoneScoped; OVASSERT(s_isDrawing, "Cannot call EndFrame() before calling BeginFrame()"); @@ -119,8 +119,7 @@ void OvRendering::Core::ABaseRenderer::Clear( const OvMaths::FVector4& p_color ) { - ZoneScopedN("ABaseRenderer::Clear"); - + ZoneScoped; m_driver.Clear(p_colorBuffer, p_depthBuffer, p_stencilBuffer, p_color); } @@ -132,7 +131,7 @@ void OvRendering::Core::ABaseRenderer::Blit( OvRendering::Settings::EBlitFlags p_flags ) { - ZoneScopedN("ABaseRenderer::Blit"); + ZoneScoped; OVASSERT(m_unitQuad != nullptr, "Invalid unit quad mesh, cannot blit!"); @@ -185,7 +184,7 @@ void OvRendering::Core::ABaseRenderer::DrawEntity( const Entities::Drawable& p_drawable ) { - ZoneScopedN("ABaseRenderer::DrawEntity"); + ZoneScoped; auto material = p_drawable.material; auto mesh = p_drawable.mesh; diff --git a/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp b/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp index 4643993fa..37a57c65e 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp @@ -8,7 +8,8 @@ #include -#include "OvRendering/Core/CompositeRenderer.h" +#include +#include OvRendering::Core::CompositeRenderer::CompositeRenderer(Context::Driver& p_driver) : ABaseRenderer(p_driver) @@ -17,6 +18,9 @@ OvRendering::Core::CompositeRenderer::CompositeRenderer(Context::Driver& p_drive void OvRendering::Core::CompositeRenderer::BeginFrame(const Data::FrameDescriptor& p_frameDescriptor) { + ZoneScoped; + OvGpuZone("BeginFrame"); + ABaseRenderer::BeginFrame(p_frameDescriptor); for (const auto& [_, feature] : m_features) @@ -38,7 +42,8 @@ void OvRendering::Core::CompositeRenderer::BeginFrame(const Data::FrameDescripto void OvRendering::Core::CompositeRenderer::DrawFrame() { - ZoneScopedN("CompositeRenderer::DrawFrame"); + ZoneScoped; + OvGpuZone("DrawFrame"); auto pso = CreatePipelineState(); @@ -56,7 +61,8 @@ void OvRendering::Core::CompositeRenderer::DrawFrame() void OvRendering::Core::CompositeRenderer::EndFrame() { - ZoneScopedN("CompositeRenderer::EndFrame"); + ZoneScoped; + OvGpuZone("EndFrame"); for (const auto& [_, pass] : m_passes) { @@ -83,7 +89,7 @@ void OvRendering::Core::CompositeRenderer::DrawEntity( const Entities::Drawable& p_drawable ) { - ZoneScopedN("CompositeRenderer::DrawEntity"); + ZoneScoped; for (const auto& [_, feature] : m_features) { diff --git a/Sources/Overload/OvRendering/src/OvRendering/Data/Material.cpp b/Sources/Overload/OvRendering/src/OvRendering/Data/Material.cpp index 39f6b9b0b..5087d59c5 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Data/Material.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Data/Material.cpp @@ -4,6 +4,8 @@ * @licence: MIT */ +#include + #include "OvRendering/Data/Material.h" #include "OvRendering/HAL/UniformBuffer.h" #include "OvRendering/HAL/TextureHandle.h" @@ -45,6 +47,8 @@ void OvRendering::Data::Material::FillUniform() void OvRendering::Data::Material::Bind(OvRendering::Resources::Texture* p_emptyTexture) { + ZoneScoped; + if (HasShader()) { using namespace OvMaths; diff --git a/Sources/Overload/OvRendering/src/OvRendering/HAL/None/NoneBackend.cpp b/Sources/Overload/OvRendering/src/OvRendering/HAL/None/NoneBackend.cpp index bf927a9be..6a1b3ad21 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/HAL/None/NoneBackend.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/HAL/None/NoneBackend.cpp @@ -25,6 +25,10 @@ namespace OvRendering::HAL return OvRendering::Data::PipelineState{}; } + template<> + void NoneBackend::NotifyFrameFinished() + {} + template<> void NoneBackend::Clear(bool p_colorBuffer, bool p_depthBuffer, bool p_stencilBuffer) {} diff --git a/Sources/Overload/OvRendering/src/OvRendering/HAL/OpenGL/GLBackend.cpp b/Sources/Overload/OvRendering/src/OvRendering/HAL/OpenGL/GLBackend.cpp index 7d8b1e6f9..f1e83cdf7 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/HAL/OpenGL/GLBackend.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/HAL/OpenGL/GLBackend.cpp @@ -8,6 +8,9 @@ #include +// Needs to be included after OpenGL headers +#include + #include #include #include @@ -218,6 +221,8 @@ namespace OvRendering::HAL return std::nullopt; } + TracyGpuContext; + if (debug) { glEnable(GL_DEBUG_OUTPUT); @@ -231,11 +236,16 @@ namespace OvRendering::HAL return RetrieveOpenGLPipelineState(); } + template<> + void GLBackend::NotifyFrameFinished() + { + TracyGpuCollect; + } + template<> void GLBackend::Clear(bool p_colorBuffer, bool p_depthBuffer, bool p_stencilBuffer) { GLbitfield clearMask = 0; - if (p_colorBuffer) clearMask |= GL_COLOR_BUFFER_BIT; if (p_depthBuffer) clearMask |= GL_DEPTH_BUFFER_BIT; if (p_stencilBuffer) clearMask |= GL_STENCIL_BUFFER_BIT; From c6c189b731f02973639b9e7a975de776824e1567 Mon Sep 17 00:00:00 2001 From: Adrien GIVRY Date: Fri, 4 Apr 2025 09:53:32 -0400 Subject: [PATCH 03/11] Added support for memory profiling --- .../OvCore/Helpers/TracyMemoryAllocators.h | 46 +++++++++++++++++++ .../Overload/OvEditor/src/OvEditor/Main.cpp | 12 ++++- .../src/OvEditor/Panels/FrameInfo.cpp | 12 ++++- .../OvGame/src/OvGame/Debug/FrameInfo.cpp | 12 ++++- Sources/Overload/OvGame/src/OvGame/Main.cpp | 8 ++++ Sources/Overload/premake5.lua | 3 +- 6 files changed, 89 insertions(+), 4 deletions(-) create mode 100644 Sources/Overload/OvCore/include/OvCore/Helpers/TracyMemoryAllocators.h diff --git a/Sources/Overload/OvCore/include/OvCore/Helpers/TracyMemoryAllocators.h b/Sources/Overload/OvCore/include/OvCore/Helpers/TracyMemoryAllocators.h new file mode 100644 index 000000000..18b2d7261 --- /dev/null +++ b/Sources/Overload/OvCore/include/OvCore/Helpers/TracyMemoryAllocators.h @@ -0,0 +1,46 @@ +/** +* @project: Overload +* @author: Overload Tech. +* @licence: MIT +*/ + +#include + +#include + +#if defined(TRACY_ENABLE) +#define TRACY_CUSTOM_NEW_ALLOCATOR \ +void* operator new(std::size_t count) \ +{ \ + auto ptr = malloc(count); \ + TracyAlloc(ptr, count); \ + return ptr; \ +} + +#define TRACY_CUSTOM_DELETE_ALLOCATOR \ +void operator delete(void* ptr) noexcept \ +{ \ + TracyFree(ptr); \ + free(ptr); \ +} + +#define TRACY_CUSTOM_NEW_ARRAY_ALLOCATOR \ +void* operator new[](std::size_t count) \ +{ \ + auto ptr = malloc(count); \ + TracyAlloc(ptr, count); \ + return ptr; \ +} + +#define TRACY_CUSTOM_DELETE_ARRAY_ALLOCATOR \ +void operator delete[](void* ptr) noexcept \ +{ \ + TracyFree(ptr); \ + free(ptr); \ +} +#else +#define TRACY_CUSTOM_NEW_ALLOCATOR +#define TRACY_CUSTOM_DELETE_ALLOCATOR +#define TRACY_CUSTOM_NEW_ARRAY_ALLOCATOR +#define TRACY_CUSTOM_DELETE_ARRAY_ALLOCATOR +#endif diff --git a/Sources/Overload/OvEditor/src/OvEditor/Main.cpp b/Sources/Overload/OvEditor/src/OvEditor/Main.cpp index d48f64453..d4767e5ed 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Main.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Main.cpp @@ -6,12 +6,14 @@ #include +#include + + #include #include #include #include - #include #undef APIENTRY @@ -19,6 +21,14 @@ FORCE_DEDICATED_GPU +#if defined(TRACY_MEMORY_ENABLE) + #include + TRACY_CUSTOM_NEW_ALLOCATOR + TRACY_CUSTOM_DELETE_ALLOCATOR + TRACY_CUSTOM_NEW_ARRAY_ALLOCATOR + TRACY_CUSTOM_DELETE_ARRAY_ALLOCATOR +#endif + /** * When Overload is launched from a project file, we should consider the executable path as * the current working directory diff --git a/Sources/Overload/OvEditor/src/OvEditor/Panels/FrameInfo.cpp b/Sources/Overload/OvEditor/src/OvEditor/Panels/FrameInfo.cpp index 42809a60a..186e6e7d4 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Panels/FrameInfo.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Panels/FrameInfo.cpp @@ -52,7 +52,17 @@ void OvEditor::Panels::FrameInfo::Update(OvTools::Utils::OptRef p_targetV auto& frameInfo = p_targetView ? GetFrameInfoFromView(p_targetView.value()) : kEmptyFrameInfo; - const auto loc = std::locale(""); + // Workaround for Tracy memory profiler. + // When using a non-default locale, std::format + // will call delete on a non-allocated object, + // resulting in a instrumentation error, interrupting + // Tracy profiler's execution. +#if defined(TRACY_MEMORY_ENABLE) + const std::locale loc{ }; +#else + const std::locale loc{ "" }; +#endif + m_batchCountText.content = std::format(loc, "Batches: {:L}", frameInfo.batchCount); m_instanceCountText.content = std::format(loc, "Instances: {:L}", frameInfo.instanceCount); m_polyCountText.content = std::format(loc, "Polygons: {:L}", frameInfo.polyCount); diff --git a/Sources/Overload/OvGame/src/OvGame/Debug/FrameInfo.cpp b/Sources/Overload/OvGame/src/OvGame/Debug/FrameInfo.cpp index 6bf14a649..2a92c961f 100644 --- a/Sources/Overload/OvGame/src/OvGame/Debug/FrameInfo.cpp +++ b/Sources/Overload/OvGame/src/OvGame/Debug/FrameInfo.cpp @@ -25,7 +25,17 @@ OvGame::Debug::FrameInfo::FrameInfo(OvWindowing::Window& p_window) : void OvGame::Debug::FrameInfo::Update(const OvRendering::Data::FrameInfo& p_frameInfo) { - const auto loc = std::locale(""); + // Workaround for Tracy memory profiler. + // When using a non-default locale, std::format + // will call delete on a non-allocated object, + // resulting in a instrumentation error, interrupting + // Tracy profiler's execution. +#if defined(TRACY_MEMORY_ENABLE) + const std::locale loc{ }; +#else + const std::locale loc{ "" }; +#endif + m_batchText.content = std::format(loc, "Batches: {:L}", p_frameInfo.batchCount); m_instanceText.content = std::format(loc, "Instances: {:L}", p_frameInfo.instanceCount); m_polyText.content = std::format(loc, "Polygons: {:L}", p_frameInfo.polyCount); diff --git a/Sources/Overload/OvGame/src/OvGame/Main.cpp b/Sources/Overload/OvGame/src/OvGame/Main.cpp index 7c7b44e1d..c0b181761 100644 --- a/Sources/Overload/OvGame/src/OvGame/Main.cpp +++ b/Sources/Overload/OvGame/src/OvGame/Main.cpp @@ -10,6 +10,14 @@ FORCE_DEDICATED_GPU +#if defined(TRACY_MEMORY_ENABLE) + #include + TRACY_CUSTOM_NEW_ALLOCATOR + TRACY_CUSTOM_DELETE_ALLOCATOR + TRACY_CUSTOM_NEW_ARRAY_ALLOCATOR + TRACY_CUSTOM_DELETE_ARRAY_ALLOCATOR +#endif + #ifdef _DEBUG int main() #else diff --git a/Sources/Overload/premake5.lua b/Sources/Overload/premake5.lua index 4456edb14..79d3d1418 100644 --- a/Sources/Overload/premake5.lua +++ b/Sources/Overload/premake5.lua @@ -20,7 +20,8 @@ workspace "Overload" "LUA_SCRIPTING", "GRAPHICS_API_OPENGL", "OVERLOAD_VERSION=\"" .. version .. "\"", - "TRACY_ENABLE" + "TRACY_ENABLE", + "TRACY_MEMORY_ENABLE" } -- Disable "Hot Reload": Doesn't work with Tracy. From 6975c5481fd8fbcc75831ab7eb0761c1fdbc630c Mon Sep 17 00:00:00 2001 From: Adrien GIVRY Date: Tue, 8 Apr 2025 12:40:11 -0400 Subject: [PATCH 04/11] Removed OvAnalytics --- README.md | 1 - .../include/OvAnalytics/Hardware/CPUInfo.h | 31 ---- .../include/OvAnalytics/Hardware/GPUInfo.h | 47 ------ .../OvAnalytics/Hardware/HardwareInfo.h | 58 -------- .../OvAnalytics/Hardware/HardwareReport.h | 33 ----- .../include/OvAnalytics/Hardware/RAMInfo.h | 42 ------ .../include/OvAnalytics/Profiling/Profiler.h | 88 ----------- .../OvAnalytics/Profiling/ProfilerReport.h | 35 ----- .../OvAnalytics/Profiling/ProfilerSpy.h | 50 ------- Sources/Overload/OvAnalytics/premake5.lua | 17 --- .../src/OvAnalytics/Hardware/CPUInfo.cpp | 33 ----- .../src/OvAnalytics/Hardware/GPUInfo.cpp | 57 -------- .../src/OvAnalytics/Hardware/HardwareInfo.cpp | 55 ------- .../src/OvAnalytics/Hardware/RAMInfo.cpp | 36 ----- .../src/OvAnalytics/Profiling/Profiler.cpp | 119 --------------- .../src/OvAnalytics/Profiling/ProfilerSpy.cpp | 21 --- .../OvCore/Helpers/TracyMemoryAllocators.h | 46 ------ Sources/Overload/OvCore/premake5.lua | 2 +- .../Rendering/PostProcessRenderPass.cpp | 10 +- .../src/OvCore/Rendering/SceneRenderer.cpp | 26 ++-- .../src/OvCore/Rendering/ShadowRenderPass.cpp | 4 +- .../OvCore/src/OvCore/SceneSystem/Scene.cpp | 14 +- .../OvCore/Scripting/Lua/LuaScriptEngine.cpp | 4 +- .../OvEditor/include/OvEditor/Core/Editor.h | 2 - .../include/OvEditor/Panels/FrameInfo.h | 11 +- .../include/OvEditor/Panels/HardwareInfo.h | 28 +--- .../include/OvEditor/Panels/Profiler.h | 76 ---------- Sources/Overload/OvEditor/layout.ini | 122 +++++++++------- Sources/Overload/OvEditor/premake5.lua | 4 +- .../src/OvEditor/Core/Application.cpp | 5 +- .../OvEditor/src/OvEditor/Core/Editor.cpp | 86 +++++------ .../Overload/OvEditor/src/OvEditor/Main.cpp | 13 +- .../src/OvEditor/Panels/FrameInfo.cpp | 21 ++- .../src/OvEditor/Panels/HardwareInfo.cpp | 71 +-------- .../OvEditor/src/OvEditor/Panels/Profiler.cpp | 138 ------------------ .../OvEditor/Rendering/DebugSceneRenderer.cpp | 10 +- .../OvEditor/Rendering/GizmoRenderFeature.cpp | 2 - .../src/OvEditor/Rendering/GridRenderPass.cpp | 4 +- .../OvEditor/Rendering/PickingRenderPass.cpp | 14 +- .../OvGame/include/OvGame/Core/Game.h | 14 +- .../include/OvGame/Debug/GameProfiler.h | 60 -------- Sources/Overload/OvGame/premake5.lua | 4 +- .../OvGame/src/OvGame/Core/Application.cpp | 7 +- .../Overload/OvGame/src/OvGame/Core/Game.cpp | 31 ++-- .../OvGame/src/OvGame/Debug/GameProfiler.cpp | 96 ------------ Sources/Overload/OvGame/src/OvGame/Main.cpp | 12 +- .../include/OvRendering/Context/Driver.h | 2 +- .../include/OvRendering/HAL/Common/TBackend.h | 2 +- .../Profiling.h => Profiling/GPUProfiling.h} | 4 +- .../src/OvRendering/Context/Driver.cpp | 4 +- .../src/OvRendering/Core/ABaseRenderer.cpp | 18 +-- .../OvRendering/Core/CompositeRenderer.cpp | 20 +-- .../src/OvRendering/Data/Material.cpp | 6 +- .../src/OvRendering/HAL/None/NoneBackend.cpp | 2 +- .../src/OvRendering/HAL/OpenGL/GLBackend.cpp | 2 +- .../include/OvTools/Profiling/CPUProfiling.h | 13 ++ .../OvTools/Profiling/MemoryProfiling.h | 106 ++++++++++++++ Sources/Overload/OvTools/premake5.lua | 5 +- Sources/Overload/premake5.lua | 1 - 59 files changed, 367 insertions(+), 1478 deletions(-) delete mode 100644 Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/CPUInfo.h delete mode 100644 Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/GPUInfo.h delete mode 100644 Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/HardwareInfo.h delete mode 100644 Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/HardwareReport.h delete mode 100644 Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/RAMInfo.h delete mode 100644 Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/Profiler.h delete mode 100644 Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/ProfilerReport.h delete mode 100644 Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/ProfilerSpy.h delete mode 100644 Sources/Overload/OvAnalytics/premake5.lua delete mode 100644 Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/CPUInfo.cpp delete mode 100644 Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/GPUInfo.cpp delete mode 100644 Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/HardwareInfo.cpp delete mode 100644 Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/RAMInfo.cpp delete mode 100644 Sources/Overload/OvAnalytics/src/OvAnalytics/Profiling/Profiler.cpp delete mode 100644 Sources/Overload/OvAnalytics/src/OvAnalytics/Profiling/ProfilerSpy.cpp delete mode 100644 Sources/Overload/OvCore/include/OvCore/Helpers/TracyMemoryAllocators.h delete mode 100644 Sources/Overload/OvEditor/include/OvEditor/Panels/Profiler.h delete mode 100644 Sources/Overload/OvEditor/src/OvEditor/Panels/Profiler.cpp delete mode 100644 Sources/Overload/OvGame/include/OvGame/Debug/GameProfiler.h delete mode 100644 Sources/Overload/OvGame/src/OvGame/Debug/GameProfiler.cpp rename Sources/Overload/OvRendering/include/OvRendering/{HAL/Profiling.h => Profiling/GPUProfiling.h} (71%) create mode 100644 Sources/Overload/OvTools/include/OvTools/Profiling/CPUProfiling.h create mode 100644 Sources/Overload/OvTools/include/OvTools/Profiling/MemoryProfiling.h diff --git a/README.md b/README.md index e2eda9934..75aa39317 100644 --- a/README.md +++ b/README.md @@ -55,7 +55,6 @@ Overload is divided into 12 modules: 10 libraries (SDK), and 2 executables (Appl ## Overload SDK The Overload SDK is the core of the engine. It is a set of libraries used by our applications: `OvGame` and `OvEditor`. We designed theses libraries with reusability in mind. They are highly modular and easy to extract from a game engine context. -- `OvAnalytics`: Code and hardware profiling - `OvDebug`: Logging and assertions - `OvTools`: Serialization, INI files, events, clock - `OvMaths`: Vectors, matrices, quaternions, transforms diff --git a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/CPUInfo.h b/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/CPUInfo.h deleted file mode 100644 index 010588318..000000000 --- a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/CPUInfo.h +++ /dev/null @@ -1,31 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -#include - -namespace OvAnalytics::Hardware -{ - /** - * The CPUInfo class will gather informations about the CPU usage - */ - class CPUInfo final - { - public: - /** - * Calculate the CPU load for every process on the machine (%) - */ - float CalculateCPULoad(); - - private: - float CalculateCPULoad(uint64_t idleTicks, uint64_t totalTicks); - - private: - uint64_t m_cpuPreviousTotalTicks = 0; - uint64_t m_cpuPreviousIdleTicks = 0; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/GPUInfo.h b/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/GPUInfo.h deleted file mode 100644 index bd6b649bd..000000000 --- a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/GPUInfo.h +++ /dev/null @@ -1,47 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -namespace OvAnalytics::Hardware -{ - /** - * The GPUInfo class will gather informations about the GPU usage - * Reference: Open Hardware Monitor (http://code.google.com/p/open-hardware-monitor) - */ - class GPUInfo final - { - public: - /** - * Constructor of the GPUInfo class - */ - GPUInfo(); - - /** - * Calculate the GPU load for every process on the machine (%) - */ - float CalculateGPULoad(); - - private: - /* Internal typedef for NvAPI function pointers */ - typedef int*(*NvAPI_QueryInterface_t)(unsigned int offset); - typedef int(*NvAPI_Initialize_t)(); - typedef int(*NvAPI_EnumPhysicalGPUs_t)(int **handles, int *count); - typedef int(*NvAPI_GPU_GetUsages_t)(int *handle, unsigned int *usages); - - bool m_NvAPIReady = false; - - /* nvapi.dll internal function pointers */ - NvAPI_QueryInterface_t m_NvAPI_QueryInterface = nullptr; - NvAPI_Initialize_t m_NvAPI_Initialize = nullptr; - NvAPI_EnumPhysicalGPUs_t m_NvAPI_EnumPhysicalGPUs = nullptr; - NvAPI_GPU_GetUsages_t m_NvAPI_GPU_GetUsages = nullptr; - - int m_gpuCount = 0; - int* m_gpuHandles[64] = { nullptr }; - unsigned int m_gpuUsages[34] = { 0 }; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/HardwareInfo.h b/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/HardwareInfo.h deleted file mode 100644 index 5c2d2fe7d..000000000 --- a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/HardwareInfo.h +++ /dev/null @@ -1,58 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -#include - - -#include "OvAnalytics/Hardware/HardwareReport.h" -#include "OvAnalytics/Hardware/CPUInfo.h" -#include "OvAnalytics/Hardware/GPUInfo.h" -#include "OvAnalytics/Hardware/RAMInfo.h" - -namespace OvAnalytics::Hardware -{ - /** - * The hardware info class will gather informations about the hardware in real-time (CPU usage, GPU usage, RAM usage...) - */ - class HardwareInfo final - { - public: - /** - * Constructor of the HardwareInfo class - * @param p_timeInterval - */ - HardwareInfo(double p_timeInterval = 1.0); - - /** - * Generate a report containing information about the actual hardware - */ - HardwareReport GenerateReport(); - - /** - * Update hardware information (CPU usage, GPU usage, RAM) - */ - void Tick(); - - private: - void Update(); - - double m_timeInterval; - double m_timer; - - std::chrono::steady_clock::time_point m_previousTime; - std::chrono::steady_clock::time_point m_currentTime; - std::chrono::duration m_elapsedTime; - - float m_cpuUsage; - float m_gpuUsage; - - CPUInfo m_cpuInfo; - GPUInfo m_gpuInfo; - RAMInfo m_ramInfo; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/HardwareReport.h b/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/HardwareReport.h deleted file mode 100644 index 7dd2bb410..000000000 --- a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/HardwareReport.h +++ /dev/null @@ -1,33 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - - - -namespace OvAnalytics::Hardware -{ - /** - * HardwareReport contains a set of data calculated by HardwareInfo - */ - struct HardwareReport final - { - /* CPU load for every process on the machine (%) */ - float CPULoad; - - /* GPU load for every process on the machine (%) */ - float GPULoad; - - /* Used RAM on the machine for every process (MB) */ - float RAMUsed; - - /* Free RAM on the machine (MB) */ - float RAMFree; - - /* Maximum RAM available (MB) */ - float RAMMax; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/RAMInfo.h b/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/RAMInfo.h deleted file mode 100644 index 14d92c182..000000000 --- a/Sources/Overload/OvAnalytics/include/OvAnalytics/Hardware/RAMInfo.h +++ /dev/null @@ -1,42 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -namespace OvAnalytics::Hardware -{ - /** - * The GPUInfo class will gather informations about the GPU usage - */ - class RAMInfo final - { - public: - /** - * Update the RAMInfo - */ - void Update(); - - /** - * Return the total physical memory reserved (MB) - */ - float GetUsedRAM(); - - /** - * Return the total physical memory free (MB) - */ - float GetFreeRAM(); - - /** - * Return the maximum available memory on the system (MB) - */ - float GetMaxRAM(); - - private: - float m_usedRAM = 0.0f; - float m_freeRAM = 0.0f; - float m_maxRAM = 0.0f; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/Profiler.h b/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/Profiler.h deleted file mode 100644 index 534ad54af..000000000 --- a/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/Profiler.h +++ /dev/null @@ -1,88 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -#include -#include -#include - - -#include "OvAnalytics/Profiling/ProfilerReport.h" - -namespace OvAnalytics::Profiling -{ - /* Forward declaration of the profiler spy structure */ - struct ProfilerSpy; - - /** - * The profiler collect data about the running program - */ - class Profiler final - { - public: - /** - * Create the profiler - */ - Profiler(); - - /** - * Generate a report containing data about the last profiling session - */ - ProfilerReport GenerateReport(); - - /** - * Clear any collected data - */ - void ClearHistory(); - - /** - * Update the profiler - * @param p_deltaTime - */ - void Update(float p_deltaTime); - - /** - * Save the given spy collected data to the profiler history - * @param p_spy (Spy to collect data from) - */ - static void Save(ProfilerSpy& p_spy); - - /** - * Verify if the profiler is currently enabled - */ - static bool IsEnabled(); - - /** - * Enable the profiler if it is currently disabled, and vice-versa - */ - static void ToggleEnable(); - - /** - * Enable the profiler - */ - static void Enable(); - - /** - * Disable the profiler - */ - static void Disable(); - - private: - /* Time relatives */ - std::chrono::steady_clock::time_point m_lastTime; - - /* Profiler settings */ - static bool __ENABLED; - - /* Collected data */ - static std::mutex __SAVE_MUTEX; - static std::unordered_map __ELPASED_HISTORY; - static std::unordered_map __CALLS_COUNTER; - static std::vector __WORKING_THREADS; - static uint32_t __ELAPSED_FRAMES; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/ProfilerReport.h b/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/ProfilerReport.h deleted file mode 100644 index b809c15d2..000000000 --- a/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/ProfilerReport.h +++ /dev/null @@ -1,35 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -#include - - -namespace OvAnalytics::Profiling -{ - /** - * Contains profiling data about a running period - */ - struct ProfilerReport final - { - /** - * Data about an action (Called method) - */ - struct Action final - { - std::string name; - double duration; - double percentage; - uint64_t calls; - }; - - double elaspedTime = 0.0; - uint16_t workingThreads = 0u; - uint32_t elapsedFrames = 0u; - std::vector actions; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/ProfilerSpy.h b/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/ProfilerSpy.h deleted file mode 100644 index c0f87482e..000000000 --- a/Sources/Overload/OvAnalytics/include/OvAnalytics/Profiling/ProfilerSpy.h +++ /dev/null @@ -1,50 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -#include -#include - - -#include "OvAnalytics/Profiling/Profiler.h" -#include "OvAnalytics/Profiling/ProfilerSpy.h" - -/** -* This macro allow the creation of profiler spies -* Any spy will die and send data to the profiler at -* the end of the scope where this macro get called -*/ -#define PROFILER_SPY(name)\ - std::unique_ptr __profiler_spy__ = \ - OvAnalytics::Profiling::Profiler::IsEnabled() ? std::make_unique(name) : nullptr - -namespace OvAnalytics::Profiling -{ - /** - * A little informer that is created when PROFILER_SPY(name) is written. - * It helps collecting informations about methods durations for debugging - * event in release - */ - struct ProfilerSpy final - { - /** - * Create the profiler spy with the given name. - * @param p_name - */ - ProfilerSpy(const std::string& p_name); - - /** - * Destroy the profiler spy. - * On destruction, his collected data will be saved in the profiler - */ - ~ProfilerSpy(); - - const std::string name; - const std::chrono::steady_clock::time_point start; - std::chrono::steady_clock::time_point end; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/premake5.lua b/Sources/Overload/OvAnalytics/premake5.lua deleted file mode 100644 index a69e3d7ac..000000000 --- a/Sources/Overload/OvAnalytics/premake5.lua +++ /dev/null @@ -1,17 +0,0 @@ -project "OvAnalytics" - kind "StaticLib" - language "C++" - cppdialect "C++20" - files { "**.h", "**.inl", "**.cpp", "**.lua" } - includedirs { "include" } - targetdir (outputdir .. "%{cfg.buildcfg}/%{prj.name}") - objdir (objoutdir .. "%{cfg.buildcfg}/%{prj.name}") - characterset ("MBCS") - - filter { "configurations:Debug" } - defines { "DEBUG" } - symbols "On" - - filter { "configurations:Release" } - defines { "NDEBUG" } - optimize "On" diff --git a/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/CPUInfo.cpp b/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/CPUInfo.cpp deleted file mode 100644 index fff0d75f1..000000000 --- a/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/CPUInfo.cpp +++ /dev/null @@ -1,33 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#include "OvAnalytics/Hardware/CPUInfo.h" - -#include - -uint64_t FileTimeToInt64(const FILETIME& ft) -{ - return (((unsigned long long)(ft.dwHighDateTime)) << 32) | ((unsigned long long)ft.dwLowDateTime); -} - -float OvAnalytics::Hardware::CPUInfo::CalculateCPULoad() -{ - FILETIME idleTime, kernelTime, userTime; - return GetSystemTimes(&idleTime, &kernelTime, &userTime) ? CalculateCPULoad(FileTimeToInt64(idleTime), FileTimeToInt64(kernelTime) + FileTimeToInt64(userTime)) : -100.0f; -} - -float OvAnalytics::Hardware::CPUInfo::CalculateCPULoad(uint64_t p_idleTicks, uint64_t p_totalTicks) -{ - uint64_t totalTicksSinceLastTime = p_totalTicks - m_cpuPreviousTotalTicks; - uint64_t idleTicksSinceLastTime = p_idleTicks - m_cpuPreviousIdleTicks; - - float ret = 1.0f - ((totalTicksSinceLastTime > 0) ? ((float)idleTicksSinceLastTime) / totalTicksSinceLastTime : 0); - - m_cpuPreviousTotalTicks = p_totalTicks; - m_cpuPreviousIdleTicks = p_idleTicks; - - return ret * 100.0f; -} diff --git a/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/GPUInfo.cpp b/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/GPUInfo.cpp deleted file mode 100644 index d1d7b42c2..000000000 --- a/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/GPUInfo.cpp +++ /dev/null @@ -1,57 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#include "OvAnalytics/Hardware/GPUInfo.h" - -#include - -OvAnalytics::Hardware::GPUInfo::GPUInfo() -{ - #if _WIN32 || _WIN64 - #if _WIN64 - #define ENVIRONMENT64 - #else - #define ENVIRONMENT32 - #endif - #endif - - #ifdef ENVIRONMENT64 - HMODULE hmod = LoadLibraryA("nvapi64.dll"); - #elif ENVIRONMENT32 - HMODULE hmod = LoadLibraryA("nvapi.dll"); - #else - HMODULE hmod = nullptr; - #endif - - /* Handle "Couldn't find nvapi.dll" */ - if (hmod) - { - m_NvAPI_QueryInterface = (NvAPI_QueryInterface_t)GetProcAddress(hmod, "nvapi_QueryInterface"); - m_NvAPI_Initialize = (NvAPI_Initialize_t)(*m_NvAPI_QueryInterface)(0x0150E828); - m_NvAPI_EnumPhysicalGPUs = (NvAPI_EnumPhysicalGPUs_t)(*m_NvAPI_QueryInterface)(0xE5AC921F); - m_NvAPI_GPU_GetUsages = (NvAPI_GPU_GetUsages_t)(*m_NvAPI_QueryInterface)(0x189A1FDF); - - if (m_NvAPI_Initialize && m_NvAPI_EnumPhysicalGPUs && m_NvAPI_GPU_GetUsages) - { - (*m_NvAPI_Initialize)(); - - m_gpuUsages[0] = (136) | 0x10000; - - (*m_NvAPI_EnumPhysicalGPUs)(m_gpuHandles, &m_gpuCount); - - m_NvAPIReady = true; - } - } -} - -float OvAnalytics::Hardware::GPUInfo::CalculateGPULoad() -{ - if (!m_NvAPIReady) - return -100.0f; - - (*m_NvAPI_GPU_GetUsages)(m_gpuHandles[0], m_gpuUsages); - return static_cast(m_gpuUsages[3]); -} diff --git a/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/HardwareInfo.cpp b/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/HardwareInfo.cpp deleted file mode 100644 index 89f12fabf..000000000 --- a/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/HardwareInfo.cpp +++ /dev/null @@ -1,55 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#include - -#include "OvAnalytics/Hardware/HardwareInfo.h" - -OvAnalytics::Hardware::HardwareInfo::HardwareInfo(double p_timeInterval) : - m_timeInterval(p_timeInterval), - m_timer(0.0f), - m_cpuUsage(0.0f), - m_gpuUsage(0.0f) -{ -} - -OvAnalytics::Hardware::HardwareReport OvAnalytics::Hardware::HardwareInfo::GenerateReport() -{ - return HardwareReport - { - m_cpuUsage, - m_gpuUsage, - m_ramInfo.GetUsedRAM(), - m_ramInfo.GetFreeRAM(), - m_ramInfo.GetMaxRAM() - }; -} - -void OvAnalytics::Hardware::HardwareInfo::Tick() -{ - m_currentTime = std::chrono::steady_clock::now(); - m_elapsedTime = m_currentTime - m_previousTime; - - m_timer += m_elapsedTime.count(); - - if (m_timer >= m_timeInterval) - { - while (m_timer >= m_timeInterval) - m_timer -= m_timeInterval; - - Update(); - } - - m_previousTime = m_currentTime; -} - -void OvAnalytics::Hardware::HardwareInfo::Update() -{ - m_cpuUsage = m_cpuInfo.CalculateCPULoad(); - m_gpuUsage = m_gpuInfo.CalculateGPULoad(); - - m_ramInfo.Update(); -} diff --git a/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/RAMInfo.cpp b/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/RAMInfo.cpp deleted file mode 100644 index 9cfa4e639..000000000 --- a/Sources/Overload/OvAnalytics/src/OvAnalytics/Hardware/RAMInfo.cpp +++ /dev/null @@ -1,36 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#include "OvAnalytics/Hardware/RAMInfo.h" - -#include -#include - -void OvAnalytics::Hardware::RAMInfo::Update() -{ - MEMORYSTATUSEX statex; - statex.dwLength = sizeof(statex); - GlobalMemoryStatusEx(&statex); - - m_maxRAM = statex.ullTotalPhys / 1048576.0f; - m_freeRAM = statex.ullAvailPhys / 1048576.0f; - m_usedRAM = m_maxRAM - statex.ullAvailPhys / 1048576.0f; -} - -float OvAnalytics::Hardware::RAMInfo::GetUsedRAM() -{ - return m_usedRAM; -} - -float OvAnalytics::Hardware::RAMInfo::GetFreeRAM() -{ - return m_freeRAM; -} - -float OvAnalytics::Hardware::RAMInfo::GetMaxRAM() -{ - return m_maxRAM; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/src/OvAnalytics/Profiling/Profiler.cpp b/Sources/Overload/OvAnalytics/src/OvAnalytics/Profiling/Profiler.cpp deleted file mode 100644 index 1f8864ea9..000000000 --- a/Sources/Overload/OvAnalytics/src/OvAnalytics/Profiling/Profiler.cpp +++ /dev/null @@ -1,119 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#include -#include -#include -#include - -#include "OvAnalytics/Profiling/Profiler.h" -#include "OvAnalytics/Profiling/ProfilerSpy.h" - -bool OvAnalytics::Profiling::Profiler::__ENABLED; -std::mutex OvAnalytics::Profiling::Profiler::__SAVE_MUTEX; -std::unordered_map OvAnalytics::Profiling::Profiler::__ELPASED_HISTORY; -std::unordered_map OvAnalytics::Profiling::Profiler::__CALLS_COUNTER; -std::vector OvAnalytics::Profiling::Profiler::__WORKING_THREADS; -uint32_t OvAnalytics::Profiling::Profiler::__ELAPSED_FRAMES; - -OvAnalytics::Profiling::Profiler::Profiler() -{ - m_lastTime = std::chrono::high_resolution_clock::now(); - __ENABLED = false; -} - -OvAnalytics::Profiling::ProfilerReport OvAnalytics::Profiling::Profiler::GenerateReport() -{ - ProfilerReport report; - - if (__ELAPSED_FRAMES == 0) - return report; - - std::chrono::duration elapsed = std::chrono::high_resolution_clock::now() - m_lastTime; - - report.workingThreads = static_cast((__WORKING_THREADS.size() - 1) / __ELAPSED_FRAMES); - report.elapsedFrames = __ELAPSED_FRAMES; - report.elaspedTime = elapsed.count(); - - std::multimap> sortedHistory; - - /* Fill the sorted history with the current history (Auto sort) */ - for (auto& data : __ELPASED_HISTORY) - sortedHistory.insert(std::pair(data.second, data.first)); - - /* Add every actions to the report */ - for (auto& data : sortedHistory) - report.actions.push_back({ data.second, data.first, (data.first / elapsed.count()) * 100.0, __CALLS_COUNTER[data.second] }); - - return report; -} - -void OvAnalytics::Profiling::Profiler::ClearHistory() -{ - __ELPASED_HISTORY.clear(); - __CALLS_COUNTER.clear(); - __WORKING_THREADS.clear(); - __ELAPSED_FRAMES = 0; - - m_lastTime = std::chrono::high_resolution_clock::now(); -} - -void OvAnalytics::Profiling::Profiler::Update(float p_deltaTime) -{ - if (IsEnabled()) - { - ++__ELAPSED_FRAMES; - } -} - -void OvAnalytics::Profiling::Profiler::Save(OvAnalytics::Profiling::ProfilerSpy& p_spy) -{ - __SAVE_MUTEX.lock(); - - /* Check if this thread is already registered */ - if (std::find(__WORKING_THREADS.begin(), __WORKING_THREADS.end(), std::this_thread::get_id()) == __WORKING_THREADS.end()) - __WORKING_THREADS.push_back(std::this_thread::get_id()); - - if (__ELPASED_HISTORY.find(p_spy.name) != __ELPASED_HISTORY.end()) - { - __ELPASED_HISTORY[p_spy.name] += std::chrono::duration(p_spy.end - p_spy.start).count(); - } - else - { - __ELPASED_HISTORY[p_spy.name] = std::chrono::duration(p_spy.end - p_spy.start).count(); - } - - if (__CALLS_COUNTER.find(p_spy.name) != __CALLS_COUNTER.end()) - { - ++__CALLS_COUNTER[p_spy.name]; - } - else - { - __CALLS_COUNTER[p_spy.name] = 1; - } - - __SAVE_MUTEX.unlock(); -} - -bool OvAnalytics::Profiling::Profiler::IsEnabled() -{ - return __ENABLED; -} - -void OvAnalytics::Profiling::Profiler::ToggleEnable() -{ - __ENABLED = !__ENABLED; -} - -void OvAnalytics::Profiling::Profiler::Enable() -{ - __ENABLED = true; -} - -void OvAnalytics::Profiling::Profiler::Disable() -{ - __ENABLED = false; -} \ No newline at end of file diff --git a/Sources/Overload/OvAnalytics/src/OvAnalytics/Profiling/ProfilerSpy.cpp b/Sources/Overload/OvAnalytics/src/OvAnalytics/Profiling/ProfilerSpy.cpp deleted file mode 100644 index 58bf4064d..000000000 --- a/Sources/Overload/OvAnalytics/src/OvAnalytics/Profiling/ProfilerSpy.cpp +++ /dev/null @@ -1,21 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#include "OvAnalytics/Profiling/ProfilerSpy.h" -#include "OvAnalytics/Profiling/Profiler.h" - -OvAnalytics::Profiling::ProfilerSpy::ProfilerSpy(const std::string & p_name) : - name(p_name), - start(std::chrono::steady_clock::now()) -{ - -} - -OvAnalytics::Profiling::ProfilerSpy::~ProfilerSpy() -{ - end = std::chrono::steady_clock::now(); - OvAnalytics::Profiling::Profiler::Save(*this); -} \ No newline at end of file diff --git a/Sources/Overload/OvCore/include/OvCore/Helpers/TracyMemoryAllocators.h b/Sources/Overload/OvCore/include/OvCore/Helpers/TracyMemoryAllocators.h deleted file mode 100644 index 18b2d7261..000000000 --- a/Sources/Overload/OvCore/include/OvCore/Helpers/TracyMemoryAllocators.h +++ /dev/null @@ -1,46 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#include - -#include - -#if defined(TRACY_ENABLE) -#define TRACY_CUSTOM_NEW_ALLOCATOR \ -void* operator new(std::size_t count) \ -{ \ - auto ptr = malloc(count); \ - TracyAlloc(ptr, count); \ - return ptr; \ -} - -#define TRACY_CUSTOM_DELETE_ALLOCATOR \ -void operator delete(void* ptr) noexcept \ -{ \ - TracyFree(ptr); \ - free(ptr); \ -} - -#define TRACY_CUSTOM_NEW_ARRAY_ALLOCATOR \ -void* operator new[](std::size_t count) \ -{ \ - auto ptr = malloc(count); \ - TracyAlloc(ptr, count); \ - return ptr; \ -} - -#define TRACY_CUSTOM_DELETE_ARRAY_ALLOCATOR \ -void operator delete[](void* ptr) noexcept \ -{ \ - TracyFree(ptr); \ - free(ptr); \ -} -#else -#define TRACY_CUSTOM_NEW_ALLOCATOR -#define TRACY_CUSTOM_DELETE_ALLOCATOR -#define TRACY_CUSTOM_NEW_ARRAY_ALLOCATOR -#define TRACY_CUSTOM_DELETE_ARRAY_ALLOCATOR -#endif diff --git a/Sources/Overload/OvCore/premake5.lua b/Sources/Overload/OvCore/premake5.lua index 773a68bb1..71fe797e7 100644 --- a/Sources/Overload/OvCore/premake5.lua +++ b/Sources/Overload/OvCore/premake5.lua @@ -5,7 +5,7 @@ project "OvCore" files { "**.h", "**.inl", "**.cpp", "**.lua" } includedirs { dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", dependdir .. "tracy", - "%{wks.location}/OvAnalytics/include", "%{wks.location}/OvAudio/include", "%{wks.location}/OvDebug/include", "%{wks.location}/OvMaths/include", "%{wks.location}/OvPhysics/include", + "%{wks.location}/OvAudio/include", "%{wks.location}/OvDebug/include", "%{wks.location}/OvMaths/include", "%{wks.location}/OvPhysics/include", "%{wks.location}/OvRendering/include", "%{wks.location}/OvTools/include", "%{wks.location}/OvUI/include", "%{wks.location}/OvWindowing/include", "include" } diff --git a/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp b/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp index efcf14b6c..28e0124f1 100644 --- a/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Rendering/PostProcessRenderPass.cpp @@ -4,8 +4,6 @@ * @licence: MIT */ -#include - #include #include #include @@ -13,8 +11,10 @@ #include #include -#include #include +#include + +#include OvCore::Rendering::PostProcessRenderPass::PostProcessRenderPass(OvRendering::Core::CompositeRenderer& p_renderer) : OvRendering::Core::ARenderPass(p_renderer), @@ -57,8 +57,8 @@ OvTools::Utils::OptRef F void OvCore::Rendering::PostProcessRenderPass::Draw(OvRendering::Data::PipelineState p_pso) { - ZoneScoped; - OvGpuZone("PostProcessRenderPass"); + CPUZone; + GPUZone("PostProcessRenderPass"); auto& sceneDescriptor = m_renderer.GetDescriptor(); auto& scene = sceneDescriptor.scene; diff --git a/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp b/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp index 403b854b6..8eeb3d65e 100644 --- a/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Rendering/SceneRenderer.cpp @@ -4,10 +4,6 @@ * @licence: MIT */ -#include - -#include - #include #include #include @@ -21,9 +17,11 @@ #include #include -#include +#include #include +#include + struct SceneRenderPassDescriptor { OvCore::Rendering::SceneRenderer::AllDrawables drawables; @@ -64,8 +62,8 @@ class OpaqueRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - ZoneScoped; - OvGpuZone("OpaqueRenderPass"); + CPUZone; + GPUZone("OpaqueRenderPass"); PrepareStencilBuffer(p_pso); @@ -87,8 +85,8 @@ class TransparentRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - ZoneScoped; - OvGpuZone("TransparentRenderPass"); + CPUZone; + GPUZone("TransparentRenderPass"); PrepareStencilBuffer(p_pso); @@ -110,8 +108,8 @@ class UIRenderPass : public SceneRenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - ZoneScoped; - OvGpuZone("UIRenderPass"); + CPUZone; + GPUZone("UIRenderPass"); PrepareStencilBuffer(p_pso); @@ -158,7 +156,7 @@ OvRendering::Features::LightingRenderFeature::LightSet FindActiveLights(const Ov void OvCore::Rendering::SceneRenderer::BeginFrame(const OvRendering::Data::FrameDescriptor& p_frameDescriptor) { - ZoneScoped; + CPUZone; OVASSERT(HasDescriptor(), "Cannot find SceneDescriptor attached to this renderer"); @@ -202,7 +200,7 @@ void OvCore::Rendering::SceneRenderer::DrawModelWithSingleMaterial(OvRendering:: OvCore::Rendering::SceneRenderer::AllDrawables OvCore::Rendering::SceneRenderer::ParseScene() { - ZoneScoped; + CPUZone; using namespace OvCore::ECS::Components; @@ -255,7 +253,7 @@ OvCore::Rendering::SceneRenderer::AllDrawables OvCore::Rendering::SceneRenderer: if (frustum) { - PROFILER_SPY("Frustum Culling"); + CPUZoneN("Frustum Culling"); meshes = frustum.value().GetMeshesInFrustum(*model, modelBoundingSphere, transform, cullingOptions); } else diff --git a/Sources/Overload/OvCore/src/OvCore/Rendering/ShadowRenderPass.cpp b/Sources/Overload/OvCore/src/OvCore/Rendering/ShadowRenderPass.cpp index 669f2356a..5a7aae68e 100644 --- a/Sources/Overload/OvCore/src/OvCore/Rendering/ShadowRenderPass.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Rendering/ShadowRenderPass.cpp @@ -12,7 +12,7 @@ #include #include -#include +#include constexpr uint8_t kMaxShadowMaps = 1; @@ -29,7 +29,7 @@ OvCore::Rendering::ShadowRenderPass::ShadowRenderPass(OvRendering::Core::Composi void OvCore::Rendering::ShadowRenderPass::Draw(OvRendering::Data::PipelineState p_pso) { - OvGpuZone("ShadowRenderPass"); + GPUZone("ShadowRenderPass"); using namespace OvCore::Rendering; diff --git a/Sources/Overload/OvCore/src/OvCore/SceneSystem/Scene.cpp b/Sources/Overload/OvCore/src/OvCore/SceneSystem/Scene.cpp index af3a2c799..d9989593c 100644 --- a/Sources/Overload/OvCore/src/OvCore/SceneSystem/Scene.cpp +++ b/Sources/Overload/OvCore/src/OvCore/SceneSystem/Scene.cpp @@ -7,11 +7,11 @@ #include #include -#include - -#include -#include #include +#include +#include + +#include OvCore::SceneSystem::Scene::Scene() { @@ -66,21 +66,21 @@ bool OvCore::SceneSystem::Scene::IsPlaying() const void OvCore::SceneSystem::Scene::Update(float p_deltaTime) { - ZoneScoped; + CPUZone; auto actors = m_actors; std::for_each(actors.begin(), actors.end(), std::bind(std::mem_fn(&ECS::Actor::OnUpdate), std::placeholders::_1, p_deltaTime)); } void OvCore::SceneSystem::Scene::FixedUpdate(float p_deltaTime) { - ZoneScoped; + CPUZone; auto actors = m_actors; std::for_each(actors.begin(), actors.end(), std::bind(std::mem_fn(&ECS::Actor::OnFixedUpdate), std::placeholders::_1, p_deltaTime)); } void OvCore::SceneSystem::Scene::LateUpdate(float p_deltaTime) { - ZoneScoped; + CPUZone; auto actors = m_actors; std::for_each(actors.begin(), actors.end(), std::bind(std::mem_fn(&ECS::Actor::OnLateUpdate), std::placeholders::_1, p_deltaTime)); } diff --git a/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp b/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp index 651835e79..d32d960a6 100644 --- a/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp +++ b/Sources/Overload/OvCore/src/OvCore/Scripting/Lua/LuaScriptEngine.cpp @@ -4,8 +4,6 @@ * @licence: MIT */ -#include - #include #include @@ -13,6 +11,8 @@ #include #include +#include + void BindLuaActor(sol::state& p_state); void BindLuaComponents(sol::state& p_state); void BindLuaGlobal(sol::state& p_state); diff --git a/Sources/Overload/OvEditor/include/OvEditor/Core/Editor.h b/Sources/Overload/OvEditor/include/OvEditor/Core/Editor.h index d7f3cc613..9b97cfd30 100644 --- a/Sources/Overload/OvEditor/include/OvEditor/Core/Editor.h +++ b/Sources/Overload/OvEditor/include/OvEditor/Core/Editor.h @@ -6,8 +6,6 @@ #pragma once - -#include #include #include #include diff --git a/Sources/Overload/OvEditor/include/OvEditor/Panels/FrameInfo.h b/Sources/Overload/OvEditor/include/OvEditor/Panels/FrameInfo.h index 22e5ba6b1..f6265e5d4 100644 --- a/Sources/Overload/OvEditor/include/OvEditor/Panels/FrameInfo.h +++ b/Sources/Overload/OvEditor/include/OvEditor/Panels/FrameInfo.h @@ -19,6 +19,12 @@ namespace OvEditor::Panels { + struct FramerateStats + { + uint32_t elapsedFrames = 0; + float elapsedTime = 0.0f; + }; + class FrameInfo : public OvUI::Panels::PanelWindow { public: @@ -37,10 +43,13 @@ namespace OvEditor::Panels /** * Update frame info information * @param p_targetView + * @param p_deltaTime */ - void Update(OvTools::Utils::OptRef p_targetView); + void Update(OvTools::Utils::OptRef p_targetView, float p_deltaTime); private: + FramerateStats m_framerateStats; + OvUI::Widgets::Texts::Text& m_fpsText; OvUI::Widgets::Texts::Text& m_viewNameText; OvUI::Widgets::Visual::Separator& m_separator; OvUI::Widgets::Texts::Text& m_batchCountText; diff --git a/Sources/Overload/OvEditor/include/OvEditor/Panels/HardwareInfo.h b/Sources/Overload/OvEditor/include/OvEditor/Panels/HardwareInfo.h index 12cd0947a..5a42dac00 100644 --- a/Sources/Overload/OvEditor/include/OvEditor/Panels/HardwareInfo.h +++ b/Sources/Overload/OvEditor/include/OvEditor/Panels/HardwareInfo.h @@ -7,10 +7,6 @@ #pragma once #include -#include -#include - -namespace OvAnalytics::Hardware { class HardwareInfo; } namespace OvEditor::Panels { @@ -30,29 +26,7 @@ namespace OvEditor::Panels ( const std::string& p_title, bool p_opened, - const OvUI::Settings::PanelWindowSettings& p_windowSettings, - float p_logFrequency, - size_t p_maxElements + const OvUI::Settings::PanelWindowSettings& p_windowSettings ); - - /** - * Destructor - */ - ~HardwareInfo(); - - /** - * Update hardware info - * @param p_deltaTime - */ - void Update(float p_deltaTime); - - private: - float p_updateTimer = 0.f; - float m_logFrequency; - size_t m_maxElements; - OvUI::Widgets::Plots::APlot* m_cpuUsage; - OvUI::Widgets::Plots::APlot* m_gpuUsage; - OvUI::Widgets::Plots::APlot* m_ramUsage; - OvAnalytics::Hardware::HardwareInfo* m_hardwareInfo; }; } \ No newline at end of file diff --git a/Sources/Overload/OvEditor/include/OvEditor/Panels/Profiler.h b/Sources/Overload/OvEditor/include/OvEditor/Panels/Profiler.h deleted file mode 100644 index f49487b7b..000000000 --- a/Sources/Overload/OvEditor/include/OvEditor/Panels/Profiler.h +++ /dev/null @@ -1,76 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -#include - -#include -#include -#include -#include -#include -#include - -namespace OvEditor::Panels -{ - class Profiler : public OvUI::Panels::PanelWindow - { - public: - /** - * Constructor - * @param p_title - * @param p_opened - * @param p_windowSettings - * @param p_frequency - */ - Profiler - ( - const std::string& p_title, - bool p_opened, - const OvUI::Settings::PanelWindowSettings& p_windowSettings, - float p_frequency - ); - - /** - * Update profiling information - * @param p_deltaTime - */ - void Update(float p_deltaTime); - - /** - * Enable or disable the profiler - * @param p_value - * @param p_disableLog - */ - void Enable(bool p_value, bool p_disableLog = false); - - private: - OvUI::Types::Color CalculateActionColor(double p_percentage) const; - std::string GenerateActionString(OvAnalytics::Profiling::ProfilerReport::Action& p_action); - - private: - enum class EProfilingMode - { - DEFAULT, - CAPTURE - }; - - float m_frequency; - float m_timer = 0.f; - float m_fpsTimer = 0.f; - EProfilingMode m_profilingMode = EProfilingMode::DEFAULT; - - OvAnalytics::Profiling::Profiler m_profiler; - - OvUI::Widgets::AWidget* m_separator; - OvUI::Widgets::Buttons::Button* m_captureResumeButton; - OvUI::Widgets::Texts::TextColored* m_fpsText; - OvUI::Widgets::Texts::TextColored* m_elapsedFramesText; - OvUI::Widgets::Texts::TextColored* m_elapsedTimeText; - OvUI::Widgets::Layout::Columns<5>* m_actionList; - }; -} \ No newline at end of file diff --git a/Sources/Overload/OvEditor/layout.ini b/Sources/Overload/OvEditor/layout.ini index f3a87b73e..4e73f844f 100644 --- a/Sources/Overload/OvEditor/layout.ini +++ b/Sources/Overload/OvEditor/layout.ini @@ -1,25 +1,19 @@ [Window][##dockspace] Pos=0,0 -Size=1600,900 +Size=1920,1080 Collapsed=0 [Window][Asset Browser##2] -Pos=0,459 -Size=320,441 +Pos=0,508 +Size=384,572 Collapsed=0 DockId=0x00000012,0 [Window][Hardware Info##3] -Pos=949,601 -Size=265,299 +Pos=1093,719 +Size=364,361 Collapsed=0 -DockId=0x00000006,1 - -[Window][Profiler##4] -Pos=322,601 -Size=625,299 -Collapsed=0 -DockId=0x00000005,1 +DockId=0x00000016,2 [Window][Hierarchy##6] Pos=0,24 @@ -87,30 +81,34 @@ Collapsed=0 DockId=0x0000000A,1 [Window][Console##5] -Pos=306,692 -Size=1162,335 +Pos=386,719 +Size=705,361 Collapsed=0 -DockId=0x00000004,1 +DockId=0x00000015,0 [Window][Toolbar##11] -Pos=636,24 -Size=1319,66 +Pos=386,24 +Size=1071,75 Collapsed=0 +DockId=0x00000013,0 [Window][Project Settings##13] -Pos=2005,24 -Size=553,1336 +Pos=1459,24 +Size=461,1056 Collapsed=0 +DockId=0x00000010,2 [Window][Material Editor##12] -Pos=3917,24 -Size=1203,817 +Pos=1459,24 +Size=461,1056 Collapsed=0 +DockId=0x00000010,1 [Window][Asset Properties##14] -Pos=881,24 -Size=397,812 +Pos=1459,24 +Size=461,1056 Collapsed=0 +DockId=0x00000010,3 [Window][Frame Info##5] Pos=949,601 @@ -126,27 +124,27 @@ DockId=0x00000005,0 [Window][Hierarchy##7] Pos=0,24 -Size=326,399 +Size=384,482 Collapsed=0 DockId=0x0000000D,0 [Window][Inspector##8] -Pos=1244,24 -Size=356,876 +Pos=1459,24 +Size=461,1056 Collapsed=0 DockId=0x00000010,0 [Window][Scene View##9] -Pos=328,100 -Size=914,516 +Pos=386,101 +Size=1071,616 Collapsed=0 -DockId=0x0000000A,0 +DockId=0x00000014,0 [Window][Game View##10] -Pos=328,100 -Size=914,516 +Pos=386,101 +Size=1071,616 Collapsed=0 -DockId=0x0000000A,1 +DockId=0x00000014,1 [Window][Asset View##11] Pos=328,100 @@ -190,24 +188,46 @@ Size=318,361 Collapsed=0 DockId=0x00000006,1 +[Window][Frame Info##4] +Pos=1093,719 +Size=364,361 +Collapsed=0 +DockId=0x00000016,0 + +[Window][Asset View##6] +Pos=386,101 +Size=1071,616 +Collapsed=0 +DockId=0x00000014,2 + +[Window][Texture Debugger##15] +Pos=1093,719 +Size=364,361 +Collapsed=0 +DockId=0x00000016,1 + [Docking][Data] -DockSpace ID=0x3F20F338 Window=0xEFEA1D90 Pos=0,24 Size=1600,876 Split=X NoWindowMenuButton=1 - DockNode ID=0x0000000F Parent=0x3F20F338 SizeRef=1214,1336 Split=X NoWindowMenuButton=1 - DockNode ID=0x00000007 Parent=0x0000000F SizeRef=320,1003 Split=Y NoWindowMenuButton=1 Selected=0xFEC67CA6 - DockNode ID=0x0000000B Parent=0x00000007 SizeRef=304,504 NoWindowMenuButton=1 Selected=0x92035EB3 - DockNode ID=0x0000000C Parent=0x00000007 SizeRef=304,497 Split=Y NoWindowMenuButton=1 Selected=0x6AB70705 - DockNode ID=0x0000000D Parent=0x0000000C SizeRef=405,467 NoWindowMenuButton=1 Selected=0xE5046E25 - DockNode ID=0x0000000E Parent=0x0000000C SizeRef=405,555 Split=Y Selected=0x6AB70705 - DockNode ID=0x00000011 Parent=0x0000000E SizeRef=272,433 NoWindowMenuButton=1 Selected=0x75BB73B4 - DockNode ID=0x00000012 Parent=0x0000000E SizeRef=272,441 NoWindowMenuButton=1 Selected=0x6AB70705 - DockNode ID=0x00000008 Parent=0x0000000F SizeRef=892,1003 Split=X NoWindowMenuButton=1 - DockNode ID=0x00000001 Parent=0x00000008 SizeRef=1162,1003 Split=Y NoWindowMenuButton=1 - DockNode ID=0x00000003 Parent=0x00000001 SizeRef=1248,575 Split=Y NoWindowMenuButton=1 Selected=0x81B3DE80 - DockNode ID=0x00000009 Parent=0x00000003 SizeRef=1298,75 NoWindowMenuButton=1 Selected=0x5D0727F1 - DockNode ID=0x0000000A Parent=0x00000003 SizeRef=1298,498 CentralNode=1 NoWindowMenuButton=1 Selected=0xCC579E31 - DockNode ID=0x00000004 Parent=0x00000001 SizeRef=1248,299 Split=X NoWindowMenuButton=1 Selected=0xEFBCD82C - DockNode ID=0x00000005 Parent=0x00000004 SizeRef=625,282 NoWindowMenuButton=1 Selected=0xEFBCD82C - DockNode ID=0x00000006 Parent=0x00000004 SizeRef=265,282 NoWindowMenuButton=1 Selected=0xFEC67CA6 - DockNode ID=0x00000002 Parent=0x00000008 SizeRef=450,1003 NoWindowMenuButton=1 Selected=0x92035EB3 - DockNode ID=0x00000010 Parent=0x3F20F338 SizeRef=384,1336 NoWindowMenuButton=1 Selected=0x8A753355 +DockSpace ID=0x3F20F338 Window=0xEFEA1D90 Pos=0,24 Size=1920,1056 Split=X NoWindowMenuButton=1 + DockNode ID=0x0000000F Parent=0x3F20F338 SizeRef=1214,1336 Split=X NoWindowMenuButton=1 + DockNode ID=0x00000007 Parent=0x0000000F SizeRef=320,1003 Split=Y NoWindowMenuButton=1 Selected=0xFEC67CA6 + DockNode ID=0x0000000B Parent=0x00000007 SizeRef=304,504 NoWindowMenuButton=1 Selected=0x92035EB3 + DockNode ID=0x0000000C Parent=0x00000007 SizeRef=304,497 Split=Y NoWindowMenuButton=1 Selected=0x6AB70705 + DockNode ID=0x0000000D Parent=0x0000000C SizeRef=405,467 NoWindowMenuButton=1 Selected=0xE5046E25 + DockNode ID=0x0000000E Parent=0x0000000C SizeRef=405,555 Split=Y NoWindowMenuButton=1 Selected=0x6AB70705 + DockNode ID=0x00000011 Parent=0x0000000E SizeRef=272,433 NoWindowMenuButton=1 Selected=0x75BB73B4 + DockNode ID=0x00000012 Parent=0x0000000E SizeRef=272,441 NoWindowMenuButton=1 Selected=0x6AB70705 + DockNode ID=0x00000008 Parent=0x0000000F SizeRef=892,1003 Split=X NoWindowMenuButton=1 + DockNode ID=0x00000001 Parent=0x00000008 SizeRef=1162,1003 Split=Y NoWindowMenuButton=1 + DockNode ID=0x00000003 Parent=0x00000001 SizeRef=1248,575 Split=Y NoWindowMenuButton=1 Selected=0x81B3DE80 + DockNode ID=0x00000009 Parent=0x00000003 SizeRef=1298,75 NoWindowMenuButton=1 Selected=0x5D0727F1 + DockNode ID=0x0000000A Parent=0x00000003 SizeRef=1298,498 Split=Y NoWindowMenuButton=1 Selected=0xF6B4EE16 + DockNode ID=0x00000013 Parent=0x0000000A SizeRef=1071,75 NoWindowMenuButton=1 Selected=0xC40E764B + DockNode ID=0x00000014 Parent=0x0000000A SizeRef=1071,616 CentralNode=1 NoWindowMenuButton=1 Selected=0xF6B4EE16 + DockNode ID=0x00000004 Parent=0x00000001 SizeRef=1248,299 Split=X NoWindowMenuButton=1 Selected=0xEFBCD82C + DockNode ID=0x00000005 Parent=0x00000004 SizeRef=625,282 NoWindowMenuButton=1 Selected=0xEFBCD82C + DockNode ID=0x00000006 Parent=0x00000004 SizeRef=265,282 Split=X NoWindowMenuButton=1 Selected=0x76B58996 + DockNode ID=0x00000015 Parent=0x00000006 SizeRef=705,362 NoWindowMenuButton=1 Selected=0x76B58996 + DockNode ID=0x00000016 Parent=0x00000006 SizeRef=364,362 NoWindowMenuButton=1 Selected=0xFEC67CA6 + DockNode ID=0x00000002 Parent=0x00000008 SizeRef=450,1003 NoWindowMenuButton=1 Selected=0x92035EB3 + DockNode ID=0x00000010 Parent=0x3F20F338 SizeRef=384,1336 NoWindowMenuButton=1 Selected=0xFD7203C3 diff --git a/Sources/Overload/OvEditor/premake5.lua b/Sources/Overload/OvEditor/premake5.lua index 85a7b9083..ccd034613 100644 --- a/Sources/Overload/OvEditor/premake5.lua +++ b/Sources/Overload/OvEditor/premake5.lua @@ -4,7 +4,7 @@ project "OvEditor" files { "**.h", "**.inl","**.cpp", "**.lua", "**.rc", "**.ini" } includedirs { dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", dependdir .. "tracy", - "%{wks.location}/OvAnalytics/include", "%{wks.location}/OvAudio/include", "%{wks.location}/OvCore/include", + "%{wks.location}/OvAudio/include", "%{wks.location}/OvCore/include", "%{wks.location}/OvDebug/include", "%{wks.location}/OvMaths/include", "%{wks.location}/OvPhysics/include", "%{wks.location}/OvRendering/include", "%{wks.location}/OvTools/include", "%{wks.location}/OvUI/include", "%{wks.location}/OvWindowing/include", "include" @@ -14,7 +14,7 @@ project "OvEditor" links { "assimp-vc143-mt.lib", "Bullet3Collision.lib", "Bullet3Common.lib", "Bullet3Dynamics.lib", "Bullet3Geometry.lib", "BulletCollision.lib", "BulletDynamics.lib", "BulletSoftBody.lib", "LinearMath.lib", "glew32.lib", "glfw3dll.lib", "irrKlang.lib", "liblua53.lib", "opengl32.lib", "dbghelp.lib", "ImGui", "tinyxml2", "tracy", - "OvAnalytics", "OvAudio", "OvCore", "OvDebug", "OvMaths", "OvPhysics", "OvRendering", "OvTools", "OvUI", "OvWindowing" + "OvAudio", "OvCore", "OvDebug", "OvMaths", "OvPhysics", "OvRendering", "OvTools", "OvUI", "OvWindowing" } targetdir (outputdir .. "%{cfg.buildcfg}/%{prj.name}") diff --git a/Sources/Overload/OvEditor/src/OvEditor/Core/Application.cpp b/Sources/Overload/OvEditor/src/OvEditor/Core/Application.cpp index a9e02f18a..409135fb7 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Core/Application.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Core/Application.cpp @@ -4,11 +4,10 @@ * @licence: MIT */ -#include - #include #include +#include OvEditor::Core::Application::Application(const std::string& p_projectPath, const std::string& p_projectName) : m_context(p_projectPath, p_projectName), @@ -31,7 +30,7 @@ void OvEditor::Core::Application::Run() m_editor.PostUpdate(); clock.Update(); - FrameMark; + FrameEnd; } } diff --git a/Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp b/Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp index c048d11b9..ad371010f 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp @@ -4,27 +4,27 @@ * @licence: MIT */ -#include #include -#include "OvEditor/Core/Editor.h" -#include "OvEditor/Panels/MenuBar.h" -#include "OvEditor/Panels/AssetBrowser.h" -#include "OvEditor/Panels/HardwareInfo.h" -#include "OvEditor/Panels/Profiler.h" -#include "OvEditor/Panels/FrameInfo.h" -#include "OvEditor/Panels/Console.h" -#include "OvEditor/Panels/Inspector.h" -#include "OvEditor/Panels/Hierarchy.h" -#include "OvEditor/Panels/SceneView.h" -#include "OvEditor/Panels/GameView.h" -#include "OvEditor/Panels/AssetView.h" -#include "OvEditor/Panels/Toolbar.h" -#include "OvEditor/Panels/MaterialEditor.h" -#include "OvEditor/Panels/ProjectSettings.h" -#include "OvEditor/Panels/AssetProperties.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include -#include "OvEditor/Settings/EditorSettings.h" +#include +#include + +#include using namespace OvCore::ResourceManagement; using namespace OvEditor::Panels; @@ -56,8 +56,7 @@ void OvEditor::Core::Editor::SetupUI() m_panelsManager.CreatePanel("Menu Bar"); m_panelsManager.CreatePanel("Asset Browser", true, settings, m_context.engineAssetsPath, m_context.projectAssetsPath, m_context.projectScriptsPath); - m_panelsManager.CreatePanel("Hardware Info", false, settings, 0.2f, 50); - m_panelsManager.CreatePanel("Profiler", true, settings, 0.25f); + m_panelsManager.CreatePanel("Hardware Info", false, settings); m_panelsManager.CreatePanel("Frame Info", true, settings); m_panelsManager.CreatePanel("Console", true, settings); m_panelsManager.CreatePanel("Asset View", false, settings); @@ -80,7 +79,7 @@ void OvEditor::Core::Editor::SetupUI() void OvEditor::Core::Editor::PreUpdate() { - PROFILER_SPY("Editor Pre-Update"); + CPUZoneN("Editor Pre-Update"); m_context.device->PollEvents(); } @@ -111,7 +110,7 @@ void OvEditor::Core::Editor::UpdateCurrentEditorMode(float p_deltaTime) UpdateEditMode(p_deltaTime); { - PROFILER_SPY("Scene garbage collection"); + CPUZoneN("Scene garbage collection"); m_context.sceneManager.GetCurrentScene()->CollectGarbages(); m_context.sceneManager.Update(); } @@ -123,28 +122,28 @@ void OvEditor::Core::Editor::UpdatePlayMode(float p_deltaTime) bool simulationApplied = false; { - PROFILER_SPY("Physics Update"); + CPUZoneN("Physics Update"); simulationApplied = m_context.physicsEngine->Update(p_deltaTime); } if (simulationApplied) { - PROFILER_SPY("FixedUpdate"); + CPUZoneN("Fixed Update"); currentScene->FixedUpdate(p_deltaTime); } { - PROFILER_SPY("Update"); + CPUZoneN("Update"); currentScene->Update(p_deltaTime); } { - PROFILER_SPY("LateUpdate"); + CPUZoneN("Late Update"); currentScene->LateUpdate(p_deltaTime); } { - PROFILER_SPY("Audio Update"); + CPUZoneN("Audio Update"); m_context.audioEngine->Update(); } @@ -166,7 +165,6 @@ void OvEditor::Core::Editor::UpdateEditMode(float p_deltaTime) void OvEditor::Core::Editor::UpdateEditorPanels(float p_deltaTime) { auto& menuBar = m_panelsManager.GetPanelAs("Menu Bar"); - auto& profiler = m_panelsManager.GetPanelAs("Profiler"); auto& frameInfo = m_panelsManager.GetPanelAs("Frame Info"); auto& hardwareInfo = m_panelsManager.GetPanelAs("Hardware Info"); auto& sceneView = m_panelsManager.GetPanelAs("Scene View"); @@ -187,25 +185,13 @@ void OvEditor::Core::Editor::UpdateEditorPanels(float p_deltaTime) if (frameInfo.IsOpened()) { - PROFILER_SPY("Frame Info Update"); - frameInfo.Update(m_lastFocusedView); - } - - if (profiler.IsOpened()) - { - PROFILER_SPY("Profiler Update"); - profiler.Update(p_deltaTime); - } - - if (hardwareInfo.IsOpened()) - { - PROFILER_SPY("Hardware Info Update"); - hardwareInfo.Update(p_deltaTime); + CPUZoneN("Frame Info Update"); + frameInfo.Update(m_lastFocusedView, p_deltaTime); } if (textureDebugger.IsOpened()) { - PROFILER_SPY("Texture Debugger Update"); + CPUZoneN("Texture Debugger Update"); textureDebugger.Update(p_deltaTime); } } @@ -217,7 +203,7 @@ void OvEditor::Core::Editor::RenderViews(float p_deltaTime) auto& gameView = m_panelsManager.GetPanelAs("Game View"); { - PROFILER_SPY("Editor Views Update"); + CPUZoneN("Editor Views Update"); if (assetView.IsOpened()) { @@ -237,36 +223,36 @@ void OvEditor::Core::Editor::RenderViews(float p_deltaTime) if (assetView.IsOpened() && assetView.IsVisible()) { - PROFILER_SPY("Asset View Rendering"); + CPUZoneN("Asset View Rendering"); assetView.Render(); } if (gameView.IsOpened() && gameView.IsVisible()) { - PROFILER_SPY("Game View Rendering"); + CPUZoneN("Game View Rendering"); gameView.Render(); } if (sceneView.IsOpened() && sceneView.IsVisible()) { - PROFILER_SPY("Scene View Rendering"); + CPUZoneN("Scene View Rendering"); sceneView.Render(); } } void OvEditor::Core::Editor::RenderEditorUI(float p_deltaTime) { - PROFILER_SPY("Editor UI Rendering"); + CPUZoneN("Editor UI Rendering"); EDITOR_CONTEXT(uiManager)->Render(); } void OvEditor::Core::Editor::PostUpdate() { - PROFILER_SPY("Editor Post-Update"); + CPUZoneN("Editor Post-Update"); m_context.window->SwapBuffers(); m_context.inputManager->ClearEvents(); - m_context.driver->NotifyFrameFinished(); + m_context.driver->OnFrameCompleted(); ++m_elapsedFrames; } diff --git a/Sources/Overload/OvEditor/src/OvEditor/Main.cpp b/Sources/Overload/OvEditor/src/OvEditor/Main.cpp index d4767e5ed..f29864d1a 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Main.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Main.cpp @@ -6,14 +6,13 @@ #include -#include - - #include #include #include #include + +#include #include #undef APIENTRY @@ -21,14 +20,6 @@ FORCE_DEDICATED_GPU -#if defined(TRACY_MEMORY_ENABLE) - #include - TRACY_CUSTOM_NEW_ALLOCATOR - TRACY_CUSTOM_DELETE_ALLOCATOR - TRACY_CUSTOM_NEW_ARRAY_ALLOCATOR - TRACY_CUSTOM_DELETE_ARRAY_ALLOCATOR -#endif - /** * When Overload is launched from a project file, we should consider the executable path as * the current working directory diff --git a/Sources/Overload/OvEditor/src/OvEditor/Panels/FrameInfo.cpp b/Sources/Overload/OvEditor/src/OvEditor/Panels/FrameInfo.cpp index 186e6e7d4..6274a2418 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Panels/FrameInfo.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Panels/FrameInfo.cpp @@ -15,7 +15,12 @@ using namespace OvUI::Panels; using namespace OvUI::Widgets; using namespace OvUI::Types; -constexpr OvRendering::Data::FrameInfo kEmptyFrameInfo{}; +namespace +{ + constexpr OvRendering::Data::FrameInfo kEmptyFrameInfo{}; + constexpr std::string_view kFramerateText = "FPS: {}"; + constexpr float kFramerateUpdateInterval = (1.0f / 60.0f) * 10.0f; +} OvEditor::Panels::FrameInfo::FrameInfo ( @@ -23,7 +28,7 @@ OvEditor::Panels::FrameInfo::FrameInfo bool p_opened, const OvUI::Settings::PanelWindowSettings& p_windowSettings ) : PanelWindow(p_title, p_opened, p_windowSettings), - + m_fpsText(CreateWidget(std::format(kFramerateText, 0))), m_viewNameText(CreateWidget()), m_separator(CreateWidget()), @@ -44,10 +49,20 @@ const OvRendering::Data::FrameInfo& GetFrameInfoFromView(const OvEditor::Panels: .GetFrameInfo(); } -void OvEditor::Panels::FrameInfo::Update(OvTools::Utils::OptRef p_targetView) +void OvEditor::Panels::FrameInfo::Update(OvTools::Utils::OptRef p_targetView, float p_deltaTime) { using namespace OvTools::Utils; + m_framerateStats.elapsedFrames++; + m_framerateStats.elapsedTime += p_deltaTime; + + if (m_framerateStats.elapsedTime >= kFramerateUpdateInterval) + { + float averageFramerate = m_framerateStats.elapsedFrames / m_framerateStats.elapsedTime; + m_fpsText.content = std::format(kFramerateText, static_cast(std::roundf(averageFramerate))); + m_framerateStats = {}; + } + m_viewNameText.content = "Target View: " + (p_targetView ? p_targetView.value().name : "None"); auto& frameInfo = p_targetView ? GetFrameInfoFromView(p_targetView.value()) : kEmptyFrameInfo; diff --git a/Sources/Overload/OvEditor/src/OvEditor/Panels/HardwareInfo.cpp b/Sources/Overload/OvEditor/src/OvEditor/Panels/HardwareInfo.cpp index 96cdf8892..be6483b64 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Panels/HardwareInfo.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Panels/HardwareInfo.cpp @@ -4,10 +4,8 @@ * @licence: MIT */ -#include - -#include "OvEditor/Panels/HardwareInfo.h" -#include "OvEditor/Core/EditorActions.h" +#include +#include using namespace OvUI::Panels; using namespace OvUI::Widgets; @@ -16,74 +14,15 @@ OvEditor::Panels::HardwareInfo::HardwareInfo ( const std::string& p_title, bool p_opened, - const OvUI::Settings::PanelWindowSettings& p_windowSettings, - float p_logFrequency, - size_t p_maxElements + const OvUI::Settings::PanelWindowSettings& p_windowSettings ) : - PanelWindow(p_title, p_opened, p_windowSettings), - m_logFrequency(p_logFrequency), - m_maxElements(p_maxElements), - m_hardwareInfo(new OvAnalytics::Hardware::HardwareInfo(m_logFrequency)) + PanelWindow(p_title, p_opened, p_windowSettings) { - auto& driver = *EDITOR_CONTEXT(driver).get(); + auto& driver = *EDITOR_CONTEXT(driver); // Display some static information about the graphics driver CreateWidget("Vendor: " + std::string(driver.GetVendor())); CreateWidget("Hardware: " + std::string(driver.GetHardware())); CreateWidget("OpenGL Version: " + std::string(driver.GetVersion())); CreateWidget("GLSL Version: " + std::string(driver.GetShadingLanguageVersion())); - - m_cpuUsage = &CreateWidget(); - m_gpuUsage = &CreateWidget(); - m_ramUsage = &CreateWidget(); - - m_cpuUsage->minScale = 0.0f; - m_cpuUsage->maxScale = 100.0f; - m_cpuUsage->size.y = 75.0f; - m_cpuUsage->data.resize(m_maxElements, 0); - m_cpuUsage->overlay = "CPU Usage (%)"; - - m_gpuUsage->minScale = 0.0f; - m_gpuUsage->maxScale = 100.0f; - m_gpuUsage->size.y = 75.0f; - m_gpuUsage->data.resize(m_maxElements, 0); - m_gpuUsage->overlay = "GPU Usage (%)"; - - m_ramUsage->minScale = 0.0f; - m_ramUsage->maxScale = 100.0f; - m_ramUsage->size.y = 75.0f; - m_ramUsage->data.resize(m_maxElements, 0); - m_ramUsage->overlay = "RAM Usage (%)"; -} - -OvEditor::Panels::HardwareInfo::~HardwareInfo() -{ - delete m_hardwareInfo; -} - -void OvEditor::Panels::HardwareInfo::Update(float p_deltaTime) -{ - m_hardwareInfo->Tick(); - - p_updateTimer += p_deltaTime; - - while (p_updateTimer >= m_logFrequency) - { - OvAnalytics::Hardware::HardwareReport report = m_hardwareInfo->GenerateReport(); - - m_cpuUsage->data.push_back(report.CPULoad); - m_gpuUsage->data.push_back(report.GPULoad); - m_ramUsage->data.push_back((report.RAMUsed / report.RAMMax) * 100.0f); - - if (m_cpuUsage->data.size() > m_maxElements) - m_cpuUsage->data.erase(m_cpuUsage->data.begin()); - - if (m_gpuUsage->data.size() > m_maxElements) - m_gpuUsage->data.erase(m_gpuUsage->data.begin()); - - if (m_ramUsage->data.size() > m_maxElements) - m_ramUsage->data.erase(m_ramUsage->data.begin()); - - p_updateTimer -= m_logFrequency; - } } diff --git a/Sources/Overload/OvEditor/src/OvEditor/Panels/Profiler.cpp b/Sources/Overload/OvEditor/src/OvEditor/Panels/Profiler.cpp deleted file mode 100644 index 49f7145b2..000000000 --- a/Sources/Overload/OvEditor/src/OvEditor/Panels/Profiler.cpp +++ /dev/null @@ -1,138 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#include "OvEditor/Panels/Profiler.h" - -#include -#include - -using namespace OvUI::Panels; -using namespace OvUI::Widgets; -using namespace OvUI::Types; - -OvEditor::Panels::Profiler::Profiler -( - const std::string& p_title, - bool p_opened, - const OvUI::Settings::PanelWindowSettings& p_windowSettings, - float p_frequency -) : - PanelWindow(p_title, p_opened, p_windowSettings), - m_frequency(p_frequency) -{ - allowHorizontalScrollbar = true; - - CreateWidget("Profiler state: ").lineBreak = false; - CreateWidget(false, "").ValueChangedEvent += std::bind(&Profiler::Enable, this, std::placeholders::_1, false); - - m_fpsText = &CreateWidget(""); - m_captureResumeButton = &CreateWidget("Capture"); - m_captureResumeButton->idleBackgroundColor = { 0.7f, 0.5f, 0.f }; - m_captureResumeButton->ClickedEvent += [this] - { - m_profilingMode = m_profilingMode == EProfilingMode::CAPTURE ? EProfilingMode::DEFAULT : EProfilingMode::CAPTURE; - m_captureResumeButton->label = m_profilingMode == EProfilingMode::CAPTURE ? "Resume" : "Capture"; - }; - m_elapsedFramesText = &CreateWidget("", Color(1.f, 0.8f, 0.01f, 1)); - m_elapsedTimeText = &CreateWidget("", Color(1.f, 0.8f, 0.01f, 1)); - m_separator = &CreateWidget(); - m_actionList = &CreateWidget>(); - m_actionList->widths = { 300.f, 100.f, 100.f, 100.f, 200.f }; - - Enable(false, true); -} - -void OvEditor::Panels::Profiler::Update(float p_deltaTime) -{ - m_timer += p_deltaTime; - m_fpsTimer += p_deltaTime; - - while (m_fpsTimer >= 0.07f) - { - m_fpsText->content = "FPS: " + std::to_string(static_cast(1.0f / p_deltaTime)); - m_fpsTimer -= 0.07f; - } - - if (m_profiler.IsEnabled()) - { - m_profiler.Update(p_deltaTime); - - while (m_timer >= m_frequency) - { - if (m_profilingMode == EProfilingMode::DEFAULT) - { - OvAnalytics::Profiling::ProfilerReport report = m_profiler.GenerateReport(); - m_profiler.ClearHistory(); - m_actionList->RemoveAllWidgets(); - - m_elapsedFramesText->content = "Elapsed frames: " + std::to_string(report.elapsedFrames); - m_elapsedTimeText->content = "Elapsed time: " + std::to_string(report.elaspedTime); - - m_actionList->CreateWidget("Action"); - m_actionList->CreateWidget("Total duration"); - m_actionList->CreateWidget("Frame duration"); - m_actionList->CreateWidget("Frame load"); - m_actionList->CreateWidget("Total calls"); - - for (auto& action : report.actions) - { - auto color = CalculateActionColor(action.percentage); - m_actionList->CreateWidget(action.name, color); - m_actionList->CreateWidget(std::to_string(action.duration) + "s", color); - m_actionList->CreateWidget(std::to_string(action.duration / action.calls) + "s", color); - m_actionList->CreateWidget(std::to_string(action.percentage) + "%%", color); - m_actionList->CreateWidget(std::to_string(action.calls) + " calls", color); - } - } - - m_timer -= m_frequency; - } - } -} - -void OvEditor::Panels::Profiler::Enable(bool p_value, bool p_disableLog) -{ - if (p_value) - { - if (!p_disableLog) - OVLOG_INFO("Profiling started!"); - m_profiler.Enable(); - } - else - { - if (!p_disableLog) - OVLOG_INFO("Profiling stoped!"); - m_profiler.Disable(); - m_profiler.ClearHistory(); - m_actionList->RemoveAllWidgets(); - } - - m_captureResumeButton->enabled = p_value; - m_elapsedFramesText->enabled = p_value; - m_elapsedTimeText->enabled = p_value; - m_separator->enabled = p_value; -} - -OvUI::Types::Color OvEditor::Panels::Profiler::CalculateActionColor(double p_percentage) const -{ - if (p_percentage <= 25.0f) return { 0.0f, 1.0f, 0.0f, 1.0f }; - else if (p_percentage <= 50.0f) return { 1.0f, 1.0f, 0.0f, 1.0f }; - else if (p_percentage <= 75.0f) return { 1.0f, 0.6f, 0.0f, 1.0f }; - else return { 1.0f, 0.0f, 0.0f, 1.0f }; -} - -std::string OvEditor::Panels::Profiler::GenerateActionString(OvAnalytics::Profiling::ProfilerReport::Action & p_action) -{ - std::string result; - - result += "[" + p_action.name + "]"; - result += std::to_string(p_action.duration) + "s (total) | "; - result += std::to_string(p_action.duration / p_action.calls) + "s (per call) | "; - result += std::to_string(p_action.percentage) + "%% | "; - result += std::to_string(p_action.calls) + " calls"; - - return result; -} diff --git a/Sources/Overload/OvEditor/src/OvEditor/Rendering/DebugSceneRenderer.cpp b/Sources/Overload/OvEditor/src/OvEditor/Rendering/DebugSceneRenderer.cpp index 88922a438..47d805790 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Rendering/DebugSceneRenderer.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Rendering/DebugSceneRenderer.cpp @@ -4,8 +4,6 @@ * @licence: MIT */ -#include - #include #include #include @@ -32,7 +30,7 @@ #include #include -#include +#include using namespace OvMaths; using namespace OvRendering::Resources; @@ -85,7 +83,7 @@ class DebugCamerasRenderPass : public OvRendering::Core::ARenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - OvGpuZone("DebugCamerasRenderPass"); + GPUZone("DebugCamerasRenderPass"); auto& sceneDescriptor = m_renderer.GetDescriptor(); @@ -123,7 +121,7 @@ class DebugLightsRenderPass : public OvRendering::Core::ARenderPass protected: virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - OvGpuZone("DebugLightsRenderPass"); + GPUZone("DebugLightsRenderPass"); auto& sceneDescriptor = m_renderer.GetDescriptor(); @@ -173,7 +171,7 @@ class DebugActorRenderPass : public OvRendering::Core::ARenderPass virtual void Draw(OvRendering::Data::PipelineState p_pso) override { - OvGpuZone("DebugActorRenderPass"); + GPUZone("DebugActorRenderPass"); auto& debugSceneDescriptor = m_renderer.GetDescriptor(); diff --git a/Sources/Overload/OvEditor/src/OvEditor/Rendering/GizmoRenderFeature.cpp b/Sources/Overload/OvEditor/src/OvEditor/Rendering/GizmoRenderFeature.cpp index 39be57b10..376fed323 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Rendering/GizmoRenderFeature.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Rendering/GizmoRenderFeature.cpp @@ -15,8 +15,6 @@ #include -#include - #include #include "OvEditor/Rendering/DebugModelRenderFeature.h" diff --git a/Sources/Overload/OvEditor/src/OvEditor/Rendering/GridRenderPass.cpp b/Sources/Overload/OvEditor/src/OvEditor/Rendering/GridRenderPass.cpp index a1e9e9b70..e7c6efc07 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Rendering/GridRenderPass.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Rendering/GridRenderPass.cpp @@ -13,7 +13,7 @@ #include #include -#include +#include OvEditor::Rendering::GridRenderPass::GridRenderPass(OvRendering::Core::CompositeRenderer& p_renderer) : OvRendering::Core::ARenderPass(p_renderer) @@ -28,7 +28,7 @@ OvEditor::Rendering::GridRenderPass::GridRenderPass(OvRendering::Core::Composite void OvEditor::Rendering::GridRenderPass::Draw(OvRendering::Data::PipelineState p_pso) { - OvGpuZone("GridRenderPass"); + GPUZone("GridRenderPass"); OVASSERT(m_renderer.HasDescriptor(), "Cannot find GridDescriptor attached to this renderer"); OVASSERT(m_renderer.HasFeature(), "Cannot find DebugShapeRenderFeature attached to this renderer"); diff --git a/Sources/Overload/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp b/Sources/Overload/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp index db134a9f9..aea7bd7ad 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp @@ -4,17 +4,17 @@ * @licence: MIT */ +#include +#include +#include + #include #include -#include #include +#include #include -#include -#include -#include - -#include +#include OvEditor::Rendering::PickingRenderPass::PickingRenderPass(OvRendering::Core::CompositeRenderer& p_renderer) : OvRendering::Core::ARenderPass(p_renderer), @@ -81,7 +81,7 @@ void OvEditor::Rendering::PickingRenderPass::Draw(OvRendering::Data::PipelineSta { // TODO: Make sure we only renderer when the view is hovered and not being resized - OvGpuZone("PickingRenderPass"); + GPUZone("PickingRenderPass"); using namespace OvCore::Rendering; diff --git a/Sources/Overload/OvGame/include/OvGame/Core/Game.h b/Sources/Overload/OvGame/include/OvGame/Core/Game.h index 240383b1d..1df3e7035 100644 --- a/Sources/Overload/OvGame/include/OvGame/Core/Game.h +++ b/Sources/Overload/OvGame/include/OvGame/Core/Game.h @@ -6,19 +6,20 @@ #pragma once -#include #include #include -#include "OvGame/Core/Context.h" -#include "OvGame/Utils/FPSCounter.h" +#include #ifdef _DEBUG -#include "OvGame/Debug/DriverInfo.h" -#include "OvGame/Debug/GameProfiler.h" -#include "OvGame/Debug/FrameInfo.h" +#include +#include #endif +#include + +#include + namespace OvGame::Core { /** @@ -65,7 +66,6 @@ namespace OvGame::Core #ifdef _DEBUG OvGame::Debug::DriverInfo m_driverInfo; - OvGame::Debug::GameProfiler m_gameProfiler; OvGame::Debug::FrameInfo m_frameInfo; #endif diff --git a/Sources/Overload/OvGame/include/OvGame/Debug/GameProfiler.h b/Sources/Overload/OvGame/include/OvGame/Debug/GameProfiler.h deleted file mode 100644 index 65b6898c5..000000000 --- a/Sources/Overload/OvGame/include/OvGame/Debug/GameProfiler.h +++ /dev/null @@ -1,60 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#pragma once - -#ifdef _DEBUG - -#include - -#include -#include -#include -#include -#include - -namespace OvGame::Debug -{ - /** - * Panel that display profiling information - */ - class GameProfiler : public OvUI::Panels::PanelUndecorated - { - public: - /** - * Constructor - * @param p_window - * @param p_frequency - */ - GameProfiler(OvWindowing::Window& p_window, float p_frequency); - - /** - * Update the data - * @param p_deltaTime - */ - void Update(float p_deltaTime); - - - private: - OvUI::Types::Color CalculateActionColor(double p_percentage) const; - std::string GenerateActionString(OvAnalytics::Profiling::ProfilerReport::Action& p_action); - - private: - - float m_frequency; - float m_timer = 0.f; - - OvAnalytics::Profiling::Profiler m_profiler; - - OvWindowing::Window& m_window; - OvUI::Widgets::AWidget* m_separator; - OvUI::Widgets::Texts::TextColored* m_elapsedFramesText; - OvUI::Widgets::Texts::TextColored* m_elapsedTimeText; - OvUI::Widgets::Layout::Group* m_actionList; - }; -} - -#endif \ No newline at end of file diff --git a/Sources/Overload/OvGame/premake5.lua b/Sources/Overload/OvGame/premake5.lua index 331fc7cf8..4e9a7f0bc 100644 --- a/Sources/Overload/OvGame/premake5.lua +++ b/Sources/Overload/OvGame/premake5.lua @@ -4,7 +4,7 @@ project "OvGame" files { "**.h", "**.inl", "**.cpp", "**.lua", "**.rc" } includedirs { dependdir .. "glfw/include", dependdir .. "stb_image/include", dependdir .. "lua/include", dependdir .. "bullet3/include", dependdir .. "glew/include", dependdir .. "irrKlang/include", dependdir .. "ImGui/include", dependdir .. "tinyxml2/include", dependdir .. "tracy", - "%{wks.location}/OvAnalytics/include", "%{wks.location}/OvAudio/include", "%{wks.location}/OvCore/include", + "%{wks.location}/OvAudio/include", "%{wks.location}/OvCore/include", "%{wks.location}/OvDebug/include", "%{wks.location}/OvMaths/include", "%{wks.location}/OvPhysics/include", "%{wks.location}/OvRendering/include", "%{wks.location}/OvTools/include", "%{wks.location}/OvUI/include", "%{wks.location}/OvWindowing/include", "include" @@ -14,7 +14,7 @@ project "OvGame" links { "assimp-vc143-mt.lib", "Bullet3Collision.lib", "Bullet3Common.lib", "Bullet3Dynamics.lib", "Bullet3Geometry.lib", "BulletCollision.lib", "BulletDynamics.lib", "BulletSoftBody.lib", "LinearMath.lib", "glew32.lib", "glfw3dll.lib", "irrKlang.lib", "liblua53.lib", "opengl32.lib", "dbghelp.lib", "ImGui", "tinyxml2", "tracy", - "OvAnalytics", "OvAudio", "OvCore", "OvDebug", "OvMaths", "OvPhysics", "OvRendering", "OvTools", "OvUI", "OvWindowing" + "OvAudio", "OvCore", "OvDebug", "OvMaths", "OvPhysics", "OvRendering", "OvTools", "OvUI", "OvWindowing" } targetdir (outputdir .. "%{cfg.buildcfg}/%{prj.name}") diff --git a/Sources/Overload/OvGame/src/OvGame/Core/Application.cpp b/Sources/Overload/OvGame/src/OvGame/Core/Application.cpp index d32a89caf..5e94fe3c4 100644 --- a/Sources/Overload/OvGame/src/OvGame/Core/Application.cpp +++ b/Sources/Overload/OvGame/src/OvGame/Core/Application.cpp @@ -4,11 +4,10 @@ * @licence: MIT */ -#include +#include #include - -#include "OvGame/Core/Application.h" +#include OvGame::Core::Application::Application() : m_game(m_context) @@ -31,7 +30,7 @@ void OvGame::Core::Application::Run() m_game.PostUpdate(); clock.Update(); - FrameMark; + FrameEnd; } } diff --git a/Sources/Overload/OvGame/src/OvGame/Core/Game.cpp b/Sources/Overload/OvGame/src/OvGame/Core/Game.cpp index b75052761..47670e2b9 100644 --- a/Sources/Overload/OvGame/src/OvGame/Core/Game.cpp +++ b/Sources/Overload/OvGame/src/OvGame/Core/Game.cpp @@ -4,12 +4,10 @@ * @licence: MIT */ -#include "OvGame/Core/Game.h" - #include +#include #include - -#include +#include #ifdef _DEBUG #include @@ -22,7 +20,6 @@ OvGame::Core::Game::Game(Context & p_context) : #ifdef _DEBUG , m_driverInfo(*m_context.driver, *m_context.window), - m_gameProfiler(*p_context.window, 0.25f), m_frameInfo(*m_context.window) #endif { @@ -30,7 +27,6 @@ OvGame::Core::Game::Game(Context & p_context) : m_canvas.AddPanel(m_fpsCounter); #ifdef _DEBUG m_canvas.AddPanel(m_driverInfo); - m_canvas.AddPanel(m_gameProfiler); m_canvas.AddPanel(m_frameInfo); m_sceneRenderer.AddFeature(); #endif @@ -46,9 +42,8 @@ OvGame::Core::Game::~Game() void OvGame::Core::Game::PreUpdate() { - #ifdef _DEBUG - PROFILER_SPY("Pre-Update"); - #endif + CPUZone; + m_context.device->PollEvents(); } @@ -57,9 +52,7 @@ void RenderCurrentScene( const OvGame::Core::Context& p_context ) { -#ifdef _DEBUG - PROFILER_SPY("Render Current Scene"); -#endif + CPUZone; if (auto currentScene = p_context.sceneManager.GetCurrentScene()) { @@ -98,7 +91,7 @@ void OvGame::Core::Game::Update(float p_deltaTime) { { #ifdef _DEBUG - PROFILER_SPY("Physics Update"); + CPUZoneN("Physics Update"); #endif if (m_context.physicsEngine->Update(p_deltaTime)) @@ -107,7 +100,7 @@ void OvGame::Core::Game::Update(float p_deltaTime) { #ifdef _DEBUG - PROFILER_SPY("Scene Update"); + CPUZoneN("Scene Update"); #endif currentScene->Update(p_deltaTime); currentScene->LateUpdate(p_deltaTime); @@ -115,7 +108,7 @@ void OvGame::Core::Game::Update(float p_deltaTime) { #ifdef _DEBUG - PROFILER_SPY("Audio Update"); + CPUZoneN("Audio Update"); #endif m_context.audioEngine->Update(); } @@ -135,7 +128,6 @@ void OvGame::Core::Game::Update(float p_deltaTime) { m_fpsCounter.Update(p_deltaTime); #ifdef _DEBUG - m_gameProfiler.Update(p_deltaTime); auto& frameInfoRenderFeature = m_sceneRenderer.GetFeature(); auto& frameInfo = frameInfoRenderFeature.GetFrameInfo(); m_frameInfo.Update(frameInfo); @@ -146,10 +138,9 @@ void OvGame::Core::Game::Update(float p_deltaTime) void OvGame::Core::Game::PostUpdate() { - #ifdef _DEBUG - PROFILER_SPY("Post-Update"); - #endif + CPUZone; + m_context.window->SwapBuffers(); m_context.inputManager->ClearEvents(); - m_context.driver->NotifyFrameFinished(); + m_context.driver->OnFrameCompleted(); } \ No newline at end of file diff --git a/Sources/Overload/OvGame/src/OvGame/Debug/GameProfiler.cpp b/Sources/Overload/OvGame/src/OvGame/Debug/GameProfiler.cpp deleted file mode 100644 index b124659ba..000000000 --- a/Sources/Overload/OvGame/src/OvGame/Debug/GameProfiler.cpp +++ /dev/null @@ -1,96 +0,0 @@ -/** -* @project: Overload -* @author: Overload Tech. -* @licence: MIT -*/ - -#ifdef _DEBUG - -#include "OvGame/Debug/GameProfiler.h" - -#include -#include -#include - -using namespace OvUI::Panels; -using namespace OvUI::Widgets; -using namespace OvUI::Types; - -OvGame::Debug::GameProfiler::GameProfiler(OvWindowing::Window& p_window, float p_frequency) : m_frequency(p_frequency), m_window(p_window) -{ - m_defaultHorizontalAlignment = OvUI::Settings::EHorizontalAlignment::LEFT; - m_defaultPosition = { 10.0f, 10.0f }; - - CreateWidget("Profiler state: ").lineBreak = true; - - m_elapsedFramesText = &CreateWidget("", Color(1.f, 0.8f, 0.01f, 1)); - m_elapsedTimeText = &CreateWidget("", Color(1.f, 0.8f, 0.01f, 1)); - m_separator = &CreateWidget(); - m_actionList = &CreateWidget(); - - m_actionList->CreateWidget("Action | Total duration | Frame Duration | Frame load | Total calls"); - - m_profiler.Enable(); - - m_elapsedFramesText->enabled = true; - m_elapsedTimeText->enabled = true; - m_separator->enabled = true; -} - -void OvGame::Debug::GameProfiler::Update(float p_deltaTime) -{ - PROFILER_SPY("Game Profiler Update"); - - m_position = { 10.0f, static_cast(m_window.GetSize().second / 2) }; - - m_timer += p_deltaTime; - - if (m_profiler.IsEnabled()) - { - m_profiler.Update(p_deltaTime); - - while (m_timer >= m_frequency) - { - - OvAnalytics::Profiling::ProfilerReport report = m_profiler.GenerateReport(); - m_profiler.ClearHistory(); - m_actionList->RemoveAllWidgets(); - - m_elapsedFramesText->content = "Elapsed frames: " + std::to_string(report.elapsedFrames); - m_elapsedTimeText->content = "Elapsed time: " + std::to_string(report.elaspedTime); - - m_actionList->CreateWidget("Action | Total duration | Frame Duration | Frame load | Total calls"); - - for (auto& action : report.actions) - { - auto color = CalculateActionColor(action.percentage); - m_actionList->CreateWidget(GenerateActionString(action), color); - } - - m_timer -= m_frequency; - } - } -} - -OvUI::Types::Color OvGame::Debug::GameProfiler::CalculateActionColor(double p_percentage) const -{ - if (p_percentage <= 25.0f) return { 0.0f, 1.0f, 0.0f, 1.0f }; - else if (p_percentage <= 50.0f) return { 1.0f, 1.0f, 0.0f, 1.0f }; - else if (p_percentage <= 75.0f) return { 1.0f, 0.6f, 0.0f, 1.0f }; - else return { 1.0f, 0.0f, 0.0f, 1.0f }; -} - -std::string OvGame::Debug::GameProfiler::GenerateActionString(OvAnalytics::Profiling::ProfilerReport::Action & p_action) -{ - std::string result; - - result += "[" + p_action.name + "]"; - result += std::to_string(p_action.duration) + "s (total) | "; - result += std::to_string(p_action.duration / p_action.calls) + "s (per call) | "; - result += std::to_string(p_action.percentage) + "%% | "; - result += std::to_string(p_action.calls) + " calls"; - - return result; -} - -#endif \ No newline at end of file diff --git a/Sources/Overload/OvGame/src/OvGame/Main.cpp b/Sources/Overload/OvGame/src/OvGame/Main.cpp index c0b181761..6dabd6e82 100644 --- a/Sources/Overload/OvGame/src/OvGame/Main.cpp +++ b/Sources/Overload/OvGame/src/OvGame/Main.cpp @@ -4,20 +4,12 @@ * @licence: MIT */ +#include #include - -#include "OvGame/Core/Application.h" +#include FORCE_DEDICATED_GPU -#if defined(TRACY_MEMORY_ENABLE) - #include - TRACY_CUSTOM_NEW_ALLOCATOR - TRACY_CUSTOM_DELETE_ALLOCATOR - TRACY_CUSTOM_NEW_ARRAY_ALLOCATOR - TRACY_CUSTOM_DELETE_ARRAY_ALLOCATOR -#endif - #ifdef _DEBUG int main() #else diff --git a/Sources/Overload/OvRendering/include/OvRendering/Context/Driver.h b/Sources/Overload/OvRendering/include/OvRendering/Context/Driver.h index 409dad737..979a7061e 100644 --- a/Sources/Overload/OvRendering/include/OvRendering/Context/Driver.h +++ b/Sources/Overload/OvRendering/include/OvRendering/Context/Driver.h @@ -48,7 +48,7 @@ namespace OvRendering::Context /** * Notifies the driver that the frame is finished */ - void NotifyFrameFinished(); + void OnFrameCompleted(); /** * Set the viewport diff --git a/Sources/Overload/OvRendering/include/OvRendering/HAL/Common/TBackend.h b/Sources/Overload/OvRendering/include/OvRendering/HAL/Common/TBackend.h index 85f930f21..a44611fe1 100644 --- a/Sources/Overload/OvRendering/include/OvRendering/HAL/Common/TBackend.h +++ b/Sources/Overload/OvRendering/include/OvRendering/HAL/Common/TBackend.h @@ -39,7 +39,7 @@ namespace OvRendering::HAL * Notifies the backend that the current frame is finished. * This can be used for synchronization purposes, profiling, etc. */ - void NotifyFrameFinished(); + void OnFrameCompleted(); /** * Clears the specified buffers. diff --git a/Sources/Overload/OvRendering/include/OvRendering/HAL/Profiling.h b/Sources/Overload/OvRendering/include/OvRendering/Profiling/GPUProfiling.h similarity index 71% rename from Sources/Overload/OvRendering/include/OvRendering/HAL/Profiling.h rename to Sources/Overload/OvRendering/include/OvRendering/Profiling/GPUProfiling.h index c4ff467e6..8ec41bbfe 100644 --- a/Sources/Overload/OvRendering/include/OvRendering/HAL/Profiling.h +++ b/Sources/Overload/OvRendering/include/OvRendering/Profiling/GPUProfiling.h @@ -8,7 +8,7 @@ #if defined(GRAPHICS_API_OPENGL) #include -#define OvGpuZone(...) TracyGpuZone(__VA_ARGS__) +#define GPUZone(...) TracyGpuZone(__VA_ARGS__) #else -#define OvGpuZone(...) (void)0 +#define GPUZone(...) (void)0 #endif // defined(GRAPHICS_API_OPENGL) diff --git a/Sources/Overload/OvRendering/src/OvRendering/Context/Driver.cpp b/Sources/Overload/OvRendering/src/OvRendering/Context/Driver.cpp index 372cdaa5b..a8620cfd7 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Context/Driver.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Context/Driver.cpp @@ -46,9 +46,9 @@ OvRendering::Context::Driver::~Driver() { } -void OvRendering::Context::Driver::NotifyFrameFinished() +void OvRendering::Context::Driver::OnFrameCompleted() { - m_gfxBackend->NotifyFrameFinished(); + m_gfxBackend->OnFrameCompleted(); } void OvRendering::Context::Driver::SetViewport(uint32_t p_x, uint32_t p_y, uint32_t p_width, uint32_t p_height) diff --git a/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp b/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp index bca9d841d..a87698f27 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Core/ABaseRenderer.cpp @@ -6,11 +6,11 @@ #include -#include - -#include "OvRendering/Core/ABaseRenderer.h" -#include "OvRendering/Resources/Loaders/TextureLoader.h" +#include #include +#include + +#include std::atomic_bool OvRendering::Core::ABaseRenderer::s_isDrawing{ false }; @@ -48,7 +48,7 @@ OvRendering::Core::ABaseRenderer::~ABaseRenderer() void OvRendering::Core::ABaseRenderer::BeginFrame(const Data::FrameDescriptor& p_frameDescriptor) { - ZoneScoped; + CPUZone; OVASSERT(!s_isDrawing, "Cannot call BeginFrame() when previous frame hasn't finished."); OVASSERT(p_frameDescriptor.IsValid(), "Invalid FrameDescriptor!"); @@ -78,7 +78,7 @@ void OvRendering::Core::ABaseRenderer::BeginFrame(const Data::FrameDescriptor& p void OvRendering::Core::ABaseRenderer::EndFrame() { - ZoneScoped; + CPUZone; OVASSERT(s_isDrawing, "Cannot call EndFrame() before calling BeginFrame()"); @@ -119,7 +119,7 @@ void OvRendering::Core::ABaseRenderer::Clear( const OvMaths::FVector4& p_color ) { - ZoneScoped; + CPUZone; m_driver.Clear(p_colorBuffer, p_depthBuffer, p_stencilBuffer, p_color); } @@ -131,7 +131,7 @@ void OvRendering::Core::ABaseRenderer::Blit( OvRendering::Settings::EBlitFlags p_flags ) { - ZoneScoped; + CPUZone; OVASSERT(m_unitQuad != nullptr, "Invalid unit quad mesh, cannot blit!"); @@ -184,7 +184,7 @@ void OvRendering::Core::ABaseRenderer::DrawEntity( const Entities::Drawable& p_drawable ) { - ZoneScoped; + CPUZone; auto material = p_drawable.material; auto mesh = p_drawable.mesh; diff --git a/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp b/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp index 37a57c65e..cce4c1b24 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Core/CompositeRenderer.cpp @@ -6,10 +6,10 @@ #include -#include - #include -#include +#include + +#include OvRendering::Core::CompositeRenderer::CompositeRenderer(Context::Driver& p_driver) : ABaseRenderer(p_driver) @@ -18,8 +18,8 @@ OvRendering::Core::CompositeRenderer::CompositeRenderer(Context::Driver& p_drive void OvRendering::Core::CompositeRenderer::BeginFrame(const Data::FrameDescriptor& p_frameDescriptor) { - ZoneScoped; - OvGpuZone("BeginFrame"); + CPUZone; + GPUZone("BeginFrame"); ABaseRenderer::BeginFrame(p_frameDescriptor); @@ -42,8 +42,8 @@ void OvRendering::Core::CompositeRenderer::BeginFrame(const Data::FrameDescripto void OvRendering::Core::CompositeRenderer::DrawFrame() { - ZoneScoped; - OvGpuZone("DrawFrame"); + CPUZone; + GPUZone("DrawFrame"); auto pso = CreatePipelineState(); @@ -61,8 +61,8 @@ void OvRendering::Core::CompositeRenderer::DrawFrame() void OvRendering::Core::CompositeRenderer::EndFrame() { - ZoneScoped; - OvGpuZone("EndFrame"); + CPUZone; + GPUZone("EndFrame"); for (const auto& [_, pass] : m_passes) { @@ -89,7 +89,7 @@ void OvRendering::Core::CompositeRenderer::DrawEntity( const Entities::Drawable& p_drawable ) { - ZoneScoped; + CPUZone; for (const auto& [_, feature] : m_features) { diff --git a/Sources/Overload/OvRendering/src/OvRendering/Data/Material.cpp b/Sources/Overload/OvRendering/src/OvRendering/Data/Material.cpp index 5087d59c5..777e7ad64 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/Data/Material.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/Data/Material.cpp @@ -4,14 +4,14 @@ * @licence: MIT */ -#include - #include "OvRendering/Data/Material.h" #include "OvRendering/HAL/UniformBuffer.h" #include "OvRendering/HAL/TextureHandle.h" #include "OvRendering/Resources/Texture.h" #include +#include + //TODO: Add constructor with a shader reference OvRendering::Data::Material::Material(OvRendering::Resources::Shader* p_shader) @@ -47,7 +47,7 @@ void OvRendering::Data::Material::FillUniform() void OvRendering::Data::Material::Bind(OvRendering::Resources::Texture* p_emptyTexture) { - ZoneScoped; + CPUZone; if (HasShader()) { diff --git a/Sources/Overload/OvRendering/src/OvRendering/HAL/None/NoneBackend.cpp b/Sources/Overload/OvRendering/src/OvRendering/HAL/None/NoneBackend.cpp index 6a1b3ad21..143f2cd38 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/HAL/None/NoneBackend.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/HAL/None/NoneBackend.cpp @@ -26,7 +26,7 @@ namespace OvRendering::HAL } template<> - void NoneBackend::NotifyFrameFinished() + void NoneBackend::OnFrameCompleted() {} template<> diff --git a/Sources/Overload/OvRendering/src/OvRendering/HAL/OpenGL/GLBackend.cpp b/Sources/Overload/OvRendering/src/OvRendering/HAL/OpenGL/GLBackend.cpp index f1e83cdf7..b9ca55070 100644 --- a/Sources/Overload/OvRendering/src/OvRendering/HAL/OpenGL/GLBackend.cpp +++ b/Sources/Overload/OvRendering/src/OvRendering/HAL/OpenGL/GLBackend.cpp @@ -237,7 +237,7 @@ namespace OvRendering::HAL } template<> - void GLBackend::NotifyFrameFinished() + void GLBackend::OnFrameCompleted() { TracyGpuCollect; } diff --git a/Sources/Overload/OvTools/include/OvTools/Profiling/CPUProfiling.h b/Sources/Overload/OvTools/include/OvTools/Profiling/CPUProfiling.h new file mode 100644 index 000000000..354efe82c --- /dev/null +++ b/Sources/Overload/OvTools/include/OvTools/Profiling/CPUProfiling.h @@ -0,0 +1,13 @@ +/** +* @project: Overload +* @author: Overload Tech. +* @licence: MIT +*/ + +#pragma once + +#include + +#define FrameEnd FrameMark +#define CPUZone ZoneScoped +#define CPUZoneN(...) ZoneScopedN(__VA_ARGS__) diff --git a/Sources/Overload/OvTools/include/OvTools/Profiling/MemoryProfiling.h b/Sources/Overload/OvTools/include/OvTools/Profiling/MemoryProfiling.h new file mode 100644 index 000000000..879e75a43 --- /dev/null +++ b/Sources/Overload/OvTools/include/OvTools/Profiling/MemoryProfiling.h @@ -0,0 +1,106 @@ +/** +* @project: Overload +* @author: Overload Tech. +* @licence: MIT +*/ + +#pragma once + +#include + +// Platform-specific aligned allocations +#if defined(_WIN32) +#include +#define CUSTOM_ALIGNED_ALLOC(alignment, size) _aligned_malloc(size, alignment) +#define CUSTOM_ALIGNED_FREE(ptr) _aligned_free(ptr) +#else +// For POSIX systems +#include +#define CUSTOM_ALIGNED_ALLOC(alignment, size) aligned_alloc(alignment, size) +#define CUSTOM_ALIGNED_FREE(ptr) free(ptr) +#endif + +#if defined(TRACY_ENABLE) && defined(TRACY_MEMORY_ENABLE) +void* operator new(std::size_t count) +{ + auto ptr = malloc(count); + TracyAlloc(ptr, count); + return ptr; +} + +void operator delete(void* ptr) noexcept +{ + TracyFree(ptr); + free(ptr); +} + +void* operator new[](std::size_t count) +{ + auto ptr = malloc(count); + TracyAlloc(ptr, count); + return ptr; +} + +void operator delete[](void* ptr) noexcept +{ + TracyFree(ptr); + free(ptr); +} + +void operator delete(void* ptr, std::size_t count) noexcept +{ + TracyFree(ptr); + free(ptr); +} + +void operator delete[](void* ptr, std::size_t count) noexcept +{ + TracyFree(ptr); + free(ptr); +} + +// C++17 aligned new/delete variants +void* operator new(std::size_t count, std::align_val_t alignment) +{ + // Ensure size is a multiple of alignment for some platforms that require it + size_t alignedSize = (count + static_cast(alignment) - 1) & ~(static_cast(alignment) - 1); + auto ptr = CUSTOM_ALIGNED_ALLOC(static_cast(alignment), alignedSize); + TracyAlloc(ptr, count); + return ptr; +} + +void operator delete(void* ptr, std::align_val_t) noexcept +{ + TracyFree(ptr); + CUSTOM_ALIGNED_FREE(ptr); +} + +// C++17 aligned array new/delete variants +void* operator new[](std::size_t count, std::align_val_t alignment) +{ + // Ensure size is a multiple of alignment for some platforms that require it + size_t alignedSize = (count + static_cast(alignment) - 1) & ~(static_cast(alignment) - 1); + auto ptr = CUSTOM_ALIGNED_ALLOC(static_cast(alignment), alignedSize); + TracyAlloc(ptr, count); + return ptr; +} + +void operator delete[](void* ptr, std::align_val_t) noexcept +{ + TracyFree(ptr); + CUSTOM_ALIGNED_FREE(ptr); +} + +// C++17 sized-and-aligned delete variants +void operator delete(void* ptr, std::size_t count, std::align_val_t) noexcept +{ + TracyFree(ptr); + CUSTOM_ALIGNED_FREE(ptr); +} + +void operator delete[](void* ptr, std::size_t count, std::align_val_t) noexcept +{ + TracyFree(ptr); + CUSTOM_ALIGNED_FREE(ptr); +} +#endif // defined(TRACY_ENABLE) && defined(TRACY_MEMORY_ENABLE) diff --git a/Sources/Overload/OvTools/premake5.lua b/Sources/Overload/OvTools/premake5.lua index 7d2a43e94..a9628af7c 100644 --- a/Sources/Overload/OvTools/premake5.lua +++ b/Sources/Overload/OvTools/premake5.lua @@ -3,7 +3,10 @@ project "OvTools" language "C++" cppdialect "C++20" files { "**.h", "**.inl", "**.cpp", "**.lua" } - includedirs { "include" } + includedirs { + dependdir .. "tracy", + "include" + } targetdir (outputdir .. "%{cfg.buildcfg}/%{prj.name}") objdir (objoutdir .. "%{cfg.buildcfg}/%{prj.name}") characterset ("MBCS") diff --git a/Sources/Overload/premake5.lua b/Sources/Overload/premake5.lua index 79d3d1418..adddd7efd 100644 --- a/Sources/Overload/premake5.lua +++ b/Sources/Overload/premake5.lua @@ -50,7 +50,6 @@ group "Dependencies/Prebuilt" group "" group "Overload SDK" - include "OvAnalytics" include "OvAudio" include "OvCore" include "OvDebug" From 3703c20db2016495ec34798f37423631e25d342f Mon Sep 17 00:00:00 2001 From: Adrien GIVRY Date: Tue, 8 Apr 2025 14:07:41 -0400 Subject: [PATCH 05/11] Added tracy-profiler.exe, with menu item to open it --- .../include/OvEditor/Core/EditorActions.h | 7 +++++++ .../include/OvEditor/Panels/MenuBar.h | 1 + Sources/Overload/OvEditor/premake5.lua | 2 ++ .../src/OvEditor/Core/EditorActions.cpp | 5 +++++ .../OvEditor/src/OvEditor/Panels/MenuBar.cpp | 7 +++++++ Sources/Overload/premake5.lua | 1 + Tools/tracy-profiler.exe | Bin 0 -> 21908992 bytes 7 files changed, 23 insertions(+) create mode 100644 Tools/tracy-profiler.exe diff --git a/Sources/Overload/OvEditor/include/OvEditor/Core/EditorActions.h b/Sources/Overload/OvEditor/include/OvEditor/Core/EditorActions.h index 9894afaf3..4cb261b47 100644 --- a/Sources/Overload/OvEditor/include/OvEditor/Core/EditorActions.h +++ b/Sources/Overload/OvEditor/include/OvEditor/Core/EditorActions.h @@ -360,6 +360,13 @@ namespace OvEditor::Core void BuildAtLocation(const std::string& p_configuration, const std::string p_buildPath, bool p_autoRun = false); #pragma endregion + #pragma region PROFILNIG + /** + * Open the profiler + */ + void OpenProfiler(); + #pragma endregion + #pragma region ACTION_SYSTEM /** * Prepare an action for a future call diff --git a/Sources/Overload/OvEditor/include/OvEditor/Panels/MenuBar.h b/Sources/Overload/OvEditor/include/OvEditor/Panels/MenuBar.h index daa2db266..8f50a9737 100644 --- a/Sources/Overload/OvEditor/include/OvEditor/Panels/MenuBar.h +++ b/Sources/Overload/OvEditor/include/OvEditor/Panels/MenuBar.h @@ -45,6 +45,7 @@ namespace OvEditor::Panels void CreateWindowMenu(); void CreateActorsMenu(); void CreateResourcesMenu(); + void CreateToolsMenu(); void CreateSettingsMenu(); void CreateLayoutMenu(); void CreateHelpMenu(); diff --git a/Sources/Overload/OvEditor/premake5.lua b/Sources/Overload/OvEditor/premake5.lua index ccd034613..bba369af5 100644 --- a/Sources/Overload/OvEditor/premake5.lua +++ b/Sources/Overload/OvEditor/premake5.lua @@ -31,6 +31,8 @@ project "OvEditor" "xcopy \"%{resdir}Editor\\*\" \"%{builddir}%{cfg.buildcfg}\\Data\\Editor\" /y /i /r /e /q", "xcopy \"%{prj.location}\\Layout.ini\" \"%{builddir}%{cfg.buildcfg}\\Config\\\" /y /i", + "xcopy \"%{wks.location}\\..\\..\\Tools\\tracy-profiler.exe\" \"%{builddir}%{cfg.buildcfg}\\Tools\\\" /y /i", + "xcopy /Y /I /Q /D \"%{outputdir}%{cfg.buildcfg}\\%{prj.name}\\*.exe\" \"%{builddir}%{cfg.buildcfg}\\\"", "xcopy /Y /I /Q /D \"%{outputdir}%{cfg.buildcfg}\\%{prj.name}\\*.dll\" \"%{builddir}%{cfg.buildcfg}\\\"", diff --git a/Sources/Overload/OvEditor/src/OvEditor/Core/EditorActions.cpp b/Sources/Overload/OvEditor/src/OvEditor/Core/EditorActions.cpp index 46b6daf10..720d4ebad 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Core/EditorActions.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Core/EditorActions.cpp @@ -328,6 +328,11 @@ void OvEditor::Core::EditorActions::BuildAtLocation(const std::string & p_config } } +void OvEditor::Core::EditorActions::OpenProfiler() +{ + OvTools::Utils::SystemCalls::OpenFile("Tools/tracy-profiler.exe"); +} + void OvEditor::Core::EditorActions::DelayAction(std::function p_action, uint32_t p_frames) { m_delayedActions.emplace_back(p_frames + 1, p_action); diff --git a/Sources/Overload/OvEditor/src/OvEditor/Panels/MenuBar.cpp b/Sources/Overload/OvEditor/src/OvEditor/Panels/MenuBar.cpp index 205584361..bef9d4b23 100644 --- a/Sources/Overload/OvEditor/src/OvEditor/Panels/MenuBar.cpp +++ b/Sources/Overload/OvEditor/src/OvEditor/Panels/MenuBar.cpp @@ -44,6 +44,7 @@ OvEditor::Panels::MenuBar::MenuBar() CreateWindowMenu(); CreateActorsMenu(); CreateResourcesMenu(); + CreateToolsMenu(); CreateSettingsMenu(); CreateLayoutMenu(); CreateHelpMenu(); @@ -209,6 +210,12 @@ void OvEditor::Panels::MenuBar::CreateResourcesMenu() resourcesMenu.CreateWidget("Save materials").ClickedEvent += EDITOR_BIND(SaveMaterials); } +void OvEditor::Panels::MenuBar::CreateToolsMenu() +{ + auto& toolsMenu = CreateWidget("Tools"); + toolsMenu.CreateWidget("Open Profiler").ClickedEvent += EDITOR_BIND(OpenProfiler); +} + void OvEditor::Panels::MenuBar::CreateSettingsMenu() { m_settingsMenu = &CreateWidget("Settings"); diff --git a/Sources/Overload/premake5.lua b/Sources/Overload/premake5.lua index adddd7efd..4b7c91d32 100644 --- a/Sources/Overload/premake5.lua +++ b/Sources/Overload/premake5.lua @@ -21,6 +21,7 @@ workspace "Overload" "GRAPHICS_API_OPENGL", "OVERLOAD_VERSION=\"" .. version .. "\"", "TRACY_ENABLE", + "TRACY_ON_DEMAND", "TRACY_MEMORY_ENABLE" } diff --git a/Tools/tracy-profiler.exe b/Tools/tracy-profiler.exe new file mode 100644 index 0000000000000000000000000000000000000000..8d5a2fd49b0abc43aec937811863855d1b1b2464 GIT binary patch literal 21908992 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�tp1M)u&w!X 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

~|=G>X0uqA9|`kwz#W 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

;94KvdlswP(GZA3>;38$$f{wVP4$iz9t?NUp=|c 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

V+Kr?y}?q))P36s7<^FFnMw9VrvApH*s zwmDtQ%mlzePw+oy&r;cmYw5Tgm%uL5>y}9CVyHE_>>mJ@zOcZlkf!`m*oVN0N!ldl ze^r(G;h0qzI8srydY%!Wn^div9 z_B?gM{VnR%Wi7n&K3D+NF>t?-bx7U^Q{Uz+SpvH({yLerzLBh-3o-cx7a*#ExNVT~ zuTKQPmpU>?mbEmIo6-Lwfes8E$r-YTwU;jvvI3-UgRJewd+!NkJ(b-L#{hjqcbvZo zLL&o;?v?m`OADZ4hV9MnBx;qTS85I(=~pj(j1vlW;!fyoYUAG{iNLg%qp+*oP8)tn zEf9fKB>dkJfjBx4*nE3K2R_?#tqEX-OZc$6cm%tJiXtuHqz7d*vZURjXLPk{=-8BKZYm%vvYwL@@Q% zSBA$B`eD|(gUom^^}f}^W8R3##C1h}vzS~aZ$Br|8@Bdu8|7`MwztDfPngZkMVI29lV8Oj&vJ7SReA2_V8<%O8}qQd`4UOAToP5O&y!SA zNwhqas48%1VqM_yL}iUjSNLASUw1~Su^=c|6~C5A{ILVEH8stq>aq zPxg;7N{!y4n4YRH`2|CRF7!4Sm5-8O7`*wbHE;1+n#w)j;GC}2@DeLlW(yDV3OA$t zv(_NW>4e(&=l2hfp^5k@qti}7|IOmQS|ph#Hv|jPImy?6dKR8wY6#;EZ?oh8sMVfU z^%!c>s*%t?eT>^ARBW|@Yy~%Y6Xlpz;BnUwRK?}%pU4t;xYfR9iLhbxAkUmEb9}8{ zGGWP=bOUFf`dkJQqF70gtH;S%yF_9G#?&sE4?c2};$oWTt29RI3TT7yMN`ix?Y*v) zrm50WFMfG=%=F+Rl~ZZ%qIXBzY<{EDD%=S_lf8@NLDLs$-179is@6QON>|hq z2{W!ZNncb>Uhkq-4!~<8#XtY(thFDL+BbiuW^BG&zv}mYgAnR(3x>F-J*)zP=?_Z? ztQ+;b@>2x#^(FsRvW$8pg$A_XBR6c}3KAFNCL8~2zPy2%)uz`Qx1HbH<~+K%^e&q% zuIQY6y_T7t&36hIb1wy4*1NY*IadEuM}*$-{uU{?;dm-zkGnRb2v*wwAyFev)%5FQ zX`7hmi9gf_2YS)y8j7zw-!Zt6js(W$X9N}=OP8?%zor@!C#F!?!_q4b?a0;i zo6(t9$#QJ0e_u#({EIJ9HewdqHE}reUBB~pKqb$aOc?y74Ca1T7sa}(LMfmGHr`0? zpCU`EOznxnu8OrL?MpbeSBRlW`u6s)F#b&FefAGv?IWKk_~~i*|CMSp9%Tk| z`v;ru#*wZK20#1fSz&PIcTkNR%`(n4%A^d9GHREc+n;_*QRh-r7}HlsNq?Rg|E?P9 z4soiBwCcN$RjcBSEGhA5Ybu^57HZoo-+@=DSU;Gxi}mkSe!$s1{}-94$7O^NRuL_sv;C~7@p>5RDo}*5w|bCk-FT|Doo6(h{mknCNN!JE=jS8PjR;h#9GLQ z5Mq4~;;;)4beqZB0XtzQer`Kg;mqM!hAD!|fKx-H$gZobvClLiSG>)f>&g>k`347U zte?K*WJ%d_t&Ewy@>xm(bRYk-jK~|tIDXmRd8{*uo$F!tf;r=UVfX!mtlG>E2wFHL zZF{aOR|Lr1Y_w=) zDvQVgZQ({i2c(ZUy_=JR2Q!0yY^X)a@MO0H zPJ{lBOw99UR0U%RH3}FnuFQ@pUyy7oN=Ha}Qi2z=0u&hco-hIXNeaQ7jh~DQb;B%V zqmsLM#eFJGkb8DIce=8$N)`Zd&V)}>x=B;XAZ*(#UE!VyVUf7c@+om4=2O9)@D>AC382t{M z73So+^anMW>^Y($$b9fXjk6?k7$!{&ZCN>)y}0 z|JJ&P(#^Jh-)`OCu)t8WZ0BL?_fG2`Dz~roy{mOU zVtwCh-G^K6&z5es_5Eh+9!h_n_4~Xy>R)!z(_L(rb6vwVgzG0ljy%D}mXxbM@xBi0g8$ zYq*AR{e){2*Ep^TTvNE(tP@+eD){I-cP6mWI9-AfRCcO=ri%?2S-~v?BllZ<>~7r~ ztTB7Yy8q33zr?zqW8F_%_YbZ68tZ=Ff^5cW3^m-sbqCipu9;jTx#n;^$W_6mbNz

)bV=tMxB2^w717>Xz!y{q~3dqUdJo_xG56I`v!Cr`6m-eG1LnZ>=^x zV%_Ik_q(k7tJXb~Zjtr-=hl7m|B!C4^}WHmzhT|~82T-61AgrlJX_YA7GA`4IoCB@ zL%4pzHHvE-*95L9T=#PQl4~y40-StQaxqv8S?7eF|9}2V?9#PcQgU~@ zqen;MUv{@S{-rC__-AtqjelsoPgpP%!t0&Zc>LD7ceU=J@fr@lA>-B6x*xW_Z?Nur zt@p25_xaZSF6-V8{!8Vz?nkWmACwAAKK(4?$MquD%UrK>y~9<J5CxO{(E%NosEmjkonJ13PYoUo!R81>>9entUf^)oh%X z7_bF;PBH>LH(d2%!H^hRz;SDHpl6{$l7-4bb>hzW=iO3WVRgW9+hL_hx?8pb7GPb= z3=23RUHFLWaFq?rE}V}*u5{h(#AIW`ctduQBUt03oy$|UFa$G1Scj|1&koE-r~T`R zn*s&nzmZ1O+5%lCwFJ6u7}QfWD)H8Dr3-19j~-GCuV=-C zClAky4Nr9GO^iT|GkwCokiFH(4mz$`HM5 z5e=wlim_LgAWUHrw=ebspdMn*6Fy=dKF~Lad!o;y;Q|EbI)18)opSyld-Nt$*Koc# zX0eG4bk3vkXM926!5;aA#yjf=i3wqQ;M>9rMoN$5(D4UvudeYAFRWt>@>}S0UdG*O zt}@v$2S+OmEjoA=MQ40V&B1TclYcvLci`j6djlWeelk!$;b>rUzkkdEUTXZK3mecv zq~>U1p7?p;-Wvai!q1)S`tI+`&RG%Q;Jqn)@^|tFi(!v@T8-N`^|Iw+fT--Tn(Exeh2+8mt>Xv8UHSSJmtpB7flt= zCicw@*okD)b$_a@91ucOmwlpGEK@}1y0ny=#cwksH=d*E*TDiNcZ0kcYl=*r`c~m} zHyZbD6_rr(T0Vv36JyTXz2S{JvjDLn!U3>to0sac61q+NE!N;aQ*@0 zw+s=oU9s{{*dnkk?l3bCiq8Dmmgvk!-!csYR{QGI=k12QvzSO2mgM6IGRDe4Z(GxU z%c%R3C$U-?AI*vC)-uWFOFqb_aI;oWa&)))omAa=w$W_av(aU^+qG;G`2phY#vIYT z`I5KVV0IaeyQ8zEw##-Y*$l@+%+&P_%(D*!AMky4jyjep(vqtiM*iJr7KBRyQGCw{93Y{U)Tp)`H6+khHS2R zmnL#^d)GVEZA}`tz=NPbVN>tUqSh~!pw+m#w>rQt!7UJVfk(f)0Za%XS@V?R_!!QM zm)8cmw>$!~_)me9sOhoe?!gAf2HqO0fVOHooeKAW7)YWf8ip|1 zLPy_tQui3oBGF@VqC6!Tn*+TBU$ViM#dg8S;gJ|w)d5D103%s5*labv3Y1(%Ir&dW zVUP01v&`7@yor*7DNdo}+z(Q1VsrdK2s!^W3cgE!6$QDw>lNf)9_-%+xrf$SkV^Wjg2lfSf{#GK##)++3k#OJ#$QTtE<(muF++@DP=@- zYs*>-ArD=p5Hg2)1tE9+GHNs`+hu!#Y{r85f{^2CK}dV$CqzUFBjvk-lz09Ai2rQ1jPQYzBOh7=KCIswO0OXlfRaFS^gz1IA#)DqO>}g7U_~=W3ZI&Ji^vd}f3c*8 z%)eWVYUZ25sG4fJ$(%ql85g`8TL2!7HT)q%_)3Bz-4L<RqvJ_tbwv3zdzxcM_rofzuyPd;>Q7r7*9&^76 z1~yJ^wCC?BU%!?m+!nPs&cp|1+U*;Qekvn7LyW?TsXfxqS0W>Kq!5l?7D1RuVNSu; z*UXnZ=C777)j};O7E~R-*17KDOZrTgWN%4=wTJ|={d3KsUQmjWlMxs2d!i(qYbM3t zdc90?A)b+{9LeA?*Irx;D9xb&#awBHntVhG>Vi6lR$*S0rSNBRnmqL}#;)(B2C@D4 z$*>VC_6~q4{*fDG&3|x;YKyhhQ~3MRh7ZgdoaR@1Q9){;bK+nx!nHlxFj<@{@PlD;Izh48+sq zHFn+`)td@35<K8sYwEZ7M#sIYA4VqQ0b!^EmKAy?CNv0Ipyb+59l-@UdMWG>!A1uoO>Y-tRv zUm+v(NET;D`B3~SL4~Sc2+pH$kQLkXlRe=mHwnR%oq*;tNx;V`Rc4MJRq|2h>l@>b zhoOYNWv0)kO!u$65guRIj26DEyuIG=MSFX>EO$>lKb6a;>F+5XmHu`vpT`|XXbI_0W{O~#WqNLp%JUH~Mb8ujdnuAS` z{$HAd7UO<~C29`7d^mazzJE#0!C-09v~n9jR3UD+|G^wQ%K$W8AhQm>cT8vPl}{_q zu)pFnE!vmA$E1it<^E}sK}h@_2;TvrdGg2eiSgxACgGFtmWuE_YN`(Qe*?x%y*p}_ zd%Pu6k$jj>VQjmA{?Vx0ph(?Kf}}J=$}t~;^jx!|e7`4)K&U;s!0I=n!Dh!_E!O|@ zixt}ETG{qYi)x40%x2;{RPhyf`;9g$Ny{>#Je?{)le2>43K1TV+C9nP(Bzg8a0pj>u zDcv$>=MDXXxW5#2HNKt+?(VukjM4=A76t0sTfSI)-syD>bUJ^J+gIF59Qy+js!H=t zHr(EOT0HtGZoIz7_D;G~=q*b`-RHwZth9eleeqCv#5qA!%>2ATe){74V!kg_%HT>= zupZw%C9>5;d8_Aj5~@fCFO#5P(n8O(SL z&9M^Uo}dhz$+Op!#jdbg*D8L zFb>DNE_t7*0KEhd{0EuUhP<5W;`qFrE=AXC!3`vmukx;QUXIH_c!b~v1j_Wb4-c>v zJXqYB7zaC=2}iQa44FanFZK_{?UpF{KhN`e$`z9b@>C%@m75M;KF<#0(>`d*5vT-4 z1LrAIM9~dl_#7z0)>I%Ah(91eR&K&4fPgEEK&Tem_QBR1rv4^iRId7)Cr!>>*9~wqE?$^| zisJ20peHu_6B{7lJnQ9O{+tj5HcjrsFo8nd5G zQ_gpwFhcrik7}*i4#{=;@2U+Gery}Aj%vedO0(L~$!tS+X~RU?K<(X}b&F**!2gJL zmzphjZ_$q&g}=TMISN-(8l!!|Q&*d#y+wr~HR^C!ZtHXxv&y@EY?Z^Js(h0nAS@s> z{>f9y|LjmYM7>oxpzYx4G*5&OW4ml)QSa%?*zc!T34tRTgBfnX8gbT13ms^rvln*to3IWQ0uBFOSctYz%A2OO!$+Z9$`9eu_16zT^vMp`riX9~7UrdqFgx_n&R+Ghw7ZwIJ+G zwpGHfUaOc2F`|Z?0%yrny4uSDT}w{Mg08h@iv4}io_^}N)_7-{@(yR8Rn5mgyBNXQ zVcv7oYc~Gu;$7KLT{uMkj<1Hds9wjW9h>n6eF|@RRQ`u;RYA2J$&F_5jZ{}_ObS(z z8(l@=S*jrFv(1?BKUHyiWEIEnvU>3YtLQCNd^b-rwGmpyAwuc}9)1rz+=@yVB9_Di z3$^FijC=;V=nm&Pm^INH^m=G`j8iWc5z$Fl@Ps_Qp0lBIwB$!>$J@EqRxVthIpl+-l?PwzEmNYBik(BwUV_ZNZL-pz3z;=p z=~j!2#-X8(v#;!x2bq#^{5HZ-DgGIM2jx@%1ar7tiE(7F5M20&Fbgf4Ife6zW}#QB z)G6l+54~3SlPrmltB+qT?8$ZV=OW>u`-gbw#Z?p&$wjAyx#;Lm@Xkl!`^Zp(^&T?AE4;$w# zq-?hzUjoT?Jl=~wh#v3a1!o)URp*AsI^bv<>%KD9@iNwoC;^YuXu=dmjP-vyqHH9z zMl>%xqWSu1djAg-%06p@G8DEUS*=!Rsix($*ehQH{R8uVnf&fm(9rq6Onpo4(A3qL zLt;$%t#id%S?>{I9w4n#f8QCz+!g=vJi%w>U@nV##_Uu3-!~9_zPU%bhvZdG>MDPUIFc&&>>bmwT_nx!hU)_FF7Sw&H|0$B*9{Y$otl zci|nn7%%;;HK>b$KFm=@Fth~^STt~!N>HS4k>E6I7+~@7InmG0M%54Xjebr;SW_K( zS|Vdxg!6Gt-_bw@;K0U^0hRZ+Pi7|lIV{SmRtO=)3#wZg@r?+YZARl9QDHf7)C^i>7^K=z%XWZ$V&VIuAwy~DsX zl^Byh2ytbJL;URsapltwLtHEtNWDaYMPViNB24!*l9$L9U~>Wr)hH8tfc4gtD7F{L zQc7r8=5!jH5g@pVcV{8UD`p|Eulb~MU!FbxbKvLsxdJ~C{`YM|m$^y}o&Jcxo$>QS zGFm$r?^}Ng$8i#lLxl?>6pYWy3SK<3E$3G+!atYv7+=otmE+6w;cVGBCw!+b`PZ*7 zTVF0${K{oiZt10R>i&}`1k_xHJVB^{WoGD2yLty_ycr&GKgD@$q0Xx z(U~&T?7{$nYI&MoA?1Yyyl3Ut*_P;a`|0r$H=VgeujE5$iGJbGIV_{Z7gXys3!5B2 zko=Hjo%an;R8iIflWKD5zT_L_{k2cy4YChEKd0^!K}^=Noq#4})n3`elqk2qH%Oow zU84S$3V4>7;F-;|xO`7G$vF9vhfA4n*CAg5p8v%sz|;5BYw4FSA7~q&&GBDG+1GJw z2d^kAuob0Ab3==;`SqhN@wVn^NH4pK81uIH7qi;9?k=oE7&RL-~ z&o&;XXUm%Q;?{VU{uTU6_0KT-ce~WQzt-$ufKSrDsqOmr((ZrPzhI)(zoT;^`&aeL zw*LKdAGJLFr0U-eQvEOb_X<5*)^q}e5hGd|RpU7kHTIJlFEwkt^GDa%Ml;^P+X|5H zMNuq#Ka9USDwID49XB&!@pnb3tgnKCgl~7+wOXfF{c5Y{W>pWtTb|i}0w0r>eBCF> zog57~ExF4}g0zH8{2V9M_=J-=FQ{w zxg13!LUTDF=zY^NUWR#wXlDJDWwdADpQ0x7Jl)e0++@vYuo@RHz-SycF(t%rzfhRB9_1~(z?&iWZnEUDty*^8WvBB4*y?>##7;XU zUZ*S0Mx+ZoE0f1a`;I274R`0GSuBLAI_>W5!#pi^w;B|$f?I~+z%OO4O;hwRj!$7N z&M1HL74Ej8^DEw*Di6gy^@`Vcs5o$>qP~+?Js)%8N^Fb4^R(iPTpo;3x3B?OJx4H5 zeOJm{raq`D`4RfXo1cq>jCX&J&S$_UVg=FI$9i{0L0;9}88@SlZPD1fSlOAu)_fYs z`EU-QAZ7A+=u-TlL3$`38Dui1dI z`vB3`Zm!ud&-@%rb)S;6gj&(tj$M4T=-fP1^{9V^xve(}emw|m3Z|x$hFzmB|5xcU zd(z&b47b(PqWfVT54iPwL!HY+u=ncX^V;G+s$<F9Hq1CCWIIuuQA;7U87m5B?Gj?u2 zA;{)VnUfZbAPawu^7uHLnI%E*~#MbBlg$+@A|Lhlo@Z(CG1fH5U6lo zOFyGEqOJF(a1Pq$qAOrtaI%S)k?szO%`?e)V{36MoP4@O8OvX0Y(kw7U5aa(S{vw? zrYHGjPo+_*WCBs2Zg>|2yeB_WecJnXsW!z(o4hRC^`%QARf)$|i0bV1-C}E21HU7( zhBzYnX^A4=;Br!uARcM{W`cYOpkJ~b5Vm~O*mrVrV)C=+O1Ln*?tV~)Z|~f*Hk0w1 z&fXIErdjY!*Q$l-?rCxwNuvGr_?!ROKW4f&#=a(gG*4AdHgcx^_smFsV(7hLE*&;! zv`;Y;6(nh6(JAzY1`0!$HA?bEo4K$0!7T9YJH!j%Y=fD?M&fF{r|^c?7M%_*6WGpJ zaNUBU5z$jz)IS9EhXnVJeGsA!&;ERP41sOHXRrkIjRu+oQ?F_z=A5wgTbtNuK4fgF z;yPR5I*}e*h~d(T@8SXRX-f#E+9WZ*XNfOkw|S;7qnN3G+}`7;UB||=M~?-U8Bg+e ztMQon>s5a%l@2h&l&J&XlMil7IX2B&58iQ50sH`)R*FscA^WZyJgH zm-9EQLownH|I@PHi|gUE_+LKHe63+q7qgIj|2HsZ{?G6!{w7!*?N02C&nKlUrI=ZB zA&QkkN933-&UxOnb{q9O^?K*A1OCIY9JUf$omFqXJa(YmpUq2WRhP=0#dsnUO54Su zlNBd(A4+&Lmol2WvxV9^x9Q492cdBLQ1jgnmTrXaE5AW_zON*>vG^wslL^UHKFW$7 z3BTu_hQel-cqSX)>SWiq!157kS(v_x0}x_->O zBT*d?gHWu&etpb!BKG@@c=p0D3|7>V9(}OgfA(;L$v#d^<0wsZYG%{j!5f0 z^15=K-{F|z&t()TM>^Fb*lEmAXH`-UHL{FOkJvFoBU_~rUp;46F)lS@(mdV^^Q+=G zt7v38?a8%2SzA%t$?26-11DwVx&#Q$a-5HfF(C7w78zxH;TNkJ5EMGEeqiAZ5wCee zXw^IzkAd#2MvddFMbX8f7;&_BPt~N1YxDJkn)gxja4wzmXwhmDOvqIsM+*;0R(SJQ z(|6l9zeU0XmE=_siF+BLN%3D0p2-u-S!PtM$&MrIJYoBiPo*(ATH*tQsxNT}JL%}o zpB|m%4=JIMXcMun4|7^+5+qHce3sNb>}od`Q>2k*^jXWn7fvr|38zYvLUJY4gJY~i zin&q!T*BgqkGpkt-13Ie^dZ4=(Y>beFEtLaP^M-BO=pY`Usj z{naQhmsFk|;gqWG9jb2Cyj+LWy@R?bQBE_o`rJp7Vr`u8sVrbOrwAzNDH z{IZI#@jx#~ocpz$R(zh8vwcnp0W4&BQ|}-6vbmQ@pCex$k#q&hA`x0Y0F}BBde0G(SnRgZ%rSo2!XtH+MlY1<@exn z6bz6gQ=JMPoxsm0Pi#HqkbsezklwxomB3FqRteed5}Z*&Zo354?Mov~>HYbFS7xQs-#7C)>fiQEX^KoUw$1`#+i}=V8?vx>{ zs4h1J0R*teFi%0&@AoQ_jAsf>lql-+I{{0`Fc6bobx=N=kwe? z&*%1hKG0{9;fZ0zL@1Qj=0m!srhpKAz+4rdMVD?B7>O}p>AoC=9G544gq-#t+42tj z^fdB-45ik*O^}+z6O@sy&M)P(*Gf+k7PG(EL_F{qO>?4s=UU)Og%2BG*n6QX?WukUMR=i%YEjPz>D8V~CZY{m9^BT|v9B z+umSZk%=!z@?~BAG%T93{h+myy~fBPohw|`cOaAke&d)&a&ZTa^1ea>(GSckIc3NJ zgoxXL_#QWF1J!o@sdTnziyUjL?4PjZ4V|ev^P7k_ZSzhu}8yiAO&X z9GKtex(Kr;u#k~;4k)2R6|Dj#7GH$i5=dlLr=!HeNEb((9>5?W`4O8g{cY=QG=Nup z8cqG-Xf4Pag71T4WwuJT1Ky)vB+iyB>>pGe%|Z&{R@{V4i!2l4V?*KxG>L=Ib}5;_ ziTpr*ghS@1 zA`ZYzO9!Nmg4&OnI9~yQ>}6e%i)IDfmu(nqSK3icU&!&}&}o(Ut2dImu?2V9Mgux` zapo>S7Xz*C0T<;0gE`3)gY2^VKma$enE&KKh7jq(WHX@X%wckBG;7qRhk$BgZXZ*A7wqLnPa4kxph4(}G7me*hm+ z%{9r=rimGtGKAb){UHF;C?JH%nu#_kcAqFTF)4F%)1fcwn&3lGBiZKENZ>>!CT+|a z5RCvUn(KrLI0RYW1D^ZqG7Tp zriQ|->)<{)jgqZwX+Wyb-tgTxxF1(4rJb$9y{fghQBqbeO{NtC$sQ5m+HG$x1`a#a znA;f3*;CI1qB?JSyisZnO(kd&z0&%$|N%s6K6}f~`ILqt2vuwvr24kWZ4LgpZ@s5i)dS6lh z_<}w(6F4eINtZA(XNZw`LsDK*Cv!k`+XzR-ZU3fZ806RzWJyJu#!dS%GFryQf8lE_ zxjT#mnIa5Fk+yOjS33}Y(g?%I@vw;vBvss!f!R6?&0cAO`rBK@daJZ!F0iG%H#hQ> z{48;M1FJKmhq^sUnUdtR)PsZV1y$Z6sP{m3*UG)3ndZ?_k7oBkWV}7_?6)&r$AM)*H!-kxQx9ndjkz;%`#1Vf)&o&f|DgNW{Z}Ik#|j~ zdc)+J=-a?0!)0ko66Aa0Lv>qqJPvm}0j?p+Hr&){D1E(&3?7CxgA@#@h{h*D@79ZY zHx4_(88jwevq4RNPpH*(?X)-lTM3oYOH-izhl>oek~5{G@-A|;yO^VWkCy)pO1-kn z0{Jhv>Vr|M$B~O$P7NRfc?~v3&U9si@}5!$E}W;bi&s%th-5gXffzFD)lOV7TDl$| zrKcR&5M6pQlbu_3u}t3HcB9biGID9Tc6KnA)@ZkaJvSc8o@TdYbG{P4MW}>MYg`7f zxRS-XfQ;)&uFhty&e9!(*PCMyM{F=cK#*O)Va@Mx*+O8X>#v^1jM9Tps%6O@_s#6>gd&&&CFt$9ih$8@ zsv8GL{vil(|m=f`?9g2&ZiZw}-|$Apu5^G=BC%6i09Xm8p= zG+rp|El|OS^X9hmS?bf+u1f*yl7+yyP; zTDUjFY$-8Y1k6tSAU*p!kviYIxCQ_@F>zS&V)o9&gUOIJd`0vD)we=PF_8m_{T`4@ z0&-#o#iAF}CQ zf1Aq3+I9Lv(h@*_js(yj#)*UuhO~!tD1`jHQ~ge-`Uk*fY-^HS*q4(L+nOg@7jdm= zPrmw^SsDXw#Oo9()Df|>`aiJiF8eeGk~E;4U%Z;1w~APug ze-Y<%iS1(izab7mVwNP~(a#x-X2u{;(Vydpes&eA;z7cILpUICC$HB*@i$?@;R~78 z+kp$i`;c;;Az?%u$lNSM(ik)U07?P;SVYZ%0V3Of}O;Mvr zuK5cmNt|2O$`SCUbdZa*A9+I|lVl*!SH}g7*5%K^dVp_xt;_$8Z!TqiTqeRHC1HHV zy#K8R2H`@6H#VJh^&ar%)=DSP#oKu)c~rg?!SAv0+UPTn4lwkCibaGcqK7`}IkC@& zAB1zjZ2T&GN5_hlJ(GdPrXycR;gQDrpCfSx2ModbroK2eG=k3>O5~WI zXYes~4L{c5qwHVm;DrOh3A2$VejLV)1zc0O!O|ZNEVX*G(AJz9_ab`X76SnYy+H_Qjk_O2le25t?r-^RrMj|oU=;39R3J$&hN$WgH0&6npA6>G zSz_bbIBes6d0af#G?vhRf=wrfu4Biscu#9s%o-5df-p@9BRB_);e?B}lM3q`&tnUp zrE?N``Ux<>z+x& znTWntf5^fi)_s(4Tcd3-c+`sh(ZU}OPD+Onq?N&OJ1(fV-ti~M?f?*5jX{Hi_dHfP z|CQry^MV8fRfS6Rg63lI-K?2@2=25>{89C^XCOg&5?*>r3kY)b49(4o8tBwI^(ll* zll&qSy*yX*veIAI;x*bFQ>3qS41LT|V2?%e)%5L-ms5d&>=Bd)+~k{*=RUe{!h3Ih z4mYjGvkwK-Nte(wYVe;YcwL}0KdIqmhM&|~_y#{IIM$w?tA*BpJ|DYT+&x!^11b18 zU5onu&eoBKbW!A^G3ubF#X#Km4{ad6Jw0F`9$OeV5Nodw7>GOZTHhpjN5K?mBY+rR zGxqBJ_jOu~fzkKL<3!*8>I~}ph^0o~&&4;b?`OeFlovPr`#u7AAU)&tsPDSgm!45i z%}Bk4NYB{#2qc!}P$*!-BBqdkdPaw`O-=fz==-w2Ykfa-T0q|)FAePb3&_-=pqrK$ z+|2tO&MhqDkMe|rvETC5ll@@cp(iDwI5J!WP&KmuG}hlZ{q3d?3foK5x=jPb#fUtO z@JP-);6yg|yUs?dIHks&_w|L*F3(FUZoN3xQ+YC{R=Kn{??HTuTYjR`dFVsh7$N7GDh>n z-qMZD10;m1u;%l8PueVt7O_*h3ezTbGX#Z^nz5vHq_%T9*&OE0^c4q_dD@ z3)&hZCP<5V-b*$>o7&>C-=Be(C8xooC#GZwG8e)%GvRknjEYuH%7Z?5$4x`vJVg;J zA%@p*UdC?@uD+k^iU-4^`i?#DMyB5uJ^1c=Tl|162^wqkquKf#NXV%ObnIM1A1a)< z;DENPrF;896@bg0@a2U{ASD;BTQ^s3F1-;udvor^(J+^4*Fn^)F7ZWVLhxht#_PoP zeH4X!+t<1x4I4c2E!_GYCLgD}xFuI|Qsu6ap>!eMs(KdTeq2l2Fg)q=LUmpy?#@+i zej$&ED>F0aAZuldLa*d4$R+HksLzKoMQOl&IDEy^I*0O_qoOX~p)@({uUK<;*1sR; zv^P1dxpn;!3ZO~+gb_TqzJJTIEx@2tT|YLkcb;p-2Hog5<_+pMKgqaL$WG0D68lx$ z0J}U5H^2_vI3%hQ*BdtVcfl5e^Ak6s#5oDtjAK(hl)`E_EpeEhCVwUlRq#~UKxMGd z4M(KxCAOPZ>GZ2Nj!PVf>Gd`6@i0P!^#S@KM3}pp%HmU?6q5J_3P`^wZFq?wZClgP znh4~p#b~?gQ>Hk(GRJU?7unCW7;SYoFp1*1nQy(!Ta7g36*ShLgcBC0F#Pmqe+N!n zlCmEn7iYa|@=$F0TW#ko(0VX<;iu@y^1^p{vhU+D^qVhm^mRIvMxMOi;A1wT_>@(< zJ&$q6=>BJVH$jk=6u!bE{B^Jm@GvxG4GoA>UCpdI zoNG3*TDPeWzrc-HC4SoP;9j&=Jp%0EY2W$~{$k@zS&fZ%e^LO6oj9LkmM{;mypg=7 z{0ukGuuob1`oQ8zTJdrI#Zyq6v|Q%e@FYC@SB;kcB(UbYH*+cYf{1@!#4BVFL1a%6 z3_ew4KNz7J;g0GgIxAh#949M-5Zh>Ktz0v;T(<853k#A!bycBv$s8`6A~@q$z+<>o z>+(}k0yE7l3{j7`@~*TE!b#f!3fFY&^fwUSda8{UihE%l?c8i> zmTo*WpnU0&gs7#^IW8U28zE$ru|u$266{xBMk`sv8T;7)lnjM$8+@IFCcwnm z5bt*;gUK+6eQGtL0i#h&HSeYxK}-)qoijcQXUMx)6jgkKoVoR2%BGA(6A2kw6Hrju z62@}X9!V^c4L_ z+XbGDO-HWTDAMtMRX8OpXgR0NVB$Ve7W)`j94^ckWjdR|IIJUrf@@6FzZd2+7BQ-L z=)%RSPvWn7y`=H0M-uVl@$;GK56o9I!mGm}KvLDei8VG7kwh3pZu8)P#k}OEz%};k ztA|7(zPXm@)sLE8F3JslVk~J(7x!7t6m@`pGf`ZUSY`a(MpTy~q?aGi|IFhN7N4S4 zt`;~Z{6)j@oIo63M=}3>@X@S*gYY>4MNWxP$7x_*dQ=1R?x29K-W>$yj{qYn?sCNy zqgu3@yY-rn2G*P!RCBhd8T+t3G)-b;{LxnRpQ{+`6!xM&h!}tQdc$df4Zn@?^6&Yl zGl}vJwNk4UtJnH=U_eJ73#zqNtK~}Dq2_B9|Me?vg#Hy+@ur}PWvHmmJsq)Gyobx< z7jpr8Np;I&9x4a|Wp=voEwXFQI~Vx#3ag~Y06p?=o-fmKOwO00>mb67Yx#u;M0gHd znPqz?0}kGfKnr!wnma0?3vgE7!DImVGZ&W+omnFGe`zAVh-3h94m}$H@MTOG{1oW` zT#DdkU0ON-cg;%-Iq1^T0l2hu0PdPQm=2)z$pK_dZUHHRS>Tr5q+mYAN`|W;7%PpW z2~tE(P-nuxZlPoy`Mg|EIh>FwV7#j6aP3lddwH)zE&aT_kF2PS2|bsoPJRJ32a3|j zo(ltd4#JxZq}6L2wDu}AL z`5c5tKxNvY=sTDvmaZXhC6eML`wiUB};Qj@;ITOO2h}xZm8dg0-NT; zQ$=f;2f&0RgH6WCPX3&4Qt&Y~8Fkp$!0Lfftxt*Z!SF(Xl|u>r8|WThBA?iLm|BR6 znXylQ2*SOWDg?9-cFOSr1r22*I7X+k1>W2IiU0}-TGF7CW%!7C@`vVF*B)@#w|K4` zO8gKQzEDod%d_Tg&htzdD!PHNZ*dO$E{y@P<~A6L3B-ZJaC7cN38lelCs}`1JOT6R zSO@thiqYbhZN?Y&&69%CER(AJy)Rw+yFNqzJsN-23$P)?0DIz35hsVn`Ur417yy9% zT=&G|k3W8JzbF2u;#;1w<=}qD&Q?$Sg=`OFx$_g^rM>LGCG!9+=5Q3-`3adSy`wCV z*MAGmb$VZn9{6FqUdPsBitVy%p;#u9O6KmFe_t5QmHi9cvs`@P#nD)VGod-O{ej^l z-Bq8J(xo@Gz3np40cOU)jE+r1#PDp(p z(+m|)yvU!cC8cQxs-B%LSiV?_g9{utc~D2A)Ae=0L`jR_a}8f)*G|!N+`y z4NdnZA=Vw4j)XZgUu$Zce%d8$<*mXaEJD!}Xa4#QOriD8jrasIc~o}I+$b^;9J=6; z_0E6bxtKD?I*k0|VzauHSFCGs{fASiu-3I%ofxFyz$q72h{EErlq+#LN=ysub(W56 zx_4$1@3XzQ|3a9}ijnf8ZN}c5N^X->sO=gNhN2Grb*8e@>FRF}9_bW=-?{_6MtYD< zTG#!<40oYXmzf)?4QL5!ABFUF}A9vq02#j_`7bF>Z!%V3V6W@Oee^cS>F}+-yAUC{$Cim>uvi z40~e5Qg&RQl0>Ck{7SsHk|jto$-DW@)eg)hB4*y2_$(n|=*UE_2D#?^YROr!NANsO z=`CgtQ`Xi{AC0hC`SmD|)D!*;9R?OFpciyI=vT0@LJs;&uhuaE2ltl zDmEAzn%`J&nSn%BI@1gR2!W+^j@gZu5E(g1kaYy3?d7cn4^3@sB8y|<_-!dZrk1Fu zjMI4OHt2rcHR3!2v#|!pnpyxpNO0DFWw0P})^|NDxYjow(3q*4`vq`e$v+R|-7=<7 zxo{J-O>k4*k7ee^2!Hc4mL2RK87X&N&Q%NU+W1?E-|Fc_0o?T;0o0+mqttUB5_mrK zI}OiGeFN}ZEZX)-nbnsEaM#l{C^7232L+U$=}?vhLKzhVB^OYz7p#?ZcXD|iX0i&Y z;?^YVLTIE;fy|o?IO^CyAfKTF{_O65E(<_qyLdhLybOO0)$?hZqBUVL0P0HSCe(wH z`RE1yTB@GJ4L6iirG3_k5KjFxPVBSmpr2}1&qV?jzsb7@XhBvkU`LhR>gsU_GUQ1} zoUM)a^tgc0?ibX>VS!z2yN1m6HZ}A27;K?5I&CPFMvc=UmDN1966+8=?JE3%IqtD? z2H@CuM>YOLxBe2%gD)%@X*Sr~ute1zeF88kM^hN=wzGijlYIYF;QJ!+-b4OX8&(7h zpH~ntA>%}m!S|2wpODny`h>g;pju7fRf?3)2@kQERKURG{0xVz2}@CjwtqW$LH0mE?1)q!iS z=F)&J&cJI<$e&gk6S86mCM2_vf>`W>KjDV$c|>xk_I~vyPj*Hv`s+Q=^TvU|oi+>4 zsCrrK!nP&9qT25j;$iyz+G2_i#C`p&K-^!MtO=E|TCI=n(`vmQ8_?rBgK9k>YB|wO zZ*sd7k7)Kjj2CqV_XPr&5CmWv0H_X|znEB&&VdoBBDxh552?;1^uu3F+zl_2Flxx` zX-pt^pyZe3y&3VX%i=kFbb6jXhn{7qKZk3RsFeIC4nJ%h*n7JKbUJb?Q^>2RzDj|i}s zSw~42d_H2jfZZZAApIN41(H%DWC6Sq+`rEF@A(H9|HlhG)tDF*b++?l2R{m}H_mJk ze_hWJ)ULq!S0G3Q+I_XG0H&KP0qeMtbCl{~&u;~!#AgXnoxZ1&8N#T&8;>(eXz%Lq zf{JQkT}Li39SG}cuXJrR(^N8F9+i+BI9%Dqtzkz3M5kX`W;aL zNc=6R{`07>KHA@(IDK@UPMi?(t_uT6ISnL_4+J_0$7d+8E`BvEW%}b~1EchfVwf?w zA6Ii<9k$J)7&E&A?#-RJD5CqTz1O*RR1;T37t%qt4DeW%hT% z;^I;s=J_w<%2yWcxOC3?8NRr(A1*%=^bL-)Ype04%?Sdxnu`0HS!+Px)))lt_9_y% zXZHcL%f7Y_B}$T9HKMYlOo)SajMXJ&VO(1;C}gU@yhQ`P!3&jGU+92r3aY67`zr83 z9k97=Qg$FnC3H4`3ESIHgql!xAS!-+Yg|RcP=|5|mn|#mhdS&#t+|KmKZgEfGwp93 zN^ksd+UuRx+~z!GLT^X^LkQY485h3xCokIpV4ZURW+yypCb^aS8R%KJ2l?A~dDMFb zZHA-p<~Ys9yQOTPZr_zXlahiAyp6a9?U}AxpPS}2@=oY2+qbx^dGK{WK3-6*`u!G3 zC`zDG87`%5<>dt=2&g{{Z)x5w_^D)Jrh?lp0any6)-viW?l^d2TyA7ca49i$6n@}9 zO-$-2%H#GKFoCmjOB)#9ov3~L7RW>aSinPCB?^GEMYh+0ugE(G%#l?%W*N@E33;z# z9W9uCn!1aB3-{CerlJVsgT{;JTJZ2z+fTmUiN8y1V+Lw}q1)nG1NDPb(}KblOc}B* z+$D0O!togv@g%<2B({1<8EEK0gujsJG-WwhJ$4vx-V=-WgBkE>T2Ocp@j*0+Yr0zy zyIm0P5OI+N5${0=-NK!6xFMr>$}!r!yEAo^ z7PUtA157R6M>2P7OQQoB`0DtXzlNVvR`K(yT7F(z&d(?2V@>eO(?$B17Yp#k2x2o+ zWaaa^(<8h{*!(U@zznX4bvUz{BF*mt2lLg1XbykZ&>Ind*Ja@^R@^`DH(U>C4u#L5 zaPY>9=g-odMR-EP=PqGAR~r28%DBS5njXu)zQixJVH3anoeF!L{+@(I)4&=0>2-w3 zRAR3JbUlu0`SaAhF!9TQSR{TKkqoxSbAJX%61bRJ*LoxOi(GRP__o>25CK5m%J8>r z9pKhD`5(4VXUmJIO6s@Ar7THuW#=YaE7L*9+)6GKfQWgrLtNI!9Vu8ZDiDEqSzR3~ z!1V+a=QFo52^SX-bd15r%ma@d;*NKDMk5C9m)6P_Oo40J#&)!da7QZx?%RQ#06R0E z%dxR!zq ziik2yD$;`3Gq_Adn&h8T42Y%2t>CJ!{qH7-z;xm!v~x}!DfmZYKL!kLLZDg zi5>8XD8h|`(qx=uIEaNQ$-PQ_`V6pY?s7U0m7UJ@ii^bzQ2jH0WH3tgmAL2AuGZ~P_C$*&q7e&ix9d{gN0Si>CDa7|eV3RmMIp1?CzsZS0A8ytlo zqL8hIqF0jgym~2?fc51EdV?5An>K=|ciOLpk^H>#b|Y-<0xQzvk-vo95IM7f7DF zYjLtD(Vl|Ns=7H2Yu+1kYNixm1TRI`ATZ{zhiP#<783GK4e6BV&C{m65tk%ISH64p zzuT417KyIx#~-z*kLb!Rr-h8-!DX55Z+Y7_BQknfLK{ zD`43s!6$1WTt5qc9zpDiacL)X2RX9EIB&~Ebk@f({(5{V+#PV)>q`dXxJJ`Bfzd`C zPGdZ88$tpL^HYn4`cr>qWNM(T-677<oe=6LQe~o8OaJAsV;Pj?Pbd4AH zt8ug2Kb|X1-}7oeidK*fcD^75Yn zWi!WuKGse664HrqRd@drRqsL#-%w}>+};x?r^9O2Dj5jm^`vSsCZshX0D)Z5jiZ>T zZn{CWY8H4s&P4ubE(J_wD?O401p4-cKroBX>ksGNs|+~HQ9W=}N^S}PXVv+~Ff;RS z=!V)x0h^LhAyvaoNqvfrfj|rSVdi2jKpIn#4&}G_3i$@oL)%ciiHpbfeol&~FBN0h z!GT6`Are7Vc><~+P>P-+z8P|O?EX4xHm=5v@7NK8u+wTNwcFMRade4oHG`ugMHAU< zNDuSH2u^?_BqaM;RArWaNRO%vI-_JDL(DmQH&H=y^SB27z124OhWZPmeeu2Ap7k^- zHFc!!fD7gJo!qvu&kf`TUn4jyM71=3A(4kZV3fwxz0W`pJ6lsv(X0>!N?K~HPPOB7I`$_iR zrLm5+(Fh7R>Ofv~2?Ik-06LIda7&xiJqu&6PF_L9DJ^6ZZJ=u~k4;P}?JIl6y@G2i zZSk_Q7H1WrCE#tpl;W8hl&XRSV@VreoFdWjuD8)vebh zMZvo(1EZhp5@Gr6L?s0&bX+wa&Hh;>?4Lr8s?toLRl)?SJ)sMlV`CLf_L#M4&|Xc0 zdhoDCsyH0I@El# zqGfAdhaoa?ez%Xpotw?-#}mcCje}KVWE6)E0%ujvhc5PIThGSejJHC@V8wQ03`V`_ z8-qCje9U8TODQL4GDLUiHQ`}`dycnGhqAGF`d8{r^G}L$X~K_wAEk@p!Juk?5keX|qH7|)A4LU{)WCfI(zMfGJI2!P&`_v*{-*GHS{0GZoi4|D` zhBwEVC6-u8m=#u!0SsDUBVI8^clR6G=#B^6IKb6MH!tf2>eNcpL&As4*)OQ*U`d?g z;GR>UqVLU((X5_Yg4<$~Q`K*l97c#rL!fU~OESc+`1^n!p*$cIZj%7qf=RYtdH5Z^R#Wp(@83YvJNNV=aurH!UvwT?y!eH;+zoU*F{-W8I|#Blted zMnQkyhseXj=Vjp>vsU))$0ek(kK`N~d`|F*f5W7TFUiIiMn)8z<3g07Zb@SfrrAn! zkOaV5c?}*LhdgpdbRh6(U5P1w;PzBe8>{wFqN7?<361s7=yCl!|BU)veF4~H3urs> zI0TzOmcu|}{&awOgkXrq%E&7o{1qzBHE;j2$iZZs2QX(E?K5&!gowZKQ}&-r%6~S- zX#L0I?!YKb>Y(?*e*T3Z*mqt~38@sy|AXaJPl<_+YP&h0;Y`3NnHfQSoZTDLPj-Vf z9KkB*hg9iX8_Z8`QYV!k=|uRL3~cTRLTpB&WGKzJD3lP0uYT4du-Rq!c{64)N*fMFWt%d zeHgMMW&hrcSbp)#AyHWf!dY^wo@LI3EOXhvNlpgE?Tgq5srUlcX5Hgf%Eu*BrR>7E zMX}k1WhIl4Jrad^W-l2s02Bc_#W4lIq-ItI1YLuta*mb^mTGE-T2y&*RQAJUs7hSO z689L{skWbjdLqCxh8|prKLxJCWXThlG65Qolg4!v&{N_EUpJ`>-U1ai#5sZWYJ=; zjEj6)U&Pb}vRUVEG^TY&i*H&j0;XWEdpfO2IH$?2UEs)ih&NONd;kZitz(4`;909Q zA3&(Makh-k@+q%5t9j>(@tK9&v&bw37WR0?=b}E5kIx?{yEEpPSHwrZAY!<^0lbe6QlFb2i1$Un+b4JR9Wyv8 zSGnToATJ}9i}(b7_v#~J#TKjeM~p@B)Wyc4_$$6?teAzp@v>s~bq@5|mUI!|k#htq zw%6iI94!)|B7Jn8RfhA)=G!i*l~zW=nknU!dpnyQHR6jy%OJghyMAOvNA%M4$iQ?~ z6AXfd;&?2<6#K?jERE#0(71O$3&^mEQ5ynjE@G0IFk{`W3v_atb|pw}=Pn z5kearG@h|(4jS~1IJUGx&{(A2C|ow4He5Ddq|1iksevGqvo@$tUUwMjh8QMZkM{>1 z6qGK3`DK`zCz)Y4kzI&s8_2N#4J;cC;j@wv4Xumdn`04|^kc*&{a8vnEbaV4vK*G` zzX%tXbZj{bYjH{K9SBO=fy8Jf&;@;M#4Ccv2-%7(+Thx>!QHNY^zFBLwxSHl{vNXx zx#7dKoynS}+@%NFgx(lhOYZU<#yix4j~Z!pybdeqsYGRbvf6L~OyQovM@GV}L_GLe z3KvA+_yoo$&HT`fj3jUFsgG zz74(*d*CN=HPl$pgVQx)k1_!(cPri@56{)975mRms*+96e!KEqWgqoVQg{a9XHBh1T#e05*7R{Qt?bkUXV^z-`D?$ z=E?7uipPP)H#$nAwwM}<;VzQyT97hMbg^2S!CnGN_Wmw7ChJC+t z1AikPqy62I0YZlXJLh(F(3)sa+zCjBbCIKZEJ8UW1&aM$hxNWjM@3^VXU+8(0XS6f zUK^&ZP`lez!N|U$@lml}jd-0?z42l_Po`u5VK^AI08tzd_bk9fX2Kh(st%|kG-V!C zi?WpVWggUZqow+zF^DeI^HDe)T^;vhR3sc{}bcur)zw)KbJ z(Sl!z@f#*7F~~86fG?tmNX62d<>EK+ear@&KZ$tTEgXc%uz{!901_u4B@sy8hIX`; zk25N9yp8biev*Qx@I6e~rk; zA5Gixq4G)`pRBbHXn7mJy~`;rf$g_w?F%$fLTevo#wSnKz#^7v--V~K6kdmb6@>(* z+KBh!h@ZjI7(;ye^$Z>4xT8}Xd~}R}hv|U%$2;~Yi5~d@6s61oYE1zzzsYTzqqTql zCfW+XYtFm31q=+{!L!j=04H%WkTpPuQjf{kKn&C;V2~LIXXP$yRfAaGaB0fNWU)Ex zoiqod{6Gf$h9VyeZJS%^N5UZ~m$l0XMO#tdF5CMpYIoZkOHV;WAy`(6&qh8Dkk~pK ze&gjrwJotW=nZCmrZ4&x$HLpMlts$;-yb^jWC7@U^zVz|VNhCtr(qUI?Rj3>2up z1_bNcs5-R|=tc%Fap%Fuh28JZ4@TrixM7bQ=GA$)ZC|k;@kHj)fo|&UASx@teTWA| zFrJnRhyr(5I5I^`q637{&#nAhJxxQ`>Or1p$Sg21yObl)*dn>Qq|93BQoa(I6KFGq z+G}&^U>T8st3E6}!?m;31*ct%RZiO}BKOIMrTx55`bw~X1~|si5ZSE)iF52@-gzkZ{vGq?m}(U%TEq|>$2>G zqf2$nK)lTGy=3MZKt|+sQ5BmY9|oR4z%EORw`zg!rAgHy-&!3wtV8MILiLh8jewI8-rHhD_C-oah{6tsME%y&O06)3#>TQcO&QBTb$q`F>$os z=V)Wfxb|pXoX$S`9PBBbO%torN5em@UBkxu00y=R1AA8HF1$e;q)Gb%-*8azW&qx_ z_`lHx)LESlMa(2%r;Qnt^)!jm)S;~jtizGi>#Pb}r`B5s{>mJ}iU#D_Y0~N;gt^{S zqilKKCGr%VErt-|z*IY842QGp=r0qIbRwxx4Eo&1g=_4fNDnliBFFAMZU14|=DO|w zW~Q0>xJ&J}=5BLYw#$|c^ijZ8!Kk|JpO#*Yxv^Hhg^`t+N?@luts`iBk>4dI%Z)2E z!YxDD4j+0f-WJ-Br@|wVqfG)LH-@Fty=E@PyxLRU#x2r!K9!f?s3Dn z97zn*m@q~p$Pig~HersV7hXnLH;46$>U6y*Wx^U;#Wz9Q+oJUn~NO881Pnqvd z+h2+sQrD%-1tIX#sZ5Pdy`OLZy#6a7cGeYdAl(k=MK#v=8qnLNNDBzya{;U5V(`i< zC5xOgU-(NPzfRuyotSM#?{jq`R1ip-Z`3rxgzyJ%AhtUQP02WjL*-Z>#(qIZ^9DiC z*~W?%-y{G;Uk(HTAa2+O8>tkIqS9KX11Ll-5vbiZ9z+>TM*ZhJ4e;Ma+P~GUG|FjP z-JTn5?zATVygC-yzTLWF8aO;8ma(pI;|sGeyho|Yj_W1#I$>yzDG&!Us z0DcVtn;K;0B=`}!l{hz8n*y|o(4>cM+a@cRJe+Sh4w1Tss6$=7p=1#Ju#r?_5)RIt zqE39uB830nf{Dd74)EAt0(V?ZIEn-|1?2vaz=lbMm;>@|(Os-%WN^l-%mXgZRJ_=Y zyHCVf`HzgP6@<`r{s;xF_h9^7_9k=uM7v>-1TXG~<%2xx&GSS~9N&Uh$X>!6J6nM{o*_-T zxPw#iKJwx;Fs@BNk{y=F>o4Y-fo8$?^(Ss3&kjPcYMGq8d3Khtcs}q9NVLO;F=PhF z?BX+CFb0B!x8-Mu=i)P-B0w(3#0CzV&%u2+G3So<2%Txv#!_ICmm+$@Tw3~$83~DH zQy%Ds?4l#=Rxl*V>L*_@2@lNn?+Dq1C!q2TkcEtP##b{*eH3h0|@Q&&_c%uQ%?XS8j zzC$LUd05;6BH^$alXE#&p=aD*2)+>l{}YeyZa!Xf_bfVb9_N>aD;-YMY$oIKg^r4==ygL>|u5<>68O@^FEf zJiHB_PA5hlF793)E{;SVHir`=4;P0OT!ZD|;-1LE;lT#U!$v_8m9FJsqy32F;o=_2 z!^M%y!^IKF!&<3hmWPW?g;{@jxVSrc*c?O{d3brKJdCR=x;)Hdy#ZSb@^Ie;e)4bw z%fSU*S}K1uS-u(ckE>rx(e zmP<;Ou5Uv&7@JQXrkV;$a5H&0hg_nh{>u_Z9xe`%hl_*cVZmog>JmT*l!p&PRwZ3E zk%tQnd3Z7O-?}`!uTG#sN=A9L$SVdzWWOQ>DQ^Bv+S^Y})KIm0YK1IZRxU(g+^+J< z!a{yWBEhc2;khB=@Z2^b4$lSk*2Q6}HgT1W=R+6r@V#Bi!}{AW^00UtRvx|=oOf7x zSg#sJ9uBEmWXNie;O`A958rDh4`XQCM(e`dNPT^Uk%xg4rq3r2W6=o-gW_KY1nieF zwnD&x!DM{(pm?fTsBp7eT@|~LbcPRcH!pXe*~1pIhjnHT*O)zAW%jVv_mHBk7X!GZ zd$FoG49xR!iX-h)+u4Y*U2=9UrCF^oq*=ehE_=&@54^H0^1=yOc5#R-JD;*FMBPtI zFB8({D`H^0vTW2b$**PQtyO>{04~Ls2*uX|N||sf$uL{rN=~z{ZN|I+uJL2`%LTNJHr=N$-m-^NWX=j@e1wcy( z&9f=PdWQ?`3-!XQYT~&h(qN7C~t_0>WAlu!W8@Z;J>g9 zqM#M9^n$Ny1z*$(nnHEMm<59s(eq4c*UBqe`6K`xuj`F$!~-P(Kfhh}jE4|_DlX5J z`?M;BS`{HvPlUqBmfwz|qITk?`^*|Sx0^;-C)q&ErnT}_is-RGj2J=3MI{Y`Armnh z5Yzes#9Fi}FKbma#9D|L`v8kIs$JS*)`+M3Mzr4ZrZ{I%y-KTrTj4gUm-Vir8Q+{i zTdbA6z*m-fN$;!)sP|0v_rLEjbS0mPHRCp$Ig0O`u)6Wm-X&BRMjcY7FqebxcOUC zx?0MHX~$aiB6uxXIU+(8iC2)XHT)^>-~}^y`(gj&RKsf-&f*^4P!ppedXXB^3o3Xy z7~am`6ux>wt5X|^1 za=|5llkf|@ecv5B??j48_`k4K6GoV#&itO{_)i1=##|_+tNqpwmOWx#9ko_m4-(F` zX{8WTgl~zUtBLS1(pDrEqpa+kQ|nuACQGezivLpcP1NnU5YyFi+hkrZVWM8I`x&~M z_pf<=Q$6WjPr-}n8uNC>y*IvV{LVA4m+)7;UibLjCGLkSM_N}1z4h!>9AH74oGOMH zQ3~hSS}z`>z%2Xch@X&B6aDXUFB6V;p-w0nx(g#ojK_om?q#_7X3Hs3t>x3W_ zIqFT9ABMEOULzm~x^o?9gorCPdaL2@F#)GW>1sNBYQvT2vLEF7JZ*EXHY(V73LNNa zocq8AfE;ZjQtCiJ)`kngP^(w;4$D3%?M+=C)Yj+FAbPP-tk2o2^fk&LKyvo% z)z&Jp=a8lcO?JQsBubsx{w@7YtezEQIj~eSINKn6U)VSpIp9DLsRxdvH2V<&M8DPV zKU}6G%saAzk_c>1d*6X>A_xzn`Utv)SP2?P5>%t|Ip&oU{-Rely2{Gvt00O&oxE!_ ziO6f90baB-#Ds7}Ige^x0mBvC1ne03ZM04=z7-OlVV{wdiO_elv+N_A_0HE&9T#K1 z=%@p$c7~WS{8ftpKg^W9lcNoSuOC@r&UAVb+!bxU1Z_vKpj8}nL}TJCArKa3Y3=9V z`gE9u^ywLJlD4*yeOjEeiM=y7OPidl1x@7It8q6&g?SAVgcnH_`{2`qHQ;&ZJ&sq6 zv)WbhK^@BPVfjorh~Q?oXt8G2I?mQyHj9m7RqbdxE6M6vi7VeQGXYGT6PJ8y%2ZkD zq^*y4!Wpy*z5`%raavWa0!-uqfKzknNleZNv$M98z~8hD5Y7_x@5w+hn02Xs`$KQm zC~J0Uhc`U1ee(l9N3KX1?l-|dxjF^}75iAZ8vk*#9ojHn&S5Yy?WCg<16nIm8zy^a z2cfYv;(0E%VeU^cHNzRtjLRD_9;Zl=}$<1Ec*hw!fvoTn79eard^3MknzNLXO3N| z9v4bkLc6j>Ht165cc{#wn-np z!j%}#Xiy(c$b1x;_C_hqh*N!MHbaig|LU(Pk}i|Ks0JXg;Tpj#p93inXC&tWGu z?Z%lpA}&wNc7s48R>qh|vN@nKa!30Zh|n$affRn5Un3v{Oo^QKrI0VcN-uE)HdnBp3&M6oUjh8G3~&cs%G~ntq+U6hnd+VoNUxKnS^_E2myUK6ev&l>kA>-cy4V+ zUntR%2x@dHv_CqD>SH=5l@9Yo6{BO*^`e?!)Hdl)!${Lz5td(qqe~Soef)8w+wzTe zF0aG6jB{z72oJ|_vL_eZ-V=sCqh{7>>NMbG z`?jWi(e)teMek@zvK0fqpmM;C;hen+*O^LwiZ9i&W%eGgd{6(5Gdtl;&-)2d=Vq#B z@IT%=NLF5hdXoTTNU|da9WcE269x$044CiI z^?UT|K!Ur)wh8St;ox<sx8x(bS{Re7Zf;Y`ml3RyJW5VaOUVUUBp# zW+`Z|H(OU+WB~(*;H4`@;0t{{Hp0|G0~%Z_KC)I;V6(YAywqywaa?vJvzW)nFd0y@ zqOTv`O@OJVK=?bqi)-lW5?r362J2K5Mz4Bf>VOpQGi-!^9G*bYh>PxRG_AqC1dhrZ zuqXvzh_qBtz6vH6yBRuLRp%1D+s(OJW51#_=K7_v+TMkT0b7kul@XrhlAmDj`iJ9N zL!PGy`Znae66#Ip$X2Vj>(xO-)L=c&k#vIa$r#Qxa@wIewBJy^@FU2d(SUP~;GPj# zN>aG|(P6NQd$eGpa2W@i&FG1^Q348wTN#BIb&ZRqDi0o=Vn{j0RZj?ocNwgW(=Y;J zLf)`eevL>!F3$r0`8a5;e1}irEZXIKe1bxp50NpI)(i0UzBy?OnUHs_l?^?ckUZSj z*L3SeYP#KgMxIQIXhuG}SSQ9}M&e<<@=zB~HF@kW1PDoSpfwjp%#9i8u&%XXKH{^| zcG93$hrK7}+SeGV4) zW_(H)cTzUu9!29LFt47e?NoeEj6V}&FRD&%=hF%8m=@$xI8+XZxBZgE^Ul;Q*TMu1 zlRE3k#=~Ueeu@t=jN4w&+8ve2`vmNLfUVt8ncTwU2;zzi8&90jBAOLEYv|x?c}hqKC$L;;*mbc`^p{3thqDVdRMd&OCe- zK=i~smbM@r9qG~Am}zQnDqkfz5(hR*z#?g_tm8W^8n2)ITC+!AjrqP_pYNmkP;iP& z=KHEK-qG0Rcf^i)>zts`2%Ya_v#PLnt`b%KMnaqGa!gaW`QC?D;pQ6`nl?$EtFVl* zd@;2cEKE1JJoGU9ELV&+@0TUGU!k)snN>xe|_xN26B{rpzaGTGmKEG;b`Dt7mO60?05v43^2f6j*hUi~LH*G{=>QDU%^7 zh#MUxd7jqH-cp>Vyu~ih17(0GIbVtAA%c=*CH^ZD6`l@Ged(8ti` zO1R`1BfMc)i@Xi0ZdWr{C$I>_$h0HYwf(^|+0&YNL~o$ai^#cHg%AR`ugwKM7c#6= z(U`#=UE}Qw`y}GsbnlNh<|oJIk5_#bm)wc*$8+?=A8(LWn5SkR{5MX`P=CC(9{S_y z{(C*~$E)tKKi;%s@W(sLuMQc92>kKBND+={J@Cg{uhrRvR=qG65-a$5frk3yJ=_K4F8uMX7uEht z{&;&wc&UolAMffjG)ik|-N0;Ul;}FmAMdfyItjz|I))ksb;9}MRi8M2yi*NKLN#UM zR-PW*3kuilh}R$QouBBP53QasU9TR{Asjb>;wk+LYmVI?Z>Ej_#N%Lpyf;q^MqfKb z1P6lS;LNa96CT#92BIF;AFt*I^2fV5-G8ZhnbUD!oNC%rulwgk=JgVu)9VFx(`<&S zBl5@Fk!FtHrQP87fO)-yAra$O6Nx|GoD=Vl_s;NR_s7dVMVqw=Hkj)|{P8LPIgE2x zlwQ$0ZQc3fRY&fRx2^eD{qc64uOsYLR%!ltmk&cXyYt7p&%AQNV7;=@)h_(;YP$8u z%RnQ?;g44{RO^T_Um^Z@EvaFr%&ph;^`k3)yqfO(@y^{8?2mWJ59N>d#74~@ulf7* z$E$}Pi#`rM`@PSe;`4XtnLpmB^Sra;_3ENO-am(6T93~k?~QYfrH{1{4Cg=HTOmj7W7IY|)hl!ezLl)GuyxxXgzG#5M!+8W;w?QV zbk^vL_ub$~I&z6o+oU5e=nzhLM>0%jN({Pj*qeW* zHpo=*_^bNb6WOKi9QH=(wV`1QA=3X45PX_3uo*(Vo5TH+dvVN2gHpG9DfPh?dhH>s zb^RA-K-W$`HO)I<2EFze?bq-ONQ8!rx9G9@>8<8Fzchb6;ZN@G5)k52?llS0t^CGh z^L^K5>tbI0Ampg$>kz`Y1N=z`6g0hI=m<^0m{UxrKmq=G=JXb) zx#$7gnve6`g=5`q`KTvOd%rr}yhmRSh@?lEMs1TGJ*7hk?onPB=Lct;Lxv+A-4Wf2 z)Man=Y33bCji@6x7`070@=<~|6hR#cvv$R*?Y0kfB(GQ*gbDsk-0sLxKRngE57+4! z_>Mob<@K0R+oTU?eGh$DW7>yg1B;*|VpV)33+nw-^bs)W!__*3pn0HQ)N#$lD${-x z8khw2V^9A``Z3I?ZPJhXbqGQI=&}#j)Y8>WqbAy3_w9==UHE=8%)6v~&LX&1ny4dT zC=)4nf{NtmZHNV#p-wSsn{;DGKa*_%7d~TuXB)?xpCBUk_pR;hi||oHS44x@?7seV z>B3h()Y~7gz(v;Gp<~na7O605oAjr%uStL4v1atgM6k+J+FkXZgXHQye2*GFeDOG) zjgxvXZCP*|7e0L2`E&gKdoLuJ55vWJCrpRI@4(Jb7wZth9N1sRnU6*}&(CoCO*>b` zv8}oA(ZBvUUHBy7!uKp%HC*^|M7*XS+JCRt|C;~aqGxsgy?2pzg&saG#OZBB-&3sK4IZH6=^v$S z@GkuK3XG~I-fi1DM+W*nb?LuX^L_g7{cV7G56>4U`qWs?P|vPk8dXht_{q_r9(Lis zSN*@^zxRg(?`Q=0@0}vL<2M@R6nZlJ{WXiss>080-+zKeqFevHntfneL0nAzHIL1I zZ$rF!zs3vX{Q4C-%hhI8(XY7ReuekntM0M?-nEbXp#FQ0_Q&ve{r5(EH!=eMz4@$T z>c3~XIL1yHc0-UcZ6-6L89sazc0zpk^n7&@$VX^c$KiUd-Djrij_+i4` zThD8jlPqOBl5gueBD`LxyO{7@!Sag=uNR9bF1%hg(#Y@c6V#5bwL1rL) zbof9lx{VJnCA+d+$+txuAwE}|gUDjU>%hB>60Za8Y2LJX-n?mgr@M?4ub1g6R=hqX zreH+0_$IOVK@*uhO#^7XThDqDm_Kb&GVW6aIP+Ji}0=30JKPM_6Ui@Ol)`xu& zFiO*~q@4Ef;qK~dy=uN{ms5fVq<_g-t>6_{Dg_u8a-Q4n^a+0~5d4+qAR zKLB5Pn1agNF4DuvXB+mf(0KA12qNc;C@*5NhGbYfh^-0~f>NsK_5T=-m1P7Yg&j99QSSM`Y@hf8s6C>0A4GYCDGX3wx;Tb-^nw0D&LsWz_&l{mWkp7C( z5Ok#;*^9FM}t7U5_k+eF>0my#mPT8Q5+ip8x;I!1f4KV?%{%3>nxSfo@D> zgX=~1DB=ukfDtp4dND2Ca6G>=0Wd!E#l6IhKg_6M{0b`S_MV&` zTd+J{W-3S0TZ;2NPBvUlFl9zO+kuyew26FYAFkzBE)GFZ<%e%HvDBlgGci zFPuDH79x+AnaktP1H=y|kINdqR?q*UJpNEO^0@v!tUNB>cOj2I)U`aWR}aYSW{81n zH#)2#)dS`6hfK1&8Py*;Zh0KY9hW@*U>EYZ{?1e$7w^K!;}3?H$Mt&V@_0x+pFI8` zM$s(cxiOLt9-}<|;E(cnV$AoM@BFLUALa35lgGYE=xRDQClgG=BOCDd^r9A$xU`Nb)x0*vJ)VWFFkH~{PK^E zOCFbx)jl3WeWoJp<4R6ywj*_6SJJp%q-$BcD>z!_-iO$~ z@6hD!^9@6{u&$x%!oYm#d=iu|eUxTFp9Bbj;&$HmXa0VtN;iMM9?txILJZym41;$_ zzI2B&ksC;uyYCMbuT5V2OV=T<1B7e8w+`$5A+ojKYpZBFz|`&c)}(Tg-)mG3HgtR6 z-XADeA2saUBXk38MzDQbuStY_;`CldunaM8(?>Jdylqr}AXJ(TdgU)n2fPZDrS(@1 z>jNR8bWkmSNjiM3T3;J-uBx6ezb3=WNLKkPs@Dr^cz3gw_WyEt(9Hdx1Bgxon&r~L!Q=P$SJ9d zzJGbzi|=vB(|-8=C{Kf|{Qp6oZjRW#JwngWZf@W9uD@fFr?uMosf)Ulr{@*_@bYx^ z*(Xe%9!F3oN}hItnRilvJPvu9qn?+2Y3icmmZy8YVIoiGNoil^Azt_>ss3n;)4H~U z89@tV<$Z*kuSRZm+~7rw;iE~`6{nssdAhiJdAc|fdD_{GI_eVNAh%W59I0Mh~#OlR1YlKf%0^*sW7bBvGwWbPM$Ug5k{U~ z9x6}o*5&C*kf$5qzy^8RmAb%Bo^B|HKe=RMx(a0d;M-y$PX|7tJl#vSHxvi@llSw= z)05i0z=b>=R6R(ZK1uS-u(giuTAp^6L!8#+_JJ<>^AHVn0&#&O=;xkMnjAm6Z~5_X<=fkBK|DLgc3&050!W zq>Oee|Hh%7*iZcp8WO3T*9cj`C7l&AH|ex_=#WJgPN zNaX-|`rh#J^u1>CG={isoGwsbthr-(<+X6~H4qGtuQ8i4?$^zwJjsm6n}i4`BW_z~ z!}#h!@l@wffoH!o)m5=O%J+0%$kQ`Xw#D>mo$1pxrcYOyKCSh8>Z)ic*YH4#z5HHC z6^GG-@erHc%9m|v?y9@5r4_sYufh5a|j1F14zaa(h@xh&gd z=5>-01qC1Q6#uleK*-A5#6TT#DLdV19U^~JOqP+aiqV2X^Hptv=UWUv^n6uF_EFwi z1uz2MQhY&>WK<2!T!l(n=BiED2hj@)cq4KyLyOIq)36+O$Q~)039NeT{#{ls5_AzK zIa-D%a9S&2FLqh#-Bq8tta(Q=ci{`NR<)4fSnN*QUmC~o!iCt?UKQYIjbzm<@Cn8V z-!VzRtZH0tSc7{wOToA(R{(z1XC)4VLR%?WkdA~))|em0zc{}WQ_K8SuFh8|FYwxT zyf$ir(x7(f8^|ICB2hA)-7k_Yhkg0N^2T<$I=8W+MI`JJlK>Fj{8jzA^hsfM87P(3 zQaCGMY8Lvv+Q#GR&W3iW{&VI&VR&@sDz~!Ltu)GMTiu=;ZSJ%tX0S4HR#{~GcI%1- zpi06E{1^B_FYqJuNv0S0pE0L?Uf{pQPh>05^ry^g-yrN~I}Com_(aIZ3wkUcBemA2 z*2*6Ee|zyg5%Tc@VQN@i`@iJ>Eq2pL$S9lg6gediDg7j6t4MX! z5wU!Hbwu)U@o~w=3%Zn#gi-le@cJ=ETuzOV~>b9$h?Iek%xy&2VmgkX1)qzZ}zVh zWN!{ri}q%{Rv3G;Uhx?1&FRA4oc^P|S!9&{KK-{xUF#F8f3!E-BC|KA!`_^Joc3nG zkWCbwfSa}*F1_AQ;?&ax-?ae~! zjojWWu;_t2-Mzh8Ks-Kq+T2)d*qcQI-O1DDAi~JgVeHM6r~U2C>0R2J(?jje>BU{x zn>BgbYi~|p5Mpme^&ojVVtaGCiM=_!dwcV?!Z7l5h`l*IjJ^5SfDq`v{XN;6&(u)0 zdj8AyX0ApdPwNKdnBkebjBsWCVypf-oII_YjCaD2TOBhHvCcC5Dw~*$1LSGFa-hB0 zK+L3afIMw#Z`LZG2zxUjS%Kg&*qhT~Z%z-fHwQh{?ad}nVQ)5h3VXB3Q`nnLp2FVj zeHv_U_P*$ez1dsoM|*S1d>pqYz}`Ic3ZG#7qrJIj_GZEFAE&(;Fd!fQF!p8*-xDDp z|7dSsvGxBc`S=I1H*4$fxa8xm?agmHk6AuGW_xq$A^4-57<=OSs?xHf1qgHUYe!ah>XK&b{*lqpD3CvQN(EeqqNntc31 z#8CG0L(aK-l<7JSGVI5+LFLLiK`(0|qK$K*Q5EZ$q4H zuU{B1*Nn$6cxW=7m;x&Jp%b30S(6&G5fvg_sR&6Oda77_A8eL?QN0 z>r`8|q@bJltqlkv10!(A+JLb0+IaBIKz%$=qo%*J@pq9!+NJjOdU|z zuKSA-r;7Rx+1_{2H!l0@rDsS)roQ+*xDjLYT4a0N!cW_Vdi^*29)Ba|&%U$xd`U@^ z6(p#!$u-eZMJvXm@1ld6{N-Q1Z5J~L)>vQ?h4WnB*3bG7voyEzx?EF2|I4=+A9@2A z=8Yv;hR5kRjJ_T*PNJ+9SJ&F7T22{Rx!GFz419N87%h+U8u&-TspLHu9DrRl78#zn zA_LqgS4}?w#|2kmsb*=)Tp~=@$RdG~z#49We3d0DAFH>Z5n=O`1neVDgcnub*70*I z4eqoJa9pvts}7XfuoUQ+H%Qv~iJaEZW~JNVho!OnZh>G#FGawF!>h(~GY+pavvZDb zd?1K1E%^BAn30)v7)9KBo#cs+<74E`9)MSTd}AD*OP)b-nVaA$Ac(l*@0LG|JvNUJ1 zR5l*%F-p~YOSOcSYDOs-A|(r}L!x4B02~g3CoGWrG>org|1;YBL=sp+q z`09A{VK~6Cn!S0!zqJ((x794SeLsl|7Ry{0oOj`X<+dPABC;gQHD$GoKtBcP*Q}Mz z7#VlkAzAs-yT9Q+8=ozrC)e+{kT|E+WBy%mVg+%F*#Y9aL#}}v`sdN5yXhdD1u~bC z(|Q}}3NpIgg2H`K4S$A6_3vAxv<6TwRJ(#D;XjY>tRT^UHxFw-_WY_-PIK29{$Xt2 z3MVn7!(cT~U&6Yw(+f<%(Aw7^!Jjru6r?XOJmxL++^Sh}+J4FMCPvVW%!hQ~eSE@9!YIcK5ZI_FQKO>q$Qsn(fMy_pZkd6o9PvO< zk;N61g$x8G5J)1KZ3ghhT@Q5CWxZezIlM@KKoCd*UMMbtxY{A8@q%#3{Ga#jV|r$K zCLw_O{r~jyktE$!Z@u-_TW?jp&-+%hLE-fKe0k#lWwy?}4WYZ-L&WZubD(S{UCx<} zaNc4X7|cVO@{j=(7m}t>{p zE2@N#FY0@26u&Fz@`pKM(P7Q$!nP5-Zxdhy3Q;!g_h1ccDe@|s#K3(`UPSvMY}bv`fn|>|WWGbc=}V(}KHmGq-yJ{b9n_ z7u<$;7q29MZXW2uHdTAEO!a4mweb?L;&CfjFgF(9Bh=S4A$_C?1*d*4N=T*X1Pu~k z-aOWAV#y)9V@@4f6tTFV1>ZA5V5(ho?Q@h4NBi9L0J|4ANtX`5-_+32v|rPr_Vd*C z(Twkz`W^TSS11of2(6XEl}ipHckBV07ZhK;b(+l^xDoT9omhFO&ESCTzj%Z7!InbH zn1oSnpCYDL2+{~F?$|&KK|Y#OoOQ4mrDhBkB~J?0P;4=6P*c(GC?SK$?S z%efLY24YjOPV{@Ow2SGhd8dG{YSX5P*gH^+f-?qzy(^vGKtIf}5#VG9ags$3!OjSD za7YSxrazzo*gl~;^G1ZR6;gQPZIItd5w1fi)K!o^q^(^lVld@rehdb4Fa2ByjI#4~ zFEfa+Ou;|07#n2TE(%!mmCa#bABu{u9R=45SW4-aYc&1xK(BH6aT9hhpy_p0PdPVA z{{q)R=Sb7Bn`na~Q}gk^k_IF=H+|9oe>jj2INMD0& zCCH-5>6n{{XOwWz3tuR2dfQGCNdKPpS4r5^lnegcaszNEWTF|0k}mD1M7fhQ(3p!5&PkSUWAS3jYhS5m>SN7{um$qH

-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ℑI3`4mmnf>l#GJAb5 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 Uu{+6n$m_09`YP_pNYP9DRaZySgd!F37 zJjDIN8aOQzeX!i4^U+Ot^1@adXF^!cSUa!OC~KT9x;qF!sZx3ENnd7^wN4*o3|nu^ z-mUarg&|RlZ*Y9dXs$hdR-55H;m_qmy@q#c3B&K4a-jestLti)nsETxU)NRPJYFHT zr*}#FWXl`ioj6s#RVEkUDrCAuXp{LuKrXI0U79nSHNJGwP9uRNcTCHe%8}k)Asvod zZ^o=vF~3kfj$7MMU~*{1K)1g?=A4S&W_frcUQ~Iw^ zAw;eJ70%#n^tOhXfSN_Nu^zXu9&d)hiQuzf=QG`7=FDxvA2?3r=5)r2ZxsgW4VQsB zQI=t)kAtg>sPDFkj2E?1MSPo;@ggnIV??~D_dbKyP~TJ#5+c%2f|9HjDMsn`isY`Z z;@vMIW%!o#VZ+z)+y7ah?@4!m7PY5mg^wTAn^6zikgim@3J^ z`fI=li-`*350qY)W0?H^(@P-8o|(V)4_<-hOe1D(GiEo-N*jGaSa$xMJ-Kte!6~4K zS3sr`Cj#K&uwf7#+ysy-oyRWGd~np4YM0k#DX|bv92Ux?#KF;3*AOc6W#`VfL>f4Z z;JwR6T_p9tFEutd{tt!6>`@b9!#H$fGv|-{mwC?cR_C43Epb&AR!PTOeU|);l%Ijg zc5lKMG3w`u(aGQ3)GcwQVck^z%l`R{3wcQF==x$cXq%&};hY_F8rM`HTPUF8}^bN}Ao= zPJPkj4kWV2l|&{W7uN3qf%yW%>YW*I%@>GN_U|O8k^Ib?fX;2o47iZDGN|W9t#O62 z{`SZWi103I&C@L>xHaEjSdtlVq7(p)qcfk8ds=3|Al?k$5?a1oYG>%Hem+F5nE^hP z_1@wJRoR+pT^Omon{q@!wPLb&R5)>h>rXIA^b1%i#VrTWGzc{Y&sd1WEtDn6+55C0 zRYWEfN=zn_%qVzSNsn1o#NE7-0D7|`4bGaU1dU&)U`oI|kS*wJzY?EYHG#?tS;Vl< zoJ8a}f+>Q{ig3ovr;DZM9ki3JFT5etkve%JTw*dDV$##yFSy(&+dch=9O8M97~yRQ zTf3Y!?@CMC(xV|JXa0PY5R)63CYzkECghS&Atnv`P){Ky4bF9AaU!;^3{sfHeiKKn zjm~FRb`X@!E%ncfVy)f08ncoxs?ffyz;sD=&+Vpec2P9oKE3WYM* zCFC)(;Sthw(xRkY5yinaD;7r^KjhEH6D(>^_la2}NkMjw`SwuN1qCoVq(NP+F<3v~>-2s=unPC7i?0|WlIr=z1yQ@t zks(;19&s`6dOtv_(rTSf4jGCXzPEH+;=WyiYw`xgP7hqE;LH(fTX-5*5HW8SBiTb` zPaq^ogmviM;;fn~KEZdYuh0ge*O|8%s5z%!2*t4OUn&q(JmXfQ?Ec4j@~425B>J!%{-g+e{z-nCz1PA~5-WYRij~eAiIx5n9V`7Og=;^k93?^0 zM-|1bH^l}w5N-S>z=K(?aOIUZ3-TiC*I zXMMIr9_cdQTz@Sg3<#=9bwBYTr#t#1H+H>YcRzNkD6nNq{*sSb>A6M@bFXj2>_5sT zOUz9CT=*eq6;~|22j43i@(xD<88hc>yuS?lsSACKI>NNJPCK&uKP^@?_hTQFwr zY65h=r`k&%5;umZ#a^kI$aQ51kRal^i8M3il7|sA=vJK|!@y#7;w3 z?NgpUT=D=h$MS{Vzr9_QPhAZGAzc_{N@u;`J7AGEcC;;Oz2ppey8{A5>Xvr-YagZ! z(l)Jr6=zSkeNj*WEs*TNP*^ce4%r~qsr{zlJ^X2>{kL)b$RF;)t>r(( z^^sdUAn<>~^|m)U3i|Ki`cn=6F0O}|unP?P|A6b8)(EbzWgI5 z;kMKqvM%Tc#X1FD>-D{(;=Xj)7G$2aM%f7#9G5!zYMELK;coGll5c&RoL=$?sXDt}DtV@eLu&Zq zcCI6}Vh2r}A!-9{$tX&|)|-y@b{c;JDCK_>h*_qmP$uS^aTb+2m=KROTaJeE*WbQ_ zi@R8hnM|oQTb&>UcZtjvrNUdO@D}HTgJ6@A`kUwUHy;B?v_?rO8ugekq{i~UJfi*$ zbiqtZ1%dQx%>3(HC?qfMDtaes8?O?FvESlqCASLst$*$vq0fzKujbuNmc9Zoj0)37)3zM$O*!8lQB;>@GB|D(st#%f;Y1W~R20fFcYd5VgA^_(n`B zd5Oy8+!N%Ql8QJ6QQjuD%X{-+W@l4MH7r!KGD>S{phSq{Ne*1$X(&&Sj{77CQq1+lWN{@Ty^GRLn{4&^JIydY`~Pu~11N_>H2!}?Kl zw$s2lms{3KB{)Tf6{-G*!RM_rmR}(29 zUI_E>KnL5U-lm-#h8<*68xD;~bCCKUeSXrCDHp%D-US#VdZ0nBywq| z_4%wpc0B0xMFTCa*ScaAqc21P2gtM-?qoqa4D#j6mWn;m<19pvCJmE!U@9A+ zp`yf*x-nEK6;-Ibsz_%HM^dGI84jA!9o$AG%ES4)ze+igZKz7ciCU|-)Ch$no@x=j z1EYd@L=+yxJ<{z;g2L*~D=Y045Oo5AT)A=x*=x8L%>=mxn_nQO$9!fEzfGxI`DOWN zcve2ZDKL4`P_HxYPVsAAD4AtRwR8!+Hv>IYH=O*hK`I_w&>!^xb7chC{G&AP&=7=?pqk5uvcCQOrhpZQT58~pj#rzNkw!M{$_j)yB^brcP zuI0U%k^p@`b+ka0814$HCvsINl`2)KdRi&NPUS@_zTo+yIJFjFteKsNw1im;vm*zk z3ecozk#8GA8K#r$PmAqc#r{6wyjt&IPbXNkO=A|*GGrB+3rDC1a1zdBbKx1>%b-ih zKryW{7mCFzkya&>_>jMIH_XxA&N1JIo7oTk*guP+ zs-OVxC18Lv^$96E5y&ECyzChjA0UN|04SHwZx%!Qa4(IO6b(yk4LmM}u6|Z9bb-P& zg`uL7*IrFw^BD<()|9%3-&`Dh?|9JT5mpXxRI+OvRb^-#mD*h#mA9QUF5CK*#E=#g zm6CH&RF@_ws!QuYQJkl`qUc4^hGSG4?ESvV4ES&bC>pb_C?1jirCzkN(0GR`1sW)p zU1)6MF3YKRVpeG6n0{gi44;0|JdIl_&VaDg8o4CWfFPGF`B~)ZM>Vlx$nbWi14>L; zJUH;zK24dBy(ZVT#MSN!TMMPRII(IH(Ghbqmb) z*P}xqK%{DBa*-`e)3?BR` zOj#IvhXUMLw}ac5`OIfrR-o;KfIYZe&|?YrE&+Rx+Ya>jGY?IvNBC9fA)i3P8iq17 z)_g@hB)b5^N-dGQ-t4j!sv243yjH4>m*|H%{qbw=I5Vt|1ViT*vPMU;gkSaLIA((2 zj8vD!nQ;)P{i>)Qp~)IJvysEmzSJ~rsI=-IjO2kn$qaa^9)w9>Z>HL%cuj=9m4=wl z>{S&iL9P=$6n3Z}6#ZWm%Z>UmM7LnsL>lYeAW{|wWJzD8I9B!kdHIB;2i_qwoG<;& z;~q72IKK}eDwxPiCWkW3lfz|acOr=YmL9O&il0_oUg!z0X8a=78f)TWS-sZ=0BZ84 z;%RVx^Lpy-%2`|u&cA>^sv-iNHEJfjia#YD%7%GP6`ayIRAq~!_A@O*Jf7w;J!l~x z;KJaq_u4ZuFn1N=ook=EwjE(X%OAo$6cFAczzKV?-t7eWVAB;|=nZMbdnXGILCmrS zf33(c*s;v$!KP(RXeGT=d{wBX8Ng4_Tu*PD3z=}JvIs0>h0lSBRBt|E~o-REe^2|i|Y4}w2U=6H^zz_8rXPn%!ljx ziw46g#45+a|UG$60~p?(u>f3#FQ80 zw)bXZ>bl;bO1J=qfXR?oAd?|nAcrzeZK1+O6#Irt9f`Ir!Clr>|50PNYHp$rthS(E z>o=edmFPiL3;Jf=Y;~fACWhf|ion8^;|IrgVQaez<&C-;^rsIU^phrT1lwa}+x*Ez zlng*_ri~xdcEM+16|!yI4Qh@@zq4IV=qv9d6x=>_9ryOjs=orP)H>B)lnP(CeDvGI zv``aZB&7p_oFf{+fqbO<1}Wkt8le}5l*~Q~R|jdFW91RFJ6uuVPwi&7fRZNnN=~5x zXm+&_YS{tGN4*m=Io!5!cK{kPz95=egD{JWHmH!()7t-$vMwL*XRgZtrPkeWGs$bX z4VmTse+OMfc2QHTtmyz#Y-&qy@gK}9kS!CDRtmBMCJfkSMwF;jCVPETzvvyqF>C;U zxn2o+0`)e*mYDC0Q1a#;tVS1h!Qh;3B=1&hVl|d(je7$kLXH@3pK%4F=VOhm@E;jw zrCNPp=$>PRN1|#^wE&4x*yN4m)b-8W!>Y+E)=JC*?X5t>IgW({)(j)Sltilcrxufe zW^CdCX0Zw&%BcTGP&;k)0iXuela)d0SE3%KCekEV*b^BABJDOWy8@~f9;;3)r2FZf zRiB41qeU-g+R= z?~kzH=)OqV2vW9b#1$P??u@$SPNKx1nW^Ypm5s|qknpAg?B?m^Io&f-_ooNpu*6$t zio}1M;i^uQ!mFv5(t@Bi;rIu1Bgl85DKc9^zfub#r+$`w>95@e4A7Kl(Mm~Hacd*v zePA`lA?u^VUeD2*?)n5BB0dvYTUF5}hPv1bt(WM;Xl6x47)84+N)0S)t~)qx8>mtm zWFU-Tjo7)0+VmAso36*NP-x6Q*QUU0yzp5DQ_Ow(hcpE+nw(!Fwkvp~`=cLf4*rUc zdYXgR$%Xm1Aevl_0Sa0YQFo;Vf11glMN|4ROpOhpewZ2$Itgn4``%(v3gW!s26MR4 z$Z?yzB-fxKX1#;k&Fmcws*>(~?{t-jwZ#i~Q?o*bi&lLh%SVO3_E0votl6T9JB4sz z^|x#NoQl;@hcT@+ThwwfjBX5cb8y|@cC2hOMrZjn$GoU8YEDIyc3mK9-q;p5FL&bR z)NOI|#;u%+uGiD3RbYi?8Y4qh{@MyYies?~``oc!#jLAja=&ebru*x!y3yTjPz3%Q zJMU8(i!Je5!{^}DLg2$V!?(SV)g)xiQ8pl)hs)>lbj0B80aEBj_}n~P&qlk?nrPXk zYQKsVT%A8TvwCvbyVt%hNRN(%!qv(aBUXn&fx9rf@ySsP`=g}bo=AZ3nrHa;E= znro9FUS~5{5N=b23q25GfU_}jo6EQg!)i_Kky&d_?Gdcq=}%q4d@R$Rl&CT%6dBG<{r4i@vFjyC5s)N0b_pDRw)RSGp`TYK}e|FpGuM$=%02Kf7g zGA|j)&tX>m^CPVC!kSfD;}v)M5Dm3@X4Zk8Iy4Zd*~y$%D3o-gq{Pb3FAm;(gA$DK zLW&CalhxOT%u3-;VP>=ZsWnGf9>(u3#iqh)WI>x(Aag;ps0ZXv1)E$%jB*6RA6;~% z#W8CyTlKxIjUZ-8>qihHX}b{RnDvocKKx0E>Vf~otGlu6bptd14ra1f80^q5Gfy=? z+U`&OP8H*?zXn88n~Dheni(~Gt;}x_D6aTXJ--#}sX5YlS&meujIg4D?|62 zUiP~_Crs9;IE&2_9+g6Cec%I|=Se3x7-?#9&Jy_j$jU-X=*SF=DD~CgSrm}cJi5BNMi?|c{E!UU6AX0 zP_PG_rXZTTqCz1EA<*8*W(M6B3cAJ0+WogYDgg;$E=xk<8BJWyIl^M9^;E5WIV?o# zWex%KFM~5l_juAP90~_2P{ZmN#=RCW*9laE?+mh<);R@!LUyasOlO05lQinl^oP8PK% z!b{{8y2hsk&cY|9g>7lJ+fK%4wVTNJ4!kFa%||M|++3PxvT9 zj(cunUK{-y4KC(rc?qiRt0HF-FMt$o! zQ7B`WA@=k_C3T^p<_*JeF{+Vj&2iH(NW>+5T2t^O_gd;+Pj;`TsH-{SRKvP-T5!Zl z!UB5|-NV+V^gzQ(EiVu}G5RQ}YMYxe}!?w*7WfuMzASbKhP@yHv8 z$yu-$9TUMN;%sYlAY_kK#Zc9P zJ01M8HMWOfxuKXywC`C7oA^uNvN)TC~@*5<~74YHRFfQLgEStmC7{w8cA26M_rST+XWIM#-VGc z7e=iU4c{jaMp5A8r>i*cW%>_{VV@YYzf(?Y1ofA?$5XdqIq4uy7k$4h9O{jF$CWs< zkCwUR2q#m*witz7P!uh@K>Ke+lVh^MnM$0@Kyg@8P{4%W353jRRGV?Y+K?G=+}%=+ znk!MWXQ;XSBtkrU>Bp)5`b$|JKM26%^xmqLQD?B>OTz_>^UM0rFrcFb?s5Cn*=t)T zZCSg0(%Wmln6wTtuv}p}`qF@~umGd9X1UBNrWIQhGOcQ|(@IcUrWQOi(~4uGP<_xw z35XiZiKEMhy%1O;lcMwtvG3OJ7yCto`b;x7VgC0ki~X4MaF0LF$z~B16}lTs>IT zE^AG;()3@mOs)V2`xR9!{e)%fEdAn~(($g4(u?*f9X)ZLbSZV3=yy=HXn7YqV&tRU zg%UZR@}&9uwRj&$<+RwoXfV#2?ci8q8HHD0guWnWHzwO!G+Wj=KhV{TQti&EhqeQi z1J)6@gZ1|LReiN;jiB!^Z{2I z1_k0EiUn4&bMl?rPaY!S!Ln;NV1>Zv+SM-q8x1E9mo7GDP|&pMvew(VpeZ-3Kd1D6~rOq=4X7=?Q<@?kN5 zT5*|*or+m$!z2JJ`6T$aTBMh2JI_Z7477c7KZZ7nbB<(D41{yJI(1g@V!9;0oHtJ; z-?#V>p_ShWH(Y}85yx9*cNl^8X7R}m3d6)2#DXmZ9hKt7>Z28}HiEE!{k@7|GX#;M zh1ngHk~HDODNT$+gokk&9@a8Ysj7%MgT345-h`d)o3bZ-f$1dwW`!R2Mo!5@PWez4 zsDNmg=AG9~dNUpc{A*eIpv?6{`PDy+oYD{;5o%9xezzx`hiHx*DvH>qm_OEr%CyK3 zcjnCz98pu5@s@0!VMwC(%?G0^2<*2QPI>;4Tg9e!8Rk`Gkt7w#!OEl zVwkR|z(^^PfjxT=&G~p~HdzF)nFXcTt9DD_r6c&lBCR3tynaG3)XmDI$lr0=bX26o$h3-}NacRO0JicV5 zJ|sLt;;nmK)NqDujn7UwNt{omFde+^d>yB9M zVn&PoY`8A&!L1U<$I({agmQoV)e}%~DLowALIT#S3B?O48^e!z#PkAVMVp?$=(D%C zu?#s^iF7+``|!78_7#}ehR|Ur*V7UL{-K*y$9sr&n4M_F3Ha;3!uZl>_+EF;M*k&R zovtS`RUhOk-l}_@W9A)$zC8U%%}i`=t1)(&fhb!@sR1z(`}{I7%8g)SI#;ZU6XUJO z4DtjdkA%(s!uIOc?FzlOw4v9ADz+%!)aZ4(6y4@{c$8Gj%j?f_1kn-8z*4W^|B)4o#091&+kd}B-Q=nyYo3g#k1RTdel@I9Mim@_G- z`#HbKq5<168V%k84Q2}(U=^N~d#r92ZO%K7rri{j*xEsNpMV!X{?|xwg$R@&0X}&e z3HJJvPbef{o@y_9kYG|L5)heMBf;qyglg4ZuG9T~NYI>qL{5=1lD>Ro+!!9wu9^B# zL^c|5Ev zMf05V=?m*2p*(FFQbriMG7-14{t=IJEL#gCiunxl9sFS=|9G$($tnW=PQk>7d3vRa zG@-{ZJDnLn*B4z*3Yfj4O09rkh+*Ehn0q|JpD9(VS@&CJxZ{`#@FGGaJTo2yrdubQ zmvoC+?;GaCe8$tTy2*?e%c5Z2ObGTgLNt6h0t{1Xz(H2nkb13yZETsNr=*g}ub@eR_z)f=em>9^&@nh|ru2Nw5I38l7Gwl~$ z0owu0V<~PpP7?NJY3Z|_$0jV?CNFGd00*?3E>CUpWZLce;-L(l#DbJ=i=k>jB`k!d zN)bW1n988H^GW11K2pZFoKmZw)K+nGs)8pe0>eUSR?IFhi1`Q^v2Ys+(j6~melC`0 z;Vva;xJ!}pFI$&om+-~~>a6(+?khbV*`*WmFWXnkR(;iDP@%GSi~)0gH7CP<1}8EP zP6Xg%7kEiGWe_^KY_&i662+n{XEXdyGHmu}7>5=RG9UkwxOGM`EK_+8_`=#-$vFIN zt1V2NgU<1r2Ww#XC zguOq@8NCH+^wbzJ<8UkL7&3#USPfVzMjrpNOFT8-;DIdm=Zq$tZu?j}4@>!mf5L{m zk1WUvq>gJc?CS(iN;$^)<})$Zv6`~-1oO4)ae*S_^gl@S&xf(u+5c$vRSshzJnx`r z(m|dO_6^O9xl%9-d;3F#F4V0&lnX_Li+l1;Op(E{aB;7?)IjcmqM}PC9@qB7e3p!D zg>WlR3~(1Z>%KOgIXX33b|0$-)b%RB7q#ybRTnmNI}P7Xi?CXD-pN@7tB#TM9`=@U z3UePjuOI7H%o>hWm=H%XFWu+_Q9P;d4se3ygM3OXI6l=USXyQ5-HG8+dC$6Xj+cbV za{^)W$Gpf3*UgfE5UO+KJ>8y3ruz)lz|mejp44qea1LYeRzneCkf;Ww6bva$=}e9@ ziIlo9SRyd^bOidqc%iUi3wmfa?5GYlO#I(j)l-iv=s+JOSn^FR`4l7^Zf;=;pq}4! z6n3Ut*a;nl4VJ?2t)M&wZSxEY!(BaHU=Z#>q`ylz)eF?R5;wDNz5Y8JEQGyCH>+*f z7nt*iRj0%sg-8W?C9fry~X7!Kxwx}a0RxS~& zpyb3UAmLPOtHajD$>@7>?bF%v^wK?CSkKExdBc=w^(Nj)pBXg|mzZqHz22Ko4lU28 z9btPMM{EXJ&%1t)!g8O_{}%UsiQTej>3$S3FCf~7*fs^S(LNYhB7Gp2pxnbU3=!Aa zdhB-@^qjOpA!~&U)cGCA`b?D?jy9~}r*P*_y-0IH)-!kUAoZ9D3CaMrsx=c>sqY`W zp0TlufPswlBPe!dWV*22woDR+N0%>A-y``l4_lZC3n)Bp?bWe2$3mddM2co8D>W)Z z5v_ZAKlhBdmkCqQMY-YHhlEYyedySmYzY-u*XKu$TRBCr*_s%j&B7Kr4L@s#ePtJ| zaXY6o+RJ%|BU^xIP{ISj@s!ZUM8Imoz^AeGC}Vg_^!e=RS5g0CFNyV6<0rg-g{O0i zv{4z4xcZ!HaNH~BTZODpOwPD!jQALpPf)o=M;L?GN3C;9IO)7Vq+jM)C{T84OZAx; zrIT&H_d~k8zkXvhc>{3{^MSapkaeG6xYS`@QUbt$X6N)+ zdtC?Vc?;St@ahuvJxh9|WI^nJi`Xj#v18WGC?RaRs0Xu%{e59QzFsVdovRMffowEh zyMb&9plp%jo)Ns3<4L}-R$D}g(U`g)exmsl!l3c<_By(pMbX)}@z4cJ2cL`CR&+`( zDpr*Z+AJu#Y9AC;??KU=_XqjRIqAv zMbAynhS@H9R;$45T~Kq$tLm7_|u9A*D0D0DgJq)z9}B;vI5 zs``Cd{Wh!LM)mug{C57^SAUG`(B1ikNM`D&%_<(Z7Z3F+LF`f2K44GCS|>(l=s6nI zPPt)rf1XU)6@TiwLqko$f()DbSZ3k6FczL6ua{A_N}?wYXKm>v;x5qyFEYy3Pya!5 z*ejw^V%kl2PnT}`t&CnR0M4-A?2t7dK%XFKu0hv>`JC?JJf1|efxxkGVc3Gj)p5mnRU>$Lkz1t zpD*(O!1>;8Ve4XV0S8QaiKP%ai1Sqftu)jluGjE6R~H9E=wg_K*1OTNmlDTD%f3eQ z7xkCFK*B=!0)|0qB4t0qCm=pv3}A;;atiFb&N=sU71if^eXKfD~w6TzsB@^ny;1V)l9@+Cc)0;SJa>+nQt8IcPdmK%DwB zTz(E@1sDY7R-hFq?+4zPw%8Lx7!A0~y<%N&dPO~Bs?Z$^yTDj!8sk$Nuuxyc7&wt{ zHHg&|$c1zMwP+g^oPjQfwgb|1;sxQj1VKlHV0K&teM8{6OC#ue&iPxrz;o@PUEqm* z$pPTGL^3Jt?1ZOSevS~+_fjMrCRz({0$|Etg(!)@v`RL*CVKfaxn@QV;nESey3(WB zJ6I+d*zOZ2yCg}Qwu<7sP((C+0+X0F(JeSECQjdz1OJb@Gl7q)x*mU$2@nV{L5K#V z5@p0-T%u@=hH54Yc_R}Dr6}%kqoMe#Q4*E{5=^L>KBu5R{nfU%Qd?VF+e%x@qE-^N z1d+9^f?7rE@*t?V5^$OS_uTv5%$vyq!T$d3kB?@yd+)pV+;h)8`ypGPxi@J3!j~pr zdY%o21`JnUQoawTeMP(A70XHO8p7@(1|l)$Dx!4^)G7rb0Z-}frj<#*+jJDk%?Gk94khX6r z07$9FsR{&wQI*X58@?+3UhVrYvBupRgv=Exe-OQz65lPd96SRr+ryu0tw8b#<;khg zfX3yOSEj&XRZUn~mo@Cq(0TjorAskRbLVUNpaUJ0;Yn`Lu9ppsS@o)uKV5dND z15kmPh3<2J_O1=Z!_F69KnX_%!sE!Bu)(`{j#~5G+O3_#UiG<8oU-I7cR26jG=nK0 z4YAT2i`JMlG$rN@7{|!D697m!4&Ef`A@IQZnxNq9ftWjkAs-b{i__BDu2>_~Ef~fN z$UJDiheJaek~>5$m&@pRqo9Q=^?>0)gTB#vcaXqfCeZ)f$o(Sd!O3kNy_1u~Mz`5| zFaI5GX=vhm7{qG-T)y}XZ$rDxx_)6gqSGzDsWk({+Yl^6Tbruss z+nfX=<>50Xlox#LZTJ)YUGjk6?2Q}N1SJ7-pcVJ{w;?%Y>aIm5Fu7N-=9n`EJ}o^yZR>5GJwL zO|4DHDqLXoW$baLRvO?u7?kgU{u9T2j?8rbQrUWrQ$SMS>j4I-0a5~?R8)1+d7#~y zUU%qTf{8uoW$0eZde-YW-Al@__25}A4^r#O?^&;3>Rwp@y$8>#*1fWO*6SkOOOj;U z&q}r-&-L#0u1KNsL7EXMQ-Eh^wOze*r;=EwR97c6#c%Ics_d4?-?GQsGZZWgI%%H9 z-{0<(Wq7=}aHMRIWCBHLNa3>8{iQRFRpsIa9^&p-*G~6gAD` z{HxS7rPv2gy;7cPs_<^*3z&eP5Fg@w=&EpQu!ERf7t;AFbXI;wqJv>3*8V+j+8Ew{ zm@xH=4k;2w+D5PVrjRk@$^nWlr->-JUB=k$RTJ1H3lV3;9!=muIy)0+l?lu^;skd0 zPnf_|nLzk{i|#$Zrc-pU13l}tf1p~dFls$t?BjHH7Athxy5rR&L3@9C!eVF01j6CQ zY`R|(`~crxkt!9okY>u>E;ij8qeh9Fo+H!1ExFnm=kl9`7yZjJ#+2z*2MS*GHvEJo z%6(p(<9bAqa}1z)UUK1Rf|uGh$T}r8TC?6 zN}Ri@t>Qaeo3r?41UOLsLLAF%QZw8pHKz!vX@}IbE3dIjGoU$v46`UJXqs8;_54ozW#wF z`L_*5V^-&FkaRY|@K{qFl`DiAglFPZ3slnsxm)Ftm6(ST4ndc+xKcLbo_^6&6NgT{ zJDxHsc5Jh*m-hARhTu*xglW_^?A@Uzbq15dCwRT=F_Q|K1+ah4qaOOJ-%+v zN#S3bc76#*LtRx+!nLb+7J)6S%uO8&uLlA z;$l{TN%nyNu$v0={Tw z*Au%0xHu4K=&mk~@5>{UWFdN&_#34A!}AU4X_HjU$B@*uvtzSbTq}sg%F_lM%gPV- zj;-91m2bRGuRKYHb5?#g>)^hOyY`N--k-|A$F$y?q-WfEcg~8? zu%5p{ueZ>>-ijPa9HM3Nx%47o-XV zGr(w-fRY3~qOF|$VG5Vm-9AI~#eDvzdI!!i zNYoF;ZS@h((*zzQ6i+y;4KiP;bJ=rB*Tz-w>;B6leVI z>9#-&?QM}ASd^j`(_0qvsGwgC9-~KI%<=Ieo{V&XjO1Wo8l%XUYo`kmKIqGqQQ^!% z!gadnfSbSdu1uT8k*hKb;iFKM+lMwKdh3{Y;ArVGr42y?CJ(Ly-KQMdHOV|T{**g% zKz{5BaET}CsE4GN!pKF;YPlLvIAFgzw)R99-)K|x>Z1aR>ls|1+pJUN84g4$7{Z!4 zO@pH<4jhv8K_R4b|9>fXJf3tc@R%#Tq9-(8ivu;cxpr;wG#ePLSoV&LA&J1qk_R}z zc$6Wmx2B3f__VJ{#v@)4iSQsvV?6RnoyVhMP@5v3vHfC%Q`E_0ii$#$ zQX2hAHQ^DO#P~d5n{}7dv3{+`X89e2!!V#aI|`T->8Fs6eiLK;s*YY%7#izEB5tLd zbJQ-#d|hdX{`rNyxcarz?OsQt(fe(z+igAQR;#*^p3O9-8o5S=c$oBjqtCWS37XYY z4RdM*jNzA~x37E-5HyEbyMf?VwBOa!O+&HBoU=I6-R1qR4&;3@5>cjzTzyq&rN5Vm zT(=SI_ZD{h4R>H`E70(fO@YXxpX;cd44PY8^p>N)mgQlV8 zhMXxJcF<53Gfkx-^)m{1&|8Ur_kjnp z#jDegWs5&KB&SofZQBle@e<9u<7>>nWocpX^ z5+U{a8tnmbulrc2PA62ax8fbg#dt>qC(S!5#i&6)jKh5aOJ8PLgU30m+IziXlD(n? z^VdD?yOdifsb(||CS)y?+?KN;J0$B_fRp*!phsNOHyhyrUw>=_`P+%7R7kL(=YW0k zqXfX-Hcvs-KU;zH`UP%y{`P+po_WmVSm4?IVb}1iZ%Kn#2~53C2W~*+xW1{cP5mP%2Eo)P75@eHaXcvl!FH3r4!L7gZ^VsRUa zp>=}eBHGbxo0X?}%JVP^9JLR^;rHcv(ksjEbrb}7L$uTIqo@8$qn+?K?Bv*YCo+B` z+PAO=YdcBx!ga@}?)hfFc0d3_U0N)u*eolo%BPgg5?MjnP!U*K0l%DuD*3~Ga}2hF zc|64&kMgB_dAFP~UICiTnL@j5R*6h5EWVBUa>HV(E;mu)WS8X6IF1{xX`8y?hCUCD zMD+{VT0|JaTB7S%oDb=Qn!;@z^ezryh4GvB`BXJ6h`Jo~yM4OQmeBnMpJXf%AKP&1 zjsQVvIFKdR%{e<6r=SfC z;GQ-rKc){jUD)FS3Ukk{yNGbMt$cO#*qFl8bnm>Q@3iGzrxT``qm}m_h;};n=sVpQ z?R1{q=_ronS-O+m!Qq#?^FaFS9cMv3VH`I`d-a6UERFVZD9zE#@Jf2&)JC~0(-_tB zQ+%R&=s@%iKCO4i7QKUiRB%T7z@X<-W#1KJFQ(MqV&8T68x;z}AeRWoaG*?T@$JISa3+-tT&8Uq z6*aMSOrptP86V*ykF}~R!w?HdD`Q!^N`(7)(6>hhhLtjmg1^?B2g}Fz2JTE!$17PJ ze;^_ia=XYGS8fZ2HTLRQpW2-XOLmmO-8hBJZxcGkaM9UZs%Gw451i8Hq z)?N|Wp3%xIo)I)>AXNTWlYpR7K;Spam8W%H!koKTV{O?d$E6(Yc26Cl{+pgWb5PHF zUO`WU%39Kf2uUnWQsl5y!bC|_#_BZcIql`^SdJ_SBTqu6hZi#Q?MV-*@V5olwd}q*Y)}Qxwz;|c! zD`Ob%64fiE*Fx1RjuRNBl*dd%i2%$Zsz0W)k^w*#ZrW{DQOC|&^Lzy9p`YqE4#hJm zS|S<5Ba8Nr#CjBtA#s{~o~j%wws0p~<>J8`caGx`BzEpCnbhwrfdeZt*9CH0jKwb* z-hc$_u8MaT#$#`I2SBcp0d7$Ps0TW_NCBicqE}6`Nk>P8jZk)#EXy` zr6e`1J1-YvVw0A|k09G9$q@qkikOI~@zUcn{`gy*aaC0>Sb!gg_byZnN&Ypx`RklV zc&P_{Ivc)J*@Typho$cdcwUXua~_jk`fQ%>U0DM@llvuMxJfEC3{{h2T0F`<#d()h z{!_Ggj(5rHZ?d5g!q8fJ>(zW$dFue5G%r)`F>vl>yeOrY8Ut44#X_H+@JUAS=uR}8 zfJ_t9|0f*2BiM(}l4qFM%j?(nw(-LeoHDvL^|Zec?IodjVrf5mTh>#m^LR)opbZai zGCVJ#a=@P+l|yn2*0}q}X-q$Q&8;z=C4=bOHHM(CkrO8hmc<|13f}X?C9uc9&s4J% zx+F?ol5~~IT$KcWt_)~vdC!vfXnDgOG`uBo^WFGQf!IWHdN%k*s|hh|-FzSSPQ$}o zMR)<0aCPTX@|T;d!FL*MBo0N|kK{e6F{544m6eBw807_PYy8ueG9^O=Blt~bLdF1p zfA7jbKkwtsKg?abqrE8HKTUjKlj>%BODMM>_}N61z}ni4>VbZ9H^HFRwOf7A2TMy# z2mk35Wc3yi1Ji01s$cgQq0&{Qi$Bqh8N{hS5Db4WYorKtRIZdE{GZ)Y`jJqVmeK>~@)F71P(+!$Qa%rtyK;3>Qel!cX$z=^p(I>-Ko*oE zfXXg6pDQ;v5P4R}Z(FUKZ^}v%g+3d2*AjY~+hOtY9j)6|>;BR#0D3^5DK^OVL&jQr zf{8}fAL^eWd~iqo>w~W$-l`0&a;{Q`mT(M+g3-2v79N<5j49TRv=HKI?=N z_B$g&Tl%y}IXu4YbS>NW$f$A5fWzc;!{PpjUZBN;>JT{QGmS*bB~hIpxB0A42%vLc zB$^rf*<{UO4!X6MkKoaX15iX>$*o5qI9N@U4C#(-8b{8gJj+pgGO9~so@pe_> z!;^`#erfcqb9^*4R&J1z1=D45dg5jGUG-HS6g7oy5|e1SoOA9av0ng9#vD1a^36|q zHZG3KWFAs~+WN-@d|{R@3luc?RNd)Y3^OBe;eEdBZ1UYv(FLy@-nDrJi<+)rV2qEn zS4me@!I{~;>*p>=su?81s%LzM>;|eyr1Vjvz6nN~=Hc>X)}V>;&#JwT#1Gqz-11he z{ha8YN)-NA1RW`9EK~}tZk4z+?Th^wG+4`TJ#@x?=O1$HQhjL5(#%N+NXn?D4qoSS zuZyKelGwG21!yS6*i(~Na#~2ebT$`GqsaGN>F&=rRZ}UEN}>4H`3kDq*whqa&zP9 z?c-2N@OnP(-e~_7qTb}Irru>#v+d(Sz7gUfl@uKPuJ;b zSF5dCfM@xVCZex<4$KE+Y^~#2qVn^86J{k~u9T#_Q3ki+dq7g+k>bF01b+WwHS*-1 zs4ml`OCqa1E8v>R;yKEYxFiX}-}A*jwkx*SJuJ}r&KYX4?Qx409?PrsYdu--1T}cn zA6V5JApn`f*vF0u(m|#f;;fRvGX$%KN~h?GagipyfVIBNz2aG{*l#X*R|K&hpOw`w zh-Pcap=0VipUxmw<1uxEhVAGFwIy04RT~H453ZKCp-D|2y;7C(_}PA#Gl>I3pUfgaQn$EL@f3vEu%x zhl-_hfR;)Dr8q6a;hk>IZN5Aq3LzUgPb+mze{n!VC=Yz@IdTq{@on0Z!3b8{nd&&^ z$Y@a%`MySx68Wwt=kb}p$>=?zKc;kvF4)#ZeWIT1=%Q@;v;3G)B3DgGqr_4{i6>80 z3x3o=38hJYSfNCZ*SqzvdcCsKJD(9Ydoq4&+pLZH{U~|=q<(+Cy#Kv^Un1`x*6%0F z`~Q*mQ6N<5b8%0xYfEhZ?6Ib zoGed>0@*%V&-ra2E3d&XzOY55n-A?}Hsv{z3n%a-qnHo+>I6KC)=TCDSDK8tYzx$T zm@=6}8J8R8ev&NI2_Z0h<&SWZEF6%acyXd6^%g1p8+qscX2 zG4GOKKkv#VI{xpqY`AOLV)MM_wi6#ssR4RimfNg1SBj_pfwn$I`23#@IfeA|NN=H9 z2414@W$_m3IU$rA=3SL1v#4R!2f{2f72@9 zzi2(ZfctgVUUkhn#;@5uW|Psf4pJBil`os-ztBr|Eb{KATvYmS%>?+=KHil-(2IUO zTUsD>s^1$+AJ#xYuZQ4DJx6oMTIvJTh!5wqrBcr-zkf>YLEgxOo-Blf-xW?B!OFPY1>jPfZ%L(+M4DMRyg+%;7ua!APc;H#n${A(QA<<3=lzIZ%Gl`C-wS zC8d^_;!p80C5wo0&M^v_B~e@fiQ;lX{6MM3n~Z|@rDD;uq6te?iQ@h)8C!m$NNRgq z35nv)FMO19kUTR-G*Qp3mP6%aUuri(y5Mg@0;U1Mu>RgE`NNy!tJ{jc@JUdFu9Rk3 z4o0c@FX4@<947Ta3IRrrTyc4@fH;2;^e-qZdAtgNGWuleSNqu+=owoxQMM+bXq@g? zDEKbvLg}n_hqH^ekYiTTN(NFguju;5GidZrO%TYvVtqQswL4P(Me^lHuAJ~9@$oe3 z^OI^$GFlcb=Y#w+%+NA<(aDTAoF}=D!^MQc(~fe_#nrme_)5FQ&+QiZ(H41ji)_2a zB5C1WF&Sd8*0*r%!kSCsOdmCQ^{+2fj#BGipMJ2_IJg_p+arnmmi=;ca$M6$=K1Pr zB$v_Izg+9_u9$SG^8k)pKnd_>aUlc-cy{rGi}e#+Z6ldG$LJ;JL>H88F9?r*l_Pz* zYN00~W$lxR@52opH^=66KsP67HhWi~6JOD+mRrblDpIuyKZ#Rbb9Vh}&Vp}a!84ja zV70ye_{ivFTDrCCk<3#2Q8^A-m-9v9pBi6=N_?a@vI>5dDsva+qRg;;3TNt zle|sxuM$0m^&(V5U}=fNmGiJY^1(E>%Zq;4LK%exFXJl*N3pw@KawV5w5b0ddB>+M#76^K^UA`x6FT5*^g+WYEJhXqg_gL(53!-}CfLzn3s*Lv+x( zP6qv02L0e+HPa3)BbjwFC{U`Bt`3wc<%4Nf$cu*3751|W_{t5X^QDP`(mC?3Gbqi{ z&+gDNl9_4`nwK!>>Cr()buy@0(8+qx4lN^@k5g1$_Vd()K}SRfJ+Z4npZl4DQiqn2 z%q#6dhb0U;BsyqDSA)*hgLY^c$?PSA8ewyJU$AxiVc{mt3VFYt_p&GXe2DHzo_sLP zY=S)RLDj&7C}Yu0|I-nJCJawFJhy_uIn zuy%QufMDvxWG++N)}du2^XD?CkW=aEEO?iEfSk&UUhsUo*)n&t2XwQ>ShFei6mRA$ zXNp1{`%XPD5v1a9VvpMc&)w)?_ ztl21gS(oya11?!si8N^za23kC&UUo;rwUdbT1GN=~4vgLzmX2^?P$!~Ns zQ`9Tglw7_Ko7M7uE(%4V4&UN~Gb!1_oA|6JRVnYf*u%$uqUP11aU}CXdtQe0cIH(m zA51e(Ui7?{zptr5OwE$5+mR1>ULB zL@hW;-gN=*f(I46J2Z}DZW^uEY$5MP7qdq`aJkEiUh~6tv#IW86}nkrtl2ziCU*v3 zIkS{)86i#7EKiho3EQGh-~&HaQ|!<(k~zvAbeL;US-Mo|u=m;?v@<5EP>xW2OaN^7r*?i?kYUUkUMlx@aCot%_u0dtys!E{( zM~*#cXEXn<9=Ai|Nahed^YIm;Jj@eEIRumS+1Ks$unL4!Jl`|+zWv{CIudIq{CaUB zzkY5!zaA4%B0ubeWxw|{fnEK2&9b}Yt)(!I3Xx7k-f9$~f`8;JonvFtRMpemEEB$J z?+wV>&poH)3kh)z`TI8d@lN$0*XYNgzu6WD_DcQ~NBEZYiG1LQ2FOI2YRA?9%On_V z%8CXkR19G(PL~ZEZL^!(5JJ?3oym$2xm;}`na!irR>kDE3*v;bnw-QztOwK}h&()q z@axt{<^mZ*Z;9-NBh7T2@01Snov7zKzSH?G(2sJpiDVA4=R3|pRw<@hs7D#w=_nWI zQCw{znVYHV2ZBz%z&*-2dXzIe9p(KWsAap_L^2oKqvW_pIYp0hQm3OlrbltLiDX`4 zk22If%3wW;x6@H>)}y%EL^2Qgdbp3-dJy+M{#nLw@1u?1;VaO`1PaCNf>f0hk>2dR ze{G~98-+o>!g4`r*>yL5zG#GdJ@@t~R3+&5CNaPv@t-onB=%6O%Iq(-B}@#c3kUY#Cq?>R>p5B*gzdWc?RT1>(h8&^4bF+rJVBr}&m zVS;)U>rpA+iY9k*mNoN)w_&iED0E1ZAcgc&awr*}X;cQDMt`r^LAK9u!tXTe*XZxh z%Ya6|mzT^&KN@}K^t<#QI7(G3;)0UKUu9F4sWxT#LQk?d&uLK%w;H#wrMr{G&|fcGPhwyz;GqeJD^V zq|hq4Ta(-vJv93Ywp@eKEyGntl+q3d$s2u`MB{6z&T)z1*-jM~T}jj~BT8_Jza0mwaIE^8 zl>0g%{`a3O*x(R<2j4{>3R2Zb=4xsx`Y+?D*@XB8sMc}VOeU|qR4qrB6Qs04?jfT& zk}7G&?FzB}eyY$9#imt>Wg|Qz^}^!bQi^x8^_P#a3-ARBQ6iArYetjlI=97f+d|od z10)ZjhL=Yq=GQLs5>ont;bVTd`<>Ycr|#t$VAY|H@}@KN=8U$X%b;` z`ZARmIvgsE^k%~YV$Ub+0|5Ko8J=zZ)c@9cw|vy|^`5<=2kRAhlv6!sPR2kR6o8@s z(Srf}61493WFhBk?~9N5l45tAV4#ElLyZ=>lc@y!lEmk2wk9X1Bt4leJdeWw^!hm} z>BJKm>+f_N)}iBb563!&26g)Uf=Ssys@~$W_f+QZ%U=7=kl&XDy+!_P|LQa*6?p3E zC2K#@U?*1EY&l1ScX(} zvc!w5P8t(pII|y^Tyu80XH(k~^6u1tS(IZ?z_g%s)?jq}xD5tO3VsO3Q*jZiR|~dE zzhY~xJI5!#nJ=2pRZjJ(60;@feZ0vqXP|ujAZT8d6)>C3nP97RasZ0peH;$T1goVM zP_sFHtfWqEwt5*OH`KpAV*L#t9$Z`E*%%~mP4jELFw6A!#QYH^XOt8)*Y@@oj2%=n zp5KBVoV}V<^PTcbUw^^;LD@BDwh^(iGx|G4!V76bgIP}-i{DXa8FxjZPJmE5b+3rU z5=#k_A|!|#t;Podn2)7^830>KfCR$*J%P{!YQ1cX9WkL-)(KE=o62Z>m=?kjXLm`+ zPqniq7DjEQ)@h;f6oOJ5fRvq=l4t3y*8V3yi-d}yu4t;|O2$VrJBi|N4wl&PM!zhi zD$AUUhci2rhjlP$UIFRd8qB2xIu4QH)JuwiMtX8V>+Qwj{Ym-MX-oO4B%SO0>luZo zw-h&~rUxRV)i0t@Y(^@729;zGh+ULVMZnbAYnP%ZA^d-orC%gKu-qkXX#O*1KPl(PKeb`P{`K-- zFqcAf;KAW??1~4eB>X;DPs|zBg*OM9_g)h4?1o(5QOM2h2ZHO&z7k##Ob5X!JBQ_p zF5BXH7wWG-8G&|iM$-W6k;i>Wqp#(nRiY_3s3V;^*mjKk$cF;o+s#hk+iPe7e4+Y= z39nr+DWhhvRFD>61I=&+4AZ2vb$e&r7nP0WzDj^UZF7u+yX1K(JkK!a!tLJ1@j1yT zc(rD*_y?w2!3SkC*71;6Yl+U=YOmK>>|SeO>=BC9c5IT$wrlz6jxjyt2}y~I@em@o z)X?~Bbu}sXQ|p&M<_W^zg%Aqrn}pYcdeT&d&xkl75;MQGC`LE+fU&68gzt@(8y9ZK zCVjFzXMG9hTlh0B5^(HEbm2+xmLQ(B{LeUe%;x6V&V_>KiFqrx&2`Xjx%8xtoLM%O zU{0xP=&yfm#QGxY9C8MYk$>k%rw%6H#!lcfk^7{n7AeUSC`j#Fn=Y;q{)Z*7Lta8OO5+%-F*t+{KCQ)j(t7LM<7*X(TjN`S+$>h|F+ zx5kqz900Ju#S|S>SD033+@VaXx06x zSgAl(tv49L2)x#4DH1L!2~r}pdQyU+OP$NhCzsb$HMs_9l0?1se$;CxY{Y3((_Ovx zzH)7$tf>klgO%Lco%2Tl#UBXI2;W{?>qRuvJ!v*3(ps}w?uU$vY%!BeDhWyTjI~vi7Yu}Y3r^eE3)*%LA35I~Zpvci zNQw!(Z6*-J6}lpuvu91;E525iMB(M&J7iAGsvDc0B(6ylGbC|_;n`}Hz9SBD5R#2m zM!`RBM@cX-BT%rlrcWgEUg|4x%oT~3lci3T9I5z&q^OV3d-$&&;?Jt{1-ZWj{)AHl z$Z;MAhwQ1Sm(Jm(`JFg?LZ(#6GXolU6*O?WVz;};BalewqSSw7;}s4;6u%DBo#Lz~ zicj#{eQU1o44>e)`}VIXPQa)7<}4eTY<_!ZTed=`$9|*!oo*x3j>DbcQaJVN8lS@b z7s-aB^9uP1^FKl}QCu=tWwbs%#wiU4O^>a%ofyVNGgQX?(h>}Lqip%H(7y-rjvYT;(x1LRk468dJaba&I^nnP zACSOrcTP_`=PxTB!y(xFI2B}JBsF*0Dhwt(C*lW+jAk?xw%S57m`@$tQQ~<%Xf}zO z4_etD;q`Lv;~m0ZrUwf8X9#~e9{w_zkydjBEgbCyot~9;@Rzg;W@HF|sT*c#S@PLv z>p*=IvgGqLclgVuHm%EO7WJ>l{`$IW)x2cv#uJ56qAVGI4FU-+kmjEG%PIGqJMZWO z{+azdgMR{kroHeH_^DtP^dLkyC>ll2K2h{c5Xw`bwty1Q2*!nzofVav`3O03$D^n= zguAaO=d9+!!mj%2eJ@m8TRe9_;Gji@MtB+|V~RPx2Z7_zPs%C|r(zloUL?ApOGVpV zXv}zTu!_4|QF2kT|MaHD)Qd=N!-BV9>KSbHIyEWD9G7oI5P~nu0tQV+{f5DwCVP;X z3X=*qre2g}%-A;A@Jz_C?xc$mnSfk|Zl9|e05VU19kt(Y#yL6=E*p%@7z|M<8nG5d zQI7E1^Un}kQ5end0l%FNzfHOar(L)FHp&Q|Hlum4k?cW*qw0FBExUD)(XF!Hn^jV*ffffXyE809T_pYx1Gy~u)T?lHv7?$(Y7Jb z`T9HFSC__4%b|ZnPm9lWUt!s9+h^atLhl$GyMqjIdqCM zA9dK=^Z6etj(5-dtNA3*qeqwET&nL&(vuwFzSQ!!qp#?k9@Tt{5bt1Ut`cW{^s)l4 z-+WahnnJ(SE469RX;hYlF{#Ld4jJ_qCDj~{S9))7G}xP^JuA}8dTPkK83kn8D5LPG z`mIaSqA8fhv-N zk=_F4r5ORwCR8H*@sIcOhl-E>AvkEqsTG_tXRZ;ov43Og;H0S9`8ut3?jNsKI7z6< zz?@OZJ=ZuZnO)0VDac&iYMnd7538+neyTBgVY&FJc>D-r$<7vZgZh69vWd=gn6YZ| z{>8(-SiP0vaH9D`qZblAg+EKQZWFVOP#Q0JMoU?KHrEg1YN?hM>eVjFLaS>JKH?4p$mF6}eC)@eG21bV_Xu)ikD| zGwjdPYJV*31mvB&K^2v)At`a-|L)WX5m%ZCQd7sJ2yS~)?Nc5u zS}^sMXmG`lVCcqb#NSHWA}{s8m+~vl19-8^uX+5MZU1_P`ZdxLShP{O6%~Ab`!D2z z4HRsXV>>|ooNzR`G^aWjm;Y+5bM6e^^51#i=8t+E9e)kNB&E{yE_<*Z+Z@ z^gjmqc#iMbSHdclkc=c>^)zopqPni)YPxE71R8ZL`hnK$F9~0LS7RmCI(9dJJEND4cSEnjsf8khABkZ8C+iQF3!|;P z0;~<6zNNiNJ6mtgfc?iRKil*T4_o9O7iIfbI&h>y!^D9@P%=r}%fw4V(YHZ0L1Fw7 z95@tx8`PZz-KKAj)&p85T90l#I67)Q91EI#KIi+$TLcJRG$%pmw~0>$%&)M*xK?<= zsmD2f5w{nM^cu^Tqx~yRU#naz@T<5KwVLp&V#5t3YaVxdf@{U*j;=Z}||kt}fx+Qo|dJ%Qu~J_K~6wGlbB^pgY!%EbBX&-xd@bH>{IuGTyMUopPkFV@|0zsCM+#^34SgNuNo zn9UIjw@Ce1xM#@KlZVaRjE1z*P$}V%Ko!F* z&LYx4Q$U6m`*&~b-yg|Q>dM}oxPMol@GscE>1&0*R9n~`J()OdbaK|}ESg3#Kl-p| z^kglE4(I4S9-%3H7)Yp27c_;oXf`l9Ml!?dF*aSvGt-4lbkP<#My`-;)^|f4Xv=uj zvs>CC=d-)@UU&28KecNUZT=8_sjU<_WWK1~;!dySks%V|Ow0&fhm?N+0}@)=%d@Gkg%e+WSyoyb zW`!2(*SEYG5r?;HZXB&0-WHWfvJ-07oB#Na^k>ME)azOvIsZLd z9{Eq6Z>6NQ)AL>Y?*D=LW^Yo_Ie39ve}Cuyzt(@=iQGfX+9$=$_ELhwD4ggKw%{-O_{Z==;L!Mkn`P z-CM2Cr-nLudZ+I*k6L0r;~Zg$_;GBCWUkroTIJcX+f0Nd#kdQzY^}bt!$R*+9lKqq zTxR^U&$qc-MMuGC!)~XyYI$JEwWE{MrGP5?d7c`vi}e+w_YXlmy6=Bk*8wGFsGdh$^M5kE&j=oL=+XVw{{i~BOq3s*e!ltk|AF}?!OA)J zfBbwqr}wvBIXXE_MG1iamLO)A`0tLW#8*-08_T1AJZWegk3Y8^kALo__fd&h{bf z@SiF^#)%^6B0i=K{o9KY7&Er}z?i5FC>9jMEom)9OVxEyOn2~JICXUL;MJ5F1>Qcj zv@Z9%Q+N*+co#6p5#T+Tx*c!2=v-&~{$OkEybkcbOZ7T3yj}KB!$ifygeD#5#QGyI z2DD2Uo=CWab(SuV0GH$ew_VOkR*rYICI1sM;9@FE<7O&O^R6tTepWG_er3ls79S_~ zQW;lOSw>^oaVi4NB^c=I__@7u-P-TvMeOZV-NR$cAM;u(icV2`t(_}gYj#S%3(0V& zGG?ebZn;e681KDy{TpI0vUP%b{I%o5Ly({eS#*?~6g(i%d+ljPZZpbI-V*ao&PNpA ztg51_Vis;-g9>)d&UEY>k+n3?U(O;h?yz^oI=`psYZ10>R%#GGj=HgfD1Q<4 zuaB&iFUTi~A5imKgqqIAXW)g}Tv1%(*>+i0d1wOBvlB9S#YQnMjaN(y*dvvQc4MjAr99jOx;eDuTfcyM}H0!lLi*5zH z-tpeKR;9Ns%Lx|jsTodrqUxlYbP9PyGAF!_#vK<^-WKzAsSHykSAjdxt(EXkC#U8-J(z4`wD{f+uh+5GF&M!sSE#o2b9 zkJw)~_B?jKUv&3Dr)}1Xr}ge%!q-&umW>aL@v_xhzVyZq1ViI?`~&xnr{T4e$C8rN zuBT(ajqdl1PY95a&3?W%lUmw_M9N6|WOnLu1lP8c%0)l0&H5e+vV`BuV%ytWZ!gB( zq9-x#vM<#J`EeB(qo4^y)>D?ODp>GO@0~B%dyG>VP{%?%l-l2QGQ}FQXWYDpjmAW9 z4X4#@Q{Gw9U|K$*1bby`x$7u-b{T)&X-Z}uHh|v*YJ?p z7RhI`we34^!w?Fokc>z8;6W#f>&Bi9f_yCP>*qlpK#>p-fKWg_=SKaSvE!a8>WGS|hB_*k5pm#(GbBr|AjZJ|*VEtMs!8k_vyd6eC zOU*!3OA;!^!hBg;n}^7x6W8)7hVY4P`%38GK#z+I8BAeeU|S50H*g z{6Po(iFnrq!(&?wIrB`^ALwjM6fnOKctih3fXU+4ZEmr)qKr{ik`^pjuiXARRXb~j zl{UO1*BW`PXTPMu!P{GStH4naMfJ+K3r@S|b;-X(?=t{_-6rlnb6gT(Wqz`}!iMLxEKNEku#p8Qm`oZNwV{LxscuerUr^y|6nZDzGjxgCa!e(8@Av7d5*eTlP zI3DJw+R>>%C%$fHbQ+AeNNy!AmcQ98J4nt)D7W?JKO|g+!SKSI7+?c1J&QKV{DK8- z-aCIF=Y>#pxS*Dr5z+e)EFx9f*BQ4Bv6HuD>Jgl~j<=$3mp(J`=jA`_K3p@?xerfM zsOGv4-xOfR?!(&K^?f*85X`&`llef)KTCx}9m@rn<-(``h5K*WG2VYkpi0O4?}aFh zyqvcQL?ND9a{oOaqm{z;+WIlczZR}vs(^~OFbM|hg(Z`JpzIvmGwXXpfl7Oz->ZQf-(*R%kY_(iv3Q)0yHyLNY;tku zUC56lgttXpEkB-}AV1onPfLxC!lTcAj*}o=$&akb`f!ijSuRf#Jq@+qyJY3|XYJn| zwYP9oagTKvQ<3 zGfan6OT{FL)VY>~S1t84Yp%3;_K7a~k9%GU88A4s&5}Fm0NiRTb>2Lig68%`hqP2{ zgl6Uy=AV~RqvV?=c?-XaXH+?%B|s?Xc`-n>+HW(LVAzQ0k`^V;9)Mj-?6H+K&b${W1bXE7ZQN_~{W6)s_-T8K2+SA4Rt2us!4R-7_&Ftvs#v zc}9QL{@A?2qDs#gUD_@3ItTqB0AA2l{tKS_ou*Uoz2rldx7e8xoEYNb9)F zeHPUw;e~<P+aEjnZmR}xkhLP`i>bHhRDh6C1J}F2Pn}}D(lSIM(9?)x|IfU zcC=x=P`kpY0~E>h{8g!8F-_(Frs?fu=(n{X<1dS48T^q7xd6hMGmgLjGaW_9SV05^YD(b`))M8vQw{?Mbv9 z)mW5c7L5-1M@!o?rR|xtJ)gGc)AoW!{{^b;nY2B>vFHL)a)tc)(sr!09ZTC1+DdTh zxJLgt)pjgxOB##DnMGwGf0?u$FKx%ub~0@z({@Uue~M~5p0<-4i>8=GmxV}o81oZM z#CJtcPPTiKmsx zjuo?GW$ainJ61Ndu~_X`89P>XLSxxbvus$Xco+}NaTL1pz*EF-Xcns!upJ)ws9&wl z)h3cT)_$ODdokNy#cZ$KCGH|CD+$p=Du~^|w8Msq+eq-4MXe>j;`8+V1a918!s8^^G?siz= z#zM71R~zad*bfv0ECvC~K)_-Uuxwmou|mKy5U{MIv22`KRu(EQLj>1<$nC7NIle`Uwg$jnLH&lOdQq43`ButPn6uCWBVgy3bxwGZw z;FbHCn8m&kHKQf>u3O~KseF*~ibHwbl~m_N!d z!Ei`8T4)RLhIh(aNKC)dF*`dYpa$OXa8JOm2>AJdUlH*0v)-Z{UIAbc0Q5txi}HDe zQzCUfRBTza zj4!g~%L_AVP@ff5GeR}5b9kL&n0MCkn-N;1Ud%g{)-ttLK0g;9flk)hU~1it2WSpOV?mJmgNhaItsgO;?}ljPwbQRb`|+FJ(gE$#=s7250JT%|#WNje@X zL&)t4&x_fo7^2gTeG+R3MVvxq>{BuORK`9PvrlF0Q!)Eg#y%CZPi1IN;B>>Yt5p5O zCIJ&F$UyxiNj0^>@T{CM?*uM9tA-Q--v%QjPEt9mzPU*dRSqBq4mGiH8N6okIg8h9 zUb9h#lU9mPpwBpU{>G{EH*PGa4Y<#v^$e1b!4%Ah9=8f? z_y7riDFf@@;}0bV%t`G5GjJea`mOTN+;;vy!2ec&lNJb(-ZM0bs?b)=IXV@D`LS4v z0=bro7gRy{ByredReu8Ys^7TBsDCH9_ANQmY|bsdLP{6bya2{wVpx&haroKE~vwLgkX^feaKEVPu3S8 z^;o$7cC%#rD%R9wFX_HFK8yreQn29Tnu`<&#)r@Qgnc1?+ ztP04Y)c&9~l$Eh4wLfEalHtCa{W+HP*!wg6S;g~9tiReK@5)6LXg`ebJyUrh2fEs* zfvO_W%!t9N482j)KheU%#~R-Des$h`#HZ}qqK#@`S>w+5jf3@N#f7$g)RYK5A z?j))B2IJ1#!HxdRxN8FQ2N#Q6I&$HJ*kWqOPlB9HGSDtmDC!)VG?n+2K!Y%Lif}`yKL>RuK(bNp!zc!{l`UftP|(L1-FWZ@~@6h*+OXT=f$|~D1V~lOQ!(n z2Vj}sOp-$GA_!A&I^R0)^$#OUC8|G9qI5WC+pI}9a0LZ@Ia2fU=R8JEXg0EOO_BWh ziiGp$gQ+hmu_#P-C#i90wQ=^^Sbyw$$;qkrTLl1Fn_l}cQcr3%s@>h+q@0*Ne|5K) zl%UxXN0fs|UE<3YD^p1$bXiUG#BItJu`w8a&{xN-D0-L?FlS=2{wI2i0qfq1EVWfT z>LqBt90*+nRht1-qg7~LHeLXlTviz7KIBD`+ey?=IW`6IQ3L66b1ohHWE4J`JGne` zK+8K&B$ZceJHluN3*4JhT-C|Qfhv=r1CN)m6H|3N2(4^cD?v5B z4T{)KURk+y0-jbsJEh>ER+k52HkLBX25_&G&66|~Is?UTo8nax0vAc;vsESMMh zL}!l&OfiSD70sIw!u%MjX@$EQ&l%;svjxmi={hC(mTZ8AJ`fUuAXuqa-NhD+cIGYz zT>DE&gdGRgrDt$xKoq~KRX|0hN@adn_KN+k-X$0YSPD5(6{}dDyx(KZj^80~!%sMf z(OsG->&z8ID|NO(&({c@*Sh|-L(iA6+VGIp_5VC{d{IVnTl`*1%~yLb(YM6yC7_ve ztQ$Jy8NHz~d=!|NtaQGt6xb@_4g&~nhQRa9RMv|T%^RHR{toxDXx_yys`tc zt)!a-QA>OvYHKMf4jz2d1AJ|zFnO;o1(~>i=wHWZMWJ+*RTG?Id#$X73%e=kyJJsmZBm|^JFj z&fKOG4NvPC7gBzk%G(Fj9nkBUpXVeSW1x5qzCG$2brpM8BI5$Q=w*EH0C!ycWqjTh zvCH@k)z!X?C&*Uh$Yoq&Oy8_{Cpcp7O2)IfEPd;K_&)dY$=x=oD&;tPb;ITa2$8u z2je3;fx9&<#yn@;`Zc7WMe7Av)YV>RUGh|C_k|QRcO3Z^?U%tfw2!V{#h*EkQr-N@ zhodmAlZg-_ZXTl2THdr0BmqPGRnFnyp?~1ZxoLb$S{z&puJ2dUc$4o+VF8k-`JpC$ z7`#$*dU^@c$5n_*3Icfo2B-+^7jN?APZgg445VHDRLcYA=J161zB#gohB|Lnv5RA{ z)V%BsyhS!}sBGX3#*EEmL4kqigc{cS=Vhb5uY`~Z|oIZ8c8#1Fgc^&vJ=ZOr$8am~r5%y;?fjZPhFA0&BS$ZwYeB zxX`SWnzPiM;x|wlnc%L_Ot>JqBwJ`KD5>um#RjyY6jAL|qEwvikds>cY0^qxN~nL( z;-r$!E-m1}^Lc$9%v+9Yf~r1Ou+cvu?g&j))_YN2hWu3`uuiHLDOAgrcJaY%^^n8_ z4su^bscZfIY6xoIpV$NyQm3hDxtS-zx}v2L^CbL&{5=|qD&$eDUBU{hzgIzqrw@jz z-Qtt%Q&czuX8eD%62{Vn6c2_JXGUo$^=~vS%@fJ=Rke((eK|r#=gFVpLQ8MM7>@-4 z*~KBJDVIV{uZ#*}c*Y4qg=vww7j{inRU4UVp-i&sL@dJ0&-jW6+$FxNQfUbGI||;>SXlct=6#nlW~e6 z@Yzv^szVUv?}08LmK3F6WVY}pX^uLyLY0bnAEoH3I>C~IuZwqgOOsN$c#C#DS*UPl zvsF;YlhIQx#>MR+z6+Y`I5a%_aDX2cf8uRuke1pgjZDai$|^M^%jqL{a($&m#AQ zl6>SS6$+@;1GBZF2&g50&`2ZmSEy16C0h7EloD0A zmLnvE{7FiA#iH^Y8m*QiryI3~RlngAo@LlzO_mChIhourU_Y=Q?TCLhTZ{EJhQsP_%c9lkWz%TwL{hoQuL0oUcr|Jm6 znCcFbs|bq;Uj_@mEt2_DX~+GRM;pc#cNhK?dRM^XD)npBA1}z$lqhO=SNv5%M?S5@ z!sqh;R40H&hBay0z6kPJ&HnoKl-d>*!KEH{p_&v=&F9ThBYd|{_-X6j6W&C*|4@eyfhD(-r%a%H-d9o<91WMmk#_6)v3vb=Lh+1Y4%Q5m`wVCdVi$ zj^_WPgE(4?Y54vp_)0Sq0$F4b5Zs3cNW{5c9`sLK+*`^smuYBtu1Gb&i_3te& z+k&WDL+p&!jii!q{qC-)q@otYh7LQM4b^gq5-RuoHhP&V{*F^OSz^PqPB_QECMhWy z*c>7aQMR9BpW7_PGo;A+_O#oNLqnSuG{?egqi(`F-!|(RVb_fCExt-^KYxW3thJ{F z3h+qV7Vwt6YK`vo7N_KLx`A|CtREE%f^9ZJ*JZbzCf^6tLyUrr26vL-Aq$*pce}Jp zzAhUh1}tQok^5oo!$I=uREi3%N`jaw%NIwy4Sxhf>n8MD_$1RvWx^$)J9?Lz6S$jh z@>P?K7UfJKEGQLC`jSG703h?EBHsJ4cv8@;?J6>jQ9U(xhbWp;lagk8rQY9GYvxk| z$z5#)5?Xlth|$S`0@&+Fcmm!*~?(CAzTf#&w?aUtKi)5e8L&V@za*gJqB)VugX z_=_MaV|ETzLC|Cyp!_+?u6gY>SFK}tZA1)73FFw8Zhoex^rgyX@&29k<-T9X?rRQ4 z2YXWoqOz`~gTX1|<`_|FR^-SgDkVZxl)>pDusOltbmb-R^{2#r-+|y<#=|W#24cstZYO&+U%<>FTgr)U9DsHM3dp97%L>+SE`*GTCBB2b~7 zhe~TA#!+YFf@{DzBm@2dwm+qMs zDzzF*_qFA_=N1h4#E7FhU?Z4@S%fY%tqFZFS50Y>&EfXLy}T?d=t1p34Qw&(hllJi zLQ|T8p;EN#8Kq6)Y}}_5#?uIw@3O8Xj8G_xS$;rxnGrdVGz>mUn7o?Xk6^2|N8(UY z@G&klI=ZRHgOW_c5qyntbXnnbc;=k%_)JQ^Ecfg_UMD?D_GjV}~O(Y4bL zZgHxmT$81om0WEineRVBp#F+$_K~e%fwP~bt@5PUe&Rn`5?Ywic-?VQr{Ws+^BRk# zwUMkfHlf7*M3dZ_(Relc8P_LO`iNFYb2D6?o*l6@iT$p;i9L<&XYW$1-NgB+iZEwU zkNOSeOIf-{mUt3;v#hdc`oRr>8QVYLdd{4E!sz5k=1|tPRC(Fy-9LGhTzn5|^}B-w z*Z9E$(BO@qYc#Owk&}O1c@g=g$STKpFZ*r;62NXiZe7XD>9(!6q(z6I%kF$=*= z{9?{+YJ1zc{DeNX`15%Jgtk}n<0t@7h?!(WP_{iI6v&S{M%aB^?L&V!n)brKN9ixD zM%@D=MY7T>em`(w-BLc+`eOVDw3Wz;nx6_V>!q=AVZF4edBa|hc+{w+$dsb;fhO&T zg+tN`T1>-=zVk(nSf|9H(M{U_e_E&B`k6!0d#q0~@3E(CTd)8B>t{ztCl9;>1>3z1 zX({Xq8=GzO@vEvcM4xmHTb8?r`>CukD&|!3i&A3lhVS(@JPQ301S{~&&%}Xn2+o7G zAMCxCZ|(dFxGx3jts!`lc^k@AE|V!dI@?jr4T}&I%iPo2!Ck)h>X1h zc^G2`4!*~g8fcC%W{V!PozTYSy-mqjn(!Up{Pdl z?9$#GKzsM)*LjU8Z0#NplA~*U2PvXTj|M~wyl!wT(n;H+vcwm z2t+sd@dptM6@Hxd-6P}2?SdabvQzx%@5Yahz>k?x{BX+L#PDOs7hRwSrBz@h6nfx$ zgr~jw$q;Ri?0GivE`=*fCnL1ER;4_g`q^ z$H_N5|1A@odSNyK!P8jhN!y0h^a?~A6Gf}F;z`P;YWovh#?hzs4o?MRDd7a z8C)Pjd`|*?Og+zm3qS)uV0L5paq5Vp#1F;)$gNiaofy$z;{kXMH&e)vC`{*NBni?h z{i038#eD+r!rf}S@~m&(Cp0mpTg3QaJ4%cY$wlcFc! z-?8?Kdf49oo1TrosfXh)`c==y4;@u|N8flve&UAT{`<_+|MSBrKM~uX=A&9)tbN~K z_6&a0AL&{9xkt61D8iy;(~X1sf;h-x_0_dpNuzy7u-wezx_9_POu~U37R621j`yw! zCZ`sgsU)#~EgM!nP_TKy@#W!)zP8D!+_NK)+eAs&HtzE6jJ1$zWo};t#XrjPojXH4 zpY(Kxi9L1C!C!7>IQgIWVTT3PE-VkHZVH&eO=(8+A;KG;ojKTOX%mO8-6J!AWLjMoGObeVR6I`1a^?&s=3_LBx_nLYvSo@O~HcQ3ov2rXv>@! z9zvmW^?*SA+KfQ%CLSPTuZde!r}~1GcSJ=?#fx>JFF>?JUr?eI26IsuEa*zMd|ol7 zG1>AWE+?fYco8l}y;&x2L}Ad%8xhC?Gj>zQ@H(u(BZ(x7N|YT`1;|= zI%*1j@B^hOSRkThR8^2DTB0f_QM!V833C7WdRo+)#N8(tLW`qS1Z|K3$oobe}V8UcJcZzFb4MFSVS@hEfr&6d!RmoG4LZf4q^n5k0eJyI z8Lvi>8c=o?8s=Zc&T!(-I@temWV}La(xqM4|I`%3{>K{x8prQfS;80LbNiip)QK5tNSVPBg?ZieqdF=^t=9 z4_6blJA3(1zhF&rG(2FN5l&?e;v$QFE>yY_va<%Et#qY`vc3KIhoTF+@S01g?h(4? z0wY{{3A)MCY~6X)y|RDx3nG$WCv*)d$4Wt-^0)1uDIurySrX|Xkc~xp%)@*%6TgRl zqR2Y&o+zzS=Uw=v*m;S!r(ZHB;jpy3?CDOHQ`?^2tkaq@9PzqhNl#%XBAI`?+hs|A zk68&WRJtwc`>u*VH^ZKgel_%S&dvMMjdR29%R%cKa9Ps7A?>=cq<6HR|DwbB$&+yn zYfxF|=jV_qQ{nuy^CotFzTWPfp9iiydi(kQUnU%##|Fvh5BdrPaozUw56B`W^<>rt z@ryG#2L+QdYED$ABqd-XYlTSuLKPe%Y!IpwNL#lz=`SA<8ihm8WaW`2QjNhaRE}cO zyRs5BIT4O;aFP!N)A#tz!rsP=rsD%1=)Fih1$(>=?|5W?Zo!1dCKbwoRndTXq=ZOA zJnE0<``x}ewHrk##@EE~JA0sEdZvZQ_EBG)meO|h8dOU}l0KoDnFmeWN5`kFQYPZu zX32h8(1O{P{3=wG-e^5@DvM8^$vQqaa=!?AJ~0-}!#tdvRLfVJtu;Xs*h~H0_l(7n z+CK-(R3D)}oWRyVZaMM4r9f^nfQU{i%{3{*o>W@fv^8RKc26qCk9Iq~5#3KOJAQgn zBD*|X<2x=8E=;v2B3a}}t>F*h6$60SgUM-aH>|;KoFu@J_{wwz9XQ<>bcpv5=qy7C zJ5i@*qBW=kOGU^)wTgd zj}4&Iz2}2_YEE%5@~ZrX-ECiFWNd<+Y+sU^T6FvNZe=2V^R7pAGO@>h%PYAdvyF5s zaAOHt<{7Q&5%Clg9^8V)Q!}l)SM6N=D_A zZjQ?mv_1|(bOP_Cf%xN6zyA1O!A*D+EiPcn66?uH=1gmA0v7i3fWDQA#{{>5Q~gb|5XO%I^G=({{N~t*%x#?!nL0u9`29?vFYleC=i3E+ zIZ&$R8>25zt31GJ%9_q>bLh;o(3x}E6`lDOXE&bC95rrU(*ZZRZ@M`zXWR4d;yTXL z^N(J~^&5Hz3-H_VE*|C37xCVKzRVYK1&4Qu1QjAvAw))znE%J#o4`j^o{RrUW(Wad zW+ICbQKQ649j->>wb4P%knJ2e6QU?!T|jFs7HbhQpq14G&D_H%-Ir@`Yirk^t=9JM zUQO5%P=R2}=2a08ZJ0Upo_BfP=Y5{%eO47;EVPA) zBxsA=l2hfAm~b-O7ETJ4aFUmqN>gS^oH3m8xq@G^Ggkb2FEYXs*}f1$Q=GcQWrUkz zpps^aHy;B38`dj+rj;e(r);7-#w-#yvDcYR?J~1u|F2&5b8_$Vn^KxIKOuK9GHg$& zdnxbhF;biWtUBP9dOlL<-P%)nh1a^#Df1bt2*H(j9uxK+DF?Agk1{69hwaeqYurjWW20|C zgDZ4DFexIcX0e*Cz7SVtMD|?f8pHh7YlJvQ1?0oq&&bK~Id>zEq^a4)Ag7HTgfHl}>R*}ppdG>PQh|Rw3JNDGA zcse<^z3qPry}mqU{weZcNl6kuMhQ)H3BCpMEZLBI5*KVDGZ7GlaOaU`0|D_404rx6 z1#`D|mR?W&5z(V>=k>ZD(=Sh2kIW4ZeS2=lf*!3E-D%JKeBEWq^Q&DxT;$h6_zQVY zL>w;>Ar`JO2Ma2nCTZp)Rw{i_$SNr|S$>7XOihqpdly|{Gl;I2#o0_4(RC}LtE93> zW;Jp85|d|bSvHCP^dmGjDn$0W+c$SPfZg9`Qt0XYA-%$L!KKOYJm&o8jlsRnZ|kU} z`F;NUXI$^|sZO2G=gog!5VdK~=b^!y0-v$MpFb!5Q57_T)|KHHAcz1=R>{AtMdo;3cm%Hq`=P_vi0-eLo>SYAxj=jmbX**&kH9e&p(C# zG+dlC{~q`ce8&c*`HDg9ZQ({1A6l|o@u60TXCfccJT4U;XkBi5rAya!p-ai@NuftO zMVHw#KDQSqt>@VDpK-m#iS(hYSFNnd}Z^XoD!)TJ?Z)jQ42OsYkEgmjJ#rrvb^FnN4t&|@##NW|MkcJ z$aUXGa(3*p$)rLGIE!9wyHrEKb5r7eBoZ@5gGSfA$}5fd$lvTAPGBZBD3t5GH|cDx z_N}d2u(Y!+D;$*HBsPTzG~A~VE>AK%C=*`{pXEm3?Kdwn%)WjcRt=S0%+oBMbseoK zW_EG7PAWhp>4HtIlLVLOLpxRarArJlbu*i5WyIj=sE#noWG^GlcGlSVXSd36WAXRe zXnwoM;BDU_FH?BftJ|Zg$i;jS_aDu-LSvcsGyPa&xacI64PT;O?l z6>6Yn)F=ZVK2->&a)ht;&C{1JeYOL`euK~P3N@yk+%2**ye$EY`x1{eV5~PgJwO)R zv00^;80lFxlKsWXyUh!od%uI31YR6zez=yB-zi-gQE?QwzFxH6Pc1PY3u9I5Vnw}{+G}KoS}FO}=reVk$5?T=k3QT-a$GAb zdYNOHtj&RsKLFU~Apg0nk;qo>p#C-Aly#7-UDmiveqxRC(^dVonyT1u+QOwm0Iepo z8uZ$`QkVIn_SD7qzg5ita&(WbmZ|(px-K=2k77f?yjPQuX;L%KA;qm`{xkf?yiXy= zvp}s)e%GTnWR;uq)V_k7M$smpSuslIBGK5^$3OfAwN{Fnkri;C&+&%V_^xv_waZTP zZVG&zT4Qd)EXuJjWcMw*#FrVk@`Cl{bqzJ8W;*^9x|2UwJIRKSZ{S-ac}mOEi~;M& zs?3?g*x($ad!2gVR78rhFNx1HH;Gv_}&SRULMSI$^bk8gf%>fP#d=LU=Wsrm% zSIY@fKCVd~uF5~-$j%ceC`XDs_=0vRM{2B~RJTXUU2|USH;z<(@{!82sDK=(2Hi6{ zMgX$xS*!Ub;!`w}57|o%^8$={8fCl6%o~f#&D%44=4+fCYFj`jz$dL}lj-B=yh0fT zYF=FvMJHkvKJqy}mBKw>lgHZ`DAy%dyP2KIc4Xe-O%GgH=Djr|KrqD>{maY-((T48 z%FMZFcVoC!4)5WM;MVmP?^(L9qf;RlUJmcbIe}Jn22LSD%k6tA+AZ;^L&C52RXeQH zMp2ju?S`ecyK0C#{J7QdEY&ap7kFXTZ}5gtc+k*BE`m57Kny(Pv9pv&6qK|UMTYB^ z9V7lk;`VLMWd8Jx)a{S)r@|UVOcZKBFs9i14iD~*ImIN$7<1xo)pg$$bBfAKz3l%k zMNzIK$T}z7eu8kSZ_DoMu16=sslJi0`#z*7q%GNgefZ=NB1FNdKH-oGO`#0lwUTX@ zT|He$fuG8lhPNy;OR`N4qHtzTcyk|x0b>)W1{arj)BFI6%BwQ-r0t)qwgrjwpit3+ zS-;SgIOQr@FDVR`wT)1;;7mme5?I$}mH0qf4(n7{1mxkI$jjHth??)Z=rIpmaYbI>c@ z&0k8cV}{W?2ow2dvPgx9g&6sGKJ zsvH1u5f934n6u!g)XSyh%n;iiUVB$oS|Eqy#}tTL9r%#F0kci%C*1hPi1g&Z*T~?HZ&N`NhfojLtQ;6Dg&9?H+an*kS;>Wu zeCTH72>uK34H@LOq%HgTASJoL=vn5%kUE+ibqguV1(jK;IHn>GJCr{+B>K zxX`qoeV>2o7ZT6F1|_Amk~Gt;@0Rsg?@84kv66_!fE=wtLRE>R%FBow^OtYCwPQ`R zGDzgLt`PqIv_pk3ZpWu4)&x08&VdQciSq0+)DNto652!tkFbXtNEk}#Knhp@>{9Ym zRi0X3s?t+c4kQ!*DfN}7#Nx6;`#}yb)p^VEJnXNOc%s~ST4>vq2BR!Gr z_Ot{jF5Q4~Xvd=UH8bQk)i+(2`|xXiDw6Y(N4;bWa2uXxo8H?qV0h`Bts&XiP_}$z|lJK6v9Nwg-qi3@B+|8pHnTaujJ*^gMHzS z_}8F1(?MxbC?&{b3h?%yl=Ec4cS4-rYu*+s+n5oWLG=m>#RRm_9ULRgs$Ov`IL)oy zI!0%IL(rEagySy%a*Q}iDHK~&ZBo6$qSscf9weP$Db*`xbBtzljJ}P3)VcfVyy(gR(2A8PT30cqbUE!yE$*cC`X#qv+=uy8&Dk~ zyx}rpAfokb-k7mPeiPC};lfwGE>5wEr}ez*_>QXeD}UpZ`tn74{AMRAlRFKQAfgYW z^Pw8Jx{idu<`7}@cF3IwqoOvs1rSHCBBC~l38Sb@l7&%k=gg=)p@dDAqGZPzAKKU7 zF@E!MfFO4k-7(9Z5U-?}L!uX#wc)e(4VQZ^(f!U(+Y-WzbAWD)#{o;!J z864y_;p<8Egns12$Vyq-!ULG!(_D+s=FCVckMcBMuso~nn|kp2G+$GB7C)x7UFQoq zxmUev)%?hmb`=z*_mEaa;!PvV`a$XSYq(gQp{^S{pKf4Y}AbKZ+G$xuvkIxL|0F%GAbG#`qc zp;Vf-K@UpQP(_|U_!V}7($KOKuanVYxvzG4MtSfXYAdRR@^Ne?Sq6kC4NOo{eAfLa zClM3V@R<}tpHR#`pc#RC$UexG{!sQ|FE>?Z9vd+b{Nr<3p0xpc*#N0GDZd5IvNDd4 zY$!CSxy;+Y=F(V8?y#EALF<}#li}Y^6dH#k0sd7z!5_;(BK*sX3-V&{moHu5zx=2F zD)5JwOaT5^9jcBD{?T&)_{sa#E&dNzv`@0PiZqa3Gb-8)0*=~Da6g<3`{mrtl3{

j~?*<2S55(f&a0^|7*ej`Y!mN-7WsRL#cak^zeT>eShBcM_Be& z_}bJc%PteOA^r(Uclh|eeMt=42mOf?{T>*$gZky7ke)d>CXZUIR_Mo!UDl7Ht*+qy zm3^%rj!OW{h0TU{URHqH_Ym?xsL|(qq*(P8c#suaoI1}T2Z_FG*2Ao)wq+2vo5ZUh zve<#etEWbJwI`WZ-=4&)rzp2iUlfC( z5m&=*_Bl4o{cxyv)6As(kUQK^Zh;6;o4uQ6wA+mWXOUqGh3%U}CXT~OnqG5htR*}I zRV%H9e{(ImxKhbaYr~KI(%z4i(ZeG9At{%y_Xkh&HC0&h(^c@0ll2(?mV49a;*qxe z#7yK%pu-UPiKr)xp9I^5>mHK*sH6bZMfJlFpDKw^dmTY`MePa%+1r)$#N85cD|WY( z+hk0xMYXT~`^@L#xX80-YSW~$MU{Jrl4cXxd9lULQ$(o%S>Te{d8y6LuT5m1SNCun&QS3NJ)MW;r=nXt`sX1P{&ER7u@(@Jy}1YabdsSeQ>~^{ znRUBc%`Q+^iYjbkac<;RA=;Iw^M*N=i#ZnKFh;^sWq`ivqmHFzjwU!mb~-k(nWv`k z3nSg~+Gyg(89SrRMv0V)O&lG{MxVARu~@yY_(IZXlCCJ4-^^eVkp_7j*sXh))y!c) zR3+;)$9hS=)zVJx2xp7m`%2BZ%FAV&)9-mDfxfHep(|)9LojswDNlA04-9=1#?;Ksz2)xDdcCS zj}qT1*L`)rvE&EgSBHPij9zmTyNbonMK3bR_x;5Cjxei40@?k2=O0mC6}#(?wh83X zx$iuz_|@ld-?!3i=O;-H3Hao<=%L@V!~zi-4ns7^U2-V&uZuX)J^lM`^g16C2PUh- zc68`p-eJ=}Tbq)i?+^7kfASfUCzAqf8I&vVWsx^#jHCe8vDE2O$Su)fDCK;l(#u1T z=UkGKR>{{B6Xff|XIooJk>~PKN`ewt);F(kF_+1K!|5xaq4oxIEKccowN+mPA3-y6J#;IsdJI zST$tu=Tt&m*AovG{GRWzMt`LdAi-}w#*#pzmH4_b_!;toR$Re)x4hZG@FpNeA_1-tF*`} zefVnjP#2!N+O3kOaEy)B`I7Uo%1uwM`_h@A9@5h}d+oaGFIrY0OTRCx^}YQ(zAv7` z$sWX(PCZ*?SQD&S$s@rUNiTwH6?c`5 z;YR?B1TldZBo$Du`sBy|Btx}p*-!ohG}F3g4HyC%N>T?D7-KyD*YZiCn$zO23zhKEyBlRe$gwLDZANY{p+ZkBCIc9&yjQ`v?> zaiH{Fw@h}{Zar<4wbAz1?A4eo8e`)9OJ()4Rx*lUCQCe^RuU%BvI_uHaxM|i_cw|` zF%6Y=Nlsg2@XsjI8%w(+FG}v9YQSh`T$&PoY;ZhtOf@xF3U|nRm+)RRb4;6HAQ)aO zTQDWOHX|Y9(oktf=9qliKptdE_){ptXaawg{4x2Gf2o)}(gIB{*5HKSrFQ~Ur9fj# zTKD;5o-UUOkw4}sJ}lA5zqE-F!zVs&<&T*Xo-|1E#}vsC(*y_{xe{3~N3d9Zw}2xk zVquZY;}yscd1IF=kVbPZJ%6L*j7j`21)mcs<)PVgj*EPE2KQfTp>Y3AmF}i?tIfV8 zkSgcn!J;fVpY8hl=LMfti+xb|lSsq1r&;$u(+^fEX8|kzJhBw~Qf{Cl{Jk~eE-*p- z#?b)XfG_4OSOu5VR+K`Um9Kzu8#khE;~#Zw@i|@>fk3oCL#%itkpgV}&+Acnfu93c zqWn_wf^N>mB_%uR58yY6U~DoxO)-6}axO?q_7Au;)-9Fy5H9Gth8sYlvF)Rp)Gf-j zx9CQHg0XE9x8u|Bc26+2Rf@4~xII4dg?tzJ;tkOkq3u=nwwv7|A6B3*y1afEZVwgc zi{3bVa~u9WNzz0i8g2qhlSwxiFR?YZ%b^WT1z>m_cqxw6I=C5{?_$Qj5^~ z+Ex;c?l~_O-P0k>h^J{oyc zyAc|7k{*(rhtM`De=bQ1vkQcaI@Mp71d-h-E}J4Mp(j@kCfKIBM`Mn{g=cEwTLrG|PLcn;X$V`OCrlHU1CTf2!|H z-H)S(?*(WIKL>pOKSzJ!`hwU=vh)Sr_-`x$hm+68(c6!kXCA%%NUGOE1$4!0``mO^ zEV<<`)sy$i;D;A#o>s-GB#sCWY^ujwyWHd%7YOlt3O=HOf<+>z-Jj=L{4#$3jm=P$u)zlzv^6*$#PV5#3hp$iF~O5=xWryWlvNdgBnYYX?w zd#-y|(i47-a|a1uPLn@5!kaVY4>?|(1-yGzfs?;lv4g`E$UBOayR+ma=_5D0 zAUdj=Q&K3G8ouWdOSnJ3P`z8;8v)Cwt3iD#xANY^?flVp zC%s(Kp7?U*R(V;IE^<{zx#PCtB;e+~34?lkdG*|0MlO+;tL5b?@m`Z{j~>IkmFv{B)oN8ox#Q$Td(?7Mx~j-mqqFb&fEN4Z zVe(pcBg-q&fk0bxmYdapFfIQ6diDP5xkKfB+1DhH;T2ik9v$974m`hN5qoL&;0iyi z!Q=RmIIN84L-#NMi;KcmdsOve*HL40Nx;)q6I>={!@^?0-2`0BNy6f)WGs#%V*(b( z`#m@o_b_64-K(xek{y`+5D-le0CzvKYw>R8E;Amo;*%9iGYFMI?XrRMn@=_36`#y& zF$Of+_YuwY!noa}T`()#wc4F-0T-|`yp40-_EXogQ1fnd)k?Gl4aW=;OO-Ss5?b|vTEq?FH01L%GNW-`10y?kWt<{EAbDZO8?cFeUd)vw6L+$n_$ZwsMam$3jb-HT* z+DFxecd-Pyiu6@uqjf4SmmAX@5*dUZDR=|0i#k-(Yu|1#LJt>AX8ZNp?F~{;kb|v3`fH1bz{zb0_21~|&PfMG- zyl9nt?;~FvjIGyxQsTO&igAi|sP*C%Pg&oWOY5`G(;_QSyFyfKbZ?O#Sh&yi^9Je1 z(L@Uxju2SV%qBYt%^GRocQn%{&Au#kPHAS7wuEL4s#zm_TD=uYvkMgs8IaH{wYL&! zR@S9iYH!uj?5Zx!QhS>s&2H|}tikV)mNGGEP-Bjx<|@IWLY)N*00yxDI~VvJq>R`P zET26<5|fKqvVYO4nsY_IZzhI;_s>fPCTV888(cqc6ihH2pZKvIzoOUfrH6Cb4YtPG zPd&1mnG8V2T4sDxSs<{X$iK= ze58$&GnWAI2bcLBn=DwpCeXf6L3@48NbX~DN`ZG}y>mD($-DNOQIHvq&3^CF85<>w zrRMj(AtsDTy17$#jc!BQ85bIPrr*0SaIvjntl&BED2lY9zRfhR;GCe_&ls&>9 zDv_cfXiqk1o))%Ti>LxXQvJ%E{URsTDS!IwBzF(sSPoTc{jqc{V@S?BUh&Hx%mxgG zZQj5NgZ1rAr{P&8eY_%+PD;=_Ujfb1XH8VI@rSNX_j^_tp>IW^^qBb!a{EJ9rdtMn zr@WXexd+Ffj8pm=dW?4_6>S4Asu?MONb7zAk`g_XeXilzZ#e!*VPA_XnHvpPSyMS~ zl=6f&hO7KT!}D6;L`B7*W~v>u3EwVRfKo#gYuFS}y(rr`PbVa4i-g-N3GM&zH#bXm~qZ zbx+ehzzbnFgUi+tYLT|YXO3?7heivBzmkf{_@=xt#zxt7!g+m)^@?0_hrpo!^2Sf* zy_lfSmxltK+;or&JJOn(|DX$Pw@gspw~Xs@is(*+q-6+6BB3dna1L_9Qr&|q3~5{( zN|x=1O(V;7-yO*GQujq>x@aP51TFM!6lXhKbxUD4MSG0U)r`g}{>s;c`5fK#0MVng zo`={CS&z(Ft*3P_+u{TL%V4e-y6Rq54L;$9^aT4NV9i0PrmUqJ^;sJ`GsH&-t)x2V zQZ`)LI1?njoE3_>yT^%7O{M(FB7@}udYgBPv@OfA1a~ESTlWpaeuPD4OosFv@6(d( zv!&A#@xB?iReF^_n)WX<9tub>e*Qw!ZJMH<)3)t5hqVpG1o4o{?zo&%;WiGdL zDSr(4=+2PQqk2`I_SYA7s_B12x?_$S=?oeingiS3n@*lNk!Nx%^ZAo4l8v)T+7-$( z`I9YQM+;IhdH!0nA7edOCz>K_`s$~3ypYA&EjYj2d|AwQlw`}t04XZfaC;#g*=;5l_K zPjl5hL*IU(8du7yLRVO)tz5>2+{NT&=tGozNC=~l4_ipE$%lQ?=Uyu_v&csxy_Bb) zg?`AA`o#{`?GTFAhoUo=e0h{jXXY$Ju2=A9R0sZ$b)jLtYnX3U_w&6%W|p)3%}?f0 zO+tM2Vl+%$5To=yVg5q);KXwO^oR6zp?)@%+hWhsn#!U(g`7e5l^Uh!rSPUdi@o8& zf;7=%EL<-77G+0Ps{88`y=$!eR!RC9gR4NjNPvQ=Y;o zA=;WU4NJL_@Si@5@+a~?ViBM-;N~XG>s2{j911lNfs)B4(O=?Lpd3zzU09l8y zup^vy$u6K#y@#%=PE6?4tjMuYX6{8Y-;!NGqY7{g0USdCM+J(2lD)x-Ap(yBzyr0$ z-MQK>0J2vAa)9)zqB*)cEWqBA&@=Dtvb!E7U6*f{zr1N`SOcD{hKSsqTf*1!_W^@E zDsLBnsOSFezM%hozFyrfGXx$d_SpaGBcFOnjsWFE0ZM+t)Xj=vNkGXFpbRss3INIo z0m?8IHzZh5AV3)kP(~=A|B_iw7PB|=$&x4c zUG#Z-kdw^HU8o^)Z2UC5tLD6|d;b|IG`vl&+T{RRojtv_K{fFy>Pf4)Z`caGC_n9? zSy=TmhklqEO1Lg)h?AbRSCz57a*-zUmf*zfBzeV}uRT*+|F>#RT>sb0_%rHcY~YZ| zU~C}?QPc+V1_qu>GSiV^2;tn1O6mds+A@ILaH}?Xw zoFFBY#@z@8elHVc{P8CertULKbI9Zev@G6A|OA{E@QLA##xWut}Sv`eF9P_^8CL8&}P`L)`u4FJNYJTb}&rW?U;HTZEkfuT+k z@3Cq|zo(xK)YemUzB^r+o7GJo#?pi{?3th=N`O2LUvvlKdMW+F8x(VyD?qbb(!B) z(r!|hb`47Br4}mgj&RR%Ai6gyPTIcDb!*{EFy}l%|^{Gq(nT zZwhcp%peNK20<9Zu~ig~sDDM_IFh|WgQM<4DBddS2c2j7giL|n7W!N7Dovpgau%bP z8)5pkON(&V7FD5ax)XilmrdUWX|yGA9m)De`e~LXFC{fe(iGCmGt%Vwq$WxFMtXTf znmm@&B(<0SktV-NYJ$G86_`rPqKGU@nm9Skv14E2day}%P)$=H^|}E4KW%m6e+XX7 z`3K$=_0IEnOJ25Lje<;bbSizL@>tcqpBm=eCHNp~uF)F}hveUIye2n-V#E8cYf(rJ z=c4tlI;q8=v}d{p4dt%5e2;$2>Gg-^r;{o-hs~~x_|1PBp7qAGW>gV(yE6>O8Xwj7 zARs=G1l;|EdZeS4fj;|0(jF}YTK$&W-xnm6X?buoROEy7z^_T2_4H*l~DeKoQK{hjk9(O=3q3?N+yNt7jsAf=X|1SwxO_eZ8R zI-=&{SuIT!t?YKRHhX<)x@LL3^x04PleS-wOZ=g4tqeoC$&-BtDx zsec!N@a1@=UA;u;U4Jp#R4cj~7kq@M-t#m`w}lIxFXkt7pnyj+15ZIbYrd||spi-c zyT403ix+)oYmV%ojs`-i&b!n7j@8|4qk^JLSpm@}>`Vy1BKSg_|6+~HNYf3+ZK7bk zu3(a&Y0`M-ksD{NK#N^$#(iv=ASEFBsY-Lq0_&je=F1{^C_v+;`a2qYd+gBoTz z9Bu9|4fE?i5zN)}(A~TA#+?pU6J^@^v(Z~G>>C$j;o#heMG7;^7qgg?NUkLNaRGVF z5PBr;0LD$lYVj(^>s*~Sr44``HCqh~GnGqu*SZ#u;xaC}zQsj+FfK-ockd}`ZAEq#he5x#OdyQOjMFhyFutkrA4oA>z;=IV zBH#Z>GAF)U_NPOKheTf}cqkfEZhn(MrCg)n&N6WDPC4gyDv|480Kp1-D0zedC zfQCRtt<5^oy@6(%Ui&GaxfVUJfJPR+=mb$<{XYb<+S>}sh@||3`cbsPwcre>EV>b; z7dFf{2&92V$Yn=#tBPQm?S9Xu5hJ9NZ0RFMEh0xTno?1gjN5LGd!O~R%PO|BioLlBFDfL`tD_tBzb{S7*&E+pvU$no_zp1ja-Wiu=uTh3!)>1bwbP^cdT67ZvP1PrkO!UjaAUnmOwGT>UqO_g{d(d~yHe^02; z*MDMb_6xPpY%DG>!w=&8R8Cq)YcCqnk)m@A2A*nlw$YpC0~KYqqst3^vqNt=;9s<7 z-UM|&)TbTD(HsZ3Kbw_%wa|P)-M)w|Qp}R>a)@``bh&G>j197njO#O$1 z+3lIXEY8m?%fJj~qxyd#2OOYe>n%&hgt93sp#tcVC^OpndGXyxQl)_@-Pqc3=upx_-yC^lKIkY%!KX}YZJMcJI%l{xB*B%n*U z|DrGtSt=U5AlD$!S9Qz&=gwt6azsU=^fT7V#GHL+cgBi@{*%{>xq<`dqii4tPias2 zHdMrc1Vz0teoWs`nR4rFU6UQ1{USdL)69^vG+@cd`H^MGm?Fnw;c~G^q*yY<|Jp72 zhYPLxBTtJBD}2#UhNrFQgaHvLAysipw9sU-PEs2^8gOQq%|@utWu(_AT3@s(GB{gG zc~Nqf^nwFqGbL$c;pAma@Jk{oVW32|b>>8~9>*iRQvAOU>R+#lqlgi3;N$yP>4ZE< z2WN#7RUlR$EGHjvwL}wj&O9lq-+~<3`S>~$^6{NZZ04&feoF#KC@0XLi$z7&CBCer zQ2l;B2XEE9nj9(g^rfk8#g*)egf(;t=HfPxm=;c@IEr7GcI{9fhD!X?cb&*zv&;^UQWw&#&pnyk@+I9sk%+jF)rvchNOO`Lm*c(_b& zb*sYz$<=~+O(j!dCsUmCcVOo)H}_k$5Dc>reii;$ zoffGFB*Ax52%$VN_|6}#*Z_c5z^bp}4-PBvL5kEKwf>r+<=(93<+z@GZ*mi)RmZ)ZTq@=HGe!`s9KNSY z?fVcPYQ}{Tp^$U?%LYtQ@#6mA$bz;>rXQ&6bG#T$R)V&)u%dY6X*IEYXslcwq{Q#N z9NxY`(&v^Fzc;Et1@M*UTLFA4d}Mqo$ESn~E-}gy{>y%MG>z3 zp@v)10@kZb{I>0>)m9%WKTJEdqLz}ig3nMYFC8ChLxGO|z5-*C9a6Rwx z6CZitJU4jVx$f2+b_Mq4dSGM1Dm3#o-SawFY_DP*FXA(R+={D$5fT9wcP9j2QtC~_ zTFNY`f>j$HBy>#ZS4by9b(O3L%NFm*M5Q?`30@5RgIS0sVURqRrFu5DtpAewbHzQ9y%{!VRd~&UHOery?*A zdLe>!R;(oIco;Cg0A&)!O-QyJ+7ikSTGRlHnW~)fgr46C+EgDjA9G0*UkIACk!1lu zH3V4*n75Ec>wZnk_D#h22--Z6zn+2e-^rA1KgSCAOdl< z5g3vJVQDsUObWXEkX~CSvd6USt6EmlvdL;0LzjJmE`+E?(M5#p>EUa5m)H2niwa$` zTC=0*A_3_ZXi{)xIB$U~yOo#)uE+;VbqKEP23JTAEx5vB;`}b8;}I|TGSjkz%1qV0 z%9kbhvQE~?mW%wV)++dt6~~uH9|B)$l7R7^wM2z4$hY#c;EUa_!WR@3&EXnewP9l$ zwc0#_FLIbId?{o5yG53dh%;3bCPrSS2t)Tfaq4r&{3b z^N~L1ja2H*7{5Z0`xxM*X`#Wsm(NNIw||#qE@}u&)>=LYY?I}hNxIGoCoC@k#s=}0h^Cby}!mk%{I)(E|3Ij5vs|lSe@_tG9B6@2(Gdjy( zv^{EgI&e=@sg)s`FNYua#c zq>5O6In9!h`$a|M)Le7CC^B+oLh8l0FHV(_t$cr%wS6@)*W49E)91xg^%%kVu;Wof zYp@l9GS0n+MQ;<(~ zp6;?(b(>!f!KSZ({ir1PJMoqt^IM&j0DqNZF%{^N;P0Jepg(3wzB!Rtf-A|_s|Sxp zzRT?|cLVs(p6@aR{@uk}6W}lT+oHEX(&ZlX78p&{maFb3-Q;7J{2c?k&EGMw`}`f3 zq@wf9K(^Z}Uw4_Rh7i+Iv6;z^HxJn8SBMJzmu z@uZXJ?~8cS3I8(jr1dpucMmb1G@c(^%s?u|Wma-Z&ndb}5RSWsXu6exEWw||AU`>m9~88Cmk=Qru7!9AJ!bQdSmHPNxh>pb=_CSRFji? zyGiaH{k`=p`MJ9!-=e<*D{hng)HMb96K&0O37Nfh3RFsB?{;E-KGn?kRC4bHOwM)x zV*bKH#a_2)kL&)2`O2PaA+|u-WH*L?pnx?;Ss}$a7h3`G#_SHZ-j)NZN5_Zqj<{d1 zlmy?kZ+?o=C6=}OYobcFvUdMd+$_ec?>jY2zH}iox>U{Of$#8xvgA@@eQo%EaSIc( z)l^Z)PZx!}m^Vwr3Nm?_L8&Q>CyfU{zdbSy9QH0sw(po_PkyQ#=CsHf&}xd9SpZSK zq+X%>zyCrldH$yOh(i~W@q2MpDXR3LHYnps`1Ac{Sou$UVwhAhS&h46QvQ2goDlJ5 zmx+mYHs0s$WX;8fx4Jv$KK-dbTL1M|<~MPkGeX}X&n`I`x_^WCaIFPj_Xc)U!(?~g z4ZNd;oVg@b*S$@etF&2{bi9?;W1SjuE7(-Xfy8w!+7sv}wRid4cBxpRuq(~@GIrau zDJ1N=_e5R_kDs9oVXnIU@>*yTnFrq5Nai3VFhUnD6OC3m zW?{rpv8VdoVoa@aQy&7vJxPOzc((@n7@nnVCqqv7H~erNcD+y)MySdxzXuBQkMMVS zw8Sv``tcMSZ$Y40dn%T9KGkC#XOJs#`Eh6q_o`LoVOhq3QtKo}K@XL5k}Ki#*_RSJ zN7aGwvOAb`@N~*X%;&uqHG%-K|DC1UR+tT)A^NX@(b$lZ?FHW#PmW z4wTULy>lO5O6zMN{s zxQw&fZ9d-atQh%{um@e8n%to%z`r!PZW~Wul>ndE=E7TG<}rpW^`R2WXk4JacSOr* zs9A=@Olh;qo8}58A8Hwmo5?LLTW!DmF<(^~jl-*-L7|w{+EXzg$!bWc@BtW3uExZY z8g5_;oqlV0yrhQktu7@su74avCLUADT1ZKaOA+THgWugI%&b!mab1|#5=v^!`2~KN zp@{&20vAovF6!YdLIJ*5c1evW{Sa9rKe3+1DG-1J`8%PW#=@VsMru3LYu>Nz%m_3+ z!wQ%Lqui=y!-uJSh}Y9tS{1FQk@XiAak%v~90=`Q>S^45;GINfhR~w~kgsGU`TtBu zJP3b(7HhZse_oCmf|Wyx6pXQ?N%8;L!a8t+zf#4un&oNO0fp{I;loek_=yyulFL(E z)lbDmsGsKDAK2ddKXNi?oB%Hhvg@_se!4g8svBo@eKr20+w#rw4vC-_*Z0IgyVY~a zmq$>@T0Mp~A|=^DAv-w~dqr0Cd`tvJdZ5sDrs4wPdSY^xI&(_w95BcBCM!WScV1S1 z-DO#=;u5O*`T)^SZ+xG=w&`Yv-}^3pNV~i9Lu%rUSry6;Nzrpiy7(cT1)|N%x8?0n z_8xqXR{S2{qnd94;;8S@JC^TJ)~)y+Nk1CCM^l6YRSV8dO7%Uunemae-{QI3=}wo#`%IF4&RcloS=7`Bz(bSC$%#SNpYI!uToqkwSegCQ)_lpf6>ZkBL{J^dQk+wnn>I*KAhPt^xo@a}x%ngt}~BxJuiHC80%>&IS){z z2ek_mmnHCQ?|pv#h9}G~VgLHH&Zibt0xrl$`g`ag@Hsg@p+DMRe315cCGPhj!1I$+ z6Z-D~KZ;}cQJjDu-zIaH;74)y_(24KJLYjXAB4%%B!#2=w?NQGArUM?D+GOPAT!^m z53>KM@c8MD-uL4ViSRqD^*yk&_w~gW*Hpr(PvaOK${G_ko$>urP`D)1&wx=brB;C+?>$kJVT~OZhrUUCj$jU%u1tHp@1d&bbQh)K* z_j});^u+Z+ozRE%`TthfJQcl}*=N~*=ckJdk4D>9yeYl?N^GAM^IKzVQ zk|9hAx;{dvap@GOaqaTrWO5|%S$L57oN>hXGI__bz?W66y}{G$M@;WcE+Y)|q3>9v2g(^TXf$UXSw=FZAgAG&4TGoYwgKu1uMq^$zpXyPaS6@cR=m zl8D>x;P>Hodz@cS@T*!JpWow~dw|~`HYC8WWc);*>@0VLyGEda)yeWrA*`!z0zOyf ztt`n&e=J?FIbWJVqkNMmU%O1?Moo(}YR_Nyz|xOLT=zhR_AC{&-u%v>KO-J4L-jX% zC}A8yXr5E=*ouCRq8?l#xl3lYaR`X7zuEDh^k10zNzbF8g>7g+kx8BA%MaB{P0Gg4oN~9Z>p%%!b#)h0+1R7km zkFhMn{Dxb5>Z zd@mb3KHu+MH`6U+?)Yn%Z4KOQnBx(uOTpkKe@IIwE6MDks8xYEI>i)BX*)&lK;@Ra zrzjwS`J1w*Cvqp6IWWGLJ{FZ;n$mlgj_7QlOf zmv81f#~faNxt?KpD$x^YBW+Oa;5{%;>w zc-_yEd&e&&FA#k}1?lyM;|d~5M??2Ei+yNxhuDWQR7x&i{pc)%`ikd|3uQMLo@Ful zK{v;`b;l~bwy^`5$;Y4Ebk`HUNIkK32s(i`H18`l|4FMn2&;+@F3XMhGD?f<#TGU; zj{xOdpQE(cuD9tAmO>_1^HKoPjp-&uT&6yzFlP-@X%~9?=Kcf6{yhBoxYFC_x$ySB zzrDb#f(}hD@gr5R+0Z%{3#(g`7I_Vus;)afwAgnn`54Tj&RWh{^SRNB{rK>=$6o%}|Bd5%9&Z2A!T4z} z^!CQ7$DZE4_PgVXUsVT%m(UMfp>D$!%3|zfe=xU**NEI#i=is(bVAZiUsx{VLDX(D zBO;vmRC+U&J=E7pelwpNIfV>p^}Z9y)Ee|jvVC7CU-uHqj$(<<3de>noW(uT;rF!1 zu<2dk_zyIdA;>Z1m#9zP($x5NfFKGvJ{I0%A;lw0d?@mlv3 zWWPZRqN8if3UAxCiwwduBZl|mIKLoS;5!aX?%nWGyO9L)Yy5Q}d9&_G{*SG6qSV7HDLl42^S}_sJ0C4>#|V0mvU7o-XGtG!f^p zan<3k$(MyI)XYR)dqNb>no{kH&{nNuJN9a36+&C0f0HG@Rao*{l_kGb#O1dMBERt} z{92i1Zb;T%ztpS#>8Hp3KD6Vj$MrsR;Io{^zx?Fb!|U(Y99MX)+4dRqPYZv1?BNxf zbX?)}=d(V;eY@pH$KL+-EpYlc+LP`-D7@_ZcKkkN>TbD8OMed}^0ZBji)3eBx#mt{EAW*{&eN>h1bF9m2Fz^ zJ68G4b;}=`<1TBKf2bS2{GmJDMsqv=x@CxY_9o=ZCyajT&?mK`zW7YvTk|f z9JiC$w>i0GX@wF9XQbsz#EFqstqcttb?^F`%kV?SPPr<*Qa;r?De#(y=35 zMq|qi9glZld&M3-+OkKFvF*{Lquc8bj<&WJd$iKn^|HSUf%UQ8-yK!Qb$`!&^u_a5B+~A@vQ#iSCbN+Uoa)&e5i}%#^aqlVd zgbP1WAI8gqoAr9}HT%68j!3wR>)!vubxa)C_AD6XQT}Tx2>SQ`A#lKdZ6*1x-Q=hE>K zkU4I|kUO*PT6avsjV_t?wduZ=yf=iz_OJQ)A)Du1t5ayPm3`-m+= zY#PYpF_XsDs7WInH)$x_ma=#4ikURRV$x{mtEvv<`$)AONb-H(KKbPov5tww<5XoG z`$(Sc(qiXNh*#;>Nbo*V10=eqztqQDL^GOd0AxePaeZzI5N0J z{z;y1ei>Q5^OEX0NU=MU1l%_wJ=~h7DX(IeP_?IGUcO!e=%aq1vxjP-k+^BTjhp7% z(E9Aq0+;(|&Vz z>4H(`Q5I;IIH}g&U6>YNZ7+s@qsh5()k##TZc?|d^$fizM|pakKZ@5EPiC=K)I@t?na|PST}k4Trc!a;he+k7)#Od0@NtRkd$pj#BtZpmOnkMWeb@W0o4hPM?h)Gy zIO=^*yo;4@AR6DI;ZCPD`SN8|2qPo3(6H|%>^!Pg{psk|lP3Z%T!{}hKbbvJ>mWSf zMdg+o_3Gvcj@_DP3keYlwU##OPHK&9nQfQi4X#p6B=}?#9uHz{1)F_^bkc2$VYGP5 z_Nw-hf4Op#&c215{|$`Gvt-7?W4`l<1X(l__*gSaoZE}m)8tjnga3821Y`!s<%RDV zEp00E1W3gzoesq~3KKotfmZGspe69ZM~G9>rF0GFgmfLZvUArUCrGY`&>bVFC)3+u zF+v6S!*9nQe!Jn>rnkH=F`td^cYj!DjGy{;YsH3ltKq8LYB+FxR_t=Lq--Inz3bld zI0QvI;{4K8*A6g9$+JVY(eK!AKptx6TW4o&_||gk?3}=Bc6p<<;R|)rx4Rw{ulHs- zOcfLfV>4xAnKXpY&C#FaHUD(-Zh2nE?2BFcY4$~RgQz?=jC0_%e#hWuimm#;;kEZ_HJt*9&dUYryol6VteDGo zzxnYkONhJ}278eTtO-Y?VzhNchSSn#W=4+$e6L3aL+Y0V1|ug&F_=nD4h)7fVKJB? zwiiw={3X}oFY3HFc`%EDJG*S|vO>5^^sK;LsBN@>ISN0D@t0Yg1Nh6xdUE^f1*Axbma&QWM7dtp7^Rb76v*$Na zG_d(e^!}72T2QVjti%hF8Qp<+aaUgKGS#bmam1lFvA7$B0xySm&a*>rD&&Si`Nfhn z_WyKsbHM@X z-<^QZ_byQP#=3{)v01g-qVQF_sjo(WUV@l(h*&&vL;@NQO_IMOOB3*!LYNjlTki77 zD1Cyw7sF?jL z6=9wA6`5@(*~MM1*(7Gy3A-gL*q<)pv&Aj?3b$}QF(K3S#L|NKqvlgt?@3kg*sS=J z)DboRQM+yaQ@|%}`Lk>n>G7No;NJ|LESWYc?nS_c(EL_XRWD3U6X z!A!Y5R7jQU3aJNNLA+*#+_Ec9R7XRn?z1{Aa#Grc*oWgf*n=u3v?l!Kv!V=Bl9W0d za$e>>C(lHpLYk^wIZ*fRaNR>xwvEeM6L6U;N8g7mT;}7aR8;B#mpA_+${ZkxN3vhV zvl91fwf7z5UfHi()qYXBDSiZ(SX(z#_9(t}_d!tQw&+(|r*4Z{QO;2zen-5Ysr2rA zvS`}mj(QF@xpPO!-H9=BmnFNLxT8N~M@cXsyXSf)c}FF&-v3k2*wHwU*ju4fYHwfa zX>UDLjk0f+`F!kQZ}I>Y6SrZ`Y4IY?e3G z+UHQ9P|0iOayAQ+H~6=ASsOfFZE)2(o4>95tn!*J3IXLc-Mzdu<5~uP z+Yo?uRFHtJuO1pl(!dFu!Y4kvDriLbP!Co8QOeQV+oLV=Y+RM^v^0cOk zP9+eURbe7=Yx+h8-}&<>V-k-dz&l?qMQpXEdD~p~G_uux@6LoH3=b;f9h)6p9DTj( z#c0Tb(QQ8H{wC5}bsrug`x}^%c!YnqORlbRgim6_RB5sIZTVKoW3IY2$+UMR6k87P zet8V-<)(Ty9}a=|0_LN(f3sx&&^6Sve>DT_o%(+-Mk2^4D(g|ES)K*eP1>yJ^%PYO z0o_R2sB%uiLCo;Jlduy|&}aTTcHkc6V-E*z@z0_=5tlDXTl9ZeKDhOx@2btVuc*&T zT|i5HgC;Ykz7f?>k_zXA!b1=ds-8=RR!rY@ko$?2bUztXASnF!w*`gU?W;tck{S+x z!jkK@h{Jk=swWQqUY=It*Fxj##sh}R;`m%fKyT~C31ej zmxHYTINi_2-Eoln*|~tTm;2dl%7_aw<9>DjU`TmHVr^<*ZJnYx=ElCWl04CLNAP!iH2mZNsA z$midD{vE-;T&61u`L{48rDtxA$#i2!#JInb(#fiv75?qFY%x7ms4G@N-H&?`>L&a! z#$(3vu?HSA;s+7Y~TDFXp@XD$IZTIrQY#|F%psWCu(23T+W3eO;=iSCwF}pmfLoS8 z&!YO^Q3Q)(4t8MuMLx|@`d~HnsZbN~C(9&NSYNR{R^^l7X&mH7nH;%PSSH6fC@i~U zp|U%^2hhasc&24{%)!_QJR*bpQ`xxfgy^?VmvDY~-n#*E%>!}D5|>|lES zFrQi9Aogg{Ar0xy2;FvuttJ`_%IHeTq+>xq%bLZ%xJ2>)1dUP5_7;bWWl%r|`nKzy ztqOBe3<|H@Z_!-QfAX;h7WA8tjVK4bZzkf0q*&?Il5mtf71oCP+(dFVMM-|!4RY8> zF(DZ#K0Mn(ir`T}iX^S#N%45U?$wKyw?c3BBr*?+J55x@c!Rb3hoNFrO$UlLQrvhd zPC-v4UOW}2)>kMeo{E8@%sK@{)~PW$=YL*}X(N~AC(AjMamWha|8-l=vAiK-r_aK& ze1&BX#Dtv`P5Z5jW0-aWAA7(wubD)W6uwzrJhgWfauwT)H%#D!@P%KpHqXQ6SvAkO za~F!iZSR+r<-C-N=VP(@MXl%N*ijhIEpvJ42#n~;xsAFt#;!Ly%^kZpY13mOrIS0fo*&)27yxy6icnLSqV!3zXMDf4D zB=901P({WHjn@Rgs+|0X0Qjx1TX%qR`*g%Ctz~9KvFP)}zel`!xWEGU7ArHI<=#(;6HvWGbwXwZ@F%mNc=b#efv=CU!%Bc%%sw^Ss>huR{6!}({yk{(uvy{W6Jxg( zaSxv)ef-$asEEaH=P8{$UMrb;XaY1+g##+XYbD`^71HI+r^5~ zt_gdZ6s7I?)pO3ILG;yA`69Onm8}jJ2(AQjjUd;bfv;nU5adF2`=b4G{?W<^mz}PIw08vXp)Waea z98L1=^WVQad>>hKXz+bFKM}sJXNHTwu8{bf1xJp=|NivYs5>>q%GK zkfJbI(P72^8ZDp7#v?)Mfi}PSx8{HMB*Q!Ie;zu)ZRV$kr{RXDnFGRa<$fB84F3AO z;c2mitT*=^o`#D9j5HqAo%nvkfAPM@e!nP3-ajkx{eo`ZSNvD#6+9Ht=0i@dA8xfW<{m8 z4Z5c}e8$NMB_1+^w`aBer{*2M8!h+lnWx>dg#L(Xx;r<`)Utd*jgDDhm_gk$w##!K zPR)`|B{TXxqPwjYrlye?R@mGmpiww^ne~xJ>YH_wOt?>qe%lV+kR&`M;$59k^6Nc> zETVTl6yNL?9H&=+!<2vtYvz8fB|>G)c~{~RN5XvxAqZW#Fwwt7oJB&jB=;NF=Cyd} zkn)MDcJ-8iiH$}wUIolqL0i0@5ULs#b7#Bf8MTJ_D7L;rt2?6%b3Oef28hM2g2L|Bp-+7!S8c# z#+(Z7aB7+|ZJ9Hs32Tx(NVHr@IjoMIvKXypFP^=2*`K2I;j1LmP3;HSGPSus6JcYz z7#XL^+NQ{2CSR|RROAgyKPCcNo-OH_y9kCeJnJcxC2)`Jh2HTVkx;uaUND{|yQykZ zd%>&wMt{SWeu{EWbZAX168(=#u~4L01=PwQbqDcXJJ4 zdw09j>2rWNR(f#wC>}y43c>b%z92>XYTwI72B-0^84Yw7xR#DxbsIT?YC7^hHB}Pc zFNwadju1a(*gwn6WC-TV2y%?8L&xYa7&pQ~P; z!;}NBjK)h3G)$;FDA!Rrne&PzqV4 zM@OsR3d9S_Z&fJmOsr5!cD|&7XjiE3T-;Y`9;r~;X;0<>NgQL>H9J8iDCwa*sqCKJ z?uV*ftfSga_nc<5`klV#vsep7Or!S&yo!YKPf^aKYH589PZJe(9mGYLYqemeQ2X$2 zek}T|53=--6T-#R=yC3{);pM4B6m%SpX(QPZKa6a;J*YCWR}McoS7uE#N`$93NAhU z!uz(!J9BwQDrlUb>TDoAglDI`Xb-FSiFLm+H;30ew~v=g?3d3~RX5CW#S&rFd*zLj zt=^;8<5+q_%U%)d|M>>#f2-6_W^#wo|I_=`vb**lTYq@;Qt7+S?)!w8lsC_M)t2(& z?eAGF?XT+6zN&}zqqj)=f-db(>!JPk9+CFDXQpn%2cIVHpv}*_^%oFd$#9vuUsbN% z9OZw0O4=<2Zz9(DiYzTD9+?~H2xmmz2FvfxL*g^!23%&&ga@cwuu;^Ax(u$2ywS%P zUK&-GtuJ?M7)|U|-!ke23{m~@wXAQtE()^^Je{#K`g`CC-3+Ap%}tg@>{_=qAHRt} zu+s3XvHgo&Pq=v_JIm7&KzGtW5busf>ubtl-RiZ=+*a2$%aJV#wTnyhXM9Bv^jD-W zt81un`yx%gg%L$Y7U!@`Jvg$UbrYw~A9NP@sOFaig-L6Dkw2v&Cw`aBmM#f3-n7Ee z#UuN=>co}9o{ua#(jbomyZzqAnmZX3-qdU>@tTzq4~1I`*eL3(H=VktC4s+5b1kGR zeO{L6^RnDp?R)6~rO%@u6)$e3FSqo0&Rj<A`MTQS)nxji#8RZ~*_onFLU!&NuFB(5R#h{}0FIl{9w))Mj)(u2|;Tx<+ z{_|5T_<^7EGo?cO5`(x}Z`nswGVxu*79yJJ9bv6;FRDh-@hLfR(fWDR;vLAlaeAks z&nPD1zj)9>f5^FT?m(@nLGY2n5`(0?v145ueY9wc*3WOz%~c}vde%y1%jCW(YC6e4 znxznl!Tp0zC9VI>Y) z`QfwCo){tV5jC&P*Uf2oWzHhDqrV4DXAs2Pk~bb>(H( z13yye_MC-dWV-e6LW?SgzBcUaM}2OyFIkekNFI9Vnocc*X)!c0D}H`mT4*|IfeeE@ z1ZQ%0$TEWXy=@4bX>dx-jeZKh;MV+1*6_5}_o1}J>Tuu8(!Bd>0QAbX=QZ;b!^3?O zoy3~(_i3gFhh5a#C{4YuxgK~pVS2jxy6$;{)6De3Q>Cd{+363-|0giBiJdxSAsw&i zwc&*MWl(ge({D1x7M&?_geW4^9w4P}hF053$;*ur5=&kWF}7?B=gLG&)kNQ8qTCMm z2Af<|~*9^p?G2LZhHnYji-+_=y8~ zXWsdS>5}*{2wBT}{)5*j5WCqF#=Kf6U@MW5p0oaj?5odXH| z(eH@1K{Q+gWCN_RDUL+gnNv4EHN4wgb*~COKm|*lcM1m6W>TVl!2}FzT~Cg8mYJ7J znOJJX5)i0OYaZ^O_Qr6MvgV$`;;_V(4Lk*@n&RgTa|Z%BVk~ft2oKC0o>m^btnGR| zgyP7tvdnbr(^m7|Rr20mnlGJuS$QzmFq;unYQxSl*OUK0d+!1#Rdwb2cXt)gK4IuGN2`=*j2MkF7vtzP$&hZ^#|ZLhTBsb0Fp0?|cQO;_mC0nh z8I#HQh>rFHn&v4FMIgS-qslT08s#bd|Nizqryfn?BXQ<`|Mx$B68h9RXFtx~Yp=ET zTEDgS)Tn1p3GDLGkv6$Etv>Za|8v#HU*xAE$GZz(wR5jCljdgs{D36Y^n{(H*sdbK6*HlAQ4|68Y<6P3Ohb(}HyiN8 z8PXZAPPD%kWrds{);zD*WZevg2O-ONOu+JBJC87}{d^F+NZ*i&Bnh2;fE6Wzf|xyy zhVXMn@m=F)&&5#5UJSKl4?JMccxTxHQB{AZ26Bep7hTOHw9UlX5(2Q2=NuFJv7^yY zj^Ws^+~*)~7!g0uXDgZV*;YQ4`wTbJ+2#XY>@8F|ZfgDeTXUyrE%S0&(d z=6b`qHh30NsLbGi?;uW$KTI{w7XGt=2G94OICQ2)fBep{_t;p9uL z$-Sz-KKSmgxufTwXh;X~GRz;A`E-Jevh6R^LV*@uY`KpX+Rmh{Ie(^ZjPM;gk{OoB z)H1~MB;i*>g)GkmQi5LPM{CE>-hF@~ZKtW`6uBWVy^ZiGRFk22(*fj7)OSoRc@l8; zCwx8+HJoqjqM{M`^~Q#Vl>i%>mpQ*=IWu`4D(q)XmuqoNG6!l~R;aLlQTYsv{hX7H zvHukjs|fTl4ktEeoZldNosjbP%U(YcyF)ADuIK?sX?e@>)4=JbeOx(@T@24M1jP=e z0sc6$4+9`4M5p4b=bgmDlyd+ZRJ1y94&YZ9H8i>O=Gwxg9J&3u&%BNvu-lCwoj8fR z)*ZPi6<;&&4CEW_TYrIbKMsSX)?wg0Hhn+La(MaMbDxxrv9@{XY^;bq!x?iv?ir^e z96~62BB4InZHnA3IDjOV&P1SsasI4saM8&R;Ovx$7UzG+KYb z?!aI0jh7}Z)Bgg0LHG@&{gSM(hxiK!)Gl)vsLzKw44nI$m5RaaN{q*#!d>ud1yZ-a z$~5$kp7&RWcNf5KVYQrL`8jin<#;%13Z8ibX`ICwVrxpru4BCu8{VBKVrn;6+8)N% zd0qL>coB4De5VFRCq-IrjQ)fynQ68@xEWUC;$aiG4(?oa zVfJGmxg;C?h&b}!0sLU!pUOs0l0t+ZVmWub?EKws?4bG}Wi&f&H|#ohvw3%mF%_=L z-C%yr6*oqNS`P{HIHTa`eQJ_sAQ)$gyEow37*5D=>!*^w@IB6B7e$F4*`4r7z%fG0 ziN(a-sr!NDHh3euFfq;@F`o_j4)m9n$J6*YCiDC<*m}Uz%Jmm>puL!IP!Sq~WxvBI z*g`ImjZ*t?f_%~HcPO#WV;4qQ*mT2|(aJ^*8rjEUp8N6nXUQpX3iKTKNVG7u^dNP- zBulNAWU29zF#X*q$4|BVvl#I#yd=Bnq^eFkk6l@+|D^`_WNPHLRD3%P039k&YWtj1 zQ~H5h)P z58?kK^#UAwIE*QxFQFCj5q^%~WAq{UCt8P0{@9~f8aoI?#F|| z33L=5xis*ghyw(THekSvS(tVUJ_8FO}CoIUrgbmXAt zCmUgl$;Jk+{b0j+nnla6jrDzZ^q1r`eK78yDo4%w8)DYE6u+2gg^H2>76sK8hcV|O*)!(sF$C_j|Ip4ShB?GM&Xql`z5?;jfcg%^Kg^8~nn^{uJ7*g2%VN`3ej9_I z^8dk@T3r7Tvl$M(FIv*$wUbe=@;~8CS?z=2x|ZQ8`?-^!4;p)Y^(|;yQMlhQRR3YA zNLAXePj_r~7RyiJk**WncnLS%+H`zV>rv??n(~>&%uZx|_x$Pfye9E5b5OOSd++YG zGVGm-a$4sZG+@18deKJcE44;0Nu+Z^kfIihU&4SP0TmGew5v)6GmaJjUM5ha(W*P0o6@+SmFGR$<#t;r%Gg|C?H`8n6Wt8oG2fga?1W0$#D?R+E0g&MsT%Y_@m4!Jcj zto+OFQ=}#V@waJ`B)-SQC7-ij*qzE=Fg%^Tc(~*O6qcPm93Ff{6w%cnnv)s@98<`(>qxq1-@MlZ~@;JKs7*rMcur^o*rfpHZ7nQKK8*$E(&&upDchSbnzKJ6hNrTf*`0uWr;O#se053RL6J^pFWSwwUmC@h zWyE8}7*v@t*fh^IHS3eAO|2v!td*VTUfr*e%wZJ5$D9=ydrEIGENPS$e|7FyI+)iU z$h=>Ak=+Ahqq_Dv9bbjK^t{T}w>5l?p^o*M`eJ>mY~7n?j7$=&AO}_aQ*x1v4`*93rD^0{vCX_)W5&G>M;HL z-i)&T75#^Yo;SPe?Em`w=5N3CYa%=UUpucF!w<9%P*JI22R+|=fc*MDD__-T&U%;l z#*6iRhtF5_r&kr@8?WYa`9L-x6JRkrq~!n_kHPTFXT7P3bQTK_D(%R+c(swjgBXOM zywyqt;y#4p?{IYq?C`Q<+S%8k{9PsS67>Pl^;#K)mhzks*0)r8EKmIcGB0Ww&wK%B$w_7!sRI~=%zg&)aFe|`@_rq ztrWuh;A6P-TR&oC8TDLB^a@q_#ERIe+**nYIv0O^?mE3SRJ2%Ydd>Q**QY3CLaP*n z0NZBDRc8_|DURXV9n-#E;|@GPdLpNldZA9 z>KbR1vC4XW7Dh)Rv*Pu$dFXW(KXBOxyVR zQRuzNHLZ+=-E5aZ^aMyW8%zU8^lRw)sMcw!v&M9N6kQ)>yFN-dJi5+Lx^7T-LB+=e z6_2Xnjk5YuxQU=1=Axcn$XTUcsB&p)!uYK;1Of(dimBA#5UCUZX6t#Xl>ditM}YvR zs(|gOsq5IFE>T%!B^p$H^Y~y)X|wdzW93Gc0~)i~`B8p=$#3&i$e)Dtk_;`!V$=UOq3Nz(6KKQ0Y9etzq5m@lM8V#8ve z;NfAsvv3N<&M%xs5E$;wsi4*NwjSkWY6ZgfT|i$sYTMhwv832wdbob3?O(0jWU-=I zu9P{li7jBmHO6XM`W32=>zb|r)sey`43N32ALrRqI25&&UH0!mr-7?n3p3d-*)eYU zCH~bL_m~|nt9lIvm3e3DGm7?ln8|Q>Twkp>IoVgAK7KWOk(yLwHB;H=WuhC|O5lE; zi|J@>+fhw#t*UM#BssYU&uw%g9$X@qH_tn*f?ruq=GS$4@wKgWUPebNZcO3g_*FV{ z!bWxV8-HqceMS_5Uj*Xiq$XA~7k4?po}!r2YAJVlANiIkmli>j>? zlo|_YrbddNf zhKC}hbDYu6UMAndylVsdxePC(ag4fwM{G3;!MCFBO`A^DMeW6$9d^8ac?+MH3;#kt zHR5=@)z+c!#rvGU?na^ZBAflXZ%xV6;X6U|+dB83+Kx&X?nW&SAJBs|Y?PBL>CRp+ zUYM6k_(!`py?&}+ZyHbfV|?q9TjSld`Bc*^&e zn6$fOe4l=x$qr0w3)+1yb3|8Ox%M`-PId zh~8WlO=s(RXi;_|e6jd05=Dr{NaL&Qo_CtMf)+kzOR+Z|ok@*GxNbxZw%YUD`)EI+ zq2;udIy5ZfAHw`@3XPKAz=#|=MI@9Qx&LSRZ<8+twz~iJ-?9`2`fsOW^ZmcXf7>Br z_y4#3x1){Sv)q4M#ht0eg{wKfrgdm4Gdd+xKppVa(YiA>l^JtXDl?+;1$u`0jdJPOT0QZPO~<#W zG|?lYa9gMRak?=koxzyN3C(~TF?862uqT+N=g^$Ar0%338fpaa&ECY`u&{p@k77&ZrXID7un)ZIa2!l zXzBM275e=NbU7S3HY=n!lYZ~rwE9RCc{F2dTOAcWZc1QKJ+5|&^FZ?0y6Z8n9!C`O z<8!|&RsU?G>YwS}wEjp{qms#EUzcug)N50GpNiPx2W{~(z5i;1zq%}%x~Y#O@h>)* z2_IbF|Af)^)l5;pw~Zux^!`lhIHlzG)Wg(qitL{I!=mP28fu{6>LnIn?1^;jSdO?L z%w6-Mz8zZ^&O(VtGy!inP`L)eFQD0!zc)<~8%D2ASt{ht5u%ZkLxAMyHj$>K+n5bB zp-q+<$NT1A3Z`p*TF9Flgi(diRC$iy7iOcM zG11t{Jh)hB2QU6=8~eH4dExX0ENXvwi~wjK)oPKEwH{IiiFPX)C8pG4XC<9g=NNp_ zSeu2eZv#sW-e7CEp5K3Y1z`AF)A56IuuP&9zwh=L!3V<-H*fc=1H#O*(Ql@+XDty9 zlX++0Wc4df**Y)2(OF!N(~W@rSEkF{pm2tL5;A^``V)`L9gVSe42v5}aNBE?oi5w8 zg^y@PXKJ=@D8?Ihrr-q74$PoEH-`G>+=5Z?70lQ3USv+a_Py0@pB8`cNhBFVv*=|s zF@5BwJ;~;e#A1z2+=!l(nR`;bdV7QDd8TbvkOXV>>RlRKW$tcVV0v5eW`6ORVBMHG z|IcY;3kFQ#c91LnmY}umPlTcozQ}i44t6~V!mjneYO(8Kx1q3LJ+x>& z)RnD=Canj<`UIj751an2mp!|&zJDO(SiZT#D7gY_Wb(u~}vHwVU$ z87l!UX+6|xJP`zSq!vLxfpCy>o$c=naXL8 z#SpY+8Y&71vG@9t(YEr?!X{azO{g-P1L-?I4{X&opij}cM#qgk(zubnI*b2VMAq>u zXYr495kD~hV$Ls^?}@woh&#shaL}O8R^`UiN5RtkC*9aHsP(v^a$~qBqqTWC`>}}u zK>F>CV52k|>G-ebPYr7`n6_tB>=~ZBu~(&0%Xp2dy*0O5_kyYn25dv_e%+$hLX#VR zvkg`M)xxK=K8Cnlktk+E?#Rd0r>!)bi-ea*o(;MS%#XxBDA?JL!Fp}z8Ewh(ZghA- z&F(Ve5Hi!Hp~XGW@2^9@zjuh1AyGLN@hP>9OWEJO*b40Isw$PS<4ZSW>A#0t3a8Wn zh)jwQjBCD_|02~D=TaAg>tFw^zrIiX6^MZr{y6_Q)P8}@{ms(PhyvUxRW#wp(Lr5e zpy0r@*ymTB8b;drDSn6HcAMr6O=QkVWR9l_%72#lo^zUg!1WeHNipxHZPbw>fG8-V zz(DuIHd?Q1-gz0K{cs=K(#^#D*`nS}T|qHFd0eqdCCULOOa8K(`7 zp$~1VcA#8eivMprfB7z|O^qa<0?>Vs^?e|H=ba=Cl>ZxiIV_|`=H?Pgoge`=HPZzP z74*Lh7OE`;Zo7GZBAqv)e`<*k2~hu--34~H{_T;?z}*uV6l66wTa~hk%+^Hp9IK8< zL;(p^S%VH3nWU)sz#^9L@bv$V`;Y(jFT4-`LP=Eor};B)1cCDh`ZG@=CRg0|kMd`3 zkCgFLqfaZ~twMj;DpriDjDr11@rfD0DBSq&mJJE?04;U|VO*1T1ncY$84^xPA$kAh%XS3I|B&)#M-WDWXot*J&{}`l3OtpHyneXN zF(hr)^X1`wz+{cVpk;RjCNN1-5zv1ihirTuk_f?QrJC725BK`ldhDKGuq!)Nxmzf= zXJJgovX0syV_JKTz%%yef5}7u^D)N*i)d(!nD{{RJ@sAzTQR`)IbL8Ec`90 z*cLCgh8P8E*AAww*qkZK-AL2Y%6&zkf6kT4vCn<*mPdbZ+?mfb4t00GNL~bRUJB9N zlut$05QsV4yRj<=vvp&8+=cxwapf$!Pc*u4?{D>^T^g^~-{t*ceZY+{HeA=zNLnyA zd*bNx8?fqjd%Isy>PqK<=w;Vq$IT`L(kYz8nd8)pnNq;Mku`d*RQ={A3!V=4GeWXf|jsoRFdV zY*e!HkE7$alZbz6HSb4wx$L_&Dd6|O8m9c!sqBdpX1&z!&N||E+fS=bXWO5@-~#Hw zC-MByRHU=NOPT{7jXeur7*B_z%6`vHG?#iQcM@libR_xSNCt zBwi9AaN%B2N$YLyLltyzBDDvzk8ZvAvgzB;t){1h`An%P9B0P(n9?f@ZenRY&#I|6 zxQ%&Gq;vn8&KGKGHWi1qd1-B8)s*UnueNHx1)7TgNgTFlM{-+i_d;C<>2m9%xb6=;l^T3cd&I$U$DxfpJ z;pfssO|h_8w09GP#mNEt zM=NX+PMeBs^V;`~XaW02oi7Ho%kVOL+=9~tcZ*A_$OtsZo4wsHC72IJp_wv<`VzfO z)#sG)gj8&sw{ZXc^t0u&VgXvtwmGxh&1_DuDM0y6H7GnGAru?*SCvhtOAZEdEA&cS znfZL5wH;CwEcuf+e;hQ`C#m#|(z0@4Mz~Hl;gclyT7D?YDX|p4PJ3sKX+4}-09@Ez z@a-{H+uhx}Fzl05cANX)nHSyol|_#}Kibg94sTOIXEk&cPE5tNGjmm!{KegbaF}U( z2C`rSdTwc&Qn8I3`E7^E-Tl(QSqW~1BUH2b^c@R&=-xOx^n=Z3d(+x;Qy|`pECIh~*nEjX0)h;k7GETzKjUQ zQ2YHaH{!s=1vG2O)lZy;Ap`U-19`-(hL2XW-G?`??(YPj_~C#n_qF%!>F>-8Ig^(G zH{UiQ(OV5yrtdpMv*Su+sOf0{Q6ODnJSX~uGWx-gYo&~R5ye~Oa}ZG9v5DS9^>xCF7smNR{_5<8YEr1cO24fu z7&}jfm<8s@OIED8Q1dhBU{vW|sp?>bU0F@dHRrhEI<{;`p|(N$;i0CmxfvE_d}=l~oxYDjYFe-gp^M+XJF)b(VeY1!FxPHG3iFBX zjhzxu`3u-^mraajZA8VaX>LFeNMqV5Q32b*EC!1%XIL+4ek$ez$3!aDX?ap z&Z76+P3QhDdfFX@=tbAntu$BT-q@v9B!Vz_j2BOA5X&EDvJyPS7!nIUXBfPsfp14w z{M;v5R1Z#=AZ>r2lq+Y^5=pd@7D5kw2~oT=DE(tgLx{46uFu*me8_bB7#>magkU%g zeSNmN5WT(`*av+pl?*4l{1fQ8n%9?nOmFiEg^`I>)oA+q9i@BHKAlCfDU~!i?~pMh zZ23RApX$fq``NzFj#8j{m5q|o)xuE<9uGE3Jkrj2fJz)l`BB#=Rwb&x+DZo^=!=9R z$Pdxu5BVRTXi(0TA(!&k+?S;m)|sea{rYl{^I<`YMsZ7W?q;f z=~neM_@Uge^Tz1;CwcxD1dQt_McTu&%_~(aNPSg&<+<~C#T4R|>4niM_V>ESgqdP9 z*-Ym~eO&?BwSvtPBy*ItpDdU>p)I)8`o@CEXUvJPLuHllZ%6-}liFXao-;=OjA-w# zZX4TM{kg&sz17nSwY}BpLZr9)BHmL8tytTvTfjSC;c^7JNdq5hG3h!OU$yux_hgx%ahB&X`P0z+0cd(|Q|)ZX3TUF_YLD zvL=tykY;W}J?px`93eT4vqF};*<~^k^pBmaUrkFN-J@^MJgN-KZuW1KP1((mE)=_j z004C52C{|Bndv^LTKUg$qRQ zm(|ay%l-98UT&XSTVG&A*X9nYET?V9-)_MtXb>5*wFYiwSV)#|EvIVza>+~m%S!{K z@u6dt@gf=`n%djDP~QR=t!rHW*hS+`ts+ZKhm6k)=PR+u{I;W3O}ma1G4mgyT}EIU zuaIHkk{kNRM!DoFDChb=Fyr7qASj3%e|AnPz;m?UUW=brXOQ=gokW?*Q)`{Y8GZ`E zVW1QZXlamfL;u(brUz}GH`4^30^>GEg+AN%u$%pcs?R-sD#z_*zhS3iwCw?XsnwNy zoCcrrWkG}jLz67w6B5_thaUOs{)aTX{bSpY;Ts;JHm+|m*F((pO}e)JDkd?=p8&1C zuB`moD~YKxu~%#R$6m>s9i4OP9{?Fe@tZ3?dqb}}gad`!c&ZvTht zZCA}Ct6PTX=pdAIg}d;T1*VB1m)5|!Ca#cO9vUfrLqjiidb+@eET@IC54n+_hxw3; z^+*L-kJE^)8|EzTrIm@lTW;xH!I|W^cQ9Is&L{NKrKHIH7NX}~ZQ@irlLNnA&q<>F z?e6~REWNK1yf&@2lT`N3Vi}E1rzX-=&_zIB)aoqWV4hX?lR-$Ys%7))#<7-S|Bf5s z1UQS^`4x24RxoE&*ezj`Y}>(CbZFAt_Q$lAtLB_2ypm5;dO%?ds6Twz_8ZgWw{^={ zUnj21b^aCh_3ZZ>7f_hY)Z>89vOj4Z4}A98o^m>HD77vimx!+W$38tqx72KI@}n=6 z4lx)wpJppnoYOn1%I9>uo4t`~hxY{o#+jv$P_I_;)l}_f|4r+=d18Ob|FdvjN_6Th zzK0irVIrt!a-{8K=l-Fj!oY_4IoMD3A{N$sDhnzpY%`CYj)|(+CwmR-iU~g4#KR5S zUu$xM!w>AlKW+ybsup&YzUuRiaI?N;95+&erN;TLTrAgYip=JWK7>jP zahHwlOxx7r2Vsf9Y@V$unCfZal5gZjIMw5H-9L8M=%5)`+~wRV($9kLRnQM~a}#?f zojMR?4PMopD&xMZRgWc^p^t`92kb-8hRL)O-m##(#~WOv`356LfKd3pVCSba7BAHmt4^~f8Jr0i>ZDdofY2<4}Q zVRKDl+^%7B`Kbgs=MLT)erG7rnl20T-WrtYbd#ok2Pjk5XPLhN0Lta~BDSAEXQJLi z(7OI}0Af3f_d^k+g040OU-Hj@>_g$-%kU^iwF!>xc8TCyvQBiEjgCNz0JEKPrtVC~ zcR5S`o!i3vFm9>L&n;+(@vEEIAO0+j~8fss@${h;n7s|9Rp`%PMyEvSsVR>I?+@+Cz{D^K+F5<=;!p2VtX zqrNy0!FM|>n%w<2Lr1yJI|fqIx^ z{Shy|!daX*ROLcdDQ!eUsu~(n72zhLs+$Q{_y>!rTGfez9I?}R8UqHI3Hlxc}Opt`w#X{qk$ z6jbLybskig3W%(5O#j%cB#&~J^IA&O7vf_rMvV5n_Fs2ils)TA5#a6c_ zLapg(lA8Cc!cEF=7k_TfM@sTa4Vm{h-}c+ET$;?PP!-IVv~hj8FDK}fp|T3(+f_Ze zmN}xKxpOOND3I6Cj~r95?`;r{U8B|CF$iH%vC@)URJK0d?6oN6R}WmDm+&2SeXf_B zATu*emk1Mrd?0hq6j0u7Osg>O+?6!UQINjP9N?lH{rxu~yoD>&ba8VS=+|bb8vKRhs-jd%c8GC1So4n0kM~a*@KoBG^QRsP1$&LDYI*D>7xHJ8@JS zAwHyzi1)R;#$hzA^^>aG>a-K?%5igb%g#h>jo;PthU+}ijfXiA>yC5<4FKdz8Wz*u z9aRi_d`-*f3okj3!n9_B)HV?@(X!pasuqt0N-)*k<8e_ z6?)BV9o_1M8md(Gh|?OdqO|X0yMAwD6OSLP<9&0gc*03<#yEM&#)-dcn)I(9;q@de zcox}4zTGKri6l`p)9e!~g)~~+xQBw1?=^p%j{iL#BAPXnLnA~edW7c=i(7-6`F^8I zJK~Unq?0O{jP&<5PS8CL=FFUt_>beOtE+T654Y0(Z`uzMMRk`s%IKj6o`|E3=TXvW z&g)E?8`6K6Kkl{clO z48wALx!)n$m&Y{L<3&JREH+T;X6WmRX20*TepXJJIL632eL*PC6E}|f>206>n>2}4 z6Mi2?yiV+KqhhIVvx|S+b*4RjedexaEj+0B+f@n9wc;SlHEa=PCj7UPf)cCk%(vBc zN})H28%L-@rgfD6QJ^RyE9vUIYtD2xEf07d~Q`&H_HgS+<#f z#mcmJod;H4-~LEKONFmMZdGN!*w3c6V;m1Bu1@%?x^m-^BuzhOPr`qSg|;f;+}+vr zay=UM-CfC!E`>RLPK14-rg1--`)r6EHnJ*r#a<oZ>G^AYPB6R6@IFs5+r5eSv#v9RaMeA@$)9mLF6S+4`^;X#h^^euNZD8JHH?oy zkK9S*PX+4A(K9@0z0_3#tN6+`0z@|Ob~~PZdH2zuB8e@XcKH2u8vWd_P;|)V?~}5B zXHYR)B4-Lz!FS|7tcr7mSyanAyr2zJ@#!%0lxHnd2r%^G2ind_PPW^()(QT4Uf;d_ zkj8DzBByO?p~rN9Q=h}>@wfOrv6Trwmxy;d({iyV-N;ri{$$H3Ui{5lPE5p}VF)A7 zCj3`n|NdKcD5n7o`hkDkAtZy?6FtMx3OgvF7EI=ejG$lJQ_l*H`? zR@_Fv6G&Th{6`GcsRL><$r#N{X1=3-C2n+z;`Xd%iTF-u(MN_dVY9Yq<0wjM#)P_T zH1`tytHVym-*guJ86PgOt1%Ry^oFGWY&!OAI`Xv9A-WO3wMGCBhlzayk=;Bwh9uSn z7JCk*obLJS1oDcl^v;g#*luex0VRt{DEf5v3V2!PeoolnM6dP8@}$(E$5Zh>WPG2tB}UB& z1^cC@4<$9HI2sr5pkg$jg%}I8D>8}c@{v({*C#o+e`H_(P zk&t}<8esAygXo(7vR%os9mzQCi5a`&boNq8hPgEh7a~InsPZuKJWSH_<~Uj5v#Uxi>!FrC}!A?~T_ zv!0Rmy=^WwTV6gy;7ZvFr2Sj31=2nxX|H-F##-A~=o^a1HS%18F7=NZE zp<{Ot^^@7}iWed2)$BV;`saBsx7{?3o?!=;&9NO+#C>nV-)Y4C&e&EjvX$&~&Y}k> zlZx*~EOHTh&R>~`JnO$1Do<12Ncm($umVHzs1gC8;0Tm9Ns0Dfqf;VNMPs4b7ASK& zoyBLHyoFXur`Vl}-n{r`r~PR)j@lrxeNi^bA(*IskMTq1G|6!69ihG~hr|t%(ozZY zf5$`Sy4UI;!~8e%mq~$Zf5h~#%IQezCsnIQd?DP-o&Beeu$n>leUvNaKVG7;HK-lJ1^B^Ak$WQ5=g8qw#-{7=)`K-y1I%+)Ls zV@gk2Z}g;%CY$PQZ)1#|nUu}pxln6L`pZg6QbK0!0ZI}Yk})KxqgmYZvZz@aLN^)~ z>PAwEFr)@5k#oT|FSZHe%Ir`x!k!d)QuT;Dnu)T8W#x3~pUF&=YfJxW`jJ{5R5gmf z;VgPN%G^OHyaPRz=|~dc^^ETI%Z;|w&3l2ir23>SeMMsrjcY2rSsT!mfFlmjl@gQD zn4FGphPqOwLRaeZ#LXV}Vq`z=ldjbHU#=@1ul%}JjasHLDDL+^5N*jSN{KjLnm3(g z-$132o`ec5C5h##)wog3GT43m&3~C!in6q;BuiH#OMm7+i=Gt2By2RL^Lf>1N@sKN z2Wd)IF@Yr$NMCDF|FGlX@wj3<{;Tz+?m%Cv!wfRQ=~yc|%POJ{uf`Z*jO2y8 zODa?B5S2;sery#6)0<*Dn&ZzxXLrP;Fl`_WLlQ3mc~MwQ((`V6&lms zqQt>8raM^WVpW0C)Cgg`C#5M~sWjP2pjNow%G|eqi?l7OOwXIPEq~3g;|IoIHAz!Q z85n9=$3lTc2trY+uS}u{%`BJhVp9QUOTg*c&)zR#8iSe83jMVhRHV{kcj`% zS@bD>71cXu(P{jA7ZuOxsNtop=d7stO!>M^^nTLO% znx~%UUjMZkH)F88#j1PIAZxOk2}F2t`VT z`Yvtd|3vMhTmDGz#kV`{SyKQWAx&!ZyssHOD0}e%qX;FPOBjW<-mFekpin)ODl|6f z_cUX1YVSOd)Bz}Q~6H}+H;$`3{{vNN&ttVX&NsOW_eWO!WF`Fu37lwHxL zi?h+wyx0?}+>a{VphTD4lRGs}OKF^K-RA3Kn^KYA@>1^R$@|DczoN#QwVrJDpjWIp zc94%f*?g?x1cq^p%g~B1y>htfy?+?MbEjoy)S)Ve{s2BW$dI*sxLCB-y|KFnt`9E; z#T{)#L#J^$McB2%keV*)4p|hsx4ul2sB>d9 zdfu#+uqQUhVn>DpqAl`g|6VG+RlQU3 zeCu?1$71UtK!^{D3&>AeI#gCheC-FL^G?-nNPSfYq2v41?SPMlOmlEj40aX)MaK4u zD2tTX@z%T1;=bB|7B3%2i)Rf^i^ncKJS~>fpw`4;X|UX%_}=L8H=o*vc>2Csog$5J z)=S?C0Pz6d`%dKeBqFRxj(>6pIeug?a$NpL(xYUqp*0yy+3SW<5r)Q;TQagMS|oVL-wqiC^b?Yn6-Z(m zmV+E9(n@Tv_}2n`ml)-jMS-iaQm{@=G(A*Mp1v!XMe}Kwu?aO3IDH^XIFmAih^L{8 zHG#GrBvdGw-WNAG{QM!8o__o1)Y)iXFVVDIv7%pil>TAaa~4w=D^ z4mN`Z$?<;V(Qly z3(VAz5!t|nxDWQ@_Z+b0|EGu`!KeeNs}LhIcdS4;asZyc?M)3$S)Z0UhaQR+c* z2zU|x?5T6^`b&zYvR^{Y?01|+28xfa+uK}K)OF*7Gn0qrAC?S*Z)HPNQgw}*@jt9` z9E@H5Ac|ygr*h2lGAsnOtnS~|9lW37h=`m?Zk zJEb>^KP51@!<)`KV_&~>KLw<}&RQ$w*=WE2)6ytah1&0@-3P-RgAEKV7ZoLb_y@>~ zzNKkw?rTeH$slT^B`nYk8Z?xsfCMIBRUlrVk^w2${mK@AB0~yIA^YLYQeEPUDxu3d^0U zy)b*$NCL8*mP@7Q?{u@b?}CAneaGwpib^SH+_DYQ;(3EgAblvFAbOfudTwI@n^lk5 z5CI%gE^{Rs=%Mo5WQxar-gqlCEAcAyR172_e=-vi+2{%3O4e}&!VGF$CYZk#eW1bPNu)HVOcRn_RbAEcQOr#DaZBBDS1laRd-{)_s9u5Suf67~{EwgP z?Lze8Pw)x7V2BTC4cA5ldH)}Rl=b<=`EEoRCiXl z3;xt!X%MJOoBia{S}>^wgj!EsIOX&QSNjCIIjdU7Ily6bFYP}IH}2$0SX2p!>0E3Mo$7A=1_@;j0Fs9Nvj(m+sWp21MZUw4*V!9~*lh9*AgKNFx%n{@!*zlsDB z`mP_C=>j3-KPD_p;L+hD$I$y^WOE|E2AaMOsUet~ERQ14?^DcIr!> z*ENJa6YOC+))jh-QnKqm639P`eUT-4HoNNulxX%RU63796M$3Y_4z!gn8d?HFzWim zjl+uoRD(Xvk8-nPvXnI@pSsgI2GMh-tu5hDqo)VJm=*FnEjO(^Z9VBF9O~@BaHwza zL10vr$QSjxmhWBO@s_h}A$y$u4MC3$Bvp@ujk!;m!Vr zBuWKt`E&$p;|9Pg8!7;)18^(bDO>K1Ay#a$rko0`KW3#WFZWMKXqGG>wMT#u z{gh4y@&1S|%hG-wP7U#-1^jlFiF1gpE$2=pAoYHpWZU|i383weI{TgwsU#Y|+pw@Q zQ0jFQW?8Swb#Jh?{_E`0^PfjYispq`4M{2gb(F3WH35;y-x}N*1da-^1#nczHt{fD z0Kee_%f6@R3jr!-c}~ayAj1U|FasyZd3z&pR0;Cuxywf^;E$l^-=SJqomgJtK{27E ze;r_!l?jjq7y{aF*7JuYUtRy-3_lIv>^=c7x@p0FZtPhclgSv_e)6M|{s~K)BQF&z zS@H=gA=$Td&*y2#?*{B1bfME(d=yU;*f7Dvp?gKPnzgi^_fTJyz(pzxzW{a%2*yz} ztfkJ1wKM?SeSje^t)>aY_L20?mDw;q`be6Y;nFgE&NrAmSgGw=9gq0*eA1@msug zZ-8xjGPiXtJB@AN?ZFYh)yf_`O8VWEZ7D*ZSPF+Ai-JYt!w`WIe@}%w;Vo`t8*fuX z2q3zTZ^`Y@V*@3Ai+6aT;^`yiDP;mE@!RhWO01f-aB^zlR?`6kC1z>)TN$NF9Pt+7 z4qHz1;!odlis31V*waE1gH{A893qL4n)wb^l>rk!8-j_CumwOA->4Ob8OJcG_!EXw zWL_#q6q~$I0it*%K`O@mbU6im0V-8euH_Pk8)WSZQEaj1@P_>B_&JO0=2|ARlHH`a z6B3gbEdJ5~|9-=dGn zh4~Y44a8vxvC#nmKaoC`CFF$oAF!NsMDvn}7xB2#{xoHDZMmLg7b@6Ciq#%|Hv5jW zFcygPH^9ki{f1_LYclpES92$J3aN}bw@Uh1D%RZ$L^INh{ee%UO_<#C0cJ-U*!3YU znP{L?WPRoL53Y_allN`JArR%7Fdj(kSUqLctN%%i-$pC||0+i*r)T|AflbfziWsLK z0G6i%PWBC0YdoDT99!v6up?utM4_1rka5{q98m<_^NWSyESf_pcUFqsq2wl+XTaDb zIT9zfH5GYMT3dbp^^=n$fad%?3SjeO;1&Oii!>38S19L`Fkj$ux|=8dQkaHe9G(pd zbch&ww*@g1*ZCAIw%>~pl1OV+=~%bLuPOp4IwF8Ful2G;D6{1$7R|g8H1nkv&D?C! z%tj$3PUIfy8h~cD`k-QEO1#_PbD9U&2b&M453aA&2Ukl@-;ju{75iqeoMqpZ;F#3| z?XXX;s}CSL>Qd+@%eU}KxV{RHmKK*FI{)fFYr>Rv1Q?wuyqlan(&-SaxhTfU0L`q5 zcLg+mj?pa%v%Zorb2Z8TDGFf-X#N*ITsRj=-y)`20nEZQ6HQX48oEX`T%~8y<^$F6 z1Y<9?`s=^*tfIT+HGhDR=I3e0=GQUXu6M`h48zS_nn&qmZ^66Nj14-|AKM_E4l_=lD+nZeN9*fy;Z*nVDTSztR_L^#5sfHY4gpj^ zn_IJA?Uy>MP(H&RCPLy}?C*d#C;Uyxa}>_lH4xi;W=W^LB>FIv$~1KYChnqNGjqS| zktU*ETYa{0w)thWQN0ifB!xpgPgy!tR7!W{6;gp#(zYEHwB-p2P#bd7(#Ni{h;24Z zj;LL%MkR!DySiZIld9DF4QO5U`*$tAh=IM?kUN18_YBXRayS~23KR5z7|Tcn$h#F6if_+(xGs9H?m<6xO{A@ zMazFkw%^E3R#cKaEtv7{p`j!OPJ;de=@Kj{1AprLJ=Gb!{AcS$o2abxTkp?IWp8}D z*?*?l|GKn#&tD|H9nsM2|IC`)e=G)pi8by2qRg<0p_Sn=yiTKFTDKf$O7`5-vrDAQ zLz~Na5PuwV=;>wJye9FwB<6%*bAc@#>nhbP;O&Ipj2!^N4%PTO8)#pg$3z>>^|v9W zLMVM`Q$?jOJMZNk;tkgl-Y>JN*_$UbrFg@T<`TX!t6o=B;?q?!)dskEQD?ap|3A^< z4HrGA(J(@8wD9J3L_~fn!AvaRkF@wxtQH@9sucNlCPIq*Ou0qx;WY!Ze=Zdv@CK)4 z5RwSYemIm40LSV0g;D6yIe)4P8<+TbwWZQJ&&=;O@rf&Oa$3cHrB&=p(TPvOLQ(9u zgo-_f;+3iN<ri@k%DRT)UV3+v>|HP5pn8djF)c_TI~Pmn-2FA&Y~l_ZEU*QtwF**ua9Mg@2L;0F(RD4LpsDP4p zGXp)}jXiGg_$c`Xj}HNc7)=`{X7v2IWqSS{ca+KMQuyKxM#pcvUFK@(^(KKrAKLw3 zs{I*S_)9fJSuIf$xi}YU6${TDg}K-EGtlf!sN!{mD$a%UnAbxz1vG>|=aCe8LKSl@ zPnRk58;wG*OwX}^*A*3dH@3=u2DMtd2=Wg8u%ym&Y#k1gB#O}hb^ewI&@@bRfU3R5 z4b=I|jW&RG^QD-zY{9Kj17`#YG}^ zfT4}NjZPR_6_^`$bN0C*G3LeS?uuFbS1I;Zkn*Jq=#*6a9pX$Jw89Jdvz(uv{|l?@6L&0${^L;B$1H`upN#z`;h*sJWaK5)NL@?XOkH;O zQ*NIcVBEi$*X;I@!;GFpb&ouin2ecv823v|^NWUQ$|l5mOQB#Q;{!Xt-(!=vY*#9q z5#B^ZTS8-%C9|SY^Sfjcu`xhr^8oG}K9G+8M~43NNXMUHbbQNrj-d&0wtE<}P|aWC z#l(1=WwL)*=9BL-mzC=MInwHZn5!lnX)*mo$)9PJeC9Va4VUTp1bGgo=MST-(eq~- zJwI@jTRmU$Y>?F}J%6Ls^M4-b`7n@3{h^M4bl_%rV~&1m=Q0_~m{q{j#6c>&3)ucF8@jXoes z93z!}5qT$4v!uudc6IG|Vg7-e>ltV9w}xnbY=$Vpcxr4I&$iYHDaB#DWQf*sUeA9c zRELR z?uPu68rEe z0iojg-hn|H_FI*v?Hz!ySh9nn9}GS%>{r3YYlyhDAld$fWC>*$ySz@H(vDDY=I`oD z$kxh|5J3QA4)>4Hre4qxg*t<1b*J76Xg0JN8rpqimlb>Wr~oOiE)>nJf##C2d#fvP70$1h8i zB@{;|qiZ-H@f(NGSC6ygAEITXHE8_Cp`>N~cYgpL*T$t8yXQgClcrwu6p)(7sZjna zA@MMYE@Wcf@d@RyG$#zKcwxxr)53~xEq$}%Iq30#cn*>)J42Gv3Pj=pX+iT@84UY zsDuMo`p7^KoT72+G$b)#!Ga$r^A#gmoZc@TGQA`X8*F;9x4+-@8g?+yPmJcAj%*SL zM7-S`tYu-kI=gyyG34V}O@#KEbd->fuRkFm$0 z@OtoWeo^>N3iX?tk|W`}!8?T;O(g^GPOZ3GI4k&BSw(^ExfLp5Wp&|=LJhiqvBdyX ztQe9sA8DAzKIrs4#gJqf4q`|=lzHHu6)_}9XWDA+6GRfqIUF@?PfJlG)3tnvA}K>Z zODQ*`ULH$ASO8fj4pGX#lKulo-3EJj*)iv)V^8CsC*I@OcZl~$AK1$#6)TFq6GdFH zA8z)-119KWuBFqmppVJ202xKROq;IYmxs`+Of*#fZeh@~cBCSt36N$g3M+i51~*jY zJ^E1?Q8t#)-BMoF;KhEK2A4-!-8dw!!-RA|RKWr*V$mr^;dd%o84*IZ`C>#!EQ|;d z(DbkoA+|#Vg&c2!LM|UHD1_YccJ?cSLjLTcLB&|`(eD%&vL%QM`4Bb4Yyu~V?H@4< zF?PZHDaD0oxocot^VdcK6fVT$GMxYr3P~@+R*cn9Z&W#Vcf&QBu#E5ud&#Z5B8-+f zVM1XM$+AF@7bLl%J7pn~vAWt*Z3OIx&% z9@t=zgio%9jGRMqO=rLGHYr@1Nl<)MGb%3!wbZ9#n~hy89og7?V~qveUrNSjV@LJ6 za-*ii#w=962xr<;*JtidChBu$AsG)|$=S;jy`zuXu`$H-SpC4uPC1<8oE|UK3 z<~Uc5T_Xl2zKieO1+F2!>kh}A)$1FORdc^} zPpN8uyL#TR|6rrd0yHrxI9V^rks0gyj47n|jxxPdtJE9WLt20^6+O9IZkT(U|1I@a zXixJ6NxxkKMPNntQf6>liPxn(T94eACU-lu2X?8*K(| zQ*&%nB3n0_&;Yz_k*U1EVTv&EVYfz)tey|d?-Ad;p(2;+BKqr%A4Wh;jfU94V=s{ ziD3Q2!o5t{9k-loEJumm`9x$>*FNBWUAdFnJL@CeiAWdcs#jOtaa<~!YMepSM1_qfq8Oa_{6k2SU&#CE-yP;WZ^5qO=weNdCjheCP0crbD5KD_HkHK z|JW<;0_&8sky;CHn``XteYzAJ?>LG01xsEFIDHW3*=UJF4!Y& zgKMhA%cOJPVm;J06BG!=I5x-b(TRF8$9gpTyOS}1vG-a>2_mvnjq+P!)|Yd=LDFF+ zH9|U#Nh%qi^cQI5Xid)4ntW6)1_R;&=DV{(-XCs#e#eV%AdG3l;r#9T0{W(7{(f#6 z51j7O^(Lfe^+=*LmB%!lwTv8)i_XEOQW#gJzf0#+T|xsk@&877+Q;w~;MV@WW`7Iy zG$too`^6lGH&U_Q_C2*k^)mX(boVt%%V0O%o3&bbfhQ0xMJm4tC(tTF*eOp7ynr%P z(J(pUbj;y8&3PrwZk$=)bQ=&KaJ1cc`ntocsHbz1i?Obk!DuUT0ha)@`tBLZf@`|q z;oJ7eb&#E6;j>{f;D2V$*l+|MkiOQEKly)YRxAC~75VG|7jA+u z%tV0}Af;LoA-rsfbm&=x=irdi$eDz|#-hZ~3FinE-J1V1-g+bDJhCytX{Ut;iz+?nQ7^J}P&Pb7BA6P08BK$ZcIq>=P zr`+3Kjt@IieXSgyKQ=$GNNz&XB>mr!j%-Wgf#~>0ra|{-7;n3>)M`Gb+bqGGz_xL$ zhRN;hO@xHxq8FeI7@Uc9CERIo_E_#YkgBbg*#&F5e;g%*vj2(Z&DCw{lQR0+r^yoOt8-yZv6DWl? zs0x%!;vrakRmU&y_?otb;^96?)$?LxsDu}0qsI`5iR#z2FUtPE?gFjkI4`Ys)pn}NeW-v(cEpz*%G~Z`h=O|Oui%Iy6s&5{ZjQ2WAmP5da*v|ax^h$Uu zH7F!+qW#<{)opFf9lvT*isI&ux7y|la?;Q|u@iScU6IGX1mm5!y8O6=PntE6c$CTw zznTF#NAdJ05d!0Ljo+10W7|sloYTH4S{R>rlpY`lgDwJk|A;{dKTtOXXa8k9OlXJm zQvA6V^6G|piJy?*AldnP1rl|twb)A2&G<8jr4llJX>U*k+H5x1ddoFJMo^jNt01YTMcNpVNlR6;)6aDiIhvI0=e={ zdCjRgf}q#mjYB+0Rp-T@YB?)Ss=6~1gXF4Hn!@pNm>DUCylVd<9{hX<4U{t2Mg2Dm zTiy1#jZIZ;8x%k!;-y|w2Cz%$C7u|h0PeKW!)^?n6Hjc8BMzemD&kI~@C0vhOF+t$jS$pYCTNS`Kv@N4 z@B0z`=WZa4J(iG^9gh`IB`ty9W+M`NRq!}3@@m3A_b&gr*fVVCCjqQc!XcgUmSjj9 z0(`K<^x}D@{$3#fdsC6l=E;+sj%MzqvtK|A5{2C7Wv538u!V10_8;*5&sO4s+ckk@ zxL{OpftK3Po5KTd*0dD<=z!WHAXt18uRe5wkh<+dTDq~W!bwHI(NiUSnYd%0{JotP zaP(26cRzr~5N$*SLe$olBWf+)$V`~=xqshKh)tEgR%=q4n;Wo4g~=KM!Uc@v#oGv{ z)XeI@6%+9ZN4pC{VvVLSwmr7j&d8muf*4rN*}g9_e}v5W+o-sZgi2(wshV@##Lo78 zjeei=H(l-fMms;~?C3LCRi}BQNl6>SCqOt+*9#3Oohs{&>_aVhnyZxmf^7c_xb(VS zX%Nf%Op28;L7#Pl*WaV&mg_~xb^;V61)aS>3K-5FZaYi<<3p;&>W29Y9{cpH11aG6 zJN5L=r+Hn&e?!R-YpPF^!BJZcwd)sxdOg_Itgaxp=K>zNv7EFyBUC2O%0MQxxz{b!S9yrFLU%_O@j0OSGIShgkT^^lj{Wq%0*o*QPflAC66Lcw{lXVGY?0yAw-C@NYWu zoav<2ujW}Kq0i5chWKjwc#O;PkcTGWC+DL2z3m5`xhE#G7wif)u(?EJW4M9s?~HT< zBZ3LtLygJo#nq5cf+Ie)99K2hLLgPmnR(GfrmZf)x6VC@ie4Y2A}qG5sX3EAfm&*) zqTW`aeXFV%Q!M_*pv5C9p1mVN$p%_BTWEh31skdJV~~w$`uBsDjjF6W>)yu2w3T=W z3qciCObS{)E0LLZF4a!JnlnBT&pUT*;suS$SIb8woxMC6jLeR%!pV^xk!Oqk$Yl1a zDE&Wb?#a#B#P5oI=}bwh7)1q2WJV-1Ew#;=FC1W!>yz>IcRW(KMrJj# z-o*2BFH2|BNdkl44$c=#`p^x4No&f~=n3;p{?Ke%XCbLz<$G-EO!@ZCNTxdenzQV0 z$Kix2thrt4Ck4%>_c2?qd$|VZO3OOe3SRa^B2mFko0$W{!b-=o2@M} z?Pp|iu<^Fq|9A2YG7U5-ib28wMlp$=IE&X}!}H^usf4V??(jS>>c0s1C}c-`J#^+a z`x|Mr0h?IjQH@5nLxu++{M#_P>Y$FR8&f17N=69jM-Euiffv~*L(F}=&nPUV&A^60 z(~Yttd?5_NO~qEHh)3{uT7UFm?FWYh-2}yKCul7CykWrao{_nhwR}$M49qEeDQ#vu{;_)nOWZ&z*t`FV;kEO^;X{yDlheMHTZh@Z+tfCty?ZggzTLk|=dbAQ2Qx?7 zzZa&46OljXkZt<-vTeHFJ*G5O=%Tta#C#j`e8)*)mVqgez2E$7b8t z*@XU6P3QbSyuAy2ROOlYpJXO5KyW4sHCogGqYVTl6>Nipb`F`q8JK~{MG_5=8qHGC znnD6G1W25qOb=6WYqz>>|7*Mcc5Ul!ZP$WYwV5Q7go_ZMDxy_DYbV4Dpp_7j`F)@F zoXG{S+TXVSd_FmIF7M@eZ_oSO-yZ8&!oi&O*A*w~6J3R{rLfsZ#>=QSCI0+IVWmt= zZL!%&Y~3A@RLs(pem>heP4Jk7ax73S%q8s-4mRIYh14Q+KcOAEPLf~F3VO~1Kel3v zMW7>5v>a<66VNz+gj_OsUWsprB<)kr5sNYBrF-g7=Y|^QK|g=a!AnhwKNkco{P|z* zhx#}1py^jj$md163iHucJ;&m!&vvV|xO8v)x8#@J@%D4+xBz&bP}>bPVOkJBCUqR` z{+3GT=}I!|*4KRlAUNvjTH#mIQgQ7ktF@_|xxLb(vYeA^7t;mcm*&L7Qj+lPR)bVQ zrX@c7cmRovFz?FU_LUWv_&sl~&JyN5YWt&ctp6CHuBE~dMUxJjLycoyLEgZa`^(z~ zu;pKugbKKV^MRj$31SQtTXkUW-FLc`Ew7D6;Y7=7bXd&V^ zygX%lLQV^kKFD3y&xMpjVP|ybwhJv6=cW7^p4|5}Tin9sv{7g}&x=Cf;VHXMNIR3F z^P}{Hs1uJtgHx5E>Y(Q!@cK!*J%wjcb&3Y+*A6W>i>mwI&~r*|@z>}%k#HsBs6fos z^%HXnBl;xz{3gq;m9*U>DmDu#CumoZayNVqDc1&$7gFwB`q3oig5tT}Ps&a82_^S$ zBvX{!zi=ZQK6(i#Ig5%*p3Iy)vhY4BYyc&fluoS~NFE@aI_GiBy#6e8%~{7WC#g3Z zP$}wdliEI&V6f{W)^3t)=>9`LQ6TgiPAG%uH^DYSzis8$Cr45y>9@dV({IU$e`Clq zu(i-{CPC!l!@w5*o#?lq7zw?mbT4nx(K6J<0nZM#2RK8*E}I80pQU>d-ONDU%Ng`r zy%g3bKKy%}7j*{d_KmYhx2ygJ(hbLTWZaCh@rGZ{9YYf5w-JKYJWj(R-=v8IfK}w1 z%)&yGd{gYUNxcysZ{2c{p~%jJ8?4b~(rXtC)Q9vDY#s=-C^&=FkjTi|+Uw=NSrj#N@id19Z zg;Yc3+DEN9*PlhLeE}*>=8i%|XAo$=76R=PI!ZhwF@L7Qzec5jZ3j?k_>g@Dl?Lf1 zCp;P-o=KzKxDL|be?g;VlK-#MXf^Sm)bSZKT1|Y?00{nHXtWyH?i7vor?u4czo*f@ zd75Gd(P(pda~6&EHKEZUgv7f}5o$^DtVzhT$yk=D1(S;c>DYi}Bha3MM3du&`bjj? zAwnt;Yxc*P4yaQk$f(e1t^A&oPWvSv{!Vn7TB-x+G?U>vBmRoguY8S4&x*YG0qbfY zy#`bMSLiixH+HioubVt|ciYNA^qT1(-axVa`10=(doiM&n_hzf8ceK-k{S}Nd(VJv zjc1cyQ+^A73$gYrGs@>dBSDKywTO^b-823+YE4K8lUkG98mjH+AvgLFc-oD;&=IIc zkGKOyRK#+_k^7?m_MuEcP=A!~&ih~DUBrIf^#T1CddeN;4qmQabXr5!5GjL2S8no~llsh8|!}A?lc>bxRZzVbmVbY{a^hC^B zZvIeE&3bY-8fRsFp!t zxb8)}JSk;^rE1W^2>WT#XQq{IG1H zH#!UrpHa<0Dqr|U5_fuDS@*gq){GA%a`3JWC&aJ=Y$U5}5+t1YB9{;lGda*2MaJs9gt~} zeIC%PU(s}QxtvmhD);8IRJqybROS9H`dbBpN@{@sz(;3oGVrPlSl@7(keL{it3 zgQlU0srF6|y`|&sa`V-?M>p@!eGl6s=Z5zb4-J`1V`S`MBA(`!@%F!vJTw6FNhqHh}|Ip8t(t5U{LYaX+?W}mbcC!^}Y!?-5@WWiDZHxN>zF*hOoQj9}%U}1~UK8e0R3G*B)2@#@Q${ z#BaRkC;nODMLn|NnA9JQa|}ydk4(wcL!aVirM0DT0LxkqV8KO05LEvuEaqtbdC(~= zr!TZd(;7Wl@)pR-+XkD4>(t1_)F~`!6pN{2Dk534bYoxqR}_)^RQ57KH|#+*{N_HP zPEkU*xXfpK8qVvsDb#MFKy2(1qvth@gIsFo)Q~LFi(8DgSSww+WU=xU5$TOfl(|`p zuxpO8*+K^zc`8RO`>wj7mx27!Vks#OTxY7}gVM zXG2r9-8kKS1=-CUVp|zmAfmC3WGR{0BE?63Ix0o#_{#%hQj;HC=_h#7!CG!TyvC)< z&Wnd$8ikU%APXyLJ-m`HD|7hIQ*5y)9?HaNVJY8AvmFX_j%d-1Ve!lC0@6~KPBh}h zdgyl>Wdp39uTTBa<6wf-7wDcJJ;}{V43c)l-v^v-)G<5aZwp|bxI#4~HzB~!qLK&N zR+RzMudE{zo!!Goof!Qo=P>EU+^qP!0;Vz79e?Yw(J5eKB!MPimd}KOPrPNUPPQCz z@+8c6jhJPAqTy_lMilCOe&T{gkBkTyy&6sfykiJ74qk@iKn&FlT!T=OS9AFNr>ZI^FS~tQehgG?2P7$LKh!r_NU0SER#j z7AN~KPdQ5Uxk*{@R%N?Xr#iRR()i=ft<&kRS9RyFdh|UX=u_`;th`VU--B`eu=szc zNmuNSACTX$&F9=Y$8G@3e79~~pc}J^F*Rd|AMPYDqJwjAs;-dfoG%=*8(`zJ-;@rt znLWq2B4m+q?fbs`@HxLHT~c%dzdYSBU!c|X@Ul3@i+Z^7pqwQcF2gZl8RwZ+b_BvT zO-_j~={K&URy?%aT0_r5{+x}MFdcxJ)%prN6UI3^8x9@B!k>3X#B70({8yy(FcZR~ zvW-2!U53;ZCdE<%XoqidXa#KTEij9pf$WD*&iE}OhY zAl9Lsc-80Bv64=sjQ6CB5ybCm=W}EZaqmz3(W%F^$jsB8?dyhe{`A~vce<1MIh@cR);ya+_1Ukbtj`nL zt00mwkz+o}L@Lp6IOS++3RcrKS2W@0qL1j*N9@t}9Px+G@7gO(ip)6;0H2%*0Iwqp zKOsmvaBX+a-6OScr}jN&?apWq6eWRuA2PgB??|oTpo~vpc)GoNt-P+kg4ZjZTREQ! zg@SYIZYGtBNhM@RH12Y4=|I=OUDgcemd1;`m%o-WotrGVfxB@8Ml_k<9k4wPQp;DB zj4#eD&GNP{1Fv{?2S-GMifTfY)QueG1*nh!LdL8BGnMIkXLe2iwHeE*N))DOc$mHV z(g9w0ed|9&Y!#E z)tRzLU(v(s+<|cQ*mLLL~AbF!BAfb|2 zTJh@5(hD`g4GCxC`|K*ttqXmV6Goxev^#~#aWgO26WY5oFb13zI=H^I`JNL9f_hff zO3+u~Pxr);SD1`yTHl?$@6OS8=h8<+@$h)MN#__XyRmyvncG^Mr=E!BMvV@*3>!#p zTQDSaT#|IFzBo_VNt z)PK(mIHwoVYf-=F!0LOGbgVp&jmz1%Ri=UMweBa?lep#RMq!SgXwp6VSDlC4TJ1xYo#2|YrV9X9jy5G zYC({;%)o99Wt-UO)nykY+sg*yfLdc2iI?0fx~Coe|54q>Hrf_nf1XU`l@6VQVRKIh zY^U{xHI#?*Bd>PE>#se+M8tdZ1ARlH`nNKr-R8C^8)Ohm*MJ7b^UjJ)`wQ^E3vFGH z?NdAKYy>81j$_j>)oQ_o)EduFRjvVFwB|r*m4XYTstqm<^z46?+`V@06#U?pkiahK zBjzH=;8hv8;&|r9F2I}Z648t}s(5B+Rec#6sK~ihb5w*2ise`K&1JG>E(|mGr7Xw8EJshgdKlp;z44E~_i2Kx*36kbXyz!q zWfaV)pj=3>DQG5kBnoE4rvskMA8~#yV-npg^XEFbTq=_YoCv|E8wF=fqHboFOiO8) zZEyeV+EWo;PK&@ffG@2a(6ab_)oL=)Z8DJvZzUeYLfAdC@q)X&iP86cdt6F)iga)v zA!Bv1cRt7b6|uwXM*8N`D-k9`FEnO*d2>6<;fi9JXvV8VFO**g-1O9R$BCTOb%lCl zWa8tT)c9|D$EJj?|B%}Rjf#vM{{72R6Ql2>Mlhlt89m@RGV(=|>EZNUl5r#%_0aWE z?o+C+(w=7CVTFpam$jQ1J-b>8xa2V@cl675S*2m|lGxWh9u1RQ1hX}C_?Y?{TBWi58<6R*EAvZi5FMuLES*>uFb)(($`U@? zt&Yj>LE^}?ap2dS;(bIru?AJ)$`Ld1;4sr-Sf zg*RccpfL&Cv-|Be3L+D)#MN^0$Jm8&zO(1WwQG%~oEr4nx{1bx#tz+Bk34FJ=KR%m zpYfW{K&VG>|CiVDvJJ2A?yu%H%g=;>F_R|!LCeL#ikoe@PIf@*&XkbzbM`=S<)S~` zOEI=%*d*8eNc=vf+04}(!=BA512ozQr!x*3D&P#(WjhL;!B_o8LYfHWN9UMb)qNez z+2hh@gtjNN;gw{l8&Z9l=fkyMHr`04lI|r_GJkivEF?!Tvepqa?gGXjnx123_W*$N zd&gzCLG?p*W2lkRohEyLX<9;uh3;`dp4==m42a#jal|+Ew(N;(&l7Cxn>w!Ugy0xA z8>q8!3aJ9dT1OyK?O=_LDm1>*-`_rC0;i!9s@U_^`Y#jTLq-fd|3NUa8o1We%&+ii zU3_vv4GBI(zNvSmtX(UvNux;bGm7!!d~;o{LE}JuUWYHYz0mn9;^$6Sr2(qBR(B`I z%+`*5P}cfuHP6ZQd38?A-&}RW=)>wOJ^R;=^ATL)IW@M@;duZl!xtWtO-o(fU;vDz zcp)9v*Jm64WUVz3P{=;PjAr{10 ztnVJi6R@RVo_zss30cA1cbyw9x6mTx#~mYQ}pzxad!FDSDhs@xxroHtHL;5r*0r z`NKnOj1AGAspRUt`;z?cU!EE}m6PuMSAJ{nzNF&^^6R3{`R%=XwEA9q_Z4OTqMonN zC4KMRS8bNx+Pl*qHlIf}sd6$KM0&^f^hf2nC$m9Jbz(h>n&jTC?lT*T-nga{|SLr%4HXn@{-SG@=SRxRcAn&+()oP2IW5-Kd z`0~?-Rf>|ArFI34RBS;401EgYOPb@71}KjdzpL(#6u;G4K6PxnORh1uTwC)5T(=2B z!)CKn9#k*^i(TGRqeFh59nc96nVry^?1YC0bpo*bSP~p5{*c^{WRN@ALkgH=U%X{@ zQGbt|QazGq)*4n&kw4plBFFr_eovSw^=v5vRni`-E#}u1HUX0UDS1WuLI6?&at16D zrHtc}rmtUKVcL#-iD@nU(dGhb)k_2W$7|NyAidgJK7Q;gy=O%e((MqZNq#qg%%A1B z-UcPx&?*Q{AwEmK!qzQ2U|HyyM!v8kzq&31g+@K3cDw|%X3Vxv{&>T-d$Nq^Be~7S z%X@kxz~l~W_UCrSbG`>fJ=vH&iUb!8Oc0svGE=-GDOS3S+1Y0&ahpj#L^vaIYNH@O zcJhNJL!TI)okzzOl!aGLfuHg6Pi&$e10H2uHmDloVRrC`Vu}!LIF*9E0N7}=E?umlMNtYHy9CEU7^z9 zymqvQR6ojBAbKS%yED67d+2FirKHqY}NyxP2R z$M56@eRy~cJK=$;de&_EuyUT^I*qF^v zp|SaKuN0iI$2T>z>e|Sx)Te*>i(gDQ(WOEU**YWkdA6q94pdniC7bU2ebmZI9s(L< z;^^M5P`KnI0L1GW>kp3o8=S2Z8kPKPiv|7CNygo=5lS5u;w7 z>Ha*r-@UZ!7jT3Yv&#?sZs=WBkxMHR1_6^zHK1Ch+~gS=1X_We+k8WF8N;}l28n=l zCARH@kJS`#6BwvEhcIO{b0ii>W26*2&ZlhyY|#|U)7!-qk3!pW{kzk z;{S4LEDNRjVx!C(g6 zl7Tb)40sn=vRt=bK3;lz`KLg8k0Z1mXpv~q?Nev&ubLLW9Xhc4dg7d|W7MK$dSuaN z6V&*JpC}M7GG;z$oB4!i=G#zYq4j_`G*Xxd+r(VGfWe!&U*H3(JAq1g4+R>^yffDy z@)5TG^qnD)ZSTY;`g~8Q=Nqd>DYG0cADMTWSP_yv2lh@Urf7t)*7e&?pSf|FP%29V-tSAcBf z3$EXWi~fXRkJ-TR6z2bKS{7biX)OfNXeb0TY+!>vYySHT{}eIQwsjasSO_XKTx!aS zYd+TU990}vnQGkV4lHj1M`(`ljWz9>l4EJ1x)fH*(0C#IV0SvEeJKY)DM@6KdS_}p zP`<{^zND$)5cV!mt_6m}YS8QHB` ztxLC~-O{F1_`(2EpletGRD|_3e$(Wcd(64{^@Y7dFmcD}+kESgUj!pH@?|(kSdx1| zz>v3VTqv&9gYeA--mor>^Rgz&MsZn2Gu2bk7@msVW|C~lC#6dv-W+)n#4Arat5`~5 zKzXjs^iG2|Qw_<~=?>o29Q zm!sM<{SAWQ<(=O8Kf&76j9>XQ!@>yEj9>FOcQy7_t!8||!*qM2GN&-wyc^A2PG3~M z&ECj2L#Q2|CJ`$(t~r0$q~smGjlS%$A2(wr(lP>aAY8s5sa7z&vZLV;3t6JvQXyKd>5OoE9!NS*g_b6QnV=;Sxn&IYuR$LoYlhCA+^ z5QXW3B%HK;#aAil>fN;ys&gWvyluX0cd9Qkdr9CMK(s1+gWoO4Hk>lBPUimgYrShrd-Q%buVqXTqHVp(i83glCsdq!@q14rX`RU!gloi;r^adqq}O>1{(liXABVL+o&gFm+MJ zep1sa7qhP;c6?qZuMhC~Fex){%Q+f5xG2U9^?u~zbSL!5PG37E$@ZjE*oxA!Q>yqL ztHc&c?2r;WR%KAyo@8lSq%c*AGE41|A79QXPLgHuwPVfW=pKq2Jqxg7aOn!*tj{kz zO$rCu8SPRu^GsD>ufjRZE3EtgfHPnrFZ!Gklc4%?GE9ga{!o)!3&jW<5VZ$AJDr<0 zLAdy^axG@m7+odsN-i+u;S+;Mn@`m%hrAndTM-p>(?{Y?PF4rMvm8 zbWmJYx-qQ{HHdZ>88pL@)wQ}Pt}^C?y=E00~8$yS>g*r5O!wWGCRTrx|kWEocy zc!w-2C_v_EX6X)~tj%1oBg6bAg}Z!a$_4M75|HH$6(F+_(NU&v2k=TpmjDn@;FvjX zF8Qn+W6T^`M!^&`YJzqoH0t-VSh!%j$CNQ2gLK8O*MQJ!#^X}L8s^1S88zw!+D2u`l1woksQ7mF#2jXFxY+`sw9s zN?xOI>oaT4#h2ryd--~!EJ*c11aX;uwprJxd?@QyDTxW-3gpuyUv^p|MwXW(%NXz| z`~BQhc5t=%%E_W;xy6mmqmV1|NOx2^xYS6a zgj`W6_p473BLcljBlJp*07W#KnrxNmU@}ooGEtr+nqnnVB#TNI7qVtrGLcUb>GG5$ zPJ*1Dz3FBaVAo?dg*=#3T5a)eg-`yEOgzTlLM7J>!WC+vf=aGQqJV4qQGkhUZgC{n zo*#af2X zvJ4ND9O82q%h2wN+{$TiEJK}Dcry~~BWe}SD*?f>3j3Csou>CMGbYKvWoE5`Mne|aBiWGBU z^i_SndJ`^6uC%f*N%2_;qFpuz@fO+iz~Id_38k~~G3FMT^X2f~Jh)HYsCNij?Qz*n zds?qrN#}t!X?-9&z;!{k&b2g~Y3#a<;4-GZPv*Iz;8|X-!ON>mmRGS_UKW<{s#Vb= zt0K9+6hELAy;@&1z?;LesQb?@g4ToZS+0t9>%=SS9Y4mJ@RN9+>fV{b+vo(5a z$$mB;=&4K@=jk$Wy%Z$-iJHYc48)Ssr?O~vo9P%uv+jY}1j(yx{k<%RQ$cH`gMiP} zb7Z~kwrb4uPE2MSj7rI7GMQi<$u*5!NiZ|LbgNkxbJ9Ys)D?hv(4AWgrpT}rRfJP9 zToT-@S0tjz{Z3w0aNwx92+iabVNEUA0pA>bSwm49Y0dR3JY|rWLYpMy3PW#(RfqC_ zF8iQNhMt_KloOd6$pdg!b)15F)aH>fzRYWkF z(a)v!F{k;YLjpoCB511_kL-Xe_M%|lEdI;v&c^Ss8w%GN8TFT5b{g18EReA}UGBbu zN7&1i`)$xWu&~g8u&+G*=j;fdUA62fQBe%NByJ%553_uV_Ox(P z{q}MY7|yMo6}G(`XHa2#sUj?EiZfYGC;MK}8X&461RJhnD$UL({){ksd6gzs@)7L_ zD6VqdBdg-=LZh{ifcb`=AM053F$Xg^H`Pe5mcJaCaY|2YhleBX3HEX}?S%|L!5uv# zklP-}J(0k?W52cNAR!O(k#e<;UBlRAzbVC(B)LJwyHU!n!K|Bh>#xWQW=+-q0o~HD+snWDDQ>_;Ll}^bX)(6EfCh~UW zEt#S-}LC+m!}4eR|Ann_Skf#2EKmAT~HdiZ~7wDsn8ql z0r3tY99+JOPx;G*XD-fwO^1YtDiXqeF?!4Q(T2WrCjB62vl%je0R15OrVEYgWp@8T z&?my|(j66rw)dFopdaCgOk9N>J>eW9_6e=gdC(@krGMbFBCkb|RqWuRc6HhC*rIMN zHp?ZESD3nDB?4n8Wc$=jbV{}{lFcmufK6pZsjU)n1N0(PwVs9%{nc_$Xdo@oYGO9^ zWr&!hSgB0eIwpu4`=`G+qlo_6=~Zj^sA}W zyG`^mAb%2Br$R&}Dr^>N7x|@gYlpN_;T_Ps5MoI*(?QrObK6!pG6x)qmRI4`rGt>L zcm7S5$|XP6>q>99gSpo;3D@?gvg-jKzwnsov)pvbaXe{IHLNNz{0s0wDZ*^3dIFUX zmL8jGEv%vR$ebddb8eGnbjB;vL^OUAAs!%R<`nB;`<}!M6k0GiZUmM2BK>7+5NoS4 zQCTgM<3eiqzDp#8dGS^6fO{)phd_CoCZRe%(ts(oN|oOl&q zjzqNkMs@6s&(mZ=!0819(G+hFqsMai&?5d+HlNgWSF$}|qS*tLykYOUtVC3*ArR=c zb-3v_TrwTJ-P;>N;{KX(tA&s8o3uKjI& z9m6GRzhxr+FRLn2?bA-Ye`W)HxkphS5?I?$XkDhXS>K=*n3d3qfh{;|{yP4Hi^OutHem!eqw3!+XP2;aOir(8i~1(QaLF4()WB(KbLe{U4`Q zLlf<)oyaNOW@9~{I=^=(WEFjA+LVZWiLyHp94R;#(FmHzSV=8&PNSXF}AW|0gnd{9Y|;2%b5{9nO6YK#=>>HbuK zZUR2k1Usp9%3In(TgqlcG9mz#lBAqyUi@u{M=%p925Jk%9$?{3N|T}*1(&N{WBiq^vVuWDOJuBDyF=II*@^v zX^NiY26mJE=(k%|o^MUurdZF_EwyP?X$e?wrIu-m)lS5+5?iRZ?it>k#?wJLz96@? zdpfy0V@DTlYkliG!*|G+u9aD$E$_?Ob9FOi*%KYzOy~jcRT-^XE?NlJRjVPFj2l_` z_ptJ*CR#gz_a*78W$b#36&x&?C2)wf6I%H)axq^(HKhk)2N(Pik@X(&Ed%vC{VcRe zm;8UXs?SUIJHOu&YsL(%XF-hj>G$#8xn+m*`%Q`FjV7Dq+(HPJHd_a$iyOP+i$8fg zp;mDtM!F4@$Qa}_$A9$tSnjYml!c2Nop)+^=Eb-2#c&1;LU}2XxS0e>P*(30S-s;w zXZ7xm$9vyS1ejZTIldxup@^_tQ43+H-#CeJvCug(Wb3kUw-k>Aw?Kdk|0}xjV*J2~ zM56vVMewkLS%VC_FXLXdBG!}B9)JC{f#Az43;L6MFr1$W`ZyDG*=J3&n8*}~=Qnqk z7{u(3=K=TGFbhU$qHd~5PHj*NQyU^qNI6`kxk{+hhE`dmnsUvCJM3eKuKjbl4BvI7 zy|JbR*WbLHNw9qh__QVmi_eMsrg| z0cQ{q>Wg5e9MxwKt+EDJ$uT0gfEagr7cS~^P^=V#dI8-Z!79Tv6OxUnh&g)w&~J+H zkX@*2^4_2!v+PZ^S_PRvylivcD<@Zy@>)MBnJg}uF{PKu{QecDTY&%MtpC4sy z%e*BRWk>Afx3}}@3aNG)2r=sXK{RwQZ(5%72TkKToLizKXo{U&wWswh|EzX5ink6* zEL3GLwZquF3|DYCS<0hQ%A=Gb#jBEvrWO5_k|g`hi%}fZOzLsoe=BeaECS#4A~kY0 z&J|GiFM6BT_~N*Uk(m-Y=)%ulz><0Z--K@Jtasg^gKq1+7CPijev{wUx2Dee$bCgU z`6Y#9QLm%-e48>>p|zM-jDl&NsHRAI%B?*!gtW?|kBKD80u}|=K=u^uLT9z+#aA$f z(#^=DOLw(KXF)h=&j^45sPNt7ds!7A;7a}}Dt}%)zdxsIF+*0mJ9fCVy>Rk2$q53N zoUfcS=jk41Uau=i_g^RQt|;Aao;oKv1z?$Eh>F>4%}PsErGOr9A#2wIbZ4Pa2<;hM zAn_j_C5sM1ew<&0b_8KR$wM%5yQ1GGowbLu@k6|$Q0^n%fBx~?2}$pde4FswY)O%| zY)e5j%xXKOt|B>yAXub&OD=Oc=csVOz&`zaL?t!GZ=fo_0rx5!AG@AlD&e{WWC`x@ zsQf}^_17u5Z?0-Z{S zn<$pC7IQ!$e*`ayO(+I?!tiK|mo9GU7i}?g!vFLUuc3Eg5{?PcQ)c*!KnaR5BIKjO z9A2Qkc3-KWuHrQQ=Mns8#sX#0(+9q_L0oyx4Wd0s-odKG+diTRYFmIwOLAz&9L6;~ zhhd#ne4bops5(@Gs9xevsH)U1bop7Rd|HaS#n` zc0GNi3d)flgL#HE6#f!F;$nC~cRc@(!c)@^$`vHMjxUO-5I2!fYf&HVD3n@Xe}1e+ zz%rioA~Xa;o}|ti%dSW;oU53zc8%lz4zb~MS54z~^x9j5D!>r`u#&;{;RTeK%}9?$ zE{naV>VRqD;h87vF&|o`w>15F$$PkT5>w^^z}rdy`YF&mdBZ)G8Ez3*B_6l z`9*)oB*R3cFG2}4tZ}onSn6imVY4|&=nP!m=&9A$i~Z9;oL!ZRiH#dj;$s1GFm&;& zk$zb4bd93IX9Z_zrZFSH%a)fHANDHeVs4!;B5IL2h)#c@jDw&`SEbxR%DO51Qs7Nfe3h56-<^8(PWg=awRLU7sgDW#wAH}68 zOC`l-OC=QieAtnLrNF z<1j-fPVU%qRmiv_E>}ZgjsRDdl{qZ*v`o7idwj(!vda3TO(IG{6=6Li+71)9idRa} z!0QU44xaVyi=@H6E}2jCRpK5vXru;esnNC5ccT&oQ(B{7Xt@NkW$b121ZkX0YZI;< zkZX;pJ{vF-29}QztyR91DaG5fFu%aA@Z_LU)MlUD6aI!$?if@G!!5h+8Nhtr z?r|k$1j@}VK{k#uIp2_OcFYQAG!Nb};=lNl%wsV&XQ6r9XIR*AfQk1&AHTulk;iyc zo;@BH4jvCA5g69}E#pz~-rr+9+=EIv=XiWxNB;5Mfq>YvW9U-F$&|1>XK%i&fq|RN zuU|4d7QDq)GoWJyhviwbd~kot{4P7YKW&5i(<}Y?H_h)a4Qhr-$el5zzQFwM>>k(| z|4;oH8B~NlTY9qW?4FE|e(MWP%D(-28{MWhgQP(0l0VI3m+qN#03;83ci#UKQpj4^ z(6s&{%%JvJ3`QQW<5$FCK4%wo&q2MqcBl&N&^^50l|V!)vEvi4+$>G+m0}Tw>|Jnq zDta!VF_vtT@{~+T*kB>`-0?Kxm8$8oZ1ARk#w;NgLy`ng3sC09!2K=s?lL**{6rIA zCaUfbm*m^E`l%^ZOZE01PTP>d>im=kq$`H!yDGKafSCLDB#I%9# z62hrSPD{u`7A2aDW;Bg!qe6 z{a5yo0GoL6GpRz5ZwPyUU2ZreHxlfPa3atqp(mw2!$)i}$y!hu|Km<6n#ko!gq~by z1N(CjHRl%c`WWHF*3FW+lUK1>&OeL3mF~HrnzJlsxWr#gT#BHX<`6Fgl5BN+d{8Ro zF~k9HwjJ?{cuur?);a1xt>P9Hnd4}e7N@k&u(NVWYWJkakkCGt^v79p-% zFaM4MzZ8G@egZX2CE^?5`QxW|CKo|R$?pzfG3%BB7R3^06`sp^Kg+%WJdI1ap)d9 zQXw>NUC!^#M|6PiPh6rEg_j+~{b#=(t|1&-S%-vU3AHAE1++0Jw42<{~6dE6y_B?*N%5QrEEs1f2 zLdQa9Iec=a`SR`gp}JJyLHk~p3P3}AVH-+1<1ZWDTenDJFx?a|${nUxm*4nldNvZytpF?^1y;_0_xwX`p%sA%tY=>rpyj9LIksI^TtLMje#>S>3Mi`Sf ze7x>F9M!Bg1#D{^*5aSc>FI3!w)cIu0+-bff;uY6F%I6#F}cZXPq;2^j2`jk%ezF> zR+kp{jHo+;Tu(Z}<lpn-3ac7o3|;p=*}V1~p~}X~qpIB$;N+vD-fNoLuJ~yb98c z7Eimxi`XSA;LUk-Z1@HyOQmL8haJnDQDhn9YcnR*^Cm|Xx{OzxbN9u+H(xTWbE$Kr z{pIKRiC89aesdW{8Y2TK;e&HK0=8biF(XTlOw_fh)%JCz$@$_p)-qnF^zxzjD`LsI z$RXj(mhaCeGFp6n>)4cljl)@I;>TN+#aI6K6ITlnsC-|_ciq;VX!FaI_Eg*Jo)ifD z<%BO}sI1U#7)S~x^eQsKAO5y3_{0ngDNc`}y3C^~RaCnxzP^pa0?LQ@BR7>P7p73O z!*8482;JjOsUFX^kOqzy=g3)N6X$ms)3d@FfyE0=EEQ@k79mTE>w(IYM&x0WJ^>2-EPf57uTcOdW`BTP>5G& z`U&k3s-cgE>YA7jv3Ktmy1ZWKDpndY#E(f;$)eY z?cDMz0_a*4W1^%bS?(K{!Iyqurrw4_+&{N!wWaU0M$a#KsWp0WNvm^9PatCdE+&H= zxt|v1?uzYQauQPIIi(m2dRm;JVsJE|TPiZq#)(c2n$d5x_;Z^W^$W!4i+4~pT;X7l zyiGVJGIBlCQ{=qYmnJ1By%}L5^3i6A@nox(gEOh-R@7RfY8*aM6WUN6?~YBF@KS8t zgx7+R*{vMVJy8V&Pp)@*c=~=}d9lo?Ek$vBM`;^!=aN72s0@r>MJ4bGWar^kLtt}X zN6of(@d4EFEhIp5);n=q^pGR=8}k|2*u?0Fj@Zvih|ExIcCx%8$%qbP`rB8~kqHi+ zp7plW`!1Jx@h?>GA5^`2saM=92G*;d`|Cw-c6Plzef9Q8y<&fMzEq1?|Bg}=KPyUJ z=dt8Pj4cN@_kUMyMqjmJur?iGlWX1=>*mj>*B@#sqN@isSvvn`C4*ZnUG46x+l_%) zQ4neGy)O15H4A^uFvOY`;Z1k;{6W7v;dJb}3GHHaz|`5t)Omwx1I_K4{*g4{=wBJJ zhtyQ>n=V#68pg@E%iu9O*zlTj=2^2LqH|-;NJD;MzJUXgH^VU5Y956(%27YjJ6Xm# zYE9&@T9hE2m6IdZO-XYtZjvY==Qf0?H96n`uCn-Ra;9aY4}26j`be#T_;8>|)U6wj z)RS=XdwRK6BVmvuQ=0VXI|L2$tP#mt-5xL=P`PO2dYaezumo(ln-Hb{koXa2 zH?jK)Y2vR0hJZ1*Qgt?POf%tF_K%7hamQIvBW_iI++AsHT79ff`~44LYOFZc0h?GK z%kB;s{ybsFUKP-*0KMUd|F9WycKD4avL)Eq?0l)bn#%1~<^TUg+PIq9t(YYF-i>R< zn|(K+n?6h4on*@Cy<_n*ELnsMd>p)`&a_ArPF+{*{9cqfp&2KXe}vyyQl=YYE>&?| zMcohK6Te^LC`V@J#Q!@)?B&SptoZ+t8@~L6U)DtWUw&YYMOmS-QDUE*5fO#uK`4}A zRbTs?L!k_l^UDXsLZQ;c=*uo22S*JD=+HbgVAD)y4Mcl!{J*cKC2ccufLd&ugbr3h z0wIe;phnzot=#IHH%+;BUOp?hjloExs?4pct!v{xy9(!b>6x9fwwhz1r){F;SL zkS&FF?m)Ru%h9QAg*zpz(ZbCTuM3~#YfywR!BG|A!Ym?|EKX@J+z(~K&+C*;8LmPR zG@u=$9-_P|lI2KqM_TJ!YcJZ5{etB~e(mb%STnqJ�#1Xte^8mtS3e5&0DH>07g2 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 NQ%bFii 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

aDfq>YQj0*~uqon{A9v#rRV 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

+ms0Yqs#Ya&DA65W+|hL6I)BYvK^`H4eIT5Bc2| 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�WHI?w3g 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

^)RY$TrvL6&QLMR>{st3FcmrbuBCao9xG1rR-M$ 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"rQvza4#l62@>Rh0;#4o5dvN|4uqr3cl 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�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

oh5&;mZ8;d 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%0D!Cf;8q!;T=n5{K* z3#(L9K7MVu?VOG}<5ahtS{~~@lnDWg(vK_PvFUS4uOZ6qNcXdkeZ`s}bKg-yO<8=i%4!^5c!+JbsaOvOSdzZ!C`-I5!;#jedhwY4mvA2%qoguZFXhKF&}-@)a{*%~u-Qjdn%R!4~4j*EE@7axdJ5;k$g^P4?sHP_%s7 zUg*ZQ>w|Oc-f~nuy`;Qn+kpct9=SF%9Q2wM?KkX^T7G2f-(RcDQfj z5Fr9$BJt9QN1{=A9*4-4P-1W$etaA~eu2gR!W^ECwm#~-QQqO+caA|kCLkgJ0g)*= zZHSgxPwQ4rtFM4Ou!E(Av7nTomu6voDNPvO^Net;0AHa8f02R5>8bDJ;7TUvG+Pfo z5#V~6#p5uH(g0h}w8%Pr51*;vS@TIG6H>026OZy%xFhK4Ndyr>Pd$RP8b0k=vIS$B zbT{o_w9*7`hqpsU>r@~$n_lNY6K>%dSpc9b@FQF@=OpWt&jfeP4T%BDZP-coCP+yt)NoUb}CM2;M2 zDAM)GHlMzLE=4=?56~C@CJ1-B2b*0*>2>1Bn6ezi_4G#5HY``np2j>!$ABJB_B(Tp z>Ji3M^V;KFptk{#q@rfjP+V1}?1PLfE6MPgs4qD28G?AQM%?B{{Jj;73yUDWf2)!B zd0erlJOSdAq;YKf0liI94rwKXg=i7GzhU&+$BXh0dOTHQ5HT-Y540k+i9%j6ROShM zlHmIs`&0{#-Cx6QPS})U0eI#U7R|Anx$tfVAWwMZlVEr=l#I_hPz=7hu|FrjP>?^q zMP;rCSe&`?TMVccd6zQQE3|=6Q)o%OL`HvIF}(z}*EDJljoRa&##rE}N|Ycq-SZiF zPZ!?jAx!$7WZ_0Qmgzo}A4DL4sURrmN-$vcd%XxB$LmUEB*Mk(G9O*4Miq-dMLg^~ zTMhTC#9JU`NT#M@Z*jQ|znN#ts?Dn0o}R-2)k1wA&deyO$S0NnK~+`MZF`KsX`E`X zpgLNk+67cup;zjtX;Q#r6rpsI|ROi|x!4 zMp+kfz(_5#A^*?a@)T;}xoFW9*4*-HoCK+6NqV(BvFSCSJYAbZdpwnc7`BrCTZz*pG;*@i8 zLu06)RN_5|_~wfE8iJZK6Wh5(q^kC9JjK{r(2R@fbQ!<~0t~3Dgx?SF{MF7IBSlGnglkdWbgpO3z>uGCwo>EOra2)~YeVs= z+Rzcm%H51^oL^7_PPc=gTUJ7Jr|X68AiBGO2YLMYEw3=%0GK|4sXLjvDbqN2*$7sC zMu`W?b4^hQ*P>GLv89UP4qnzj6IlHT>jRGEy^%+BJN$T!QhOHIa3NG5@4oloNyaJ= z(ZR-CgF=Dw1y%SYwl!vG5{*XyFhVf@%O(KOL<9l6NB|utg+aexr)+Ac7#YFK*;g{kT}oh@2U$flVo=FP!bD* z3J?eAz)+@kqyV}`-m;FWE4@S-P*5lfq6$kNbnycODNPBB1?gfsNI~0K5F@AyDxsjy zSP+w=F6eyeKUUv?N#gKX3Yx=$;{1Xf6f};4R*utG4#&}ED+>UOa!+MIEk$3G z|80mCxm9130aFn)xDH?`uFrb#LZc$IK+b#m=t(ShgT$#OJW9$@!R2g__A~+Aw;ORS zc&`w2=?D+e9Ra$SRX}Uigjy?SrB%wK`WH=A{RX0`(#P@viGB(I^qvjgf#+~|Qf;P- z`ZBR(X8x?IH&oF-Q(y~$M9C8TR**kk>xxR)v(m4=|BwQC4Q-I?BJ!si+OIvyB!99w zrDu2MHh7lY$UTW&62u@JjZqc}NY!)ByT(3A4~%OR8JK)dL#vx(5Dg^!@sxT&iVZaI zerGIoe*9v-bOiVv{5-kbrw%<&}r`S zJB%3^jrJIfOsmgfi}bJ=fK~R;W$&(-2L-X^1V9x5<^EtlVw?WWh>a4&GW4(sL~I_2 zVce~+dZH+EAA!F?8vFkyevfDo!09glK#e*9yhQ+uIlxQ-u!8_p z$v;H^4i50C0QeXH%2@7qr|^3Petal5bqchs7Z05vLNke^%5?{j34Wds_= zL0bsWJp>BgnQ-Q5pvwsKyZVd)lK_2>K-J71p@BX|pr3HiucCRb&LL1W+Y>d=J_MS> zL0=J|g9ua=ewYS&BZ1xvQ0Rs74R0EEL~-iPR1~53JC*^qJz%MLsYT?KL-36C^E~`B zJVX3E7ZUnYJc=cCcogf`f-7|#@n{#Q#Qhwg-ex{FSxNxvIAQ<+m^r|=6&&Dk04VLa z-*>_`E<@)jNN zDZDF9Iq+u!*s}(}YCgZF11=)q({&l;p#pdV0joLvm=1U`0T*-NZUXo@0#@_dsso-x zz%K$=pDn-BTzxjD@V&%^eHT$c6~M$23@kmuG#n>YeuaWiACY7yGX1-s;GYCS)N|AM z7m6@Yx=N|0ue%%uc*_mv=Nz(ZO87(uqW5@eQu>`RcBfLAS_aRRa_LGA%0>X+vt zxx!X_uGT}ZPeSNpsJ$p3)S~$~HRh^}8c98` zr+N4_gzP{Fd8#$-PVyvKQG!SaB0)(+=1urRtXs$OPSAwUkn7Jd*y(!MNP?Xq2&;n3 zqwd=fNJ`H_FB&tN{X8$d2hXl`4T%GUNdB>4=rz+59^1e}c zPtcc1Qa>d$Pza0R*kvBE0Vj@db_NPDQ^;yHgv2{j5eqI{+N>U6lwAfWk|!fOql!19 zIR@VP%q@8x@)?gdP4D>zslfo@sVd#~i{P1pFM^~xoGODOU&1p{c&b|T+;{Ml{Am8L zAD$ObBdIx0=D_GKjB1@OKA}?K`cK?1JXB_KWz!?C)8^r;q z0Z`B5^E5sk&g;T9HF#Y(05Gh^P%@EmK)yem2Xv(XwPkd-MK1IKCR1I?1x?A7+DI+) zuA&5IQIBf~ET5Qe{2;syH8~3@Q9~#OAHoOl<^x1l@DJ}`6 zDor`!Mf0h5Bd?C75LODN0AA%ZGibaQ;V@=9rd;wsa09Z}{R3?=jsCV>5d*T|9 zyOTrTC77E|(1@9*pU5@k02hSd1`&YDeHa0B#zGL{ix%;9Bmh-FzqSIv_e9PWvrkZn zA^>$9P)q<{aDa^h;M4~IP$l>#0ldrs<_Uo91fX_}vH{?E0`#Yf&=nMlrkN#SJcW)D z`Ks2t15h`5Y(V*AJ?~4-Ar#b93?-3J+932x5jqB;o<{I!5X`{`z=IEb<43E?csnVh zvoc=FYjFY=QgU)DRZaBkH|^RDsnaT^U*@hO|KGub)-zJouo;!U{Rq)#-us`!bCd8? zA>X0S#va~fiNBl-9O~~_JG2w=ZG*+T9 zr%DplYwjjupbZga+Zb3&M-y-a&p#qK66W%NM}_P;px6pe_OQW9Cx+U?A3rri3D3rK_tSP0z4v0WyP{`re~u1;kl3A%))!1 z`r+wKZzKnT?xuct+Rd~3|{p6HGG8+FJVp@UjG;Hsmx;Gl%s@-4@UnqNtv1tG0)sV6oXcL zpy(r2la^N6GeCX$V1xigDgTug3+O^;w19ErJdyO6;0dG0bVyYnZ8sY8)&!{DvkQs# zH^@=%+4BWf0mlyJWn{&_cn?mMPaF?Ee-96SP6SiYC6+8tgXHUeBvVOTPy2ZebHOu1 zc;dm(d+mVdSU=CNs2b=GPvluwp#hB$uR1++sX6kOEP(knxSwxhDH$MGJ@O9CaZmEJ zL={R2R#Ws02Wut3HZm~7l*wd3DAYrOP)WF~Sx0<~a{N`&hL_d494a5au6n4;kN!+iwjhPw!N z+ld5IAGkEQQE(5zJr4IY+$(VJ!+j1{0{0DE+mi{V8E{!}d2r9cErELz?%!}f1}+_L3f#AFufYFfxNqQ2!qq&JV2Xq51~&-qVYnQ) zWpK;k*1_$9Q{aMrOE5KqyB%)Pg#^WChZGt-h zcL6TuEb;=bKU_LoHr&f_E8z~n{Rb}MT!LvWcsl^s2z1~1Gr<&Jr?n{s{`bK>3YQ1> z3&IxQ`EVt40MGSs!vI@|=UP1X<9P-y0^v8ookzMmjF0h?rFH^;Yg0F#q%JZM2qD22i_Z)TAOZ%>koIC z;s|eTx)*ZJ#FKP!GW=hLD~0FAmYlJ`!s4rec9IN2A!%YH>!+3h((xFqgM6@>bfExyviLe`i(-kfi?n(G9 zhWi9=A;L=WJV@Vop8?#Oct*p;!nK04zzqZ5!*DrppTd>HorQ}>ehq>f3HJ)zr*LcF zw!(c2cM`4!Mq#z!;^4Z%rNP|~HyiF5xVPX)rW@htxfb7t;38|ZHr)m{7VaUqY`7(G zpTJeX{Q`Fht|4%4f$IS`817-XEV#vR@5AY7Q@*MBMENrw@}j(oiEeF>rz*<^kc(cH zkKkJ`KUH?;;2%hCl(&>Olm{g1x8X?6`{CLk&VFzYz)gY6fO`h+ML4P>D8KK-`%1XA za2w%%fI93EXth|lr(-iPl7kms*>o<2i1wh3-Qq%?{~vdd=wAGNBaE;9O>$FaIe9A zK;OW3!nxpHfqNTnCES;A<#4;<4#1IoD6SuYb0?m}Gs%zM8^h5P<}QQ($-kiBAV!X! zbY9&I+k-1ObHqn|KStR9Vp}S*~>*JJf5f<&^V8FXT zyxIznCE_cj$O`+&Q}c7;=c6lSO)ij}bXT9WdT1z&VcUQC)|=*99@-!($ijL~I0A=* zf$+Ad4$9DtVXWoJoW97{_7iW&*7bwKoWplXmP|Zz651!i%`|wikCy2Wf1YR6&cb>#|KTLi@DxD8~ z>&+>Ua$iC)&i%$uwL3ROlEf_D0wzssG8d<`fX=IveFtQSuoF(kWYIyKg+p&PoJ$`C zgLUBcW#TqC<9Rv6-pvy0=?t%VECEvP6Npp}p`)$V(pXOnBF@2DnpcF5VxblwNx669 zeMOLxiid4H*rFuk+-ANB*#{#x+~%h2wwGZjNqyR|eqS8HA;+I=A#TbTb5dqo9PAts zl<^0wQv`Wq>TQ9wJRD*U?fku`ZmO#{hIQZ2Wk&Z}$S~JFyL?ihOkpT#KsmUXqrj-X zmvB;mvxjh60w-0jlvdZuIv?kVvwabSQ4@{8vd+iPtYMSh+B~h6w+trnn;|^o7|bQ~ zG}*nSy|cRC4)Yau)qKTXd&ssFxzxSW+yG`0m`w{y$aWZHwB)l7;3YtLLz|J9#vzLC zakx<|BBQ09+pVSWIE!kU-NJ3N!{7kj(3oH{cRE41-QzR*fR_!C&Aeq<=e-%XSfvf2 z&2X2Pw~TJ_i?evk;X|PoZ-qMsu_z~?x30UrX)wiw+gYE_#L(nBcy%8k<&LLPAiqfC za93Y%R`=LADTm5hX|E{|j(SICNXDbW@QmK5mbV;si9!leAFfD}2bae7F0+Pb+JLLs zs9{IsVF)sUC{m@NH||OP3j#tfgs=JYAf*m?EA2HIe5l5kL!{jE2!y!^?Raw+I}L2E zc)S@lOfEBcjRAxCRkHlS$Ay7R>-eq$uP)S(2m@uprNnspb|00|8?lp^%{eC=5vArS zl%JkknMs@)^y#^|)I6DFM?koCEhHma<5#scK>6=26Z+O`erRj)3ez4!TY8mRVf!ts zdo!3z-F}Hgv&9=zS=JZ^dCHW!fBFnq;fQrNDX*j^vI|vo9E|pVwJH)-iOkgUC_EUZhS5D9)zhed5^o)3EfHqQT};* z9zO5XK9}UneLA5(tpQj!;`0gZbMXdz zPR6GV(=l}T8urL6&a*h1z8y6Wk+_XK#N(PHJ7I@;S1Pwxvw5B|{Jfk}x z3dv{#YS&OVW(-_06-Q~}UDs7 zV(uZ2Bjk|=4?e@iCAyqsmIP1!+39tBwq`Jt1nxP9VCpkZs&~2PB=YoPnh6^SxX-t= zV0i*QBz|!YUCV`&nYe_*i#Br+yQKt)+?yhf-%=0#2x96yHv&H{ef!Ej~~9H z+RRidEo5dgIM!EMb0N>GR9aW7u~0Xv`r&74)vDd$uCH!!|CF){HH%iVzNG2@H{ru2 zd;BwezJO1x>v5k~2q0SnX!|@qr{Po8e3%rmI8Vpn4z_alPy55kqNM}&SyaQtn!uDB zh${5P)0Lx=!2)T`7I(LOS3vp(4HrraS>%^@FpazEFcd8Jc_`R%ghAshRH{}q1`CKf)PvGzu+sfu}ezT0ryIEbD}XO$MMZ1Q6wjr-fym$mZ{l=-FBspXI4BolTSAQ7pQ}o=xnR^>O>{OYzxi&fNG})FO z+nl<%%i@V=^wh_W89l1ld^6@7;YP!K3O5BV6Yd%D{f2lJ;<*Rz5ZoEK<}EOmgsTfj z@8lBUK8CA+i;M?dxCwC6;pW4=3ik<|2hQEHwdn#}#4VV^fs+$3{)KCU_XprCcwYfm zi1#ya&0Ar-43`bJ67FZXXoM3S;SoN;{{a_@&P6@Ao8dabJrAcE31Ro64D@bxUI>@+ z_CRZ4UNh;NZ?SIr!m{?X>{skPm^C{Tmj|t;Kn!77gXy;RK-J4G-GTkP=4|DO-EWu# z$OVA(7TUZ;&hz2ZPOcz>SOZ5Cb1G8}R4#YtRB#!~;P^I-N_sa?=*KC*UWyYIY>pdA z(87+7kuL=am}eOr--VGN3gIe+Q0MvJX(x;nJSg|L0tQxG+;z|r2TAkx!^a3y#$eRs z4iT|nggH3=4$de`FJpHpV3A;zT^b67LOwJ+p|QD<@FNDoeA+E(3#QFqX6QI&+OE_Ci=@Qqu0uAR**ipTV%P~S{j7x%Nqi~CtqrQQYV{j8~U{|GK*(;`BZ*hoiUnmfT}|uzx!{-f1JlZrgp&iX>?D5`MM3}ecHA* zje>g}t{ARKyVj=Ra89`TPp@QMVUqXWa6j0eYiz8>&eIa0%p{Kl8pCjfepfDTP$(3L85*yQ6NOnXUYVj(|f ziU6C+!6x9rh}z|>(}=dz`~XHY;x#>}SbKjUs5pJ$yI{Qn&J<+)7sURIekSgDh2JZ| z`-k~|8_9~$YWdS+2Wh->8v3xR??z~2xGzlg*L+}?Y6Ik?$tyU>WcZIsM)(AipZZ(< zw||Hp3-5@F;-UCh-eCUH_m53I>b`v;S9;@E>aPk(-zJ*OR6Y39_stQm6zU)5hYQ8x zlck)}m43m9?muUX@pko}YRD1|Q_$Az3qw&>riFAaD8}rmtM;-YbT#DALe+>Qjq16n zQD$V#LguK+TotZ(D~+Yn`!di|W&6}L+*H|}RkrKO5a5j|TGKd)%~_%ky(w4$P&x7r z-J0+;mw9x0etk5M*%undAogRn{Jv8W68RYHiAgzqh~&e&M%!Fn+XK-mS0K#VDL5Z9 z!DGgz(4BxS0D^1Js0?FTW>aBil(kbR49nUd-qoSx&uG)8!Y86qJH_LoWLsRirCVyJ z&>8hveeW%l3vD4q>DF%6KA|%)`^;#}wlkXVN^ZnP1xI zBnxCKgFFY+&JUj17b4L0_T~S`ea8I9y`TAoXGq9o2i{eCeeoGnw`hmNVl0fZCs$;i zhVGC_Ua}HtEecmPhev|z^r#83%HP2%AEu*Bj=SI$#fF1yDgxs^%f!@&3zB-%ydSa^ z;$q=dhNJu{EW7*^VT*|j3`YaT$6{)t#l&iO#AKdm!zDqz@&^ZX5om(HRJnqo3>GLQ zzui};pQE%ryfdj+nKd|*4+sJ=2p#de^;4a0({o7WDconDp5Mnk*fNwYk;K{L-_qoR zHu*WOHv2KkNWLTLa9N*Tkt{*@0&K(JPd4=~hsy+$#Y_JRNO2SD16Wju>>4 zcHnBT0hZ(f7?bxFQVySz*7Qm+BfxyQEImJT0C3t7PA87jgyA&H0$CU=tcu!Bhib{1 z8-~sV-A629mU5oO2T?lVm<3APP}n(*$3^rfJ!8-IN(ypx=Fv5^%KZ`mSVjer!xjow z%d4;o#9&9q&ILrhu|O=Ls-}-6xdQVH-U54aLFP%3z-{KsCFvHV&~mvb0GC5T*@m7B$gMbEcKq7kZ;RFXh$QhXp0No&3dej8GOl^|sW8 zcW0P&0db}84tMN#v?pG2+}qFw&&%`P#kEkhP@L zop)mk)=&E{cmV-e>top1Mw1GbwJ2>SgcTu-)8Y_y&uG+Y3Th958rz%*lbgU;=!bC{ z@he-trMN6~3pG)l446Q?Zu0T^Z)5@S8cEa*EOqdUU@ppoNT5R??L~A(>0H=nOvgjV zHKd*b=}kf+2DxaI*96Zr`2e2RG74!-zA0vs*4dLt*_m(rqk0yAff9EPeQCkx)=NBb z9T0^sBZdHzi}}k({WGGQUjp(^Y1Ez+)P5#bxP*}v?wWoWt$gvP3XD$(BMRwLYSSC# zxn(VBFVb7Sw`wwI0*Hbs^+`y*NY14{d2+^9k%bdP^y>5bF%79)AhiV&S2yJmu%*+I zJ^?tOm|ycH#3_gz`5NpSv?RhW=6ikY4iHEy35jx7OY_&vMDP|hnJ7U#J5qgm87+_< zgj|~;qm+`sUgF3aQcYi4f4Im6)RU07ijl09WcoHpeGrKFE04+!rM<|fw|Ro-u|58r z)b`_Kj-p9@kU;tzNJ8q_Lh2$JJHKJmX>s)F&k1p0_Hhs0dsir2^^lZXrM!t06`1ct4CBUqT-g7+VR0RGe2n%6;IObyzut zLth7$H&6X`_aL9HH53#dCyIuge-%XZsjcnS+K;l)kG9PqwT0S-a2PEgU zJ|eFQA|{I2Am%D};wVdcHL-0)rrVm8_C@83L2U4&DzD#^uP^?K54GC}K$HwD6 z-X9f6yLSrSm0OV-U7nxZedRnK?PH*YpfyjWrKRHEAfnInMn^O`oIJ#)XPnm}3sBwqI^ zzr&02h&lzxqb<7vi->oGx4V;l9GC>L@l`mO2O@eAo&8ngV9Qx9qFaHaJT2npO_%$w z0C7{Q-}NP6fj~dC-Cr;2`o%fU$LKJD^aUZ&N{A-!A5kZPQ8h<2-5%o8?ZyIm4j~%~ z#2Xx0LyGdH^6(!#l{P}+1%g^n#fooT4KNxM0u_YSK1xdkrOVs=6WrV{`p0}crwgPC zLgLX={vmshGb6z)!Q`XyKEbENtp)M|LN+A$6OODQHTwlgI<}Q3Nhr7s7*(7~!zv0s z8NvQ3R>3K&fAD4Xa!fT+r4m|&k5+zsymUxYugL;w2e=Xnz7!c~Ovh0e|Mh2rBEQQ= zCtlFW6R8v8`v{o4V^A+0{WKCS@B1!7fL`NQ{S49U*uq64kf#QSmeNka6#cj-u`8fzVF*J@y0zSK_>oP4v{P{b~7 zHS#`!s82Og-wT*P`q05gy}qD66V#2udBrb+V<;3NLk^tb!s%sXX_6mC`9ZK$+gKG^ zt6^ywUtUJx6)TBx}diq81tWQ~U1kzDsbhZ63rud>6BrrY)hOtiE z2P?yR^{zx+sMIqOCi}*L(h=#4;LItWj=>bc4SGS%^oyX(r&sF*QZr+8DSjC5{G^HN zX@PN~Or(QXK=u4EicvnPJ{@=X zRK0^hdfph_T0e|fUo@9a@RX0GXn5femA%ss=`G5S4JC$ji~&rb{8;mYCa7g10xvL) z>A2Z1f@wZYoG6es8>1up#`=^G^hMKEU@W0%!l1icsW$jwe2f-KIlsw}h*tm;C=tJX zuO(tH*62t-?x>Q8QGOA81;!pQ$mcdDqx-Md|56e_2Ajy4 zV@{*V)-q~%`}%0K6EvPB8bOmx>hmx<&pn^%vPor8!{pqfPqr?pfB11BHER}G^XzB z5@YJ(eLCJqAY~e(`+vl}2YeJ&_dY&JHX+mvReCch8w61V#Za=4;0A&qAo9|SA_6KU z6cuSnAaRKxBBF>WiXu{Mbd@BuBp@9`u}~#LM6l5%|L4rTyLZlH2KD{Ezt7)~C&|v7 z=eg&cdv2LCGs_YSB2+bV247%E{oRq8QQnOL!s=aL94qGCEtu!^xjA&B301eRll-FU zriF)S`g1sJ>e8CPQ}(IKrwC9oUR#&z%YURbp93lD0WKrB1wU@(1L8-O2hkEVlR)Hx zcYR3#S`HBH+9L7MJeooyVBPoG%(}_YwX^Op6?R2sc9Sk*RlAsVUW;{JW!(%3($O5Z zu8g#f>K=MO)M-tzy0FE5r23RKjV19M?#Egn^+l+bn%I^&uw6yjR{Hj1f$*&zXB$Rr z=Qvvr2euW8?Ip?fM;425bs)|C@T@`%kcb>0c+a24SO1zpr&YSdNKht$M9))K>lwV+ zcferRwbxMCmF^!qBiwIatofmq=7*~0Ka`+ys(G1scL79+S672I(|N(PvV%2GDr>q) z;x(JC!8n5ND>et?h{}gr5;T=SY#6))5LpvP*8G9%JX31S#5ubq;YSpFWo)+oBw}+r zh)u}OK zeL(*n5R*f{;9G|6obR9-Ya|0U*v&pkc4sDNAOb&xlER_O0=a!F10IHey}BUm@y9 z#B@SbLaV{s1xx9Bgq1Z$;9tVA%t{)CeJD3>0?ycleGjU-GBBT=6oI*g8`s)m+#-dT zE)l0U!MKWsaTFL_d`AK#s*i?={v$Z{2fpz)`&g*RiXDKMVs`}R?96Mb8mlZDn@EkR z*u4p)IV*0US}Pqoc|thUfe;l8^TLFAPXJ_!o!)^@WgQ)?S)#aSO7628nKe-sYep%= z!xFKc5akVPpAE?16|n({iP+@8<-Dg@J+zxZhJr>?vRMt zK$tpujRjFzA+8=1-u5Fz6hf;X<#s*;tX;(Rp#m)JTq`-MaXZ^uT3xIVsS^vR=(Oc_K4w8| zQ;6jfQ8r+wynR&_^$Sy*w;Bw^uVtQ7Oamp;mUYZpeFNX>Cn`h}iFgSJQ}3^{AZ}5J z>puwp1`vXx8obj#9UwW(LyUoswdpAwE4JJBV8YekUCV4tfTCSrEJ7_q;wAV1XWm zD+3etyAJT{r~^wUkAEk^63-nN4y1XoeK5XQeXXNr7`1N(Hv{?&aQWt*0jKnUdoQ1uK z0(F<5wFIKB_pXmHrlo>!J`-I_AN9KY+T#nHvvagL>XwB|O=iz?Q2be0u+p($%nnrwR5(iYNf1f zWfX5^K9FV~s*n#aNOrl=8Y9`Qm73uyZ&x1?5vmYi58jn-ZfT&o0zE51-+vU$2H7IM zq=Q+d(P)Z=8u=`BzWYS@Y_;m3%H(RYfl1T=WlrHDQ_vQg2=w=HtI>3BiuqhKeuHO- z`P^oH?g7&|b66K6ta1#bel0?EW;N^XvOt;+Vq-Jjg6N5Yp#Jd+=0rE>*g3HrMPwPi*^>P?j;v~7pQsT1Bq9q4 z?!?Je-1BD2iG~v7Cy;XDV++EY1t)&~kU5bF9XlryP~Fw9Vs~L0Z-X3kTN3YXuG`!} z_Y0KI^d(%kq=W7t*dPPh;ehC-54iPvR`QtKsSuSUVge96kgr=nXOTjB>L1M2@zAjg z%Y!gqn)K;@VN#W14Yag0kfCyPvIHGp&U&GQ1#t$YHa!j=n4*7jg}q55pes$PE7?=P z&V7ClVDp4`QDt1=KHe-qPavY0D^b*CJU&vazc}!Ap}zMM1}>C zhYFa!^?hc_W6-gS>lZ5fmh2I64d+fYvatIVVw6N2KwI32iyv^$JD{s&M#W0dn*>r$ zY_%XhLoG`$dXG8r7If^KsEQh3D=YyU5ya8bIpe(6Oy0J_6 zF^HQq(}I|QX7nsHU@~clgGonKl-`o;VZ}_k&CT^+JCRILqHo(Z znY0%=)N$5p0iQCdtYjYrcGFZkA4tRz^?>WGv5ylwPM0y$7CdWdxpx6tUh@vKuBU9- zT8!DP`sd}HBGeZ-vL=vvmm=mzqyt-)@*_dAE#qvvm+~mRNKp#m?8~8Jm)@Zmoidls zp8I8Nn>5Ihjz2tMF69ANWs+NeOQC8z>{!h;L-eHO$58crS0 zF}Er?m{dlwKP1^dd)pefuirru4U@B&jMEkzvl|SXR5xpqa7Z!28AP~}6ONID)*K(M z2v_Hdpj9YF*c@PU(3&gIvl8_ETQX?DuGTCdO@R_5Xc<7w_Un1)Sul4jvComsDhXYZ z;BkW>*kmS<`d2cgWh9@GY&5Ot_sYQ}&-KGO;~^K+CB;K7eN-E7?GWJz3wTE5&`{oB z&0+-AX;eMDSoX1AfxGte+xD)VQZtQ5Hajc85lr3H0GoTENP+&q*Dq3K;1L3;)P3H9 z_#TyAIm&V*q5&bwX>^TV0zdV7_-q=lu?_||qd_o7-mjO@bUWylAl>^hU`&>sd`soG zJ{&xzb34rEqWM7kP@c1<@jJKyB0VeECSuX)P1y;-^mqzja{!-Gpid>J3V|qqK~PHz zsHFl;mZ0N{01~TCD4?h(xGbP#lwqZLi4wGeK(`nzg;3y^;j=05Ig9NxWh3rcNT#B# z!qLIRRLX2~8o*{p(-bIQf*KQuIoj0%>Z(AmNYLdstd7>Ofc&Vg>RGstWpd@xoA$1p zSJ`-vY~WRDfVr{}V6!V56{u*7^q)Y?l{5<|O@Z`V4D1+*wxhr=#xDu@z zctSR?YoXPZ^NYAE=W+KzcI7=1^eTavD;q7KjS5thBmE~3OTRP==+BSfN_*)F(IZ6% zLC0<*@eN9a`fL2j&E^ienFx{eV2m{8(Cch#b?puAa~}$7eSRl1`6wXet^3l1+V(EuvbcSW|aenz~aB>SPJ}8VytC zQ*-(UC&e(3ZC_Yu@1{?+-B{AhG0~u_)&glB168Oy_oMt7XbL)W9oWyRAnwT$p54va zds*1mQvy`r*Ln9iu+LKLqb2*n1u6uv>+0*=_TI!kn_rzChK^kVG*RpoCHr{J{)UD9 zIx4&RX3jp*fqgG@WuLFvEFx2tv$wIZzo`%@67kck!Gw$yRovXoO{jQ z(F8>tBZ)IXZ0g=mfi$N;MRGKcr@(9n_A{sk>+hhdYT_H>pu355E2H*o(!JL~cQ)y6 zcd$xACOcezCtbY5mSy-vBMU*&yOf5 zOT<=*xE%;%J`pv!&KATK|c%P3x!xB z5#h>TIgd58fYKG{NeS9J56y^Wocz^y;j_umpXS@U*hVqkDw$?*olQ z_X>B>qY&jJVl=g_Tzu7nxP+>%bn&~5A}DPMAzYN3^}!ZU1=Y;^5>$#nm5i)45;cMw zS{Dp^3!;)jT-hL8>`MsNi&HG1DGIbz zf^H{J>7a{PuQ~!`^sD|BpNH1FQjBMQ+V>;JaKBXWoPH~GO{2Iq6z$x91%+ej{d&Crg7azABlnzQ_!&YiWC`LOdoB zxr7h~i|MMMa1QsflL9rBpqBv(^no4?*8?BW-75emYmH*ghHLEH9P_zZ*V(ybdCpok z*!6DE%a7NHcvUhrj~4H@82q|IOp%BanJg}m7Q`@x=qwQ*5kjP$F|)3~XOoxPXWREl zZ7}JF`Nh-gQrCz`xl7FJ$>ww0F0*rk&F5xaVdpxS&ppWVB}SgJMshle&2mUQ{+Wnm z{w(Izg%?qrTk#!h={p>=%f5RQTQ$ixiL)&swu7AQMF+N@mIQ6v`Khq231{m;Y}Ywk z9F8HX#a>rjpxB<5Y{&e}(+Fbg@ICYNw@iCaJ1Vw2CEHxE$?TA`+!}z*3ud?)HCI0o z4)x0D=wYnikL`1sWtlTM1NFO|e<{ zY|8a-XW7T)ZpCzqWO|mEN*PQtE{gy*$K{+#n-d?4xFqoAMpzI#-wMX%BZ;U;&8WDv zv>;wnh{+OhJR=yF5SXWbkI&?y3m-6rT=LtycphD^KZ*^HDI7Z;bZ=FyM#@%4$X0}@ z1up?WGi2_VX6s~gA;bM&qkF9MXQ7#gSkoR zK$;(bTZT%f^!zJ{Xi5k+lDY$A3~l@aF@Yy@+u|5rWdoOgFTJW=`T*56N+J(v>r^iv zo{pTsGQBJiXbNY?*0p;2Yr1{Mv{Vi?k>}xq|O$^N)_q367grMjI=Cr{)*2g zgG)OYJVY`1B-4k)#FB9L3?7l%%HWC;G@d{zhHqF9pQE%XQ{(uDA};aD;0Q{PIBBp8 zA22!h27^f1tXkHTZG&@x!D&vw85rcUmFHwDKcq0bTo${cm0gJvv4Rk6G2N5K-7i83 zP%i~F)3op*bcDI(im&M zm$HMPni4bxAXA4dwIH?up>NB_U1T<(CPU4xk6WPXE0br_`@*W)#jNsL+6Ymg84{#V zVOF^UY8_9>R&VYiR~3KYaW%9IjdHaLj5P4##2c+B?(iT`R3(ckDgkTKi() zp#Yobv%^`zczh^9ptk9dmHHv<+}A9bW5Scrr*zXFHW(y zVKU7%<+yIXgKjA4p1`vqCg0w4(49dG$6BsC#zA)@%0v1KT(^UR?hhCOdVlDeCg$o6 zx_6_pD!crVcSRy@oWy$X*ks<{QRLwg^t6fnbLiOh-a$lJvR`>eu=nNc(=F_SDJJop zy}twdc*VX@vfp@)*&c0SuS8M&X(_W^b6~Hk*jr2Xw>bOu=Xqp$Qry!y`x5BbMP}oi zU}Sz=A|lg{vk$YdFQaKHhO@^zu=iE$(wZuAEv{gpS(yY{Y4EJKv%_ zssA~V#e6<=?5-6jll_kuG5d#0U3%%t%=-zdLDK&B-xAR&MfR75mBDXjXbiB`{%Sae zueQ)*c{`yFHl4-1P&nTd&~Kg<##;@lrwpnh4SEJ{Z!BXNB!l+`z*d9OaSUGsqOaf^ zozXZ<1BMEv<`mlSLeTM5i-qImsU7Mjd53m7w(KU0ZNz)D(-V0Zu03O) z>L)P?6sDU<_e0UH4~Iihf9Ee|z&5wg5+tzW6?d$~0c&3$O3%`@G9XfU~D5q=!2He(( z4r~L}e7NQf;dxcg*2ZFM6SDPdZfkW1b}CBAxIQA;Hzu=492*Z?OL1Fw;h5d3R!Omy zlx!n8+gxIc=4_L3%r1^YF^5XqHZ2sM*XC^TK$>UAduY~uihEwy!PZE{-cPb;jb)zy zG>+_252hT(?H_$2XU{QoiWjbWLs!~f^t!NpFlSE((rkM}Vjsls@I30k{)S?ITe7=2 zdyIvBII)Lu_6P^|H`N;1Ub4S8hDByqGPivst?!R<_GQqq>(yh5{q$=hGCt1!l!bj2 zv6tZN9Ua(DsO4y;WIsEa*&bzK{|E^Ee$M{$So{1=RqP(gK8v$|0;D--x)FOkXMfSq zDV{Ui75mNwA~H=ldk-MZIWv#gC-XaoO&x3>rr4j9?0ZMC$Xp!5ZEr#B>0meQbM_lL z#ce;E7R-0IWFN!X7XWFty#RF}IYPdFRd^c*1mB4b0m!;>=z?SBo!IJirHQ`Di9B0dn00} zTg)c*9ni6h%#SEc%E-7R`{SHF)58A!)F5L2E5h66K=4g%FMzD65RYTDsl9*=hsm4SKm?SYP+-)B@pmyzsGbM{v(>}kXv#@R{-nQxxrk@2AN6v%&xm<9yj_rD8}wa@0@ z814JpU=v{KvuAMFE~+n03%0ZNW#M-^ZWRd zWS80m+=bef^!ql6$N<809fFI+6#$8WQz0Dtota1nldCV{ter9MsbR2lu5h&pH>QWh zm_IO(^{03OH8pgK&(J=_{-k8zJDj>K&OO@@wLWM(P$k6#jzsl?guH|$c~6hrJixb0OO*qbQ!?vj1&6D%^{jo?X8lh`kE z+t(X9#pAwLCCs05gzddJ`(z-^E8}hyg7npV-RD%r0NW470|uxDYY>+P^3 zF=gcS;r6{+NwK$->~C=P93aiMe`3S_rUU!h=YvD(=xh<0Hk|!Y3;Vk^>~Rk4y%hWN zlKt4@EHV)m_MRv+StE1e3H!)gMHy3019c?(bk4pENONR-m}>ONJnpFu>~ARc>=#93 zqB(m<3;X>x?6*0vw^8gvB>VQEEHXb2@Ql_e?T3_ z8kyk^?9&zd`=zzowpRhtoRJYW?7t1Q@6}R@ z{Z7d~m$R=2(#(DtbBERTdC;+o%nFn+Wn}jGMP%;b?7a=U)coGjhP{OY`-6&otYkkt zghl51W4u>e1=vm7`6JLF+mZ9EFqwril(fCFWS585q2=+EzF zhQ9+HyAJm&_G1|$1noKd6BhOjsQk#Ft&)iHgs5O##)aXhUKXEC9d^4z+iunNqmpUI zAQrT9L%3(HRoiz<#4Cg-Z?x^AwqL?$Q`;Yc!OriO!K8P@w#1}6#X2`O} zjV0Y}%bD)&4!UmT&7(33wrnM@zHzq5;!7)3J>Y?tWU*`qAl~UI_R9=Cu z?8CD&Ma!MhvT3M{1=76Ru1HJrUe4ad!IFCw`z*8 zkiDNDAZrTWGAZUdC{CqeP?rbq4F}yGq&tf1j&jiL1!HCKR?ZN?i{hrY08*dDldHZ1 zTPejhK(giZXMrdf$h+bQN>Tbb{>05z=-4Gi5(PG!>n?E6?MkUTmseFsN?mIL^?(gB z1|Ot}7?gq4rUbg%Vzse8&%Vl1xtxO~7g2ta?42b0s(y_9-~b+zXoaXI5t9gEn#t36 z@6H8-UBsSMOnXv=XLp0ilyAL&)X($Yjdx(1g<6sHWSV3<)t9lABDRmQvoN)AvA?j* z8ucF(TQkWvA8e+me-5O1*j~pfqgUhX3naUBp_!`K52Xmt@8h=i2T~t_t6Y<<9Ua)_ zqHd%=ARp`%RlI`Q4!RMl7(EcbB^?!Fu|$LtLS-Jx5DhG#$_g}Gg1+hvP-$ZwGuF^Nd^S0E zvah{!jZk{B&dci@bc;}~k8|6t>l}28P{YxO@WJ4B&^_;f?uAkMqj-qK6#q|g)-FQVQ1OxeUYIQW?aqyP21xT5$Ww?fC88b~ zQ$dZ@r}&h3uS45Y6jQQf`no3z;a|OY+np7nokT1J!o1)8?FRFE6Bx*E>(UXXm@Ypr z{O&_cYV1$5v|SGip}veyvHc{wb?I1&YLSfU>yrJihnZ)$TG+<|p@01+v%TmM`#zh1 zbkINKx(6I|JCW{JzcJqT9dzrEZV}gg&O!Hg#82n1enquLTKUs+!pcNgY08MFfi#bV z0kr7OzsM}<GFTst7s0AXO@tfdw1;kKF)BkLCQHQe2Z3NC)@1?p zP@qH!T0x*vh9}gRzUCK}4>?`!4ZaE{eKVfpHbs2CgYIP2>Va{>xfW>EgzO8Xd5k3~ z#M=_#B0E($Vl0U23h}f=?C)$1$DdtzGp7dzqkg{xEh3PZz(Oe;ui>-F&`-f&*MAEY z(}iT=Vs~Ov20vqI`w4~kQX=XVGdSJ?x<`RBB}&nAOI9SrV>(vnQL zwvuTHN9I1rgH=@_%1Xp2YFoKD--7rFr5oAC(Xk>ZZ3w|qbdUw~F+lp`d=JwaI(AV{ zQw=;T8~DBxGbzl%-d!Pl67eA+m`S@kbI)s&Nom}q<(1Q~6F@ee;X~cu&`bvB@8M-6M-bJ@! za!IDgiAg0wCXnXg{5|SDGAR2;i=Z?wW^gYHXqf^nk|2#hr3`~3DA%tiGJ~r)7<@x9 zb(c(QIr6(s+~8dbQBNXLfiSta+=6&rAszspEhKn?u zv9QDeglC}SZiOZ#G1qVBmymySwC~dIP+F25beA+_ z9%tPMq`6C%D@4)L!r#F_m?D&JK}=MLuOy-=A=uFCZUMc6GLSTEfdpN9z#5_20Bx*n zidkk&t)L_hiun8p0Ds4iUTW3v!(mglf0L-fW_C1NSx`k<@C;d?vVAd-X2fhD^wYS# zY+`@TfqjT#UysXu`tINwoZV|-zl+%Ke37x&a$pZv?7b!X7af@GCw<)Z1OEa0GhpWd z`;G!u0#K7n%K){T0q1~1cG>ACg-bq;dFxjuaq(Mr7>w}#T1+mfi!pIHI${K`4@%@hr1JkP5L0gb=67>2>2)-q zFXrao=Ac_nnLk7tvmLFN%>Ox_o8L;Af0sneBLth9*I7XK(zfU~FEjsT=-4I1QIvr6 zS={``9dx@WW8Qs2#IghrQez6@awdlIA-U^r|?7e zbEIS&!P#CSwz-_`c?Y&_CAxiIxJK-jqfAXp@nAw{s_FEm+NHgL($~OAz zoITxveJ^xnWVQ_zk!i@;AGEN)N$jUMdyHha_S6`~{xvew*s4jkNnkV0BujuaN8-1xuyqdKo=lePR$I42S4LvfVmY7xQwLio zDz+yj+uqj9){AYqtsThL-rUyx(6Jl%)fKy2vX23~DVr7msaNE-rb;$zTz8?iBR$W4 zRCpfEZS82W^>rZhXm0Cm4z@m}*oR2=?X8%tKeyqLXhrOu_)VEy=-5RfO0kDa_F2i>X4l0$gYhE{_6xF!89mOQ8s??^-h z5T;q@4hy2DLX4J(gDruG(x|v0F4YPy#d3!qKrKoJyp;qkCQxMq6oQ|)`py9eN+?h_ zJbs$Ne(F=8Ya0HqL6Jgb9qPwX%aN@d9w^*zNv#N@sIoi2V%KVgcvm7yC}$#s zT`?BWS=wMdb{{h-LYicqcOO&@w3iLM$C114N2aylwS)CIX6K-$*!~B0a zqP;v7|7gL&QVzOyqqe7Ny_0Nx6-OSt5B*+;uVGm@X2-TnvHjIg1YjU%n*pS`-^VM& zPKjs&gek~9EQol8cugX%HxCBcC5A#B3+QQ7mGq@Qv&re&z4lJDhpz09`(y(P(ST`O zX9H<=qCByOo@4BbBs-0L{V;ENnnTNZDD&tWx$eUbx{IJIt(@Ceg!<2Wn3XjwR*q1J zffBI=2vex_7Tm9vWX~Ml_1mBm81j1UKbX%S$aB`Q_bX~W($=5)2wM}mtxsE8-mDOx zNyIJO*47q8rb0}Yh||r2X(6ZkNDHW!0(F+4j|fC#PcOqCZrIh_K3ys)j*^mNBsfgz zG8ag5x|~1(NQUF<-Xa|LQ>$wFA80{*q!3FbBC?osjVz$&6ljzL9k^RMC%-*q4?dd= z)$cL&ZO0;O#V`M9M5Qtyyb#!Z6b|3Gi!m*hOx8?Tr*iPS{|MLHl1<9>$AB~kD@`Gm zOGH^hu!W&1K!_+-4VE&dPMQkzbFhn>`|fZY?o#aV^F46*KJLXg%~U+hHoc^5 zsv>QA21t_^i-9yF1}Ma-Uc&DO2*Fl{;Q$FQ_T~q@pvdUAbGy9KE^BnJs8pORTRGm8 z*;T?~*A9h9l8DuWV0P`ln>#aCfo_qYX9*<2ZWufspG}E12Ml)W1r>qiNcidz5tgPL z*%L_X_t3O+VB3h|pk$jO*-qTa+>f+)lCBV)CE_DO2=^lpdTjR&+!g4SmU+Q$p>z5i z=$gD-4n;dJ>#J7I^b}rpfH>saO)R%}fAWS*`p#{-MAuc>D-0n^Y7ToawiJbp#2M=yD=<<>K z!jo|DmB!4>7QoxZ{1?^uSlRetAPsZ9>nn<$y>ch_QODLozXxi(-O#6SxRz{}W)&pG zmw*bpqseaSk|6C8gVy|yC(R+^qjxaNCqc{3@;^}R)4iB{4O0C!WpxS4xtjD@j5NCB zfGN#Dgqwk|CM7>i52y2yhB;)a{xe$LSkm|$CiKIKnOA;vFx@)z5Iyw)!2}I$LG`8h z%%jq3Bo3D#HPNAxeQA?GU`lUCV9FRR%b;Zh&z;|fbIMA1@nrDa0XioFDmfnto?C}= zrV)1^PLNgfPlW2D8?pG-l;>!Y6#sze>v2Ih2Xq&1<^aR(KixQBeC!G0ib0#dh+*f3;hbGg978cs&Ie1o3Ckl*-s-Pl>&|<}s1H5? zc7FKM)9AEr#SS+`0_d?gY>Mr7ci7u94^hyT`lX?4UjJ(u<0xfV zQT#39928h(c0C|DmJ^3^dT$JW&-VfflM+!`A|?h}4c1l`T0nhNGsn6Jr`r=q^pd>L z9SYD!w-E+$#DAoqTaXAlJbaA^u6Ac*N!4Gto%LxWsNrg>*gpz#QW-l;w!0HZlY75< zxO?RlqJ>1fMhMoYpIbn!P?FSZV%|3O+5+g%cs4EqC%wJ zB0IYxl}x(B9du8i5GVujekT#SQrym_7CS!zLdOzsW-sHwo=UpgkwPX*jy15idV$G* zY01=ES;XE0(%gwd$ksU#Dq28P z#FWkSlAuilqQytAhQCaK_&VA?5M2~UCCM>?I8-(-0@56aeyS5sB+C3RX6i5ts3G+Y z78vtW;PHlzc`C?3!B9FhQ&OL;2V=xC5&^dmg|dJ_2~*A3O=1s8bCCWODJrYa+-mRd z0M$gaY+@!MRpO(Gfkr!#wKXl4ee&I zOg}K3b=qtP-S?FjyB-iBx|6r^uwje(5|D8U@w!C(RfqNAtrkRkg%~CgI|(879VOv7 zdg7OQ;@_j7k9u=F;A3)hKh6bL@lkwMSu4+3OEFDQt(4vKdk5iIPc&*`odl#gTdt#^ zr`PA~y&Ty0lJ0RlY+~ZO!)#@jx7fKT2cC4|DPNn}b*ip?xAuju^r)WnC>2O!2GOWcv^%HoY4;IItqQV$yEs=h!$h-1=1YE64byWXnk)slK<)^F8gtMpGw34@nu~LG10}yH8GD{JFw{Z!P3X!{ zyb~`%5dnWpQ`a4a1!|!Dtb#XMA`aFBLS17Z?Jw27T9lGo7a^p7M`}AwkI6LW-U&@p zZtaDdod@Zvjk2CF zcr4zeJJ~^ZDCw@{y4@Ufza`xlxbAJmEPWJO(%UE632%2*hqq-h(|OlN(tMXopH-io zsA=y>X)d1(FUjx$#$R`bM#6LZfi@0Xd@AC6M{Lo)dF&ngOm9vehWHwnUH=5ber=hNs=9O z?@(F#ahwQ7C2s!x7E5A?y(DL^;=sO}a;M^GmgQ%w3#+MH^i6Bnx!pL&N5JPOK4j)dPvQ<3QG{E2OSkgNf(b1r*2hg_T*ZwQ{g+E9oZjy-}2du8(xLgo8uGUL79nHhJ<2CSjq z0A1O@Q?h}5l~}%Cs)G5{^3MpL#4)>69iiCjO12cv_5qOQxxb}C{1Pi1e25Ti^dwtA zE^@HRS>|9@2b0oKm6Hx;$_6e}WDZubu=iAmJ`(XIA(%k zr(T<1GAsszT@0ycCJp}Xei4zj+~CJ7Z9l9K%O#?0F@u|0Ky?*poCF=Izzx2e8~jTp zdxOU-rbd$KMPgFBh0lOAcY3@+Txls>>`Mq1;VBl7TY5Ak|ao)zLIO&HA81DuL-4N2v;Jlg8wabWcq}%Nz;~nIn z`vIy!GJD>IDG__n5vK0@vjXqF=44OJPnkXYpkrtI2C(au z*D~Fu4!Yly?&6h9_ZbIWBYyk1Zf6JG24ru&RgAZugYFd-jsEwF_+`6UG|rUg(b%C7 zcSyu+La1cc@5Q6Ero3DV2D?~2ub57>5N#)b$%GtXX}c3e?8`xn{Q(E|Jt(Eg%t)2& zXUZ}5vKID5K}N37q0eF#~yko!5nLHAzL zU5<^1DQ?XibVtAj8Iw`XMZ^!3Wih$p=2o{Pt9SBil|#_6>(4Lh2H7h}_Hmqjp@rQK zgkFoU+!GwwSCg)nThhrvw;Abf`;EnTvS2^PdUAoR1` zyY3G5#47eVlKpq=NKDbLW??U>5d9@08wis>a#pfDyrMH@7 zAHwa)u(0P5`(L;?G}-)^1AAx1zT_?u%W%%#$iiNO*q`TpTSBs1$HjS6t)%VolKuUX zEHYn}=8^dV2)*MzX8Q-wv5U+!W&2M}h3$!){b>t(7qY$Ie;9iw2lfNX_H@Z!7|Coe zZ()C%Y#+zj&y}*by@6tnk?fhA{Zk;#S^qn#VtOWLpDo!b?)tTB%&)NyEq78ae{`pa zT1DP+OH0dn)bbR5Q?arG`y%Md9`7dE*OXvUJ6e+aRfE{`IQu&2*!B2%l&$nvvY4NK zscXdG5Rbvr=5vX>gwx%j4L`N9`6_GUb_ZQI>5k@YUW>H1Jq5ZlGWRtRabFn0B9jfI zxyK(O_SO6*=OPF8L#Sa%_HP>t_ST$zh=u(fAoMGoy{(~Be3!n1ben$9Vp7pTcOmJX zih9dt*L?k9Yy>g%9;5cbOCc`ZhS@Omious)FHpjROF z8Jzuw%ihEB6pd@WnTPuwbm@g8y$=SaQ3Crq@R(%^?a+P+Vcj*`f#Mc2Z3Eu{3~|ss z3SH^=TOQ$f7SFmwEyF#8}4BHqDx0LDE2p^KTl*wbgH zQSj2=Ji>IRIp}U6-G{zmx(_?(wkF*UoY&)^Tb^{UK-U-s-t~0#ig9)|)ZV?hYP)i8 zLlNlLfiO9n1te}4BG%{-+%t?rKxEg18;InQdMbxxIy4rpp!v5`W65`MD|-NF?$kfj zw%|1bFs@d!tiqaPo%E|d5W=qX*RB-#6YBc>eWQE%{K?S+ef~+&!+a@Qn|cR$`}f=O zv^z!{f3HVtfTu6NffPZuxAbV8?)PY|Vm(?mWOXZ#c2{eUR=tw-}hwnN&* zd9-F;j~3Am=OOPy>b3W1iy%$oJz8JLMo8xbk5(C_;qM_!9`IR z1LT1o9_=Sc{KFn?6r^fTkCp{_>Jg8Y)XSqygdBzp{f|eR3t0s@2N~Miqm}IA(H@5s zLOS&IXa^yGLHhJV93XZ2d$cu>i;xNfJX#Y-M@SZ=#Xyht31m0q*+Cwy?O>1Q8iE)= z`a;qnH6BHK5btB)hCDvhquueiNBb30YnVq%gp7kkKHJA*&$yke?uXMtii^$9S~I#=^d2 z*az7NsWA?H3rR;#yp7*QkbdJm+9pV~2_EfTNa#e^1?df$0r>=S1d{uVNBi(ukM`no z9&Pj_k2dgmkM{6nkJe*~N4s~bM>`D(nFc>0J0X`K6{mZ&J0YDQk3-f#!csiiLy*Og zb*Zp34S5Dhp5f6-%*1EN9!P4sN2`*7{DT~V%yAPuEF@|+;tBZzau8AonKs9x-SU!0YY%xEvJkQZ@;ju?T-Xbl067F{_OeHN z3349Nc^+Z_DftTgfn0;!KHsCwhOCFweHD2RnGe|vDTLgz0PR4YhAf2afcy@r^O{F{ z60#Fg?RB&V*#@b&5b=fVfi!-@qxm5^P*<~JW1SAh~ z`v)E^4RR9VU5-A3`~~UrA;u!4`3jFV2l5MK_)7E*q{1qX)&?>hvL12@(r&d!dkc~W z`4dv_Bg6yp732z}!N(pg1yTg*{0ZU&xdM6MQ;#+lvJdhXWYuRL?ORCCHOP6$D#*8x zh_#q&ApIeqLmpb^(SCsRUXQr|a?b|L1&}WxXCYNK!Y0TZ$mfs(NQX@xZ64$|NZjX$ zDWujH7_*RyUm|vpjLpcsEc6ZJ8svv;^nDJ-z!r>MNd8vDb{q0*JLX5o+dB{gNR?dV zH)KCVhuoWoxI<1ty!qgOoP$i=>Csj|+U`OhKyE-{zQUXa*$%0+8)Fpm1*G#H77L9Re9A3}~DMm|7BevN)Of_Ovb zf8){qfJA+Zbpo;rQUKX@)T1r?&ZBLG9EJP_dEtBb3Rw^7`UB>HA3a(Z$Qj79$1qnP zN6tV#ha7-ZJ^{ZW|2c`VhTnZ4&q4f<{SX~84(H0A@@O8&D9B96n~*h-iiD>AQK?jkTZ~qf1rOM zBOt3GQGX(DA-_UuT|^up??bjgbcp*B{D*{H#(W3KglvGErq5R}2ScVoRzkjk6hQ`F z#n^y&uc3b+?_5WY{)PO4tbiPWxNcx=fMh{_hEy#=KS4%8eui|^VzgzDh>#fVZb*N~ z=aA~5FX$d zL)t)wL*_&NfOIPvqfLe^hg^nqC>5j4gJeOvmyXdshI|hxStdqn4tW`}8Bz!dEgPdX zfy{!ehn#{$m5b3@L54x*L0nk(cA5V3W%P}XO3FxzuKRG$N4!0}4|{uhAMvI99GB4S z;`Y?&so36yxYvek#?_Tpl$$Xrx@m&{a+3e7&;Lz=|EHA8CEPQ2;gm14@^3#KD*6)F z1Dd-|oHo>5hjxZIvA{oTdYM`=nlCKB=(u}r`%w4VP9eUOEnz8_>yC4;#}!$T_tqU- z2ammUtZ>5C6VF`QUX;7_#OO;|!J~tGMO!-i4=4GzB=~oG-D{)#`Cfl^%JC`Ql?N;`7~u%UQn+qEgVWCMYv2 zw>W(Wd-8D={a=aL>=wWFAVkb2SS4O(RXMc z$bT0Pe^PW)(WjkZT-cEW{|;ZK$V;z(zb_*`x}ndX8odC$C4EEqL+N;3_u57Y8T}#) zGHMhR#ozZ?^i&I|8Y4-K+`tN_{Z!muo(taFQdTWmM zTaG*RVOZn8k&ztTRPSgp>>tEG!GAcxpPLl6lOmsh!Q44BF~sZ7_4;#+L6j31M8A5c zUYE#s`#LE%MMO^ z3n;teM;wkvVOF!#_cTrC$!|@C9c*+!)_Iz#k+76f_Cx>L8i7b8Dy*48ISXKFF zhp@t$IE&FcIW%}kosRG!e#W$wS@xB}3tDN+)4Ss_Ui=3N@Z?BQygxTBYg|Aq2r@{nH@tg-dw)0 zoxYTu8$;)8yBy`cuM!2X<>Py?7+|a}vSWgXhUr~NAWNG`S6sm|t-DvN^ zCq(WWkhDIAXNcT0U%;Qq@vU#5XD2jtr>@4w#+Rv^Q{Tm(DFvbK)P?j1`Yv@Y{?HAL zqrfJYqll-5!b_csLxB*eUWJ+UOlFGyyor5<-CMth8r+0>$&Ff{BP7nVU7SuXSJ_o2C86Vax3%dia%a`d3xsl~fk3)v%`E#(e zj`-n%=H21SMJH>1*K}`2d~W1=+D&=4$LG327#Ua%KKD)dYWx>`H?yx(!{7h4eK+IV z+2DW7_x^AHQ~OHS`}g+MzDa*y8S^S>+uk+dPw-w;zFK!ZRDOV%^ zJAZFx-_ff7-rt+e2mb$puf$FIBlf@GyP3b8j{R@PN29m?xAVcKe?4DKyIO?ga0+3f zn&2@cuvHNgeW)B`@mO0LdN(P%Y^rLh_ z?3Qs=yqOQV3#0I}L}4lX3@dcuC$@oVy=fO*Z)!yUt|esD%ol4-z8L5U>3#EEYCPU7 zp9*XL`~19FJ}vw&_->j{2miPEbad+fHlO^{|F?XxCH{SX+$?@aPycW2EB){IC}~sj z>joF9&S6>W<1iQ+<#f!5&lcI*Zig$I22Q)}@!77xz>!N7Tjl-%nDp^|Jig4XVqv7> zQ1%H|15LxVZP-3s2K%PvY1-u?Us{&2kR`g~b9aPN^S+FZk=xr@3^3aF@57+=rW_A3 zyJ4)gDaS$#Ke!773hWGxks4Ss^X2@I?+Wdlk(7@m)9Ro9Z{i~C$%BjW{{7zUf^cuj zi8|htV|7G(*oAtr9dK_v5rw^Imjj22uoumv*#`@Co-1Umr=34_?i{T~2sWm9k*FpJ zOM#+lyrF{SD;i?cv$CzisbCTh<<3P4I;4n9(C! z?7xh7oT&3J_1*tczr;V*H|jq=l(M3HsI^t~dn0|B&DZTcgz7}T|7yJdTW_{rg?<(y zlaGgGpDmSL7?pCOZGwMa%9%Re>=O~*l#_MhOYg@|>@8b=NX3ZT+^Kz#I^i`@g=$R~ zuM;}B*QQ2Hy(>oZ&zdn3zkFf4i;lNmfydb=w05U9fpX&&RJrJrQczx8_~SA-xpU*6 zu>_a+Jooq^`wS<62Yl2e#+M z+Cdf2amzw}xKl6TsyyYyv6QQI-KmB6+t#nB2W!#H@X!4EJ7u$9q^sYG0>scc-#3lX zDnrgdYCwLtGX~SRE5xP#vwT!1ZuVEGD@>dY{&6$y|N2~Lm@71l=IMN6nm%49-n|ZA zy^)PEkbSm%_^Mwi%uQ1+mvhhj5t)>fS!?lEn6Le*DXp5tXo+E4ijG~(sq0S5!O6gk z8jMtXf2yBCRanjTl*%Nd>JUsme_UkaZpdh4`-B=s$8OD@7!?;KiYxfLyerFlBhFR4 z&xu0L-nq1T;es!y6twClxrM9Fr|yo?=0XC$Tf)u1lYnku5=HP3sPVgK0@+WiGG+`+ z9CfnKhI^--D8jopSPyBU(D3JkZpqQ%yMLo%&I9h5?_-q1h%TgpVyGzJ~6Zj|BMskbDONe8mG3=q~*OP}rZQF4L)WXMdX3 z+QO&o&qZ}YB6PDqcg%-#E$q)V-B~lFu)6)ZtoXnHw`9<~m&sC7fgp$v7Q%w*CZP7Y za%R9D<@*g6Zp3|oV#quRG0d6%i}cMZp$aL;^N(z#*{x>L?{SXE~mD~kQN zqtiDTcXZlm+!@Rc&>ggf7wr14i_XmDplnT_pHRoWia z-7+VuMU3_f1dk1bpjYri{B-_oJ!3{uzt+)$oW;o$*!&kTi|)m<8jw!+#b}rC`%e5m zir*FS`!a+KG)y!G{{MeJj7clhm`B2Bsxm&i#6&_fiSapvCN=d}3FC8#2xHPR4&%r_ z@|j%L#0+^8m$lF^%@uCMCqfGuI_ICn@+Nfrlwq&ou*KhSa@X+5TyMKr0>yh>LNxB-MIHT!IoF|%R^AT|NUwCSC8zr@pH8$HAdoObv5`p{G|TCyJf^ z7c9nvcM#V9TbAIA6R<^G0Nm8(#l|M}iT_hmWbi*}iuBaVW+04him{%dvTv+yfymv+ zLJ!c5JM>s*Bm`ghVz-a4ixV}mfZ@-|#w2LD+S+1#PKZ5VTqp)6OykmV%g{NGw~EnL zLVkzzZylqR!*5D$WHx^O`)dk91vqzs>t1li;r9%P;6_?#Arbfw*BvfbIQ{ki@;}jv z?S2Q3mEobXcPzh(bY#n}6t#omXm@=N)@%`SBNuZptO$vP<~r^HSDDFoO0ad)3f z^5@A`u^rulAF{+)h zrJpejzZ2=&9~!B~I4m<^4EFjnQiCUGv)|r7Z$4!UHb7o?{6W(W$m>eTXqA_cJ}HlO zK&X&SyF8Q{ZR}2ML<4VHRtP0a%HiHM9=3dhVGO0&3Ci zg^@1&7Dl?)o`?CWSct!nl>T7ZATLr`6VQ_r2RR`s26|O7BREjW$>ndUjBOH?H0&)3 z*82X&BGS`mIMUFi3P$GNTSHr`cJ`*w*6N>dke<1xjb@FWMW2%!#p#uEM&}1&E+-3g z&yX$HNtw%-L>iZRF*)2Ddo8(kTx+Fm>%kX+Rpdo{USLhQH3%z!N0QCQCF-(lHM z)%E#D(i3fX)QhH(`;4a#`(pmcZX2UrfM87X|FQ1Vx!dAmjNkwC?-*~4b`qGU@cRw? zehAVTvH+5Zw56HJ*oE-bTdc<+A+GT7(9qDZhzR^K$I3(8#6x@mE(;B2ByuGrBs4r6 zEP<=};QG$4m#BQ-y!*BbS_ADu9emaOJ}mll<+M*n+1oqqxTe+BsPvswI@kYgVzyp} zE~iie#|&d!Eg7@LG(84OcXI1Sdy?Id=CON{OW?sWx$d>YhPu*>V%I-7fN)^1A6)74YUms z4q++=K~O2ULo+VRuv+M|z;;tZ0$Ylk8lr~60e4vKhU7C$mhP)=xfH^d|ELNA2#s10RWAXk2cpxATJDZwf$wSdJ0`(_+kwI7>Z2~)wInZ)m1ZVy-=X*_IWu^uI(p!KrrXe(w||FvPg_tO5L1Hx)!n0QgFO`Stc7-z+e zNaNlnrnuy1m943;h91Ijw08p{s5Q!+*kNnV=u10`^8DGi?ugA!zSoE`wHUO^zXjFd zJo!u&+YUHoRG|CCewl6x&}KNI!7)s|-f1T_y!}eIbW0yWrq` zp`vNeMEX#>N4AhP<0=O2!2~tkr~#K}hvwwg6kRF$4?|nr30Aury5mbxln#*wEj@;Q zs26KO_!_!PfotU_u+I&h)QPT@r;oxfBl2(m6PqaN1o9m_3T!8g zTj+HAF=E;YqZ_gd%aEP4!9aJ&A=J(lUmCamsW1C# zN_f&Uuwn3Kp9~FnY-|{~vQp$qM&%Rx2{6k}z+(c4p>W9YewW5I0; zB@VVNIe4-ninc9co4dock8H=@B_EO5XY5_}i96F`2+;f&^@vfs!43o0f!T$)K+MlR zPX!zVHf-7%x`{(&abufuEp$vtQDvz*V2g1dIVrR9gij6?rR{%az?a6wVak;{<2 z8evcq0cr;ZCm!KPG|b0|OD#|^h(2KFL%Chm9e>!U5+Fc$AQ-_Go0Q^9v9b96jgo(d z&5bJbm*q}$`%G6K{A*%{ZlI@3xAO)BAHpzp*hrtEFx-$hR*h~*B&bV2NazzPPU({C9Fi&F+qWPh&rjw6-1xc1OU+aABi zh1W;8p3ylNEPKS03}#iMSQYGT~MDE{$&Y@k+rM=j-#Fx%> zr_yT?fiIB=>{qbfWtGlJ!(J#pkM>ZsU&$MHdcCp!=eX0C0^_BZcd%P{=2EV)6W9`) z?M|IVC&YwYIqckTcyM^5X_je+{fa9;Asq{XnBu2B8|kNqPU=cba0gLLGcd`^H7gwT* zrLz*#^29@NNZ)LFD9)GBPV9F~eNE%Y80&e)fKE9UnKCK5VdS{TgtRPETjC7~W250- zD_4BJ(Fn|+G?L|pghsvX4$IO$L4yw?8Tlz6g~v-e-W_yFjU_sc)*+vfrk3%Jk&4&J zNXvf}ueee?hI(VOCbUUthD}!Uo~7Kl(Sp}ogYN@&%5;Tv_8-9z85$p3X?ybRlmIZG zD9PPEud}=Tmd>%c!yz7!!ghL}tc zPjNklum<9ZDd1PQ9v_P^78rjZus>2TjIbQSUm_oCz48g3TK<0?od0{MgMl&nn-*G| z2nB;9*Gute1HCnlM;qvVT=SnIe%G2Er3G-)HC*Q5mfKbQns8^le@pw!N>%rr#o96= zw?7_$s&rREY<}`{ne9U2-R-k5+`Jew@%|(6v038}dht$HX4!o&R0=6LRsJyEisZ(LyFxP}3+JKT^3?7~+je_c+P#C?ZA&wQ(Y6O| zcSGCthGrzSi!mDS#v3QVxC3;7Q8tE}30KV|`4^CTozspc_r=?~-Mhv6cP6CnPwwK& z7#ZEPb7uP(UuNTn=U>L1@py#Ry-pj7>Gcl(UjI&?e_L!+a+o&sCqAfSPeGu%htboF}V>J2PN88spY^CaAOP*QwgA6!yPZaeRKS%4sw5u~Qg^Z#7 z1?mAwV~q(pywmNCbrTn#h8hQ@$b zF5|)zMH(m(IsTLLd7yrb7mbatGpOtHzh*?$f7$2%t+W4EycCPCv~sU~t|8uqM~HXe zS@MD|5tVV7w9S{p?Gy54Ygu^u*ZQN$1_`+C>7k$AGyW z1SmAQIe~D$L4vj!`4~V}mB?Qt@~gNT+lG2GKzk!6{{D*Y>37qstav+RAaz?Db!k^` zdfT{k+>IC+?W5kMn-S{Dz!Y!e3nSUZo!1%6pSPI*00h& zd?Q&dUZ-@gHTJGu!5e4hjO$L*2wuL#>g)5rR2B7*0^cXtu=`W$;_sA+1Mvp%35s3d zrS8CF;7;9%!+3=`{=Rkt-7~0EMo(KcP0H*x437w$Jp2beOMrjyRLoBFwNv?#e83P>1PconoL3meLW z^p25|Qu0l0H8W&fBk#rRkYqO!pdkim=+F#TN6bGs7@8b~gLpKL4#szkxzVm0=8A!s zA`(+_qA=;XXW?7<&=2%I1PFPbKwgVz@7jfb01%hwU-rU2WUUL=v}Jcb;zl7VnEx15 zPrP%eDCH`?n4=%I2)IFldSR~tbcbS&zub1fnIanyz1iD7}GZ^)x_*wKcAgl}=czLxxca{De&4tJcygb) z=idKw&MoJj+fCo+#rIL0Z-?7CY&={QR{xqW%3pfMe+qda69M_LizVzrXIL}eXhXhA zhtzS5n+(_FVUzf-)O|z0_BTO@9d!pI42Bz)vuStHmtrd<+?UR9I#<)u6h~QiGTu12 zCP%LE?EACLcfR=M!c}44j#zPd$%^9NMkl)78U??b5?vec^uX`i@w|p-8=l>u4M9mI z*A*Fo0YH5mP*1<$UBy2LFXWNL4_UYyuY-kjLZ@J@Plzg@*`gcowp z&P#RQs*cy{dHGK&FS^cUy-Tv`^69QFkMp9_W5yg*49+CUsJkrxC;yKv$YH|j%k!r*u&4bBUZ8Pm_QxF3PLhBogk-FTar70;FMPPjFa>nh8 z)dzuCngg~C^wVqr&2Olg20j`AJxgBrU<^^K&86#NG0A5O%}m%5=gO`SZ7Be4zC$|0 z_Z9d$8Gek1M3^@lU-C)&2Mx}QB_bq`lPz_=Lm1v(zZhJ^J9*o7C46f+eIM!$-=8rg zVUr_3#bl4ucSJ(@x(!O0_vo-x+P-JJIR;KBmJ1H#&Vi zec_wx^t~e$zO)73#@W~b@THaOHs6oa;T!4nUDOi3->Kn?MVl~P?aBX!$1=Q8dHY;6 zex|0bWb&|dU#!ZvwOmvzE1JS&M~i`gei&#rHa@t<E@*beoXqx(3f}cxK>v7|*MCKE|_Eo`!c}tu~%F@vOwte#`77TZ}FVQ6L$~Roa5<<=UP1D@Z67Q1)iOFzQa?ArvdnAgQqi|{&;S{ zqmN~h>lm+BClOoEA?}3pN;@B}T!T7Vu6;!Z4`abl4pudJ)p@Pz0OBo_`8bZ3G;QPY z4{obehYr7;ZLUg7r*%_9BGUb(ZvUyc>>9|Bl3<*g($CyluC2?gTmu(+EB&HRSMCd* z*r~n}yeqx3G(-Ce%RW-IZJ6>!!3B;wf7o$!s&W47z@$=4F=e>19Ay!m08t-PI9Tj~ z1t5|1bzhGad<=2AaSU+=RwOCr5hy~AA;zVB>KI}=tPrE`<7hN~B1)^e&_bO?OxQ{) zZ-g$V!D>^EXSU!TsV!E%4`EiJk#eZlIR`~bM^7>csS+iJLkY2f59XGpYVAAGvZ37kv zBGC|A1*poJO4CK8j+xQlAL%Y8z?# z12X_0T!80(6u;F}4!f#jbGM$TtVEqHz#=-#Ieo^(IUT}f)ZWO>dL-yT_h&5MPMrHo z^7*JZRwo~hZPw3U9+-r+S6^Yp)j&5^I8x?^m#^CLoart2GTTF?dgZ>RKbBw*q?)Io z5~2221g->!*w7N_FPvI(!g3yX73pc^*I<@7MQNzwykeg_Am}6$TV?lPOHUw3tuu85^7qplnnSE+TZ2WDXs_u!eswY%n`+oNfYaG3 z;&4Vkt#`}VOpBk@0%CLouz1*FuSq`K)em1N1g`b7vHf8{O|$yULD~dwv--T00H2{& zpIe&3$E)WrL3FW_--Ue|ywK`1%}f)-epvbEu+myWmz;wBsW&yz zbrGIqJOlCEf@d0@`SN@UcgQrHJ%VQjo**7q4$eZtlZdAeo?&?Iz;i#INAN7b^D&++ zcn;$E6;J)?u-WiT!7~rf-|;NOvkcEBJYV5Cf+qre={DLq+h^KIyLq-0dIHmgB%5OgQEJH?Q^i-zF;#eNHd&wu!5rpTKD?BE3zhGG z!XESDeu$WrxF2Fg7OeV%x^1raAc|q^Kn=lSuet}JtqksQWEJV>Q2sM)_T(S2&yXE9 z^XyY)p3NomjE>UJEcVVwbQR(G4bMMj;@+G4q37;Pbp3+oX}l|agmr_oJ}6DwgmpaF z7KH(%eb_`0tV2uJV_EFj6>1A>-4{#L8ZoSht?R=&G3-q7t6C4D|xuJfFbI z84|DI1{n8!ZF?-AT!#=`eX%%kMDX%-&D+#hR3{y4h1M9pEqbh*jN|2lb;3}wDhn%i zElYR7Y+>qpEYM$%s(}Ui>!Tv{AZjcN3w+W0LAtEx#g?IKdnp?s7Oe$h`Dt^(PF--D z&~(ZI76`rk$w?P2eC~`+Nr^W(&NGL0&!*$}rZj9J+Z=wB}^5!CMj}=oapK62*iKJ{A9BfV8(lTgokM&`L7`dV+d6-;L z2x`5nx$4R&Zy88%Dr^-fY~`LXWex2-MmRSgLT};HWhircVSC?5<<~it(~QE_&TA`e zDPc=nO0b2uisDA1qr&RN&C5&0AsH4)uP56{l{nZ=C~`(P89(h8MJASB<|r(h5E^hb zR+L*xoo)?K`NPpR*LxP7R-5L^v=c^(e6MPs+MI>spl)7~K_O8;Q?*Gbk#(DYOeOLF zPNn|==~;3d8PcFkDUM^g$sEwF^Iz*)`X)_bKMvF3+Xr@Xar;EnzJbE;%XY| zLF%F6QYbIT)QvY{h1fKSbx?FwKeo zypkW5z+%@I{GcgimWvmp zjj1;iP?Bpay{XjZWe$y@JkO>zsT}hjHAy6F1y|)5`_0R&+xAtszzTd{*Ynh)(6d*a zFhHgp;z)VM>69qvYhpxTiomG=Xq0~+P%k`O0i8k%ThA1gHY8<>lGoi z5mw2floI7X*4s}=XnMVdRrIBYxeVl?Z&d<2U`y=^-X>gnI1XhY2u8c_~V2q@37 ze3ic5ltvY?TAQ25oDWaJ=Gl>6`VDI5P9$){+|!u)`4DNGPPYP?EyiQ;;*v1mSpeE8 zRfcv+G;(LN1dyJNTEmK(%fJ?Ei(#m7s;r@9Ujde4b=kZl0`p* zMaD{5`A<%rb^-PzT$@7|z2(5NAw()}v-46N^SB@I9qrk98qBN*Or;6dvrh z7a6I*GSr)Ra|oHxWA)_P$}*r9J{Vff;n|`p5fLSfgfvdB?b;lyLP})~WT`rPH<&T4 zf#y|P15n4IRsg9WBYmw(h6|Wo$*{r@1#H$AOI3InC4`e{F5Ya~o^B5;6mYtE%o^i+vEKv`v!xJ2VKG)L&jjkd@Q!%q9(E^>bb>zn}d zNC?Ur-H292?)X`Y++k~xOEaK)FcfxZ8ujY`rpS5n-vNg#-vYe-c}35t+D6R|zopwK zqS`9G1%P#Cwq_`ts%^1rK{6MV)nFFd;^lJ_U90e@!yoBHPWk8f%|ESw^?*1tlK$(C z;T`Tp!ZAtx&`lTRD*J`nFWY&z%gLOnpmX1~3XK2x_xFLpQo6qucI~1;%PTK|Cc?-x`82vImIO75*27FYKBG`#5uzh)5X|xbEUT8kqB&hl)+BokT9uyf zP}_+uO0a4xd|H1pF>rVhB68VjPY`6*nu-fn{|c$LQ2J3Lf?dp}QneK9djXVK_@)9a zNmL3{8P1~6zNRKXX1jTVe0bYdv8I}eCm;#)_8{I=xfTQ0Q$(UxVdUlnqCkYiSN)45 zE^|nnVxV?q)U!yO6ISA!;JHbx8ol2o@he76ep;`|BJq7yne-!q&BB@Vs<~7tZ%cFC zoJak{;UB22yq%PC$YR{}jnY=Z617yfGB`^cCW@N(zCga6YV;uDbHs7w&!*y_u zVlXyueAx{--A z5ul1~Xm1Rqv&F=a-WdCyy*Ji^+Fwo*bKftTe>P;ocF0m<*}nOgk%h1RsaY7(BQr9O zvr^~R2v>C$Dy!a9A?U#=A2OD7wE_!XneJql#$#)u_M>*F^!xKtk)4O>JT`CX_jTw@ zgF~_Y1Fih~Ta_MZ;q@QzkO{B$)$b$|K8`Y2KO~SgDKf%RIAN}{1G*m8R9P+Qlf zx9uE|Al{Ths$nqqt21w5}>9vZWW^s#XRl7S8cO zE-YtP2GWA*CFN{wm$S3;mZ1z@b{3dFPoL{bob`Y@awbF>=zV+3TE+Cj3F|P_K;3$- z_LSy&=hW&))iL`XN$sq!kiO<%N)r0g^;9o`I)#Cew7A9?hUVV1BJ>3TLxUa_l&VEa z;Lre@&xNYgAVxCgl`w?}zsd{>GXvsVHk(~i6hfEwYZ$33LU^!<1vktrF zzVT`ti26O$-wNi0;d?~z7Nd~O7NqQ%MgkB@8!JkVby(Dt9{o%jgbzQIz~+&y@ufx@ zLs=>(ZS6D;vu9O}z2#=6rFzm}jjk|9g1J$4n6BR8P~O^)P~35-h|u1LV4*^1yP>vA z54V7!s#<0md-3FNA}f~8M~JSmfNZGE=@@RyaMPiEkv%csQWy0s9ivpNsb4_oyi?im z%j%n|ZO0g#N_$%DW~3Eq?%VBYl@%t%bAqE&aS6L16gv@YsXZ}lYEL|CYKI@ZtEykk zEg}YL&JV1>McZJd0xhwO`aUcgMJANiAXZDasqiOF>LcviVz&npnLQg z9tudHY9O1MdN$|U0T8ocI^e{xDKzm9q>#Nwo7+9oGp9f@FjZ6B`Ag6(`$*XH6p(#q zlet-#sUBz)47GvL;GUuj?Iag-sVusD&D9YfC)%7sFYFzLfx?9HNNh^ann%qIAqK_`+ z4l|1-dcmVkY-rb)ebEtI6P__;Ss?GI>wB&pLFNp_jf$YE4YO=q{rffplvf;0(_n)5 zTqk!%B_NAQ>tT?Fqrz68TqhWAhvK#6>S}TsFQHP${RNEpr=pcPd>-`?j-bP^tMrIo zr1s;m#DlHS6GW3kg-i7pRLQdU7jEW>xp*mH1^)bSYDQ-hg@?N+@TRhA>7sxn~5bHDgYrb>@ttH`X#;?t1S3v(x2D|MPs^aOkdGv}{BBDGe#}eGRV`q{M--s8$pl zR`ch!2|8{JFp0iNs_PfenALUjAu4xdI&?EC#HFlp|Kv&Z!PKKh!zGjG(pknhqjNQf z(FVL`RD|cwwIYl=OGTjXtLbp=EgH)loZr`b{;Gf@l(xF+RW&?ONS3EUCSwQ+j> za;VP?oq~1@J4&dY&;lH+ydh&rolZ*Yoa%o3cOR& zt{cEOOUts%OD(+V>s;og7T&DY*Lm5Wd`MxA(;>x9`>TFpc<_(IJ@_O04XRA!`@iK@GC&IT;ZM7sT#dtx->VXG8Q z&L)PP$(Tqp8C4jtR?faU$GIC$v!+=&%6Oe@FqY!;oT_O5kF5bNj&bm~`+5c+s_T;}LEs>{yPE7psin(DHvx4Ts!y!A*z0t}@ zo|HNlyV$G_(8cJvDI=Jw1GZ+832agAbmbWzQBCUoNFCL8i=!ccBj-^U4LvpLuW`@q z9Q$kA9tm3!{@Y*sJ#*o#Poe4m+g}UO-};0S6<9SbX(^~!U#JgPRcDWMd^l`5{ld^a zpR(>b%PN7hD4%Kv6@KsF5Z3(CBp0{(v^2z~e4MTRA5+-px?;m9r7s$4@yT;li+}2< zf}s|xp8GbnVpt==>`sL%Z->bKh3QM>?FiYwys&}Cvd+E8EqU<2Mb5HO#cF8&|G3Eg zd-f?7UsyU{)!V1N=Z7tO|FutLw&(YBzy52V(vAmSK~}{gq_d3Mnwq#O`;_`{SbrIh znd@EDJ%jSqmy|VCX6b%qmRhF}WKfcgUHc4GYGK%tf7EDA)e2``a72?H{|Pfx*BH#v zy3i_{dY+4NF3x1%syp~JG?DW=XQ+%Gh|yCCJAg0a0G|8@4U2#_o!SJbYCPba7Bm_y zz1~qW7Pugtq_?EzuFRP$)&Chy(*g(VQ&>U}{Y!IXv`kH{dD~U`JvI12^oUf8e}Fcq zUDt33s z#ONw>$voCEhS{Y7-HY}e53 z8#KrN@2oS?4N^-XV&-J?OkCD>HLSK7qM4fx+F@sfWrf6uka9xlJp$#VirqYBISDBv zJg*pLVS<#Drk;FS*Tuy+nHFtXw^kt4mWNAom1qpv-*Bo^i(4E zG4*<$hU^MHN1@_v$;RrkkP>GujI(btv*n7p$&7X&oy*EFL)q%uuDWKo>i&;PubYf@ zeh?WetZ_#cT0GC}i;%b^qOrs3DtK`A(yDo-rFdOVTeb7rvcJlyom8QN5~yn5HR#;- z=%r3gsMEqFyG5ZE!R02qJ+tT7(_bm7Fx%txDt~^MI;&RSRJksvij{bZ13Ob{7>-s( z*oLOhA<<b zmEtM54n98rZ;_taJ0S?}S);S7{5ess`)c8~DK}(_2-2-y{h-O+ncmWJTFKCS{7F|P zvX_p{K$+QIvG1RJA`xvx2U?V8b`0TK&~UwRKdcA_4q+fJ;7ZGz8bA8EgRO~5K_V@_ z)-bsFx$g5Dsa$MVUj|A=?0f3V`Hw@O#n|ZX$}Ft$c0{0_FfuvkPiMj+H~5*DbJA7e zf0vlZYLZ!2Bg%!Z7aNJ1Z%+nK5uIbBC#*Udf)k$)usEm0Z@b2k__w{riBAU}P~uO1 z&?<9BN>DKR)}^p$&zAmymtjm(00f>bfve1kKn?;cI7_i;F~Pyv`UNUo>ZnUfRmKE! z6o(V79R4Xq!=5YGUV&UW{4Y+I{n({=c?ngu6zb^vs4@+v`Zq$IQfscD$~#Sm0-9I$ zC48n9?D+I6`*3^r^gSo(+BO`JoKaNwQ~bbXfF9h4Mz;Z`_gFjgC=8MGu_e%AxCL;z zanmW=c~ZZz=~>-BsSdQb;`XjMWlmk-+Dm<%c8SzRe4qB{>Jg7$ghNy}R!li^vQqOG zQ_UnCtD#Fy*jXoytJ{{#Zy+`7C+8b$=DuaaSSO@$YLC=HY@Nv6{Y zZw@pEt{LwNibuOn&3K97<9+iz#nYbV?;ZYY!w4NE^c#yPtY?|d+@}Z}?5+ndYWxI# zlZeF#hVMSlkZrvUl<&RjL;eNqJ5$2m3SWmPE2bkIzFM2;I*O+;-rM6Di01)3x|J>I zkH#jg^X_!IU6D4TlC|kS9Wl9gvHxV$tmN!Eu-Izl?wyr;$}=sIj-VUACI;5Ef8VT? z`zD>(lIq@7S(27tGQBwlig7ToZ|r7Yk6lx65tvfutk*Nf;*LDrnu}$Rg{+<*hEb`m z0qwcE@0bX?cUj+Y5D==|8n&?S1iMFS;f<&^Xd%3Xd55Rj*SUy-;n!jcGMPA$#j-z~W53{ew&M7M? zL8yZSmNC4GhQd1LN~ukOX<$SzyX1zo4~EgLp`8!on$Uq-xhm18v|~6uS(WKNY9Zoj zJrCVR9yaujUv5bi%ERTz!w$Ga8VRz(nuoT9BgA|%-L2^zwZiK^U77WjIsnsK_%9O2 zo3y;g(JAZt7S(BjA~3lWg{~>QaW!T7*mbzdRtjNyVWFz$nvwZet@cu-u$nR`4zVg- zt)5;jkG@mrooEk?Ukb6%o1^_!a6BtVl?VE0kDZ>`U6GC%+HMq^ZW&2f>b=T`jyj6C zXLbuvaBF6i=b;98%dU^|k{-o%-!r!oO&rQf-{cOl_cij;`cNv|n=??`*9Z0y5mnri zzXNY+xUaIT$C=4R>0{A*U*${MfsaAS(l-`^F6XhUFD=0D?0Wc;Dx;pcPY_Z_ImLm| zR7|Ji!`33YG;jxkr=yDbPvP66=!Z6kDom!=z0O_lzg}~wN8SiqPO-e zDpi_A#qn_tc(pkctuQYaF<`#L0@YsLhGPRb-F2F-?Noa6$APq#yAxVV=*oKzgAn1Cn3f!aJb9E|w2dy=p?{>H>VYqVS8Rv9?o9_OsaxWAK_9@c%kFV%@khSO2@A?8i^lH;CT2QP>R$_B(PRQGXbr5YD%fi5J4l1{nDfs zH>0{%X6>_cM9I@Dlu^_SGIZ@>Nm1H;G74`%d!dpuwNNAd!+M6|W)wcf>PN4Ep8N<1 z9r`UJQS8|2?p<84oLRX%voH=thR)RI3~5epMFY56&8~}ITK|Y80CyF#4dBd=tlpuY zEgUk={=qWugix6Q3{4;b%lsrF1uA@mO21jeJo)Y69r}^#WK)6-LS10N`qCQ<7VDYa zg?@nnUsY12hJFwkhmz;WI7mhn)h;e0J7l9^oP~^{=UrBZ&`(t%8?sDg-IAKX;+(q+ z*0Fqi32JSa)H{T}6uyA-zLm_XL{$;=6A5aUMrWpG;IBq%{){tUL+b5FoUKY5Xtxv5 zSx#_T4x?95Z)*kU{2I=y$HJi>7WC=i(SL#T5Hr&LVV(Ed0h;ALdqR~mf*wjrpo#Ek zwMjketO#`i*Ajx#d+*VaaVU*kARss-KN&Hl&T3W3Dg%##?)jiU6r%D_`IWA%>6wxp z^>$?tnrogT8A;jno;PHSU3?T-g>B1>!XXY-0|o7xXOvcJ&7)&PLqPQusS|jGq)_sF z3zZ#G9wptr7lTOiXOeTD9x^-~FTZ-+%f>vom~fv%NDc_9!2XrTVj8?I?F- zy?H0kLqYb;orAv_TKdF+1#7c=E}??-A#FadY}~hgvj|lraRvCJ@_$`;N`nA4m)h}@wmn5wErM@pdvs=a` zQB#}9`RkRX80~j2&rI!>nie(f2Z6{adWewb`Pu_R{1j#ffTbiVvKpJOsm*&oFKg>1l zs0oldFJ)x<_~oNP80E^YEw4AZvKjzWuU;^yBhI8i;UlG1ot#FUk!0$KrKrw7dWd5Nn}i(lGi&thE6u87E_fAu8Y-kKKy*f-PBIU%_tNkfil%j|ClBu|92m<)#dryX;>^htpsjt?}RIG>ll>8u-4V z48&YK6R!ic^{JlJl8R@)I$5dOVW0L{W#fwP$oSnsKs8n)Jo;c|WiXy9eU)XoJ$t*d zPx!_b5Dy9oeJMKDO#7n3m*2>xDS{inIl&4!;1jD;qvA2=sfS$5?v7-=8WDoc@G_iUFbCT>jb38#G8ivu+Jh4jIipBnsRXO& z^yNwP*Oq0$-!-+JZ)_2zB{=C&zd^*j)H?B;hLt7Gw99Igf$^cD#?L=c9~p{FtT?b+ zA>|NKR^P* zD_c!P%BwA$Gp1=mgtn?pC0WYuP24~ARj$tMdATZTnu{v0dwr_5x?+DGikR}i1y5s3 z3)SoDsHQG$RcQr|J&d7?z%V9BC%kzvB$-=|YdSi_qdHSJ4aui!5)JZ=1Zc3g)u(1{ z_;es2kWe}|R?z0Z;Q8>OB^?_p$fgS>;irm^s_Gl-C*Cp(yEN6*o4+KoP`&t`(3z?W zrohs)5yZ~ZU`KJn4Gtr1rWCCPDcF`(!KYS+N7Mp8s|@xEfrInV{QF}nH~4=;BAkX8 z`0AUB^{>iT6cme5CF>P*qG(_-5DfeP4E2Djy&#b{B|{?$MyeaXmDVE9O8gFD7Egs( zj=n;0vix`-KdO_Jb{4Cc^z~peesJ>Nf$vurS7I(hu237(i5eVfXfRsjqt*rkTF@ui zdlFr9@jQv=bv#S(9Q_*i!XT}#g8NTAmGHX^ZZaMZo?Ad`jwc)ML|=+$GoI_=_YGXK zQ}lo4cqfmq@1n5^_imr|gXe?PosH<&BGTM>(_^24l*)q8ChTnLDWJ5(5U{6U9=-e) zjpb#()yqo4;YUxVoO1cfR#2@e8d!9O zr^;sELR$C`-5XxPW?FQoP*N*+^_`a*fdvM+6b0(RTd3ZAPxM`lVjjE}A8H=%>#y`y zUq^Zx-}jAui0kV{oMTXN#r>$S%EP^$>Z^KP9hHpSnL}-_KWB_9D;+;9>HKUNs%s z)H7&P@VxXBJLvbt81MK0a$+W_@XP22O7wkS&@jKr@>BLtTUka5R>krt3(JN9#N%GX zJPN0r1`#s8YP;GoLz~n-qo~b?Ew)t-)Xt=9d(t;!fR$AQrWMZ$ z`CUukK2;RF$k~V-oUF(Ey8F3* zwl>8~)?>c>J7Vsg*)XDD_hPd1yvhJX5!>X`Helo+OGD;n80cP6QE%%>l;{Fo zLwNG3RKSDufEPonGK!4lOrj~`ZUqHKBL6O&88^;&&x)I1yl2Esr1yT>{G}668%WEf zyFV=)6_-`HR}WN{8mH_j%kP;~r`2zm>`F7mjR8ZhKnng^!iB`6K*8145QG$bDa2=; z)rVqPeuw)y!337u!=1y|!yyO9TfU_*g6UQt^{Kni=r}!tkA(QV==8Dto@spCOhn4G zGsrVE)k=3mqlaABnpr&On?%>UcrHA^PdVOOerx`|5$|*HyoYBmo_hNeU035N!1D>7 zzari`JhhPJ^n8c+GnU_R2T>I8+=*vCo@epAi)R&{?Rcn77yDM9FZXFTv_}(CquVL; zp*Cs1pk0URje)Y|RgtOMdd$mXE&%JDqXr}7%qvg1GTbH5a!aN+jHu|i$=;sKthznn zg3V20;mlYRY@>OcNO`0GE*uq$f^N{HG#I}n`SDv%{#aFpRjX;6iZ|wKW0mPb@=?zk zJ@509(cEi0Aw=u18$@U`OL6o^-50u^a#0n=ut*C2MCIU?w+uJt+tyVK*ho_P^=h2e z(LT~;;r7-Pt0a)pU`raskn}$dMzEf18#|Y*8D*}Q zMI{ftu5V3E`S?qs3e^i)`pK?}IvD+vz^cE2xYCVS4;wpKj}&Q(wEdV7DNG>x{1asQ zu2*09Cj!3>&1cW6qQ2XE<$`g~T-xM{JbJOwHk!iAca8X7O;Y6!hMVqQQ@J;HMwB~y zYVM3i5!n-SXCy>q-ei%uTy>h#g5*fDO84n3?>6dl~n61S80Z>1ugvwo7 zS?;4Q^HwbXKF?p?Dh-s9&Iu8`DBv$Bn9il|6uh*e0m7C=Z3LYc$fwducYEXnJ#y)x zy8eBwd}>E37RO_0e7Kkoo1Z-dRQK19iXS2IGUo~J@J!94l>kjCgYWwpYJiL82MdDM_X(^P8T2OID&O0Qsz z!haE^;IOBlK4S3l;S}nC`lwhARznR~oI;0mRgpDWu=)l>`AQEp_&q6`^(e)n1gbVe zjxUePa{JenJF~$zb~$o_j0f5mf&Dhf_P``kH&iO91bMYbRSCjM08f5Aq}L&^=ol=! z*J>-;jNTIDhz9QH2x014`?Zh8;EDl(mx*a8<_8MPd#&%>Qsvp&p zY{|Hm_;BC`;%j|rAO@h77?NMIx6zaud23y+a!F+RfJ&n+MN!ncp{ZD-<}i)#l$T?= zfImgw2^>+=&^X0aFL>C*(m*eK&cwo6ew(@?LHkKTb%qT|5UDS}r%G6r)0a)Sur|Vk zeV}Jpt}WHZRhjnqBj9JTE1=^LsT<~Dj4qZf*I)$gK%8lg+fkSnzi|UFt6V&+TQS{oXIv>?xe|L4(h10c?;+rNwz?PA;+}a!m^Q?(=gC(~MCWUa( zfLh4-2CkJ>Xy=f$Fjy>R#}qxLrOa4UMV0x$->NEiP7%Vl7S`gX^5VA>NKpUTi_1=g zIX8I4qumaBT91rozbeJ=XpFc-gl%D{9kEqAsxNxsIyWAzN#KlOO>YWk($7}gBAiS) z8Pe+vI1ikp)jB9&RoJ|Dp*wDVm6dS#tPGRZo%G0mN?LyqQqsvr4%AomI#v6LEv^f^ zo40>&1acQg=eW(}yrjnqBpgNq_*S@BL?_Pmig=2aWftqda?)0LRy zHVtP_ek(+!nFD+=ung;vyRMcJ&uvp z;Vji9N|G>*h8|l_xbQh{ExD@lrU{GiI9zs8NA&kt$bo@qmZ~my2Mtq#dMZ_XmMjqe-dV>>Q_xpk zn@i=Ct+zj5e()3sIE?phmnZ?ia-2CZf+AKO08FUHxdd zt8Kw?>wp&~XwTrxv_NY_v$Xlo792JQ!t^k|eTN;chj~y;_Y1%eYeOm`lU#$3B)Wn} zv3B_f%+39n=!*X-(X|*)?Vl4}rFi-s!7xgPHQt|Zq6 zJXb~}ximcGcshVL%lw`>{yNNios7YD>RgH4wjXwinBc zy~}7kQcZz)TBW!=t@7~`BOgy-sM2?EvW^_Rx1 z+;{2(rrma8QEBe!+$rS)lQ2G9BA2A;AC64z@fCBLPZyQq`rlZL_++>@2WV-e$s_R> zqxcKfv2z7RNC0pGeu(uQvR)98|1ExY2gbt)frywd#F|52WoggcDaX^3*5NaeS}6nw zJc{I`&8>PG@cznh-}Bkz2d_v1unG`xOSxlPpL=fn7VOE6S-ITz*M;m^_vZ;q{a{2;XRaHMx; z@sX$`S5kD6>k&NlY9zUSz_SI?U759Tltw};oTL$r{q`l=>6F}q z*lxYfTN>~{pdV9m5456_f^aE)QA#|xYUcT1jn~t6P41~yp1E{#hUbG)%pO;s_#At- z^Jklr1s{S&XUU|GU7^jNT^^g{^10X1nhac^;@^vN8unr>sxk=rMWuK?Se=T~ad3Gx z4rizn?1#fVTBYQkX@(7>@%Y+u|H)R<#;0nJ3O+Wo-DCol#~@;ZwA#xJJb*-FSQKR? zt@iqUMRjVTPT(75a28YD#)#4WG>7 zwh)1yPvyygOOO6rr|Ygx*IgfPK=pn|9As#@wAx&4bexSBEQX(U4<_Y{8oz%Wx@i9F zl{F>7yk)txX096oK{w#|D)qCw{bvvRPfWX512?z-#6*drVk@?w!9)2JzlX10k0%pP zHlBPukKlO$57G3skmRCRWN2%7VLO&LX7|Nzh}2|n)YNXiq9IK)i*xV&H6pu(R;$Q+ zkg_kj$QvK5UF0p3ALWIlJ-t!bhT!urk4x=QGIN8h(6=;XUDB`!zKxe!vijIRU6w~n zubJKDEBF`XA1aXiA~OBL`i}7Foi!R0N7sPitOlF_S%`uPgmud*b?GO8G^MqOUaeQC-{K?;^ zB+Z?U*>HS6+4lY9knby>u-~Wk<22*h3Hy4nbq7ZlL`|L%n#Jlw8CuIyabRd8sFMNM zBexaGXh1}UmXR>dIIShddRWTiHM1$7~?BE=q=+4(CqVggH@S}PD-I#oPt@q zPB*Vmv)l+i2FDMOZ)RaECYu#WFVp_%W8B%T{oPw+xA5^6k+PJDN?Yi^XdwxoeL!)n z^TDSuC5-z_i}JRj+2}<}_&jrGA};Fl{vSVwJ)0l7FfIva{^iep9&Uzvxwo=BcNQ&Y zxemc{XVG$&tMR4{XzD*XAS=~>GSgE)CwFSmJ%`h@zgiYw7zOnkeJMQVr8bMw7pO;D z7pRxTP;C#a!k^q(v>--Z1>~QVj7yE@!c!a2-hXmQmmn6mav$FcWiY)qSpa{)02{#){$z_Q=M_| zs3vY2#iiR(v5Cp+jNCJZ44T6B&RW4w-`OW{b#{t&>L&zAy7$_ROrLPGXuqNH|+ z*CA{hGb(;V5J$;CiB**xYp`LTT~;^AHML%ns~8o~g&mXsFZjocTfln>_|EktxmMvx z#`7zF*Mc0n?$Y%UFEt_i4(AKgkqR14DLe{O2)lH!OJTFxr4Wm>O&_ba17I6Z+V`JV zs?7?r5kZ@wZQ7d+?l00uB@8#hLuhaj6ztvCBa&}o#7s$XrEPl^fIl*d|a)?ymyQ%>&D!B z!zNZu5_nYU%wRV&Ww=5)(-i^Hs+H#0Q~Zn}5NF*(5f6KdlEPQ?FSV*@H_oiV z4juGmd|Ch{%AGxQb;<!kvG7KoPp}JJXMOu zWE8zda9%p^XhQ|<{m&@+n0yA}oR~2KwcoIu_LD&kBe;JUbpa|#_ta*U*=fk?8ra0b z3-7SzQX7T?!?X=J@j@-J)YstISC=*ezK<8ttDCP=VIYmbQ6MnNz^3PeVXGS9-V18` zUAeHxWBfBOZaN_A`rOlz*=>CE!|L}jj(rFNf;v)tM$*$qipyZC%VVeqh2+H^EjrcbChsU?JB+^m+8Ccv>I#Df6;uj~ z8ov>MUebP`CCR9qd1Yjj_u7R&)8eu9w&Y*EXfNEfE6B9!)D)vX^Jlk*qxzT~cOzJq zhZb(?t2ZOEYv)zcde!^f{<65Dxn%L9BjTA$D?;h0v)LV*No=y&`ZkCNd`Cs0sIm7R zyqEKPFY>3e&*0zsRlL)>V+xajjT=k({S*!t3%t$m0eXLl-|wQhPw;z93Qucu5jTR~ zbNPJ;!UU(mb5rN~5y89h5(8@RHoP1<4xdqYseb}thT`SRXYg_rUJhQ3FkZZDp_gR5 zY@nA*@sctgVcO#5E%IrJmw(a=N=f5~>7_PaO72D&s9@3m7BybPYJ3B!@!meD@n=|# z7qA*{kK$wQpTbUM>(;Hp>BxJvu-VwIr|h-N;^&(rxn9RZ|40-3(SPTFQuXT5KZS$e zDS^vX{5jVcZ&Za9{ScoJn!St?S-)Cfy(~g4hN_L%KqM2DYpH+&v)hhy;x*Y z-TvO_{%6_WTL(ktG~iatGj|}SUZ{y(c#$-*R&y|(7GvPV3$hV;>u5dlIf5djx(0z= zc;l`DlQ&|DK5#k~WYXw?j|{TWlX!zdya|7-zHOP_5S>l4m+>%7@Q>x4z{=zd6ak7t zh#^|>5N27l=-ZAph`?8+E2Man{?I^Bs6PawRX0~{U80Ih%uirn@l6~EO4hR1IMAK= zr!NATIzQ_$bE2(Mn-NMY;^^RRq}L8Ty@X+)iG^HQ64;9Fk`~?HXLJjMy{_=7vb!c- zDz?I&0fOBeDD%>Ilq=v@*t-T8*whnT6uki+Rri@}*e!7=T?jT%T>&>yI0GpCC*Exs z{kATm4Q(T4L_*N8*VPqxUs0l)J6Wx#vx?qP6yB@s9ofF40n`2+WhPW_be5%-=A?li zdt@}1fnRg*q$>!2-NfAuxbzRR!EQ1emhSCRle=0eh(5nc#tg z)W~bmlfjiR%w_d9VKWK^U?kqptpGgmNBFrO(gjY_x+pWh_obToy$A1qa(<80;kD=y zc(rEBAIa}VIxO-#4)1?berFB(xAU6P)*cy^tMit?L1dT~{pI)QHrWQPK7|j`+8neB zyhsSFcYGhlx5*qkwo`|AUtt~NFo@Wy%JIL?^=09>=2k6&N}9AoXFHLik-yx{o8`LE zc8Mr$Q}A-M8AfZh7Yhlh!!gcicn^W;?2RS>g$eD+C&i*(XvY;T)Gzo4)hAOu$G4fT ztEZ~f^IfVAhV(ekO>GVjmqvl}0jWg~KGYzBTXkFJ_JFrNbCu!FT;q1}D$mLA?{{Z4 z^&f`drKqO<-y*VWu@Uh+m{3U?ptGz{^l1qf&oMmDU4Xg9R!Oc0@$AR*Y&`5x zJo*@w(SNrb>P3T7+93>1RSe2MS=o!OgYnFL=VAQK?==sFt>lAV)J^ito$?Km6z4hb z=E3wecXps2-+VZ#$44@E00M18OwrT7q85C7+M0^X;o?ZAb_U@GtVkxp^zXjH0dXf| zv+JOnp3ny!vCXLwlywzfBLso zl0u!SLD4@jJMoM4lLaO#i}Gg5&yBCsI>c5?_=FNt%T z6D&ap3mL4o0(+|$z@h}KK?vBZe}pI0=tvI7WL&cTZItzV)mlMSr6Bi zW)BFV0fW_1U=aj%r-0>zfDM;8_dCIQ31L-0rCF2$E9nWamI9U(0#;MvT;>Ejn#=O% zFj!p$wwu5x zM}f^Hu%`v=pA6iMLPzdh!=oiMI>!$U!A;jHjRwWYp8H1l&)6hcK{3 zwOuOlu2-NI)z(A^&oUsZw$0rEb{q?Yh@U6{GgaHZ`&r~#3}&jfwL%y|V4~WJ2*`R)@!G&9DkZ4H6lBw*u1z|tkoBqvxWAuK+il8sfHMqqIQc0mZ( zulKQ(2~MzYgfO1LShY1Fuobw0m6B{TLfFN8OX6&YYZLP^AzZ*|(Bw zI7i{y#C%H#S27r@wtprA>>&YrCIoDT#Cg#Pc8d@WeXGP|)pi$w^%bzeAz+tCoZ(Ke z#zJ_8!C1BJAh2USSxk2b*xnhOG&P-IYlJYE!C19DMPLgA>;r_br`e+tXDM7;n#~Y` zo55JMT|i(X1?-LxumKY19w*o(Lipetm1eBk_Ff6FdIHuW1nl&^Eartyu)RXKgTYv} z-AZ7kI5dum#zusIn4W?|J1wg1HHo(wE}g8r!AhJj#6}DX)%GUHP;Jc#c$@%FRlryW zL5mX%n`*Gc%~8NvcN>H&h49Hfhz*T2%;@8^6v`DGrH4U?62f=WPgc_4;Ah&7isIrL z5NnOLwc-`LA(zNB8rl_nZR*Yf??GrRDB(lfjL$EIFEtM3a1rYsgYcXX+7Vx5QJRe9 z3+ZW&V=^{g2t(oOjGcH$XRNNt*t#pg*p)AImPZp=upOn3D!)wwiN3jgcV<_6pOMj7B8e^ zj$<+wBZMPUO~xK6(o^g;yh)1nC&sp3$&Bqq=upN!f-e>RZ{XS(dqD_^%$VE4*jyn! z$8k)??iRvuxO$46p06_&XEJtMXE4@X81o^tVywWbEiM$StKfpM2}Z4~DTIgjs1%FL z9-?g`ZT3SpOG0!+FuB?xgc7(qSGO8m-HSI#u7j6@tCzZRa=nAlp~*F0u-=1fORgzG z_~k3bRfHwEMhIyl$1xe}BZPKvb;j0fdUEZ>n=n?77^^LeHACo7#(v6T>6`OM%#y!L z2)8g}H7$&NBBbqbZ7KGO5FUi9Gj_Sb7^c#7#)>WjW0SAo6w5{EP{wW)tl4mFDdrWz z+Amd#)v_?wR!F@$j+tV0g>VephjqrDd_YgJx9}z@_A@cIvkNnJ5TQdED}^tW`~X}V zV+(}Pi5aVHVXR015T-h(eyhA-hFHB8&=DIr`$OxkR-JfS?vQOpD!CxpRp^#uHR zj?P;x#hbFtws!`vJ8bXIMHbk(d!?mSYvJgtXP$_1$%~}fS3XWqk7A1u5?lKuG z&ev1y6}(A`jqCu%HeJGu?Lp{J#umd@+5d2Dj6ElWcFdU7Hp>^%(;UZSY`hSL!qrpk zgkNW@uF2SzBrtZRFqVeUp^UW>tO0OsjMWgrgWFV!S#7i61Qy24aZJXx2w@3aow3md zV_A5U6st*$J=>8}Y#~A`#%#9P9Km`ME@GLs*;SLt2CdV-u+aZJ!xH@CE z8jRhGH%YN0?ZMbfiJW5ZAap2W^9AcYxHiV72;rB_iZQEgHbO`fIgZI#A0f1Zt24HK zmY!mJ@g|J5CB|wCW6cmcl(C=2vGmRPBW4-fC4^g;F{^F%iIBF##g|ORUJ=5BaCOEm zHyHDoj6Ks1j7`3nQ!E#uLm9hKux7)xrI=R;Yd5JBv)X2Dh18qln2gmG!m-;;#-7Bk zX%u1%`@DrWNwLq{g0Y?LnX!Witr&|ev)E>(@TI~ZfJ?^G{?!)ZOG50x%)vHWO=R6R zD-iNC68AMLahwnb!_`yo=lgUfYbho@`BM=EwpkBiw39H}8!_zTjx7W$6)r?GCl%d7 z&^D^n<0*kR+W_pFb}aP|nG9x532cN9Nqhn>z|1Lu4}{R0z+_6`Uc!1@uwE7{bGFkj zQC?>(ld(I6@Z)ESF`g2*f~34kz($0Cb(J`yonS46@G^t(lz@xCerwB8)(!y++{RMY zcYCJY*Gl=H4fXx)J2SUKcNt|LQ*fm1f{;3j^rvzRguuBE3R|r^hiPO&s7Ab@W7>uU` z?jtexC9s%B$2!IQ3_er=j>ENy`MwZ(F&Iw?_z3K80`_7ESf0dr%?UP62uIf|F?mYh zT@uqLV8cVex=5T+PO#=ec#*+)O5lD1`{g1Qvt|g`!CP2Nj}z=OAq;0Qo)QRL2(UK= zY$-yhDS_>!7H#;L#9IcJROJ#Yak>yA7!*?iPk{{8wt#@I6X3B7Y?l6Z3PvUfSf*l*f z;@`($tlBC_%x$e%%x@6FE@r933Ba|9xj+b=7>rfh>jXAWz#a<$%aS-xJHbW@;hQx| zOjd1|5LgcZOAi5SCvmQEg4GkkV+_Ws?T2`PeIL(a{(7@h%w6!IIv?o-D-}XIgRyFx zKw$q6u(v|MiX_haaBXRpC4^tgl$fmAE+w#G0(MIXSc=3M=LBmfgtr)sRogBCixIHK zAz(j^W-*&P!FCDZ76xP0_6&h7X~k)_1|jT4;}wbX8C;u~MM7xIV658W2<$Ean-Kzb zgT%>mf~5#y&1#iqtlDlXzf}Jmf7Z{9H+du+4 z-Gar84FNkalEtj&1lu5l>llnxTT=piL%=>l2zzCCQsR`twWV3E5MmjORhz#hz{UvJ z-63EZ5+}#N2tx##ks%;Q~H59PcAz+m^vY73hU+MTRyXG~`y3(c zV!k7BcEPoY`J@n9GZ?G3d;*&;U~@yjZj(4gPOuCie7;4sKf$$$`Hm2}GZ?G3zmb@K6|m<+!0wkguQ5fGr=T_N;xklR`3O#) zSOw_GkFpY12=QtLg=*WsNU6352>3YxegmQG>8DA&cj4O7Z?X_hmne~0wM7%ywE{Lq zz)aQFTjFFgn5o*@2;mI^6VG0PFcF6J_ca{#VQ%$J4Gk-=EC#SvJ6fISid zHc8?<=>!`ggz{xdOjd1Mn*l6Y!1{-PB}kkMCs=JEJi=hC+6EC=5L^FA%v0An#oP`b zYV|7N+QeKYg#HZ1s;xeOJu6@fL%<%8IPW;YCJEux$4X3AZA%Gkh=AQ30@h37+~x#J z5W+$RW7Rf`z@h}KK?vB6Qd7|c`9|6Pk}imwzGPq<5()A5Y`I}Jg zgDcmk(u%VS?$k&1y5NnX(B(UZ0=`*dO;dPTlMOOx!3bNW=-2{T}ZpeZL5JCyM-4JKBMA`$Fxc=CnEELM4a4mvfVQ_Y} z;>?r(fK||`66-;Qmo>={^d=#s+2Ib1(*^w%ZxFPPAy1OT7|Kw5pDtxi10no<2?UiU z;do=n`BMXyGXen|8M<*|Waxtu>lKA($G4 zbGt5QBbL+5(0&qQJVTionka;KK2#aX%~c!9&{`sBQ-p8`dTcNYT34Z2OYUx=tbl6~ z^j3qjd+`=ha$lBMAHzlVm?d|<5VGuWjSaXY1!pO_H%g4z3}p)H6~fxZN>FY}hf$8U zuFpAoDMB~|ts{{V6q;4gAFtsg*ag=j=!{G~3m(Q>h@eX)*5`0-g1#sO%?{VWfa|N^ zEP_sw7*8^kDd-3xlrK_(ax;HXBM6#|!z-w4_eThapchG`9tzDWXicH~Fvuq8UvJX| zU4XX`LAN3_wShsnHbIvN;RQQfKLhRt1!oa-p2T>Yp-e&V5yFWNl%Q;aT-y+WUgKdw zZ$b!%pxq_XwF=EDXuMEj;aYO^wOe&TKfzmwpoa#sppgpCQgk;9;X}9an0~9<^=&K{M;Ipjimv5Ojz{x9WXD;cW``UT!X z1dWhb%@m$R(25LBflY8NaFYzUxeCrA=m!#G4_up|&j_K-`zlA-bQ@eBg5Fn`1=SG3 zA?P@Xl&jFJf({Z&SGX3=w%?))dKhmZf;N>{ofMu$(8{Y>(1UO-aPthfXBC`9&!kMdVaL*ZV@8b>fn9a+#2uanw4nvtmcfAmXzN-XflXs8@g1(N!;z-aB z5yBzpV-o32xRgDnVKh@Hx5Bju8f|daTyf@TNBc{x(F)HZXh$J5w!?ieMo+g-@n#eB zmvk2NB8D;r-6w=Q-%*0HIsOa@y1W((x(Oj1g1#Y8Fk`iM|wz_ke4!r<(3#hF9U znr<>*0# za0t3mB7F(hF6cjn@>jSPK|33qr7O-Hf@Vpq`3lb>=tv>-v%`HmS{L**-fV(iEHQ>K zlqqPO5T1Bj3Ci7=r|Lq`qp>XLnE@e!?uHjtgrDHr1uYfIYj7=sUS)7LMsem4RFhaQ zDm;szlZ9}j9qyN#bV2Jo1x=9{;~2^mw4D&%dP@n)U95F=AZUyT+87}mIr?LN7POW^ zv)0iaLMef35%ezxXVdUTX=CfWydbfbz(xL;CSaiuCfVT{7;x8{3t~7&J0OG-bim7cU#zA?YOT<4)1W~)lEz7}9j-;toKbofJcu_E z^z=)XUfPEeYcpITeq|*-EyR2~WE%srhd{ncvGnC3nG)+kfqcM9Oc&zjHA!yHN7W68FP=cD>({>W6k3zF{PwNWh zSU;PfkKL#Xx)5(9sI7at9id4F9Dxf#&F<+kA-rOT8(_fQq~I*w)AVx*KmHg4U2&7brZ7pohJj0^8tP;HDaI^A(&$(2pd>H*jr&z959e ze=0$_dwK=s=fRa27$gAS6|S({OEqekcU*Yf4b=o<_w$&?h5U&{q+{A!xotdRn1b1-(-! z*TS_3`qOY-(3;@{?IN)<6rM%U=0b4W;a)P}mf#KYn5HjXvPFW{XDGAiZW6+X1xirv zo_4MQLEm<0P*#J*Lvl6UrTMErQlEIEz=DIhxh0CDvGlXA$&rA)IfA z`{+77-8SRRCa6ndv}Y(&(1X1>1@3uO3Ci8m$Y=;!R*9Ad7U4F8a0vR2L|O;eF6a|N z$%ShXw6($6m5MWmptne@dljBV&~zbOW{2A{Oc%5QZ#F^ClNfy%$`tfWFBWvpD@suA zo?aFOLHC?tLBB%?hoEaE(q6cBLEjR}<8Up4CL5d$Qk*#ioi4E+R(KXc#|Xh^hYJkV z1+B!JP0&ju#&Cu*1#K*ZXI@roAL^kE98zCHmmiOe;ISJP;=xU+73D+X% zH3nz5Db5^%7E7!J3eO_wG$Gt!{!? z%4n3t$Y&^1(0)Q#|DqC|V z2;mU4jYR6D(5!;i7RpcEY=S;ISQqr4cncA98$wf?a2T#l(4|6n$qtuhz>QRJ7C|47 z81FEYDd;32ocf0nl)I-hT@Z8#PBkV$Z$=1*pgkqhFok9n^g^N3f@{gq*RRn9EyY`i zpx-64piv6XQgpWp;Ul;fxKRe&WCdpt^dAyqEnK9TDd;>Q#Ic~W)-xXP+G&aaJGDqF6a)tg$U}FSj`olMbJZ6atdsLYk`|$z!fSui=c}o zMmb!Ypw9`R-Sa9(xqEu=83;P-Bnw)E5K7PmI6aQ13h$IivlW^r|3QN?SSZPGEu8Hf zs0(@oZzSkQL@}n&&X-u13tn$4@wcul?0&cw$TKpdZiFr+2KmA(v$5Ayg^RW#*da59U02hP2Y9q1ju??Whi$~ z50apt{>*~zLI{VTizL!UxOPFG5lR7Ei=b@{&Uz}&9D?31v1Tbei=cyq(A5sNJzW>{ zFy3r}wvZU93}p)H7J~Ma5|q2AO-Rshequp?xI9GA&)`M%-~e2^pzjIgX}A_adl{S! zRh&5ly=imB-VJ%4j+o z&50R4qtAvXi3cQ8O^|^f||`V`lN_Na2eGwI`nTWqSV z*-WEpi9CMWGCH-IV{`>Z0Y=YawmRn@pjt+^5m;=~)o|%P(sYK=uh_9(s63;63A~)F zjmqQcW&CUTagFe=`Kw#sc9`Ka8p@`on$0v?fJg|cv7#%hI!1S66kzm^!eTVJ<}(i6 z(*$Br4Z7AYT|Z4{7+t`QUr>>mXLKxqOkz|XPtz)+-R_Ff0hr-4+JsF#G@EI(0+IZv zhO#|X9HSR73NV_CUAZ)$Vf0=hN#GQ!LD%1<8>i_Eqg&W<9n~^Ak3gYs^osI(+RA9u z9WgoqGkiw7vuT88GmSPRQXbV%_FHAg=wBEG7|qG9Qku^&nuNgJf)?FZF5P@hXBhnz zGu2t}9Mv+qnLw3E+NeC9j{6Hnr{j0Us6%%#X84Q_XVWarW*Y5E7=dOJwNZII{SaTCi(7q5jK*Mw z&*)4xtwmMK*S9{H87=4#OcAIWXB`3Gz7+FRWu;VSE z@{Gp4DG7W!K^v9F(=iWVbl*)edI~dqM%S?EAgXP28j+!>hS5B(veH_a&uBY#4b*&w z(V7H`+jPHHbd27_$TFIh9ic+y84V&Z@@s8W9#5P90i&1V#OU2OXf!$g-EDb1J%CN> zM7WBojNZdP10={QB2!Tfqh(xWb+xjPsGrc{KAsL>*F^GtXM!yWzHd|hUcoW@0wblO zlj?FFPv2lyT~bDvU`m1$$7|DgJS_|ukEfsChwd#y zwD1jC(6X4}Gx`dfifT5~=*zrf^aiS7bVOOl=uC_PjP7OEB~;7k3IgBSbnm%zwKbh# zbPzk{3zcWI9f8|pv{89HeRKy#t6mqQ^)bU|v-^9mi3TnP+qY zfo#!wMdk7I?^`h1Q~eqT+$ask44=^t+0;j~nMSJ+DTrz)JNTYs^a@4+MpLsZpXM`+ z{*_x2IFD-34RYxwYC6N{c6QuEwTvz%@Xly$R31-v;unv^jk+R6zr_rn(cWwtquETO z&4^S+HI!W~?)`E45KLt{F%$5o8;0h(R7BI!4p}lhLy5YM}WHqpuT4Vbd*j z>9%2nh4XHG@8=YwuLzZA^b~4tHH@Zn zl@-v+d>=3M+0|L|8AeMJ$ZgYYFX7~N8Y9bSQg##(D$nTM*Cc_yBeYR@JpJQ$82#m< z7(I^}KBF7ibQIM#`W=xGsD{xuTxAusGM~{->>8r^45M`kyl2y$dDk&|4X ztVK19Hgc79#YnYScShf`YlY@BjDA6&gH4yzrOTn|jB_-C9leFhGg_R$<|u7c9#1RW zfYA&znj15GMqj=vMl)+R^I~+3$U#)YXt!d{5=3GYVDtxe?MB6c=-mQ-Ltv0i_nJ%h zuBJ1Lwq-}OP*G1A3d79NSI=!f4bQMO*Xb!ZvkEiD`Tb=WNp(-%Q1b-&D(54J? zDO-|qe}CigbQHT*k#e~Sb|v`N5N#Tdr{e(Q@wE9>7!Sj5G*x#>jWEl%!o}HGldRt7 zYE~k_sPv`&?&+K&j`0l`1+4JZSH$=;RBMIz6IhLE&^2)BI%zs%g{QD1MyR|M{*pja zF)NR!Z(V`WR%gU$H_XsRy~ooUY-*#~%*WHBL|#EPlx=+5F?tvyWz>2+eVRp#rq_JN zh|IYwV%6kzmCc7?VQX`}LZ zy6_^5{&Yf&?#B$D(S>aK8PzsAmPj8|!)Rt#Ss|^=cmL3sUEMXGVYC8){5IX5x18KA zU}PCh#g2D{$}{?B21#JRKy6eWPfz{^qsQ?pBGsXL88duFx3cLZs%>;0kuj)-(Za5> zDq5M(=qKzNuK5h34GEOD>3)0DG5QxqmeD-ys3}yQ(G&zG4A4g9@pS$L7`=I1j6O~u zVDtnwsT1K2s%>;Lk-4ab(WHdDhF`CkEvkH%B6c<(;4SzJ$8I1RG!iI2*iA*jmqQc+;cGc$}w5d{Fvc0nvhMeYBtko zTw00XD5_z!X8~skMq(6T^hb6bK(&lcBQVsa%j43O)^vu^j_epORG!f~1WxtWM&RAu&1?Gkiw-vT2-VGmW+& zQWe!ucKvn7=rfE0jOJ%o1O_dQzq_!9xTa_R^;DczUlB%#KZ6?j(#aJ|M=| zW0r4)C$VuEs@kP@@B2BCHmHX2gs#f0RB3&#R%KTU&1bA|K>`_Ux;43+9QR{{Bi6h3 zeUe-Z=N2k&g)b54*i)O8$J3N2U^HgG82tq^v{CQzbSay5pemzV+`6-O@@wDu( z@OgTl_`HD$z6IUEo^z=7f-WZVHLBsWm@6zy3-jG5^af&u##}`87 z87)s>*C*PjJf4m`2BSIl$ch%k44=_tY|5qCOrv)bO9UrT4Ws?CJ4-MYqX45D*mVTe zGWs2X5jNc$E?ospXBh3qj&Fp@Gx`C6^WC&jc|2Wz6h_}wzXt+`Ze`5y8O_P2Qku;) znwZF)M3&KUuR2EOVH9BWFlMV$;dfNa=sE(kY`TgrT|-T07>#1bGNJN}b|LU*S8Y@t zPlq3Y(VDx&Xj9Da87;}C+M3NYnw>}@RAWWwXLF2h#wft(jf7(KC8}lg5P`L*23;eU zuB)aqj813A4x#dl4keI6jLPHb+QTr~W~UhKff+udwb;~NvzbPV6L}TYQ1(++$LKMP z0*t;$AVxE3KI0s{M&KZ-LD$Wti_~<6(beoYi;B!Vqf-gw?xI&z9#5lwfzi))h|v+4 z;WOHfO#?NXX|x8BVyK3)YEbcKm^A z8C^->z0TUGJf8k|2u8D(`aiV;i!hPn^_#ALH}g5AiJt)KEr5w z0#Ac1y6G<6DvaRAyD_?ind)>;CRE;v?jca8lQt@krwP=GE>yp{0T-jSnBg-zflW(L z)$(|Efc=SlglZTKc9mt(%6uO$mD$xy^BG3pB#_RgTbTE4%IMP z#8p;JEAtuc!LE^-&oJ7UKt-GGQbxzUwr}+${pAcwd(>==I7)|XrT8 zvbosYcs!lOu63vi+-`zH2zIh5Q@E75NI6DzIgh6`+0~1b-A(Xqg6rC8(|A0s3mA{5 zIh64fcotJD{0e4iR38QRV+r>x%c3g zg&h@z$9wR5`BZEVZ;QP6;J1AbL|xo0qV8aVFRK0Qxq^zlFse1&Is?@ZRo)fVKty?; zE<@R|M0mWYIuZDzjb21~N^7U03a6^ZnBi0PE}J5RjjCSb)+DHgs)cEtsJ38aE#U1Z zl1N73@l+ir&|Fl>Bh?L+)sLGbt8JL!Q#FfC>rlO{MsjNpR6|udS5*POsz&ViLU=q? zZBLMhhENwcysOsD`TRX&hD0FtSv=#g6*I>_(^y?RRahl6jkyV z@U~LboT@ruhA*r4+0;_lm{n13eFfD}wK27m)nSaRtX@78clm|KQ+1s{w^lkUxo5At z6RLKtm#mIshELT>Htj|AvYN)NLs1P?d0bVc{i-^$W4!Qqs_GCp)l#eC&wqA6RS~Kx zj~PBy+1OM}*qBu!ZoU1trD|*{C#$&_Sy>&!Om!qYMFrrg+DIT&RLR|NZ5b&}OW z%f}<=D|qcsx~k2rT_jXC=3;4^>tPsVW_2_*C8f zOFSkKHmW+!tud&Es@ATmei&Im*b|RS8#BO~0zo*)d0WJXNg;#5LEdPn$P&bL2?3r+_&f^xO9s&opJwo3NzI~5RVF@-u>fN0`E74 zQQkie-2$KAtrDNhF~PT>quDb@lbP=UdJt)XYWRGT#PJzIpVoqwVOM?4XDn!L0?BQ< zB`#eIM%D%5-aYY|MX0<}@g#wkP4t4wE$LBZblplZx)U>eMrX5WBdUGmjv&$<)i9dY zRhC~X^BuYM*wsn%8AjhDkjtjqme|Sd6h@ZOBR$eRf8STif!J5x7T8BU>o9=WX$LL**ETcKtQB9~k zqlpNNX{3$Hjq~BnFna9=G5X+6fYHO)q|SriQEj7ZiOfVbj8<@!eV~>3jDE?kZ#AD` zv;%?KHr>61j?u(^qwlh#g;04$UnMZNp*AY_;x9MB=(FWwG&yGYR`kYgG5QkKHhPfA z8dSq*LswZBj8uztj!tIR51P*~I*34fn=Xkj4o%_E>s+d-p{-y5g2IG<#6eW zYdXVd8+MEqD$i&*fujwyQF&r`z5zzxTqY}83Nw60GqS0WW;2aGy(tk~K{bp<20KQl zViaI>C%ew0T1J-=m}t|z>(bTGbcWH-*fCqEJfj~Gh^?=U%0tM3^)Om#sTi$|89t*0 z*;GZdnMTtQc@k$CofhO6U5QbE(Q}xs&iOx4Eu-5BEV1cox^%5Iondr5J2nWFXS5%I z_TQEbb@?PRkW7BF>?1nG#qqwyz zs-Y^it16GEsz~r~Y<+foE#XF#p_)>)eYRwE1T%c9ma}OWs+ZNb-1;S|p(>ZFs-$04 zdv=T!9#2&SfnUS4D!I%5cm-4yqN*~O;Zv1`O+|!_Sp{=z+(k>(=!Z^L-(zHDbr>_% zk?;r=fTwC5feNBZZpq_*fU3#gOIGtR!>4Kpo2CjIRdwOk2B=0>fBo&KO5s;knjNi$ z$5WMyz@q9pE4hD8sZ<3~RT|9jsk-%>cuXj4RCR(|x1buTTDq!wV`ODDmmLRCt*k~9 zNH417W_RpzsOtQkWYr%te5x9^?RaY>>r|M@mokGQKsA@5{evN9VD(0#R^Q-E|j_-uWQ`M5djcQtz z+(s@|SyiB_2+Z)QdXr6|!bVjYxb@k2OVx}&ovc=4WMy?3Gu6?aTzEWHdkNGPRdUaF zU>Q^`nkiYW!wjFQiELVm>SZ;ETic@=StW5*W%sM9$&OyaH(*WB!U>0Cv#_fo`O2E$)3Xx6 z&?-7Nyu{BA7%%ZJFM-OF(?#Vq%+e~oH}l)rcm~zJxm`%)D^x>eQCH>rRB62=`jlOx zG@o&E+k`+Ro9^;`$MhqNtmVkhj@m-yEk|ks-&EFSMKF42nizd{hDNPn$LJM-8{BrjnY?G@6LW?UR<#v3DG!b1@1q`U_^OGvNlRWppipnKoSo zm+k{iXBdrS$5Ns4jCLmQpn^6kcf)Jv!)T3f#b^`E@EI+^rdpcKH2Nx$gs8@f&b#dx z-Gotq(d#F~=nGWK=s^N&Pz}0}&I2wDn{$+8r}| zMkCnNPP3UtixJ6&YAD-$%Q1QsqX47Ne-)z{HJ@>gUL|k<)u8L@(hb#ghS62*ID?AJ zJfl+xWdR!8?f@;u3x^z=Dondq@JMN=eMpqChRZbg~$ABwyVDzg=Vss{E_>6werU{zO zH2M*dFjPZXT%2Px9-{!GZ?UVg<}-|@Bk<&yMK{f*TdC;`qZct#o$g76%3IOh1ZtPn zM&-$3)od7DfS>iN6;Wk+GjR;h*=`P-IjQ)+0Wi&54 zB818_nv%f8_q0)Yq-vyA^wxMW`s8qc(UaJuPK3Ltw$Y!6%tJMdR&$j#*UEfGhqG&z z<}-|TBhb*MdwAV3n#ymqEIZl?m1p#I0!vD1qwiVxK%;3f!?&V$ei5UIHJf>k z9w)LH)iBz^Rn`+Dm5p@^IFns#QL#SWEnpOZt~On2moAT{GtSZa?D$-$Jfo!vY%8ga z%7fnrvtTsqSF)l7FvDjw5u37WHq+?MLlVI;RKsYmYt9mk!YIJ#8g?B-wTwTruc6=>Vp3%AlPM6R|k5{zrXH}e~TXc4~xlCP{!X44OB+T@bzP!`HdPap;1z49Z&A7_rs}O*-OF0ZPQh$@i*;5J@Aow_toDOa+#S=!^Xn`ktxf z5w@x|z38CXWS^yaVV}Q73&j-;28RrL@usuSpV{|2sxo-hMdlMJTwEWj$wG$h0R|gy z+)fu9H-wa5Ih0G>#;$CfM9T3lQlH4#Vh&|*p}ZUgm2Z=>oTkL0dp{P+%EoszrSq09 zA-CSzXXQWUlC$7*FtR>Uj$)=t=?N+T@4VbVpc0k!Nd=?5rb5+}(URQ)%)ol}X)J3s zf(_mE=IVXC8G(59Cvrshr270`T54Y$fo%QpL9nOO)~NMv3v|n4pX|6651Izpvh0 zy^ptx-b7}gTDxdY;A&BC7a?jF<+zI)n#)@80_>?MWPGcaj$5DXv3yVa&GEewBkbE- zjf{C$DtQg@ zu~M~cggD=X8HV%eY>3pGP3J?1EJn4QcO-ECZS7q4abPm`5ypKq(qxwN;%urZY;>N3 zTN9%iSJ?&U9p^t`WI4aJOPpsA9?$tP0?kB~yqBn^RIMH^&SNmca6X$2qx5Fe`3NE_ zP%Y=55O`QvJC}XLseRPuK3Zrp%Xw)w)e|;4&%>=LQ4QzI&Nutx~lCS6TJ(vKuoD=L^~JmELSRA4_B{s^z>lf#-#^bJ@q9Z?KOKxQ{lP z%yM3lO^t<(&fnzLbf|{&)n^^&doi+{KiVPAa|(~={5Jv}M3ua`2vw@K;wr10AH)p9 z`EoXVqc@w*Clc9=YB~R$Kmv0g^Cw{+&A5+_n#^)ujZGg48=V*7)-0%o^9^Sl=f7ZN zIe)QToaYlB&-pb1T?^{`U;@d^eMC;g zK0e|;KG9^B^O|gGD{ORLf?IQ-8qT+#cAWo;k>xxgI|>Sq=lte2iKORS+PS>jcrgL0 z_74^3r!m8DzL5>H^=8xgcSQD}TF!?PNMr6}wsPKq`{=F7Ea&yu)JfRryezloK{cH3 zJmok)i;?9#IXm7F9?$vx7;)bJP3>G>cD$-o9T_6df5QyJ`Oj=vs5hI==My=EYB?W6 zAfvgDFIBo-xsT5^ndQ7Oo4N}doriMko2Z8K{U;sgmoT!Nhp?lR@OaK2{w&VFctbmv zw;xZwhN_c;#rZYNFr4pV!*adZbiS0xaa7Cs1OnO2eSE0)(UbcatjR3rAF`>Bu+e#S zZY_dpI6rd2aef0M%XubtlouY)`SY#fJgR_pF0VsQjfbl9UyAdam|-|Sz=j|7X4Cm9 zB4<-Q6#l53 z|ExEg&bJV`j%qodN1%|ok0NRxQQXG_O=dao&ZZHsbwO9>GG~U&yfCfbm>>bqw}7 znEM>3iLp=bTLoR%7)e&|rv&wgltwkuID5oN<32`82wnwvZ$4gSS8>f}yn#$W;O0h) zF50D=t?7)%!6TTd4u;35){?I$Q1Nvgu6(PY=O`Hc_Hzk$K4$1}@m*oQuo=px&KklC z8%uUOq61N}FYm=^O#;PHjTC-8?4)oLBkP#R%8pQ>@{Wlh0wZ%9vd<~mmp&8OcQ;VB z_hpC!*rY%m6$39-Oct_PPq8CsR zw)Z>jmJyhQYJ^b2Rb3M!ba<*iXU80&@>I7b5SPv9wbrK_frh9?3J>=?DWvktF3XO#LgmSRoxqaphU{VLU2y`+PKz17^||w- zgpgRXnd@_$$YxYSSqoQLPmBW2pPB4hi)tB-BGA>QOYPF-(R9XvSf3rA3zcWIG=Xie zYNPVfXjvqTX6-HOQvfr3>ywC0w^u93zdkpxRUPy%Q7zer2&_dlQfRc#S)Z;LS%=kh zcI*%;Pxep(DNNZfliN1geoj-h@U2fbHVxBk z=K3@sQWn)vc7BJW>;Xmr>yv|BB{ZLL{v;xBdznQy)}@=P>5TO`hMDR!;VG(RbR&V# zOnQCfh3UaTFgmrH7+r`NzV(S>Q&$c7*QW!~FHo)ZsYRd!s*%FU?M@1}F|yX@Rd!Sn zDsO!f5Ez}&kex%V&y}ts`~K2^^*Mx1DunB(_Vw*YBGXX~W#wFD^|dnJ^=%NlzR`Tf z`m`euVbk5&<`_-rH(HDx&4kJ`nw7xp4BDu?)~%}6=SdeaniMm9>vL_17(Iv@cz>{) z=x?aj`Yb2#4XTksNmq6RM%MZaV8>jc@?^Ima5KFjyWv2{u1wi=F~fKM6lPO3&1RlI z8HhYvY$=-&;{>`Iqk!}00%oiA{u|XYx|6^%o355i*H+UR=g$OoY!WKZ=w}3i#i+b| z9ykC-n|7A<`4}^N>r<6Yg*4W2r`JbhkNq67=X4U;D>1{jK4aN5AJsm8dJ$=kY8*Mww>rwwYh}Lkr#!nFYChxq z$x9%WO}E^o+kuf~^ua z&O)`;ryGHWs74A8w>T-J^2;vEjGEhgU}N#P(y*7`h~D+%NgDo^$m0-aMCvb*(#?CtGD_7TkRt%6!+i582g6^BL65cNj%v1}c;+bAc`d8lY}UhKh;LNIe`|f?c&VT}V_@6MThWkWD$;rCg7ZTG~A5!jGux_C&T9K9X#2eaC|+ z2|#hR7n{_l!%7WR2^n?^|H!3lU&KHRrv#UEP z2bf?Pg0I_@JJvdZoxw;6sfI4N>#5wuw-R@$(WFn2Hvo#eo3q5-G1SP%aF<%`&G{nn zL88}C73uvK2DpOYx2T(vxNG;GE2TE2Y*Jm0yU*D5H7RGBU<-m(ZOZFw9Cyz!QbImP z7u?PJ6z+1TA{2zIb3le&~SNI42!a5uRJ+*N5QYgZ3V+Fe(G;_hwoW!4bZ zuAbVP<1Q`HH&B(7cTMom8Djk$s)1_=p%0o}JyVak--G~`&d4HWHYPYRIeX(lya^_>rev&JV|qV8;rf%I^Z7 z5O|mXA9ege?dWdEtxj{v?L$n^xxL}0Q-(eDHCaeh8W+h$BpIq9Z1GAbx1TXmxt%kk zxj9vQCLo{s5uKacA%bgB)v~GFn!0@5$)|sk@8mX(Evr%WErJ6KAf}ewS((J>=xR=WuqZw(`I#nyO zt1H26oBe;3&IEacv(F-n` zK!%q(IC-12pc8`Y(nx~)3^RPeHDc2zn$0}o$`Q$nYAD;a)Cuk!M#`uaToQJ@Mm{UJ zxJi=2QB)_mJ}zH0`K%*u9b0}uwXSh92@FFu^$DDPu7i`; z*!emlxMB?@xJsDe3oZwnN@zASxP(M*O|+DaS>gmY2cv-C4q>)BAFiV+&d|An7 z1y_|VEi|7ITtNaEPz`x&7CFJ~$H@9{c=EMa%`H@3aF+;le5!+!AKXW_M{qIqCAeQO z!x!9AHtj&QgZrAuXQ+ml(L^K#?apIQhmm)jt?+I1zk7MS4+t~8tKX*M&s zoJ5kM8p;;UcY@oBQ9y8UoXk>K)RhA+4vHocUA0tkq{?@_CmtTHX!JV%q!QI3RUvPWabP-h<^*$Vy6Zr(VXPbjA^P9y8Th zpGc^@;C2wG`Iin(zV$HcBLp`$LV{a`8NT4gv1tLS9b9iBEl`c%Ud(okW}s2)KCS}0 z8j;TmE;qsCs7`RpUA`R{1q63@w75;8`HbLB5ZHoh$ZP4+_11JoaC6yl0M+_%7)>Dk zpE@}Cxp9tG2(EKY39dh8_=0Q5rf!I7HT<*P@&Evm(NmLJHLN#y(91X~fTj%tJ#JIj&y5+kLev+8o* zlDx^TdZesnf~g2jy01eF2^sb_V7z?n(gH!ohDneQM=(h5_1tl6QpRtg>QvmGac8-$Y;HtE6$dhn$LJWmyJLIR72ie zmu@3QIA$xl0mcp&t7(PGdp&oUK;wG|kFV!yHb-tNt4nTMF~N7{PG`@Ls46$_vtkI5 zPN;^k6t1vbTA1(5t;w#o8Nb`MxEe72I~VoJF-Rd5Z~rjcUj%=F){} zIwQD#?D$Toyh~n70yl2!;N(Z2i<=<03e_aI2+Z&W_a>V{HJce+2$4sTma-|+oZx=I zC?L2qn61wIKTs8D1@{xdd8kfsVJ=@w@>#)+V#{pJXB=@o2sA-8f_pO6kr$%rjNmG; zqk~X+!Q~^c{FV+*Ue7I3!6mLL!DYYj7s83zQCO(F;BF6* z40_+x!O82n5seYt!O9ZcS3FjPZXepgvJt;~0-e$1{f$!8sL zH3$|%b%Hzjt>g4IMoNMeTo$$z(R@a5F9(a;8>oi75iZ?KO=kpmkR5-aTGzNA36zb~ z!O82nB#jW<#83%tHfH#O`+`lAHJce+J0cONhO#@89is_p)VjvK&93*!X9bsz;FB-C z;AXmfKVlRR+;5nwPW^|d)-`Syf#s-%yxJ~ZJ56THa zeNH~>h?~!rEvQy-V+iy{HRNS-=?ZE(Be-Vl7%Eg=aG?bD-O$0w>$!Ff5M1tx5?m3? z@CBEOO?fq&8QgK*`bn;ojbs$(9)d}vw1jlJI@>#(ZXG=}ZX9Smx zKmt@l-dvY%BSuzmu>-_vTA}iSJ4~SQH65J1p4(m*!L2AK!EM0|-w`*BO{-Du;06=v zh-xTH?kdZvmHC3J!LBysvw|y3FcYd1+{Uk+;0|M?Bv`>c{aoCp*L+5BmkI1cHRN@6 z=>}^$<5XS2j#H>e)C+Dhf!D6;;N^capZ&?X03Nw7cwPw?2n$0}osuL-KYA8E0 z-Z6RuBW2XO#-(G|o8+^C`|C4F;XJAn++de)GWo3Fwz1_5s&$Q9L|{CsA@3cRuDYf( zg6qqUSwiIn_aTAnmvwORdhUA_T=_B*TusdI1@{J3ulbB4t~-Ios77#)$2s!SXgVXf^6Y3Y zR9+`WEcG^u7YgF8WF3#y^4rK_wrMghTn$FB9L z0l^I=*csIcE{)5VmwZ-mb=dN;<}-pTN#He9L*CD0o#0MjWL@JDv7?YsdBNT4D;e~< zsDqQ&b1x$h+<{UO+!@U91-Fh(zo06k-iN~sB2lP@vV5+xvRaw%RPDg7FUV&dap45t zL3M&VF~)Iv3nL}L3NABS-qw6Za4-6Z+v})?yx}h03{7VoaR=D(C#rRgTTP(MZ#p=6 zJ$Iodf}2oMg8Lpbba0!0bzaX6V$(O8EhK8Ti?k(D6V*_5JK8atfJQ$-i~D-6FuSUe zubv5}CHT0v7u*b&Z#70LxYtyR^Lp+Arm9o_Z&U>an_vvVMW}|vaF?4* zb4NQtZp27=vtG|#>m|mYqbksPJ-3J83RLF^Y~b>BBA@koZW3FTX+Goi+yDY?Q4M*C zT)J$U&Uif+&W=xo%6mOml)#2_2#>Gl3WX!Lbni-TIWfU^=05K!J~L`E^US?MWIw7Q ztjj1Tw;>p*Xsi#}W$fCCszB?^{fb~eR42DrUA}k7XPvn%*wS0`8E0-40tHbGc?U;2 z@~&WHUGmbgqqIVr;R&n>Nv;7%8l;BH`sFSs3SI)|!^dY8P#M7~Bf zlofN8g=uBJ;CituntWDpjR;mib%MJx!g2Z-BPGEKE)QGEYCa>l6a*ghu;fj2=@x4` zi z)%vU$P9V)`9h|(L8>NElP*j5JjTye+>anSlW;2htQbcm18p>jZIl-O8NEx+)3uaeV z@>#)M`$SSWi0TB_!{r-JKI@2E#g=`jaO-_va|(gMsD`}UE?p^2X9U-Q9pi+`JK|~) zIB`-3C$Hx^Rzq-wi%4)~F~b+!D{LyN+05Wxb`zI3Pz_}xqMYDnViXYEUUpqVRiG8z zQi2mvo#0Bje6`4D1=pV~<29cVTq^?AQ4M*qk&e8V7+Kf2!t7`$R9V zel3FfF4I2D@CCPkO%;Lc&B zBv`>EVascp&j{{LXNlnisv)nhOE*T-8K>%Ic3efZu5oh+ymed$C$HzKg(A421tqxg znBfbq8=Hn{HuH#UK%^|Hq3rx%$LIr$lu_#%mxEm;$Y%u?L@>6K7u*<^Zw~pa;0|G` z`Y61PYF*>j5SW2#$Sd#CHPCcMa6{R#M5w$Yt`mVjj_Tm#^<3Uc2rm3B39d0__=0~fZ)=q-xPsU^)<}!1^4V@F`7ZM znZaEqvJcfz*7*x3xWO0&1huf2b`HbL_6ZoUOC2xXD zw@A|&N8BmQRA+rWs&$RqO5pupba3)|u9FIGR(=U?8D{u`8^xyCn#~NZJCVkyMsSY@ zI7ZXZsCA7i&8~Xnvx3V`FcGQ~+#;86D@Fmq#kCW+!J5wq?g)VmsD`|zE?sv`X9PEk z9lKGj;D!-MeMkouPXGq{pOUPCpM{rtHT+zE`7Q7gD0 zcD+JAE4Zs|C4~d1PH^2_zG39Ej<}U<*^6p@IDAXsOH@N%E|;#PrZa+T&yKM|<(;Y# z1b#iBgOk^Dd&(fVLU|>)GMM2DE(@EAXf`vr7j4AlbyP#y@Xws!W?&Q$+#YsaL{*>_ z+!BHlP@UjPx_lAjvx4i#majCQam2MG@II;`@Av+WycZZ**SJFL_&}(<;4%=HzF!9? zujdw&MsR<=F2Mz3h7K=Sshp5VE0vFjyWErZVtd^^+tyUHibvVX&JvWYB z3&^+H1V1I%6x9jtML)-B2J(HWTAbH&71+{H8;@%|oWHFkZd`Fejse}`iW5y*(@gt(!v6XGuz;c)T3>h_|Q zxXmX#-n+DG1iJ2pQ@%^9TM8z3iZSP3mG zBnrRT$20j6yZURs-rZf3)d>_qbxa=bE(o9XfuB0;Ez z%h{hgF4toe;POf{$>u4l<#Hc^Rj7{3hAvkZ&1JZp#_8LI$8$M^Kyq;@Z&r2|gUi;h zip%bp;d2?mrgoambXkl@HdMpq<{pmAqZkFaeBM-CX4HJf5qp)u0aV9jcb99J<}zHa z;q>#UNXv6Moj{)LdM)KO$gFqZazHk5ISMm;E<3R43(aP_j3DwZs^RiPcgN)|i~?L{ zX4l)A&v5yoiP*o6>bM-`a($<{441!f`a@L9xco-_+6UYL%*70! z%fW1#qS;KB9f;IMHC*2N#BrJUpIjDYSD5BATxKB<-`I0G*X7!X5zKgB4vob$^|+T- zc)YbdOrUX$b}26ymK1@@6|acPEtuhRIgL%LQPskDcLjrqbVM~=CU=$P)XIFHBsJL8 zM)Mgi-yx6{)mh6e-JHaZV`RBZ!0B%ZkLNP3k=XzAXYEqn2K@RqT<*&vE>B^G&*d66 z9YnQVP9riD)o_`|RaROn^SNxtu7R4*a9NW;aa70UsjiO8I~Z9mvvYb?;qhE1BoMt- zyOc-wlgj1Q%;NHoh5;^r!6tQN+(5Nmt|2l5)o@wfRn|Z&^SS(jU6VDR;j%q}TBwf8 zKe{+BllonjHUSrb6JYO&p&CG@=$!X5L{-V z%Y2yObD4lm*)*H!GPZ&EKZ0tw{Is)^{|Jl%T&`xvJ+b)$6^rTpV@C%G ztU)#8HFW8^XgcE&a~eCg3zheXIfOv+O;}GpV%~WJ%h@Kq)XT8Z;&X!%M$j$p1 z@FW5QQ4M)HT)N_#&NvU+uw%4PdFMemfukGrc_2@%0}CLyH`7UQr7*)6Tt+q((rjjM zPwPkoS5OUQksX}ireYKj+)j3#M^&H|+(Lq1p*q18clpA}X9d@rEn_sF5nOWuRZtCi z*V;Sso??Wkz1x>J*-=lZyx`Ijn6h36ClA66@*}wWArjon+5y3x!zOjY|B0%MdawDn z5m}6CD68Qr`$#ME9dXg@noB+_xK9W+LUn?B+RkyBmV8!lW!cg|^BKXtP9O!UA#bTm zw+$mJxcjxl>MKI!1$T--t93d!dA2U5f?JL}^!Hp!+1JzKL&Q(@G zEAs_cpIx2FX9ZV+U=CC#xNU8n;7(zrBv`>EU`sa5X9O1)Au$|9HRSbl=|*ZgNgHI$uh;~2e*kuqvs zOV$R zpcUK>f=f}I;Oe-1?a5~aH=ZqvG@o(A^&`*<)d()grOT}8jNq!Vqnl89!4)E~X0;AZ zUMh5d9l@naDZypK3}0}M!o_HaW;27kKx7xHp{&D4PH+P;3J7i?yM9Iu2yQgNo~TZ6 znO(j@J~V^9rcgJcoB>I8S8rQ`HZ zjFbc`xYyWHQu7(XB_?pEx+QO%OE*u`8Asf4%v2}CGgRvuw~0XIl{z?i^>HF6f}561 zf?I?czTk$jX{Kf~gX==10jd$)UmrR~Q_!e&jVr;fTI92Wdxc;SsuSEimv0kB0l{5= zU);VxwXSgo39LaizwTH-td)6*@S1o6_Pn1lKyL1lJuie8EMq zshwssgDXZP8>*pfa|GldZW&v4qFTXC zBrpKgkeA)1E2im;;99d|lu&uWg%LQiTn8sFXo}}RaBturT~;sKN@9jDxD0G6sM*Zm zo>Y|xE~6UChBkMCn}Sh5a68y_4po6xa0>{ILv?~H=JJJ+&kC*=TcS0eajG^WP#M*b zceR-#?+HfMHSP^|)D#)kBiInt3GPW#$7u-ptl-M9rM~7fg3C=HIjSLViAxuQ zkrmv%%3?K(Pe7wSbjGQ= zjvc?DB2h26nFR7J(ZR`^sY=-p+#vi6Uj-M98NT2;vT3kpGmp61L`tF>%1$+QjNZXW z8MUr)udu5q`K;icRT8sTQJvsMxO_9oX9c&HEtgQOYupL~-=Z4w-gD_{YdRyiLF||> zR95z5FqW1O99g?$B(BLPzdZ!;;HhJ&VA?s=ehsE!R+SljStt7h>24Nf)eKIWiP;4xo zj|Z0x3W=J7Z!3h2%{1m-+F-T)hKs}ysM`AlgL2g@81$@8!Jv~L6b$OqwqQ`ko&|$`99%G{{#ONq{+L-X z=+~t9rgv}}^|-*-LDRRjS7j+O!j}l39LUSOr-yqI7w1#^Z&{pk|j53Qlw0k zI!#F0bm=o>JZSt^sX?R0VUf3cgheO5TqR3zSn-`%<;>VGBom^wE%b|C4T$ha%qG5JPM0^TCs1^jrf-$f^H=bi{Cc5TrzBp z{v#~hZ6H*G=UG?2uIOc)IXIj);j_-uKgMuQ) zR?VAhQ)ac#v8g}4{wOH6e%-`D#rH)%jt{A}H@Zr)Q7OyU0NSr}NYoQuKL#~q zL^9oz>G*`>IB2614F050Q1qCgJy60D?vKA579E)jCwpZ7k8r}BM~B+^>v40{$b_~L z$`^~jMi&&PzI>8+?aTQ1@)I!%8NpMv8~2j8yWUG$6#rg&f3EhBJGL@tZdEn*(Yv(* z^2ENWfPy9vrht66(wp1fmB|A!IV?Ilt-ek8`o30ucvR(&Vy^}Oqbj$$AWvq!6z&3DAcUrrx%u*3L;-3kST z;(smhzqgTLP*6hkUvRK4`v17e-QfST3;d4;2@)hssQwrDUxEZUZ)2cKX*`4f-ElM~ zvi}PTvj6=5@K3?Pf#eC4eCL!4iyop5zli94>Im!|fj_IYjEEkr)-p6?U8Rm;kugcb z62^q?Nfd)a8LO>lghh{3GeXvdb_6);gKho8E#PHn#~s*7jYuLU% z<@D#~#=F=QpQ-+5S%UQ^dBoVnlm2{!NqdohXvq3xwZ>Lz*p_$guk1(aFQRY;PGhc6>(A)QFBMs%qG%&<5CR<@Zt*>zf}g zS_bgF|DMe3ch972uDBGG9VC6yIDg84KlRRxUEyG8zPoC&2Eo|*%Sz4F{RZ-k2^*Ve z7pw+VE<2;>%EbACd#COY8XwakH1cu!o)>Rrs2s9xOwl#i&J;$4;W~lUiNLR(dT-a` ze(IM|RZ_o)DolP4l^i(y{~=Gas1;U+7>9upqDw{*JR+2dovBDbZDd>q{K z4}J742Iw4psNvC7W0IjMQ`2uAtECN(-XAeG^?CdO%^?t|y2H!v8+aew;ca82WqUH` z$Q1$V_)QizYGB^9)ry}(|GO6+1y#fS+}QGO{f6B|pFtE6(K{jv#$d^CzZ0@9E&Qem zDtNR{(y;g#9MpG)9qXMTG=6(Hb{A3h@W5X-sE@Q;X~Wy@4;!2K{COpMUvwfIBiIu@ zZo;Cmv#KH0PKQSC*rCrKbN_4H{V(}n*?$Z0{rC2-yvoOMc>K1?gUclk>hlnpAc>Ka z5ODNy?H{R^Nyd+Db$qy=%n@bx^?kEe^tOnC+aePFyS%c6$L|P_+@3Z(@@dhY%jEZ! zCDXy+9u_gxN_ehvbfSy0#X4RhqPImp&DmESFF0Bgg^djhei;)wvQi>t64$6qUDiJi z!liC6j;f&OL_{cooFylyZGJ(#C+Z0u!P56#*7S2q%H1AbX3{iUG-?9;Hsml9!<6bFe#nS{>dP2oOT>*j9v{6uI%@dAXm$6oJN^NG*KmQeF z#h_bD9fl!S;?+MC#wB+48@4SrP2{DVYM;uiRuBxel?vqx#%fc*KXfI@7Zd}!l-uK$ z7|}Z>6-D*EwEwkgb^bz*?5QbMecd$z}=a~8?gsTVUK7Tf7R?IIs8 z@#@o5U)|+Gr7uQtad>hytWuO5H2-k%t)`AdbWZj<$2*;>4F~N@+)wdi!1#pKjsMBV04>_Sy$hsufc}fC zn2Je#82CQfd2+!lyyz(Zdh(wi5h_@l+4b*9;sX3@BbFY$UhSXF=~eT@6oD_hEc zI$pwX4~wgeeI?M*$EEnkQ;tW3T)*^wqcQJa>~~Izf7dT*IReL|#^R5&C8p%X2hY^rUg>c#V9D1N}0-?hvP5RR8<) zMjsbd|8*V{Ko@BBAM%Jx^Y2aQ9hSs}>t8HD?*H})F;_bbRX5dk z?txtpB*%!Bn8i6)th3N#w(aAS$lK3<_wwE4A1~kDE93p!4@mCq1pb7T-IHiP zA8Ga{3a&OPV!yhb0K_Mtf1Fg+nxt4pR#uN%`Zj()Z{zo?+xQRm2j0g27aj-UdkU^c z@5l@MBng}(Cw0K5`DO3qktcTJ?)4vT806#8zBIc!WEc7&(Ep*T9th$N{U7Sy1w4u( z>mTm9BpFDchf5$JN|c~c5=B7;Lo^d6FawEl^@ak9#v3Za3>QI7oCKI{M$y$>U3FJ| z-CbXA>lLD+W)et%a7RJJ3*ai#j40p=At>|xPF3|xcTWa&_5VEIo98*1?y6I#&N+4J zcB;CHtXtWN`6s%EK$}fo^s?4mXsTqn>*q;Yafy1A!caP^=aKOlXphy?j@yGqn=wfJ zm!>;YKV}%tiFpvS@=%fx5$u6T*0+`s(G`k`=fyHtHylY(UwDJSRJQz3dpMjP8#nU# zwOa5CYqg^NM6 z!cjqk3RVh#J1F$>E2;DL@&wdbGwjk+Pj++Y6@PELg=i=s#_);*wAfyzw79}*FPCyG z{9R`kdegw(zAmN3tu$2cmU1P@msy7PA-t=bE8I%6Qdj~U>+Vg^g{iqIRcam(vus`4 zgo>$ac0`Gm+LfC3e-0N)4)3;mZELBSa>?&}*+~x6pwVl#u%=3>Z*tkK@NYZNGMRi1 znpmA73CZ-!rHM1BNuyrXt{v+d7K3GC7{laBS$B2qJ#RqtDb#)6q^?}Q(3KUhG$^4) zbs-4Cw|rn9ez3Zl--NYIc&W?tZbs8ou3)_t&hW@;8((~>7`5y+#>U9WZ>;Y{6&=`wgl`#)i ziGL|#;r!OpoQS)G^&T88{SzSFe)=#P;z3&=vHO!`apO&dzM3VP5@Sn59X@G-b?UnI zA*r!8Ces(XE>)sc(a?pWMPEZ!rOt1+0S1F`7?N+1ni6VM_IHcpL9W@jGEofz%4PaBhLL7eK%Mc?Ht#_)Wi?zn_iY@d#Ui-x>1@q^*FW z1qISy0V@C%_Y_D0z$<`@?=6rv04CpucfdBl;Hm=YR=~S}uL0*&V=n{XX+Rs`+WQNn z<$&IS0_iwldQE}!F<@|Qf%FuB^4W{u%!LKgAi&drRe*kr3Z!blOMnjnFD@>Sjsb2C zLO#Gz0EM6T2k;9R2^bH!1@OOshycwCF4lXd=Q(N7GUp1{1lL5@+oc?Ey-$k>Y{8P&J+$>Z&tooSN$su&3nZ^?eQY<1z0`_- zqbyk7umxIk{ax5{P`{>?duAPpsIS7dSMHg2q#?F?<(|8a)NA37A>12lC|ACyP#WCI z#`yXmXgQU&F06X&zRwj1XRO?F^vIfW+YWE6zN)Qi)~<>H4KAg=+(u1zJY%c7=rhh~ z%_Sg=7T4j)TwQM4tPaF$f=A*ngD+QQ8My)@Bmg)8Kg9aSa^EV*Pl^94es-!fA%KXe z?(#Bh7YYxnnswMaU@fw-V%5mDNqq$5f#A_}z}B1E&Cg?yAG|^ZU=>8bEtO7UJ+$5Q z?dh-fbAQIl2G5~JUq_}ow{j?&#-2dJ8e1J`&5#$;6p%MfQ)!9wW~ziUu&O!GHN`dA zb*<}~DUJG4Wb4^KtFJO;b%kxMTiH&Wmq9rdAulaYyOai2=ncHkJ+`B+s@AGmpLvv; zyejCbLfOa~P`A>gY%dSqkcZXx4Q0V8j!4h1(G*_}eOE5MEQF0DfbRi!Jb?W~u+;Ma z58|1AOPJ+*m7`wl)tfn&%$KT2iM;G;OZZDiCib3L!@F|CW2r6kW8*dfPwg6Cr$Jj> zb=1p5KG}#JALxH(xUpnP{SkKS5RbW$njdMK4+vww8TO%|i>hpv?9!_i(%zKD^RQY= zzkGeFJc#`}42cgyZWRSWWFNWNamw%CNcxq()jT>E#VVH~o)1iR5N z%gR3IiB_@Pv>5NUHCTguHt23~G}~KHZ?LY`Vz+Qqn!^AAXvo2rtu#YQhDW0q!m~!Z zBlYX%)Ql1T>9kL;g?M?J8kM3jZ9xi?ddAQaIZWxADU+{lWNUg!p;}AEe-rE1%2keX z?4w#X&rbf6j3%oTIBJ#ezYH9OT*tADE-!oBhcaaF|Kpf3TPPwviDJp9z@qY^A!D`^MJsyl0Mjk*DE7YpR|AH=emr|P3 zWVJMx(!MZhajCPZG{+W*S>&2B(5LM4hFRsBGZ8z?BG(Q?AQQGU-@uD8CmnsAbd;4} zWQMVg6fAY>5M9cse9j2wg%lSY)t#~*4C(Wk^rb@#S;ocJ5g`^s;Dxhj#81g$^_RPl zWA(A8@n2qaDe$m7{l;yy`DR&7&WcB|!%JCG^)!CHw$-uSI*EM6?Wxboxiu=NJ#M{m z-BYZ`tdG(h*mOcA?%*hAu(Z2QT2fhp0j9Q5-HlXq%nD4o<{q^AC}>gSC~so8Oc^z# zOfi)zkz_T&4d;zMXU-KoKT>n4lN4*N7riFq8<9{KtP!aoI$cAVq%hW=D?E_NS%tjG62yxK?B5;`qJcR;#xB_z>7Dng+5uT24 z+RinQ%ytNkdP=CH!kpu&KVh5=u>H9}Itefcun!OebVoUsE1!C*zoFeY*b%(3r`Qo( zleZKhZpG#B1}EhV+UX76*6Iz;I)J@{6~S33_X+6#m4n{k6CT#~2dU^I66%M77_agG zGlgJ}$hC~{CXccqa(yld`v_*jv`)4mvIm|zdD%`EEnkTp-kA~l#(2Bf#{FdXL zI>ho&anJR#Mf88Q*zlA+sh(83!7G<-k7R;uIr?{H8xbvpOCI~|1I;-_pDn;to0IV1 zmq>e+g?#hnn|aSuPRg5kb?o=0yn6P_wp@CYC-ZjEE6m2V>PKe{V-XKa@=6elt%I(q zEO;t^3s%ACRvklh6%VL>ngw(T*3&O-uv^0PNqcUGy@nB3^-5AW+xdeT%?^xe;``&u zpZsYY+eJABlG)A*OL|dBzZ5BVOZd&wxw=0FcJXOM3|^*#xz@|_&m=kRr{ZfixPTuX|t!%1#ZW8Eq2|4HmW zwoFKkNPt$}CkNUbaxFD0b-66^WcpuRkN@(bTm+*_eEJ67B}#8T$-Be__+?#U)t-zx ztQSjFZFbt=DiOOBhGQOB7eCVqsW9jECW1Ef$95%y<}%6k}mn zSdNF`Ff|s2a|Ku!if{H41=1e?e+9e_SOwSt*blHkRoQ?u0mXo^fExkx08%I8pT+pv z$!dDHncnTD_cYUcy6HW`^zJadcQCzoG`(k<-m`Q=_%ia)*BB%P!!heeo z<8Ayuh5gUL8hj>S!sS{v%SJRjjL>S zm!3sv;~L>E&43R9wJ_^?>SLEwFa0Z-;+oiQ(Bqg^hN+RKw|s1|EX`*IS{cm3w%5{e z2&@d2m!8Fmwhr=*))H9a3CcrRrQmnCKc~_~zCFXM3&G8Sd%Of4u<>P;}e_cQJat6KR)Sbp&PN$d5x>MOp zfBY}2U4waLeMRjSxuz>>D-FCSl{UGZ<1Mb^rIXx2t7@a*>SK+-_B&j4xNt{`UXK7O zL<+#wMN)JubG|2WbWt6w92^ZKoc?tK*vmQel2eB}1`u;Ly=2y%$zBTSKSniimhOW= zC0Md*EX|-`r6sbrErwA9=Y9f59Yx%C8E+%hpiLct(08bz0mC8u_?@o0VfcNAniutN z6am*Hsh+i~@}ebp#OOc$Q>Yrtoli53Z-7IrZV+OkGhB6p>Gx(=-TCx8)m4W}*QDr` zuDT29cZ{oU2>p6obwla5#8r0@{SI-}72%g<8y&zdF>}=wQ_Lx@x{K+zhpP^oM5SnF zS6vDHrn~A~_(jS17H}0Tp5PqMHDHV0<*F+cv6B-DN*4->j$^ejk95?C^*62~-{1r$ z(~mo7i{`ryH&(giN9$dI`r(wBoIuJDxlwRuEX8;gcE)lS;R3-R3LE3a_~~2NG{NM* zaX5(Ilb*&mUjP|OoQmI@0W$z|0abv-fTe)P08ay62D}4k0IUUU0elRQOkbz*PvjDT z*2E)w(tSI}-tDG%)Aw|p(@pW_@9P|)hG=HC>h|zLS_wP4_|6f2j4@X(kCJC0qmgN{JBb$W)=BM-SV=-q4Ag;lwm~oldEXkJq6gwSEg*M z7!Y<3*s^puzAC{GqPtXCIy9@}taN;xR*pS5v3hS{pT)l$F_+Zt^!3GO5W|mO8nSo9 zM;xdONL79pyiHB9N>|Vk?TTnyDJXTUEDaJ)Ff-OzA}?$5#8$zJVJ-StUNQ@9GYz5h z$%&Cm-oqT%;tOd!4d>xxw%9e$wb)6|y6!>SudVs3nQY_{V;*ZXe}^iRT^>bzxP^}u zHdH7_Ec*+0Pb`nErf*#@Y%1yD zke6jv2JwHmB~QkhPFH%WkJ$0pEpRkPuH8!36gcjjb&^+E6U%-T$+_28Uv&fb*`<4m zku(j$4!7fT+;n-__$*I&j{_^K4tHif-0q0U$Xt#8ojjSF@Y9*1`J)^yLO?nt&OqWc zB$ksB+gakyJVmEOVwMd;k(1M%8Ae1deBcz&;j6b-&)_C zfI8JTGjKFlu6bCba`kIC+<-&WkTlnK1^$;rPk;MqL{=7seIw7SZ=~2(PNLG)Z%bvM zE!TGr{+IaopfSe=0<0A#7G9gN1cxqNd~l#G<$0Aci5&zwWaE}u>~VV4!t$G|H1yvE zD!w7aRTxakwRfRuK!zpVLSwLG)KOkEl?RwPpnYD^DliBWEf#6IvNRp!MTVUj2}all z7hWJ&?b%h;HdU^*n-hL-+?j)OjtGD{{ zUEbg?M%iXm23Ak4EZQX3KFP--E<0(}p#4|b7W=sRX*bgvN8{V1$;y7=x9jN_ZuHt^ zc#xMhw_(IQbH;Gw8WM%g?YaNGn=xd6qV)kvYI7$FT1?4C0!2 zGAL;sxM4}#kp)?6ro?1{eWG;!!c!zz4C+b5cR>9tiw4YO79}XiD%W17+1W4DH|h-4 z&3CCAVKo$W)77t$%G7_GR<-0slOfyNRluPlso86k0LnYu;P9WqDh>>-{gNdUnQ1C64eeyQ_nX*KvoxfR*_#)Tz#3=H&lU zV?jZPUXaS;9b}n4+*htL{6IEGA>VYGJLV zar+2XT$u@p`Ls5^q}AYDvLCDndz5|f()&6^9y?6yZy&2~AUhgY$@l*gPhxBpD1uKH z^KSBEP$|*)DsV4`Mi^*Rpe-)5&_JWYLgPPepb^Z(n|1MUCw^>;hj(H41Mq@DM+L?Q zY`X$pG3d}9F_d7Bp5SOlw2Ba=jW{ zM{?meZ5nAOx1Bl$Cp|2;1xGsM<=wCb4@bf@EXLO?9`-8vOzLC1@If#wY-9L}vpHkx zau7%a^~S_eea;Yc1!jKgLkK!Nf@&s3QnyqJAEK{cpv~#CpI0CCA$!ZKmgbR8D%Pfv z-SL=1kI}2!i=he_#YlO$gJSW4d=5)X!ANV3_NTmj&IDhjnDj^Gy8CGK6gZSoSxa>Y z=eYF3n5+k_$dAF8n4Jq#KeQ(piQ-HL91`;eUa&e(^AsAE>z)7S{|jf806YSA;dc_? z4!|b>YNE{crQ2_lD^4Q7%Fpb}w#GcudSfDj`I}2=bt~8$_yGy;5eFG4o6AGpC#|fW z@2uIjtFpgkW%XR=l5Lytgm3oUd608Lp3{px0>P50p76K1E5DrAV~w?B@r)aqN+!W5 z^8w=kH%ch>&WP>q8Sii}o;%5@is2 ziJl_@@t7wb^E^=$0i&Dep@-vPdD-U0W8i2j7<0TNf901)d#tr!vv{uHU|eNzg6FKL zTvoKok5hm=4 zx%OSsLdeq=IND*($wUwWK53xSZ1dICV4m$ zTqGgibjA^T3F@Ak-JY{Dko&l3c4+igSJB4Vq!99tdMG%*q~5h_>;Y0@5udssrcZ+O{|(RO(udFv`d!?8W022V7&^xTN^DV&(f2B)vaeoM~* z^jS9s%QsCwUUDN0VYJ%m*w4JPVN0 z=+9zhV5J8O9&PsjAkO+a{8s=8r<9!d&tlQyEv7#!Y8`^4O3)dm1F!B`AHD|R8hnmt z0_~lCwfA<~Bcng1#I4M8l!yB79fjsdQE~J^_6}M}{lwGUgmFb|bjW@m9qLh2Q*{A- zm4;P0v^@jMr_su2Z9Nv1Tj4*M?NuIGM=cXSAEBvg*m-oG(KJPZTpk;CVK+to{z6wt zVF9)cSpEvK$0mCYZ0}pUuPgprd|CKEl-i}^nf~6c@OQLB>G7L7;d{TmaBa7gDb0~P zY*>GG=M65OR*@5^$0nbi@}k=*7uuCra|67{UfVjHQ8X<;d81n7?fU1~KZ@YzDERew@DCz5M8QwQgO`cm*%VCM#yOFHir^^} ze0x0jW)bY6;L8zQbx*p*-_a|-zXoT6SfdWF`~f}LJW4IqLC6%MB(^Zfy5;4oiQi00 z+$&BqPtg321;N&M@Olya83jjC^*LirBDjfyY2lFv-zS3qMZxdIgXfCi$0+z8@!)es za5V)#7!N*61mB9_=zLE2>up@gms8kHJZz5$E2XgUJnT}D_G}8f#G{nKUzqJhV6<0U z6}|B)zh99bsJBtu1f5jCyGk3~$cNd&YEERoL?`fFgO&qr$j#J-%pjNDTr?ylY)|Ah zjg?EkdaFRnT84E!z%+mzc1gb<0JZ_T;Qh|!XkP$N0p0|x2Aq$$y8#aY&ceG3a3$b* zyq5z$#q$AxmY+1P#lf{#N7{QimZOTvK zy$)L|_O{)J755s2>bYBaQ(25(R@rkQVs7nWxuy+eUlzLD68OpH$Eizh_;kaOTy)8o zght@p!{Ku-^gM{4X+b0~6+fu^vE6~Yo#;_ZF&Kxg_7yQ9D zJ)qjKc6QY6zXREmLu46w)(uXwq?sWhS)+Hy6Ig#q0tQ1$Y>sb&7_*QL?g*PzyuH zN8O_Ks&$dtuM}vzE^!{0{36>6fz0jNfn0&M4lLd?jSlSk>kB|gM52b^TrLUgdb9A= z5ABz@=Wb3xu~!GJG$9PMW$4nMLeYlwfun=vMHZ9^ttO|vKb);5S9w05o(6mUJVzR; zK%Zvk)qAR}cI-uIqppVn>i1<-?Xke-DN1rs6#Y;XMz>uLZ;8iBQg@b6atcaPNsW^z zm1vaGb+}7dl%Q0-N0PF5VnLcXs&Y~;oA!xR;8K!mSXlKQ(6oRy{cyG=Bio>8<+%$v z5a8f~IW%@M^vv6NB(%)wIgHXEb4Of7l9MAl6{~W-@fHMIUM;&TnzXf%rIqWk7{=tm$4f%>NS@$Xj z-OBFjHu77@i{8RUAUcSv)3cZ0^O;Ag|D92Yj&E~pPr2fU)1+Lvr$lKE?@Pm)PGC<) zg|Z)?vb>I)5UhbV}-H}Hv$0-ND4-w8zLQF+Zt0xBA38k8DkPg zvkXn(hDa_5sD+5}C=*MRjp5yyN^|w@SWIfg_jy<-tA;Cj7nb9&_G!=D7(VI@@3vy5 z3hpSiHF6lkSZr-F5^b3dq93zhjel?x-Urs3ApoU}T*VnzMo7}TXd3xfLihv%+z&Hx zze3LMov zGHk&mLO=x`S63#`)SMIYpD%c7Dbx5zeIxEbZUM;Ywg2OlJlDSgm-wf_2GAw~jpz67 z*HGiD*fo|YZ?nGY1dU0c!8e&`W!>47+XDjgTws!n#20egivxu9OkFV>G7e78)0QYB zx1hAwZ7{BXR@#HMa8->p(b_B!F`H+~+!}qrSjbav zKxX$KGv-UgH~W!$zk>2+Aq3y+qKw0Pt;+VuEfhGJ@uau*1~QRL5S-dXWFhpS;bIGo zvJoH6MxKY)Qg0#=!DtJiQGv!4eXj{~@+{=pk|9Z(zpLIG1FF*OJDawtomTi0-hAEh znTgL4-rF-A>ly9+K@8sVXtxiJ(@)k1^jT>%?E~6x8M4!?2b^Q_yD75x-w^N~P&KOO zArf#h3rH@FfRo$y=EUEVoxB_WKO!qBh$x;T?%66#v_Jnf%GDLAu>Kqh(N+3 z*N;tTbwE@5pHPJJ1*MN&ygES3MCk!g()0hyouITcO_IWU;UeA;j`gs?PrE&`Z4XMU z1>q*!(v!VJ+I?74e8acKbq8)%{O`_=-suQ9; zQDSE3QWHZD2+X?(lWZi;dLA%&gZT$!sACplIZRY;hK^{uI)JETgNoW2zI+pZnF)pE zh+L0dBJkt6zJgnYlucY^5IXYhcusjUVUlXqH?ex5Y!C0tL@xuQEukukE(pYtD)PR- ze@4TPQ=VX={D{Duqw%0#4a%u`zCqxROrqR|tAO-{e38IBS)&~1VUr2dDKNjsMnR@w zbsN43NX^5paa_}E5K~Q zMQf3Pi&t>DkX}ihZx!_)Xf9>7-^j@y3)ZHzYRSUE4^_0x7UuDJvmvr~!HT zGEQKrE+6$9I7v*b=~Q{QNOCQb7**-iaTk5Y)MbJK#@l@<(;Tr-9=7y-p%@Evc!9?{6kov@*|5o!{= zC$k|oYzS9yUEP2z$TE6z%jgaI`ZDQF)$=A$A_ZXkrYjtAy6AwBKx^OG_CY(Necr*K z58E0xL}G5(7Mm1hBYQS_ptWvWk_^jmVGtNAfo`xM%#$1v?0huTU?K`oIhy)0DvGgZ zx`WffmvhuNaIUFD{vl`uLCaXC!;nHR-2#C*g)kFMm|FL}IWH?qiIE@jx`#N20Z?8S z2?{3@1w%<~Dm9kAQ(%5S1ejg*rT-5T=GQ1w>S5OqCJh|eMpL8gGm(ZBu1WS6%6Zxl zr8V$Vf)sk$s|4mW!lZT~-fQ$QVO}mUhY}{&654BON4{|xX|4|7Z)t%no!zoBy>9ncQnEy}gULbT4CZ(S*sOBW{7Yb@Y3cb?jPem3v7yt^w0`0jJ zgkK_bSe^;pp91|eLhqhH7X#A~DbOc-x!SI~z^u0JCbkC)%nJ$AU@QA@X^>vPj=)qm zCaS6su#w#@l&rbi(8H*oqlGpa%p)n#*9kuUb-tO8>rH$-D==#blNT?%4#?{}b6)u( zuS6TdTcoLi!f;T~b)82qHVWL~dQcsK(WFs=EkMH;y^|54OT2<5)>nkJ*CBZZu#7$G zcytx&0hp#S_*25(K^AMM+Bbr1dyTS3D;b*{tx&dQWBga>#ApGzMPS~GBINwCrK^*&&2wPGR9x4d;Ng}+l$f%0GlR&r+ z5jK?M^FV7)6}cqfeyuf*cTV$Cpg$z|c;sAY&R|?4O?=#hafAoh+zmc6xr;(rmt#wHIvds`I zbW38k2`TgiKSE%tXA2F+OXo=w=BK4xtPcp2xKRI?RH8Sh;OEsVfPO_1`p^{UW8t(^ z^9kKxv>gRH8bpri*NR-s zeRm2MZ7FePkl}|5jMi5sFmnjgV0|qn%uHyR z^zv;1Fb$e~#)NrrBAERa=Vuzx?gm`UXKSbBoLLbyJo&oKvPw8n&{^N^+kO}!g~F%yc8Qa8clva`%Q-ZB^?x$}}e zu)4(m7|+?Bmz21G61&kJn{wvNkvAc-MkF4Vl=!w{!6n-_e4sTqiL4+h0w%#M8QyZzdDZ%_HU%|v>{?0BHAPMA3mw~D}G)d>N zf$g)qSFqbViST-)&==-=M0i({&i}#C^s_>ra4a{U9@jueGS*z|A23RLYf{?BkT%+2 z#BwKLZ6T~Djaa87VPz4+^sTrN@rQG`Cd?}SOt9@tu$>0B;n-GlkF9NMS zEesNbn@%%pVV;R_2Z8w{VH&h>nF;d?IH1)haTu#n3;8Kna0 zUP&yhGhwbE7J4PI@OPlKR~K$C=Y;D|g=~hpFbgTvRhW*Xt_w>=;y_a33n+1Bl127S z!NorXp^K6T?LP~I%903eLvVZIye|kH%r%Si91)@lW|T6Nf)M$;)$K{s=*cP2zb5nn zNprVzQlR$)o9cZh)a_tUq!K?PNs>>_G}=Z-%Ddo%?aoL+?32D`wS-K>P9|d4C&^t2 zwD$CUsUTdPM0l`?a2^p}l0>*u3c??Gx%l}>gm>l}#eY#?9zO-LWun)K5Af z#DYJG1&d&T`YW{;sw(4$^}>8oq6XUwJknkuO%xKzAwMW2W{q>;_@v6UwvSn;drmiM zt3qHtO_&Dj8gIhv2Tb)y@=RHm?NmW*d{VaQCSn%|%rld+{j|T4!7R%58)R!NoVS41 zUU3!+!kbPqOCB&0?j|t*L6`=~uQFk(Be*sf5GL;*tu*@k=p!>%eN%9iA@aH?iL3p2 zMsYtAc{!7~YBXWKAuzx09p}nITwRjHRS+rL)755BP+!_<7UF7w&dhXEQk!3-kIsi} z8Vjb6K6*(~^iTabFO0Y?X!6K`tc<6H7U>^8qSsS?;N2NwHQkh zsau8X1pb?ZpRVsoZbA-vC0-~n|DaKh_c_HT%zKFC-3Hf-xiK0gh!rPgd*D=Kwz&ec zTT-@7Cd_oocH0TF9VCb~^)yR6&qS<)z}sog9DK5LAZZYE4hy#c3D!k zRui#9rM&q1CuRF_t})xzGm$NAbucdFS}<5vJEQ)l=4OKnD2K5Cks2ivY^az2=R_#^ zL?y8OL?|~B%G490JWD9WKrz~0v~T;BVJpz74@>W%S@-S#HmChpinQBHc-pn_#j+Ar z{{dSu<~u7z+G8T^1M#%`lhR(8B5hy6^SF50!AXlh$4+Tq-hjxrM?CEzTG%tx(+^Ul z{ijI#Nq0@&q2SqQEnCll`geT{l7=bX^b{nYgYS*hzlcbJB}u(tn>p>k6lrf3X-8{m zrvA{f)Fb$%92u!|<;-a_A8$jz!RC3&4FYQCHXQ;go0gc(c$qP$PLA4@c zmgahvqq=>onT|IFoodh_72VKHs3VPEHYZzs{hqM6>HYz^4 zFI@1=Jfz1pDsiqnNZX$Ft3W{wZ8mGER|@p8gw7T~4U+8Z&8ah;pOZwbMMRs2L^i?x z*AU&P_Q#Pz-)rrFLyZJoL70i+R~ zQ(|gLP|norG*vL=ufO^p?)GFv!H&_=|bwmlG!G zOC6d#9MDmI<3f&qI^nYpMn?Z`;zYMn+f4{}xRXYIGtA5&Rz#*6_9Lp0G1x)P(^pBs zmh%w2At`t*1usXii5J~+>!MRR@3#^!i5dmlIJu{>ysj0PC4_0PyYG7#F$W3E9)w9c zcGZ!+sdqM?=mVC|;6I`w-<2geQAZ{Z2z8vlEbw2|@Z*i#G!s7ofw_<{4V(`(VO}LL zuOUnw=WpSRnbbP$CsLiB#L13qqh^l6JETtggsXuJms(0J-4bo?q>5|<3aMcS49{2~ zOH9OGB4P#R3KXe@Q%7w`3ceWr3H8OK;Jp~KtB)YqB%aP(-MK)CVJ>b$(YZ^ifkI5@ z5z}06X((}6(RS>>)z|v%unqNTXdpGQ!GhR!)OaJYKY*Az{)CDDEXv|9Nr@|vSnr3c z5LP;aFnOyecwSeD?B0k)~Ea3lkGiqxM74a1q z0i-6j5ZY2N+o4AhF1Rkq>2#%f{CuQ46C+Jy19Qbd1lO!L2k#;?xjiX(2d1~`zn@AgTwQM&<2BkEmXpM0G9D+T(Q(d|_k&UqO4M0}PRg>JuiaEkrd!qa=d{ ze1a+)b!Jht!Ez?1$n=pW%@*NILbuGF8W4=Gi?Mu_0(Cvz&{uSyF z2_Hf0W8~urq|lq>yHwk*hMgGEd?^So5riKk!UmO;nh0M{gj+C9FcLl~1>x}|;53>e z8K{2KxqW@uVbUaEMiL+IAcbDQPl#~FDiAjGA%9FkI1_}`oy4{Q{RT!gc?;tLP$xcc zIJ`+8=OKlD1MN70Igv2Q7~|ijIZT)yA=?1LG;r~GCnL?{q~igr&CD(bT6z4yd$f9=?+qN@+hGjsK1Z`y+JU(3d2ZN2i3JnUrpSBwD`v4MOt4mG!GLIVQfif zAzpo&>a)Rq3xH@)pz?7f2Vt4`Do-tkKiUu(`6;t~*|I^Mw49?c8}B$;kV0Q_QOrWr z8LSNeZ3z&4Z=d7fQiq!%5 zsa)D|U4gU{$M6u`T95OC0NOkKek9(zg>lXvAP9IGun%x`1Md0;1120_lFh zPQc)gAT!`=K=wAs19%E>7|?$^?pz1F15g2f`nW(keMf;b5l{p8A3%ps3Zx-`n*iN+ zLU(|zfJ1=nPZ0;01b7SZ5#Uom3^437+<^x83DEO%$OdQtob*M3sCS>EceWB1^Wc=?@gaUqUv(EiwJ4~}4*K?jcwbSq!E*qPky)>!JD zaAN5t-*1W0qwcSHI?!*Uvh# zOT86o>E8S1*y@#g?mAK*j~GkzW4P?%BYZCJR@VRQee#=ex@J{d)vR6R0~%d8SDL02j=25XAkPoQrH8oF=vPD zqRbJp7$GiYy*oI?L7};kTVKUx0`<_~($BL{zdIF50l<%dJed8w&V|w=0Q#l+O6T|G zOuU@#b%3t#r~40ZITorYU6h6U9gJ5YTnW36WRK~}u4Eolj*53>$>C#U;LR3Sd^G6#|vxL|~K>zZMHr z^NDnB>utiTr ztc}=61X>IzR?b4GQ{iW=66NpCtY<8MtH_y*3%TYJ%35$@$EQ?rPEN;D)e0uC)BuyaK2<*MB;(1Z92q za4T-3-axHhE)Fpx=9aXPisag9utOYxvdc5f6GwOcF$w)zfj$`MAYJ0qNKg1n67IPI z*THceaok945^kEn{SQfiOolzA0vEL5gyXrme$N%&*Vn6TbuXTP27;eA?WTT!%%67E z23l=6lG77d=|K~{rf6*L%ua*QAR#@j3$uF~>HNv860hRQ!A-%ackzh$d6x0}PIP@( zuJQ>k&#O>&;now^dnj{>j)@(JE45wkW9AKOF20nUu9xHHOGz3c6-!bsi$tBG$cHF$ zD2p6Mkvt`;3q^iNk$qU?#S}S2l51Z?RGIPvVteGGT1LbB(*s}iRX&PsrwK|3u@%b3 z3S}iV1RE&Ow*ck^-ECai(Ba7X*c!xzcjHo>F*xg3b$V=Dj@K_9VfVmtaAu6B-|8^# z@CcS~a|FKZ+ic&)I8in1d`I|4Z2r5nCd76>6T^B4pG*O9lz}S)L*5K(-QjVhR5GiAEyw# z{~zc>`2;l-)&V2&z&yw@BH2(983qnIf|hQt$&X${E^9E^&F1a?w#-eDLA z8B0f3bE)G?QpbSWHMo@xZ(rf9B2;RRUSHJ0T}v}O(b7;l zVKr#JseNF_=1ZvTYmt;H`&!o4taZ>OGs74mYGy_!H#3X?l2h~19s#s3XxykFLchuG zNMo2tL4!h^x(w@C8*gjYineC0o!Xk;Xg@z0?B`Q@Bm4Q7B>X>FpU{c~+WOA6;d*&j zU|w#&Irc&I)QMmykmf;0jZQ?tg*m$BAl|6Q8*@>%qVmfH0vp~5TbZsmN zjxr!gwR=~nfgLV})-9rKZDD<93rUA4!81ehPOAqyh-tRBh@P&+ZcWC6H-+J8t+ozX zYYS)?uJOO8JL5l+4H4LBn&GzY|Bv|ReEmHCT+Uy}e_Gct^_zy4PM303E?O&PEoLEM zHJw@co^&=p#Sk&v)`R9CfnyiWaSqzTrVzv6mqL|~*YW%`_->aE^LUl9+GGQGzi_g! zK&#n_v8B2CvxzL-E?j&ORv+h#@MRUgh91n9h6DGb#k^fW>UiUEf{H9gmyo)#un5F_ zqv_E8v+1;ccusV&f+`#eI`acRi@DC)GtFQkRqb#cQ(_O8+1?WXyN(j*Au232P0 zUfe}UJ@+P5>1O*Ts^I$CnwT%6OrmyWZCK4f!31_^pv{p<7lAJ`$_DK$rtKzk2KX*4 ze1bI6F%answY2u}-%JfsS8^RRMsed8jW=ji7R@Vu7b$!h#nT}@E{puSS6dGug{oOnmzQdsx(lrtm4xYCz6Zy#{{5H-rbqBY}fLvX@c z>L~OLL{i&eif_hL3OfcQNKlI(y1bbhlQGN#L{zsh9+7H`=zg}?aXVW176)Tn;}-_G z>pt8E@k=|v-^4GraQ?Ua!rz*M8q{ph>j4|ZfTmA*$exGhtxtHLJ+Q~t?9Q{(E!p^W zJGht~_3+1L`(|KCP43NhOVGX9;l)jH{w=)ACtU&! z$a<`1U}19umb>UWw$wOOI2sPFa08jmjGWdGX-$bIILgsXSA|MVrFJWv!8uewo?zUy z3(?_4-=Z7}f8AYa3xAi5hJ!{hIC?&OygM7j&>#+dKw=z+8a&s9wxgGB97kciDXB+h z7~G(VFBqe^9L0O6@#$RrC^aopi|0_&a*xn-D!n4y*_-RR`$_yarw{+_Lw?p;Tv)#u zztk!lZ(HU%(Y5z5QM21q-$c+Yf2q5auZZ=G;(5e#emq&cIlu*lxD*|Ilray@^(wp} z$>gW&y0thlwE+UTX;llCNV@{NWjLGda^EV1!pm^fF)I!0m(dP&B)>N_#$KjuEic+M zYanBb0^$ys#nw{A{)j8qXyS`ljlM}O%s^VN^7WUOCGHtqOkIs$Q_aBUmdKEpFiA+b zLf2uW!V6?t6M1P$bVFw97g!c#i?GAoDY^y@gC8^*G?l;zNTtyy8)4|iLHapFpLXUD zeK5eFeypCT^O3b^v$)rqw=9N6uq=2D+Qpx130dQrg!D5*DdYHw4Vw04V*~}Kz7vA- z!|G{@bc_wNJ<8F*vD4;sVMC}9Sez-LF;v$m_XQ|bG$m)j#z7S8D`+I8n?x)gNyEWr z`$pdGY_wb4LH9mWxU*nr#m9O2^v)|&D z&_-dprL_uj`{~+NGHT{;I@w45Uaf;Xp+lG2ep&_4$guRM%o%&Q!QwBc!Caoc#!f}^ z#5_u#%_>?WPjW{YXOpV0a7i*Y!BCt(JG)Yqs2Av|=VDcvQ8$o2A^S-hVEiZO_tw*& zfwt{;rhk&2{^H+@e!|~*p`JcXuzwf+6ZD7b>0kN#)4xbhf5z`me~6xb$?ru!;SbK% z({F`M|IYfiGWwdoeBf`TzHS{=dh*h?Im3Ib<$N6A;#(TLm?W3m)_A6^#U1Z7UG@gO z7|^o$GH#b<%V#V-uBXC9KKk@tn(_2UjXofVVEHjq^I#+siTAD=KbhgSOh&JSPlYOM z^|+9ERL~vf9dv24Jxl|S(k6G9^P!R8@}!5`(tk_(Ug5T0<)K98@Y8r6`z6`y^!eYV zR~l-!_y_Q&Sa^ys6=ba>CWCyiwHc!lnhjEu*@$ghE<1Jw`p<;Y;dZKb9j|vIiO>*J z5U|4ur$!^D1QvlMCWvA#&$CI)2{A*|+IhWxs4zdc`#aT?$QB_BaP@B5tZ1a5J`q3Z{8n*)|z4rJDj_ekFv!RLG!mE{{{s zPw0Lk=y?o6{XA1VeW!3+r{7W^I)~djhxgd@T>QfNNc+_=4_NhMe%j`@yIEHK*u|bl zFE_lyUa%uA(B_=kaZvrL);VlL8ZpdwWF=e|%+5wl%c?Q@EVLw=ZPG6;7N#zJPX@LF zPHozP8D(%d$@p*2ljL7k!(w5RVBmX5K@|>vTFa52ANQcoI;#7=!BT3Z1V0+^U;!O(B z6l5fXFaE?Bky(V6rV(SsmxdNfKLD~XDwNI#+zV(1bVA`50yG=p^`S$!t;2s;AFA7e zV1kWDX_sUtdwnam%GYBZGtBBO&401=#+R2vTZVI8v`x4TvtL(rYb$(3@}h-MdAZ`9 zQGs1H!``7<|MpQt#Io;yxrc?_hFcy=d-FTm^}8DPqPyhf4)_lzR|dO#Vhz=8U4T1t zpC>qc24b@As;pfj*O1A1ZaX-ce0SIrw%HRZ%mx8@x%+HuFe5O3swCIY)+Ud#=m7F7 zLuLEX={_5N$kpE4ww!}HDXlu@EI&JM)v+#~+{&TlXWM7@5dNiDSP6S<4VCVp?lSwF zgMvhP=s}{i*ptsThcdE^W&wzmoW-b>6SYx9tzdTFN^O6J!=9S?&IA<@Gv{id)wN{@${}3HmYJTQMhVB{sd{xfdm2f;*v?;+ZrY#;u^`H zDITwtd|g2k#XhOY?HF%CPRC0okt=E-H6QSJ4PpK$&F@s*HWOu%DBm}mjOAM%%0Bb# zW28f`vbH?b>7{|kq@i7WGWfzM$>}Xxv)};C5ndozg;#Mmn0i2FAD462suvrU4l&zM z@5fM7t_eV=E;xdH_qeK6>fU`m`1dTnJJ=^2kpuXS)q@X2u$K=bzil2|C>vr!SQd0L zc;cbr!vGQu-n7Z814mwzV=Gjs)3>WyrFZUvfRRV;wM*Fe)f$t_RtGaZ%EnlBhZlQT zOi3Hpl`u1=TEq4iA1&G>2TlS3k^|exJhq+kGWU+|!z^+wedniKvjcmEv;Q!yi-jt| z5U;Yv6FPr;{gzm0cnpjDH6soz$+vhyX*Y~MCY9UjBj3zB9IHO|2go|Bqg$!@>wz2d zEm0d2Wf5(Jp~4vwm`f)7H)g_rrY-nYbEhNbVX{Fu;HJ`UWgmP@UhT$(dJzzYS>@W{j5gbP12Q{uC3wJ=vb>W5BNR*}O+SM)bNC*@Asj?D@CfSO5GZoM6 zeL@xAvNoaOv3MpGKQ+fF+of?94TW!#OOuy*&;7n5JpW&>)uPYlvKq!;G$BhEAogrBt**qY+Fm*Rf z*N6QpXrg2^QIEhreCgCg`SHcsJbU0fxJy|jYATtIwuC*x)NTH&@j^1Nik(yxh=7^3 zCnT@VT2xXMDG%Dip(`xq3KkVwB6LxbXWBxVfFOjfC~j%856q9T5D|d@DRM>v5$|Uv zAqee52x3bVgv}4PV3InS1*3`5jNYU_ta9--zPKw|7j^sIKi=5@!Ogtg?v6rE-XSv@;x%cL|(~3n)t6iuE}EKnVYopjh)fbu^*u{z#@C$B>wpZWy6dx^nGuJb}@Q z;ZC8`0YtWGCNEJ$LQ5@?N}^2P)Wouf6J=JSa?M#FsHAm4+7#tSmNXGWs^{lCfz)!X zhiCWK(VAXXOhR^7n6f)^BreE@&x%rfAAW98e4*^gEIqyyFjNOMtyfox3%Cop#WSVP zN+9EFqqIy%Ql@+EGRk;=BGV~are1xfcd_(InJ&#irt|VF{yVGZvC{WfBC|Kkwah-b z8kzZdX1wHavYb{$5UY55Y&X1@q}EJd$gKxD&@N3PFwRWfyi{zR1 z0ChP`GPGIeqRnCffv`2m9z4_5G}+I^ox8~V)RBeKOC#`|xEtS@mK91RcvkV7=_!KKw;W#r(nqbX%U!IOM=w<#I{)0awxBir#M6wk zeefB1=uh%e4AqsR9_5D-^0E~J2fme$&v0uNzIsQ##T(w6Tb|kKRhsED(5d}nm!M&? zZK_=Ai8WOXJ5TZ-@k~=lD;`^mTWN~?(7mgqumIZz&$MumJvP~MuHCXPDLfS!`o;*|2CE*yku-WbJz!M45|0y!H$lQPZRC(ZYhOqVeq73ug@c)d8)CaLXR=+69)gV;L+20Zw6Vsvd z|5cAs?>szwJ+X@=Is*@z>ER|ktfPm?czA;zCgS1Q9(X9nL-u^9B|01rPg2xHco;w- z=i=dB3c=U2=htQ-q%R(3P)H9v^rMhYcvwau_CbfKd{K^Ij+!%SQ%!OBWYGyVOtq_>Nex}{{(XzY7g3<9k_$OcIGy*rlKF@+6mMa zVyDAYR2T_-s|(RXC?j*qL;W8bc1(f|hq9MUpw_vC7-Q32V$4pA{hWd7ZE6;p9Q6S@ zd=Q-tSsPj39S2Y`S&iw6?S7~(PI=KQFi)x;Z)(*;Po)?M)R%$5+ucE+=TXwW7~h4v znnWcH+IwN(w;rLDL3b~^yezE|&x_r?(zSY&p?-tiMFJh}oira1;NY?MQqu0iBa%5l z;#NT-OH0?;Q2#zK(kKBoj0a>aN?H+7aS@U884*_&*eJl`VpnI4nrxtU7pS2rn1UZA z?bC6f#haW;5@%W3I)p$3e7fGq(+}DbsK*778}&pYeZIrVLab{zjMMUzw8xU@EJjFl zS;7z}acZ%8)r)jWT3ZKnP&{Xz@qPp#W4p$6nm$AIU1X!v<8z=c^!N-Og&zNcM=FXG zdYqG>0qIt?I@4}P0;rNnvZ|FxI@509q+L!Wt&&K)a-iI)jIs;g*{5BB$HlHwpb?GJ zzIsk0mTze^8Kn`6L9sg#q7H{2QYXfGgb6X$;!%jvh)1Is>YXgz&otEB#CuYw5NOSm z7j1%~$;4YV6K5^B`aXim*s1uab}U6%s&9%wsx=fiAAw5RNAJlNF}Gk{kFb$?1e1+u z3b3hZ;7?zHhOy*-0vMIxX4^T737Lc;7&DY0wT_G-z=1sWB5{#BymZ?^$ecaShVb259HR|-??iAQ0IPCOb-Q7?wtA6e;Wuz8}^GChO2 z8gH4Nz*A+AwM-A=F=flN9meN*yJLszeK+29cL%{WH@{$3d~D)SAB*GNapT<`qTAYO zWb|Be74;45%J5C}&<6;`>^~fkc})I!_&gc0x!& zMRnZ`H{9ayK)kZn1jVE?d550Mh#DcUL)u?3qa1fvurylB~man|9{i}w%4 zmTfnkO(jjS#=A+8!F+@m8ec=IKk8~VI=C!wgN}_2RGfH@ zo}^g^A~ST6nRq7cJ2gdi)sxjJFLEmQ7k$Fd^hZzu5=IVuO=CaIM#}jS9@pgEOkOiO zd5O+wS?U{ID9s1F2G|QY3K&*iDCJiaN@@YlEkKfDb7jOq)4xkDU1Uw9Q0`MH* zWxz7P2Y}Up&45n;Ujlw>`oUuhr9Xm?16LGE&*S%Xz<$8FmlaC)0Tu!_03rZs4AxTt zSB=A&NcgP)-jDblI-aMW4O;&Kohtl33iuE}xOV{N0$v5Y1GpXdivTTvUK0u>7oY-g z&BQ|K1;BfN+b%DZ-Uplkde;K(2GD#phnBx`U2N5irmAewtoSt4X?f8xv~qGyDgFoQ z-zcU-Ddj~Is4)*^U-u90P<7nQ9I7jBiaS*8Ho5j3AaUOmwf(NZ++2q;K1W{I6K@sD z7<`q~P*2oq(kWVAUW#MF!m6!kwH){la>KDI_>?un^)}U*l?}HX*<1tXTFnkbxrdC- zlWRBPiRdWf^I1ZWxPKFHiNG6-!2PT73L1&j^f6XoJ~=-g!V}K5Iqtzw%Zd4L)qFb^ zP3E)soW64HT|E9GE6_%1yDQi@+1 zk3R;L$Gv#pQkxnoE+UlM<0v2NQD_%6P*xMls5r`7dX(om%3FkTMjYi~JxVP{xs_1t zag;j|3YRH#aU+kvn&SVB)8Dx+E{n&P@%XM3zcLGZeRn+mU-9_A^Z3&!J}(~sU_73+{h{J5 zMBg5dzZ3DWU#maggKQ-Ksc=xkMCb%E1mwfFTfyme-qYEluEWHSBhZ1c0-=B-1c~sA zgfNdP27Tv5?nb#b3r|!r`r!jjc_AGgBPs?R1R>Y#M}V_kY4icya!UNM&8$y_n6 z1VO48e_;gfA47JiuNe0uym~%!NBZIWDE_((EVp9fSG*fzT6s}Eib$^c68sid5pRp8 z<58}m6}`eiEN&GZ1Cgucn&&9&8~pPP542kS1BSTl{?p;2C0D2aWac>TDTL0S-AN~~ ze;9Z0me3lxhc*0@8=*3*e=q#9+5X)u?M~K`%>Ga$tf!2cm9h9lDA9toI{2@kp5yHm|MR>XhNBxHzg5u=boA8AAr@uide~oz|aU|D{fy%c)#*5DpyVdNy%81GyI7f>zR3RCo@w z=<7h|i`8xb3JD?Cu4GTN>iZ5Q1K+UDe{l+PF9wCP<9t7kP%hVl?1@%dYB}cQtupMN zV}ksham*Xzn3M1X?=HztY2ZgjMkDAkRNR-6ufpsutt*zpirY{y@*-L=K~Hhv)4ZqX za|`P!BIq#0(i>HXG$5ghfs_a$se!LVse-FC@&(Q8Q6#J5 zsDt9DXC_cj;i#jl;A?$~qoVX292NAB!+W17y#shNDB}x?Hk96agrv~K>xkm5;q!t{ zd&7h!j6gf`Bb*!Gt#}f~H-#QU#d)NZ&(Q|*g7h*}GQLajBnomc9u2(zf9$;re3Zr2 zKfar6NJ0Y727&}35FlW<1QAez1kICdaDy8`q+U@`XvB&ZVOKyA5_Tgj4_nb%Z?$Tz zZPm7~Xq8(Pvk4HwJx~iut$-JHS*>^j0?Pis=gd6M?k1anm-^QC|Kr2S%sz8w=FFKh zGiPSb%=E>F78ThMA6p^+bF?5qeh@xUeJ!<|Z3v53eXruXApcMBN%Eg2uWyV?1^K-U z@|Q9ykzWa4g!{AbE2acDQE&|R$Ky*Y!T9A8=?--RGS{%tayc;t`g1X_|m z65j>+`S3~d`;gZ+X3xbS|F`JE1^MZWO5`WNCxwTe8;GI(Lwsl zOe!Av%Q=CTrFRd>7=u2%jYXS@QbEi~{+g{-7NcKfrj@nJpH0)S1l} zcyGQ3YY#H@lsk27XlK{HRC?J^^!ZTm?7q9qF5HWGnK|60ubVeUUD&+|b#nN|VrK$| zF`ELnHf3Nf=!mkiqg^}YX>j(3i6zBv%5iq8yg1d_L0LK8Y!BCa8eE}J>c(W;=Ufka zRAc|AOze8X;;<|c_m^V-2MMZT=QD8|8(6CP_NTv?j5aDSHaTaP3EK|(kg5vX4p?;R zwjGS8tW5UQILib*g}JWY%DPL4lESd7o!woZ5bEoj0LHV)&-Ht-Zq?bQtb@IGm*=`= zzzA%6;L*#E!jgvL;3DPM$tnR#8=pIdv1dei`zzKJZ@CupQotVp^?*Zw_SeB?7%%}a z8}LiOUje%Tp94Bi&NmGQTmhI3_~?4flRN##|CtjKEuE6ub?TIy(y3Ew`%Y=;9Xcx3 z|9G~PLB{fT@V0c1DfyFTNZrmoZSP5%J=>Zkdp%PS;L(!bw- z<}*w#p>@2(^mI$>p{;}@;d?s@OO7C>FyhMCDn3>_7qcjrT6JPEO$A5601_tTS8h3pzH$@n#~oWwV#-`Q%IZ|Yepvp( zg4{p<(=x3F3(GLPuPG-Ja{4LH!%F)?{gRH@l`*p3(1P}QyqZHJN{1VNNfsTa?7jzj z6%R1u=+!GJHKPWYu`jLG6b`_B;2&CTX-8CTW52M1RRLkYQD0ejVbuOUZSL0x&i_0^ zx8K+iv$>DR{y;i*2(SmCcxe7kn-Q1sMgc9ZV%?Oi9<~KOFTxM8S}gaqwpHK&2NvUj zqOaA)EP4lO5GCjmiRf_xTh0Zgkp*)Y+wkHo5`nb`FXzhjUfgHTRv&@K5FNo&nMCdsELIQy80OOs?I7%^#$3c5I<0alo}XeNFR2{O)P4LKWpST@$j{g1#rwrN zM9t&84zUc5Sch0h3khEjfOuYo8$r#k>`_KjKZi<0L^Luc5m66cYeYOH)BPQA+za!7{g_DYA2gG= z%Sg@5;aO(aFyfbMaQyW00^>P7CsoEYN@0YNf{GMGwTz^+;_*5wV3p)#a&|;cd-#yp zIh5F;{(9lQ;ACN1IxIdRS%HlXVwkfN6^do!)iFrn_eKgYBL(-uEadPUr$zjKlD@?w zEH5yJlT$qR00rdCrNpi_68kA9LA<^WzSc+@F4GuE*)Xr^?Rlhjq7bRIH&W}$;Y3;o z_#oo&CBhd!-GacrONDH_ixiOBYn0k+{d86};HxO;8zOuf(f))H{ygUkR$d%G{j9(} zoW8RcYCgf$%?{ENUEphh;A=lhuG~oOT0Oao;&L)8kl!LTv|uB(7m4_Au1F#vj7EY}j0A5#U4lg| z5;Vmo_#!2!7zy?`U4oyKae1RCG{+`5gc4lWS7+cBPP&aEKiML|MX?Efd?6CN-AM56 z(SR7jbep(*hZGoyW-yYNY_bj-)o7 zQmZsl^TkOGd~Gwe@fGV>UjJ#f0rrnSiIbc`Mr$!t{tGV5w&mMb$;s?Ub6mC}7)N~OaC zU>uFMIzNVwY8V1~kUx^B?u9RI3I&0eWD2iRJYRM(5%D0Nl@S`lQ}`;is{)pu{z7_) zIfq69^%kIVc08cIPoE~yCtvn+tIlbn`40tUnVfZ|bgsk0?wPY9XHbfLd7P z-)rLH2bRgSms12*4)22x9M$nzIn?p<0+S{F6vn3-xUvoWg1}&jKa}xppuInQpxvIV zRCgz@FMB%iQ! zj+&lxmxanmO6Q9uf^mOkG*Wt=7igpI02Y;uR9>&d@-Y_oe=V>I0#hZ{EsRA4xgI{l z=*}}3vnco66qKrzV*9eMy#S@^gHj23JD1~8P4|PZjT$*oEQmhEQHkg;;EOBcd4X*b zxsj1cQ?7>(>@5HxuaVc69Xua|Jk~=ewec4$=h}9q@n^B37&hW)+MO23&Rj}g|jz?5{0AK3@`ZtOH2ICVUufit@ zd4asX>_3hGA&a}~9C?UQiIAo6wMNLzGT{owCPF4tYTC9KVJehZMT|w+UqD!*LI#o7 zmmL_6>{E>FyD%zcp9WuR*}qpL_;85hQTFe^*E%2mD)Cn_J`wU4_#`3Ekk^+zhX`4S zTLy%PE@M<8WD$I=5pu0e_y)!%LMBma&G;}vVihnJWj}( zeIkW7Z_EcT77X~1BT&Bogs*i5ye#ooGCoo8XZR!qza_6P`(a|h0$ej97@#pKQBXzU z%_*27Q=Gh|Rm%P60HRmCFvypvAMy2d66y7}h_r^&1=LnSjJMguV{Yr_v zmXRs@74XUI>1}poKaR3rgo|th^Y3R=%Dx)D)`b6hnea`FO;lV3AE;<$xXhRM=P^DJ zat?fwkRIgqWmgRaAx*e6M-bAEQHhYRKwN8t{Jl`HV=otg2-yxFxE9kJ{g1?YnXxGQ z=Lkzw!*9sz%RZa3zuU-uF{4uU_rlj&_CJvcU&Gjx{do9V=R-eEA<=b}8%;C66`70UA>N2l`qp2C|qFOSS+ z38PUd76`N$dAdPj-ON}-`_(P53IYWZtB|pX;$eg(biQ-Q>&t$22&l6N>VS~JsG0C3 z3)CzH^3TD!`1l!oh@Xd#hsf*89(oSqug9&_C|wfP{}`1@R}Wtswe`d(!Of>R0+sV& z_*$>684`ac<5P(%+Q2Ue6iWOe#dJ2CDxsc zMa93R1y(`e5{Y#wV^N{i7FhN`Z;90pVMb{jy+u)-aH*(t(YO(Kt_)n|)r%TL@lezY z2BWAOGxVbF=0a0Z8{liB_MaRn3jGX6ph7X8zU$r0@MDO_R)Y%C&yIWq9MB|1CaMljg% z?m)0(l~rfQdS(o>)%4j2LGe+JKooxjAJAf|X{*HA$yh|^#uiuwfj>yB7Z{7Edz!FBkNhk0 z`mzrW0ClrE>O!=TQHeSid~I-coJ{*NjzDzU;A@?;XG{E^j87D2wtwDg!4~>w$)WCo0}7&0Q~O49mbmKnqRTb7_Ws#|1zX`_yBz!856Wa7Mr4CiuS>KK;1Z|iMF&1D1M}QEr>;dX zICXA+aB3tSRbgeshOdHC7gBh0S?MM-&So^?PiKJ^BP*W|6{V!RC&aGU$MD5A|AN3a ziPgwh#EW|Pj8gx*n<(`^;Oeq+H=+nxSuP_#L{W5E`J0UL9$ezUoan$OWnlkBItQ*s zFgQ@!4;(n34y*8XY%#tH4iv!GhOBguBxG;|;zcridR=a#y2RdeWcl$O9OELY4scc^ zD|_J6F3B5p2{x#=zzo6U-o&F z@c<*^3mBI&9t>X_TrkVTlQ;sAa1x2M&V|N&!G$+DDH;TIa$RiNAyKX==LxJ`C-&0=$;IzU=XRK+7ZTbS6B@s6@--6y97E z=E)TAWi+B-wm^$v!W9zhD#oIG%Lz;5TTEW;qx43;y+poH)&?^w<=Y3oHh6Gskl?{d zj!G1K3Sa9ysF(O#7@sP{-v)j`;1P-cYsM#a=mGeoI&>d-ec7QL&^|SZc?Q~NGAhwt zLE+7LRw`30V>F`pVu2RJvtAObFJlp%-CAH_{2wSv|21b$)O`-0-8a4{@IUkQes@2A z%D$ecd>wr^x;h|k##dZULuO;NkEIa*pF${3zG3}WL`k5JOGOk|&OCyzyoWlOH&2@z z8QIUr@tDbs4NI5;shPdae_>|ANaO!v#pgoSHS!QkPpWA0NI-_@S9bx+38a45sZ=UH~!eU99m zzynwSa?pvE#KIhBFZ&vLs00&fQ(^9$c6Q}={#j|^4Y;g2+f+gh^G zGSU?Ivggq-rJaiNBjGOL@n@NF6R@Qh-SjonfeRhy!kTVAlC>13x_V$6`c8jG95vY* zcpdS=8!9S{`^mKplu2e*<%wKZp|Z}AZNi0VO<`A#vThRj5x$wOP=k?5zjAFot?pfe zC9Y7G?{b`J;om{fP3D?g11}==%K6v~bv?Jj97-5gW7izHQ|!aH27a{yr+2E>SE6|8 zWL!RRT^-Km{B&l%DgDlT(*uBa0e8&GH+>DbbT-au0M-Dq=H#0S0Cn^7O*3F$YC6+H z7175VTJ@&!020{F?oeA6Dlm6iFX zHvyBXaJ~jGc~QP;A7GjrcU=Jf>cM%EYLp4^?0xyB`xob%o?L?aGQ3E0DR2OvY5Arv zmgSpz{vzL$b3g9R0Q6suxPZYApxl6A58`eKzy-eqKH$-Za2EyO(O=;{3&1-t5uW-; zzUg0pYaYct769hY(4pppp+kozT4b^K&`m}se3JhE&liQiMV(JA zMe`*+^d!zz(4jYN25y+IucH$VzMtTjS0>(|OnUg&bn0R!pHHi+EIgZS;lE6`LEtS7@x3~QL0J&97PlEtuad*^!;^~0DRsJx}kXJRWBWf2PA_d>qWy6hvyh+b9 z>!v&xVcig!+%V~OYUbW0f8Q8)4NuF?<3uT(tTUH z2c@g0^RoP{)1{|3PJY+Z?bKbc|7__Vmf;D|cc~gSL+>MZmvkSO?laQ;nRI7K_d*%3 zSi0?{+ex}_OT2^9eL=b}OZRSxw@A9 zbeXH}I^=KN9V~w@$E>Fg%>=iKRyF;GMUiH45XB3TIPRTqKj}{_ijz5$&2$HC(zz4~ z?nvo|v&8RY`MX}aJEZ%Fbf1#$Ez@0ac)(!Ei- zw@6n{XQcccmTt0a3OnTQJ<@$jx_^}J&!sy@x);lMmq=HUZdd8PEAb9V_eJThlI}u@ zH#LJrG6VZA%3^U}4qb|bo(mTwS2aD!;*yUq5SO&;gt&b1XBL+)AT@fYpG(O=TujZ} zCzo4-2&#=14bBx_UatW&9fXeUo&T zOZQRfPLb|(=?;}{fpkrsMfp>tyHkGOE8VB1`)2^&?U#=S9ajNv z1l$7nIbaUplHcZ=#sjVb+z7Y@@N>W%z(T-c!2N(n08at_2zU{&3h)M?99!YfHwg3fE|E6fOi3h0G|Mk z0m6V}q^$tD0(t??0h|jM3Ah*#sq4Zv{)ri;oQieMq{$aeydv|ibJ~dfU4!xl3>*}l z#^C%R=MFt@*zghOUof&@)Psocoz8sIswiG^Z^V63z%0PsfJK0%fCmAO z1D*lA0C*X&77(fb*6Mi7fB0X|G5X~F9IEN&wOd%RJoWearVKzgKySbRz|M0)It7ptbG3zDz`(tHzA}6uNrrG>ibauYqr&uPz+4*s_{(y^g zcs)VsRfPL(uzrB+6mgdReqJu1v-CS?31QgFSVDM8EFmlwL5RB1Qh)_aTF`)Qbje@n z2>lNJ9qg2L6i=Lli=)u=;b0=ia09<2^eN)Po&bj5!6JdQl{;aIhEq^$q~52 zc;m+c#cRQ(5J|7$S4FYcW~LVaUc!&!B{p+AEx}!rOf-&Nl5VQw`zOSsA+>_1_NkNn zIFz0|r^HS-V01Y=0h5(wiynQ^Pz<{$X54Hv2w^8o@brP_OY(GsXFqxHG;WuDx zf5Br^h^P;-o+Ii*RL1YI{@GS#EFX{T`v3+3MgYbD=o`UUfG#9BqHot4laBDU1^woX zz_RfRImJ29cxlOab}pV5#B;QET&~}6s%A+so>ktA^$^oW+h&Uyi$f{29#(aCih_?W zyN=A5h!GE2$7w6Us26~l-;wv&@HS@dlyW>Ls_oU9Hk!=t6BlExfsaj{f9H5Gz83eT zuiind$3rPt!&WW0WkIdlUrEa%+7`P%i1o4wW_m9c@9ZYRUdZo0V8xZ56z1JyAWfIM9pETbgBC z>)zkXppOYgwmC$-Uax)iY~Anm0Nup19RGV3WSXVn1$4U^*^+>ue$#4$ew;8uj?`MP zn`AfIM?-`?$gV+(SwnOKX~2clTfRMe?!h&S%pUi9RJTMRcGVA}{V=z{Cr}9zL2j@+ zsBA8QxFiDN(emxF=6KG3GL52eXVfwd-~vQRS-OzA1A>DGd*~dLPqGtjbZjgt2iXWB z?2}>-D)aBZAgVxk7v6vT0;Gci4D4%Kr$XC z1HSOEbyB>EjGQDM}*D};A^)X`DXcWT+cWv&27&^|lYv#ckLWv=| zMHiGTI@;(i$e_D{_>AE^I#z6V1wO|`ib@p1t&jN)7@RQ-pqp#nZtVV0virSWibq4Y zWn?NFh>BtPN!dO)iI^U7hJfn;hA(AnznkeIBW70!U-+(Ll5i_j!2NWxc z7F|U+JuT>vh#ddnWL@o`t7*A>Evh3ju7jho6h$h5J6Pg}pdl8G2p458)pLoV+$b+0 zita2j@HA&56A9wW@W3+kGxvcahZF;71<*q3s@|g=JnCp`(&|d&KwCm%W`ZvhI$I6; zTquJ5ilAuO({|#6dw)UI!BbexvqQO~pGD|sheN7adrWIYFFS%TtM;4dp47CRTK%Q* zdMl8ot76TEgI@Y@9aq_)4q+;GDny4+b)b?+V?Cvvd;iRs!JAqc3P3G7N`at*WSl#? zExlE6e}z=s?^!Ua$mSH?4H)9TB}ESC7?T`Ovqa}#PVc!x-I>B%@hdAE-TSlfW;0mI zsx5IJd~_d}QszG}oRIuYBZ*^WRR>HMx$J3;;5xM5vb08KSY3=%j2IC-imim! zNS7o%eH)569jrPH9_e|(BB>0FMxMZL*82%*$--+=)I=l701achhG>pZ8_bMQivdUp z+I4E<2#}DTmg=X$iq^@3NU|8$n@tC43F-7SvP@s4%XFK?VX+=8P~(a-HIvv8M;{n@MBzq&>5Koc!7rNP z%kDuIJz9T|qiQ5_wElpBP|r&r#aJWYVYlVn9h_*DW}Ql@QBYM0G9o$q4=bX&ELNtgVczk(`>?nnM2D7kBIh-IV7jl@pQ+S78NU2r;QbtL#K_^l0!xmaA+E{VvHe!M9tj6XN*^FONqq;tsh~M0k(vJh21i5Jr(<7!I=L!%1UQq~aB8_ zsrdJoOa)J8X!*h)FdCgcQ?Gij(u9e>n0fl&ON4?HJ71R+#Vj+*xh~c%uxK#?niy6q zhSO37rW>b80P`wn%W`*&h}eax2CaI6giK5ed-mH;yJ%^fkj`$JQ&t@~g{?OXZo6q# z-=Ni(VbRK}?$=JCQO!o)Vu$u4{B@wfUSJ#iu zx_~qu=Jw~<{l^E{@$CrKqJyb|WI7XN0)7gJ)+ki#431&JnJ9u$p+mbse+h&a0BxoQkss_U(y2aiAH|s2tu{Yap75 zj>y82v39UQk0gqyZ^aSi!SwfJ`-)mDkD7_lRvS`{)tGDanFwZx%n%kkDJIO6Gudi8 zSEtI@OEUJ6AlcYTqOGp#_l<^!4UjY5T$7!!Sgqf4G>acTDp(HuA33^TO71B~&&cTUZF38?z9IML@1EUf9%Yjq8i0g=VbA?hot$ ze}_Ht->iUr;Y+Yj1HAY$>}CFnGeLkmUx955pu?+p`xdYYaK}oVH3Ix{73`ZFnE>Ul!PW`zI3WLZoO1%)3)ly^V;$_{0N1{eZ#o4SPy-uCK#Cu4 z?gE~xMf!C(ueCnkl(+#lc7Qhk>PFb`078J<>tP=T7_ced^d~@m184{A0bH{gv;w+p zfxQEu|5n&qA^n|jtGB`CZadx-2J}PO??hhBVKK@~(EPjp`~QWXIe&Ef68S!a`V;j^ z^(wp)fjh4t!AVK~>LOl=@Z{#;i?R}Z+S}SgxzFLp>sakJIkZ=DpT-aO!34W|v(w>q z;@R$UhkDO5E-fF>tDEmkr;`>^LPH+zSfV*Ume(F}!L0!CQ}QY8Jc(!DV4QUGpwBS4*`$(fJ|q3_KW#LuUsT zs_xq4^#_}dH8>LADhvB7PgKs{Up@$_`5iF4P*z$2=vkGO_5>owHu_z~b3JVZ_z$Ge zP{+<@N1{J?3BD4tpq=PWX1YV^&Bz2zef=Pb(gSf^BqGl^zll`71ARCyYEwLGFkrN# z@pt$d%@y&!**D4$W2@baKNFZAs{3RIoOePcs(3+X*?omkwYWYvy)a#Qs3tTU8LZDu zDommu74#!?1Aj^^Or%d&l;O~+Kadm}$6tFF_NK36_(w)z2K^YyKT-=*=|^Aw(WNkx zew@WWk_s*KBb9#C1QK%1xR9m#RR~&{wwc%f%_yp>oN{QhMsS|v;{dJQf#bqc9E0jrnA2%BrP>C2 z;&HprhJ$o?v;{}^Y`GK2m#3^8sjU1t4&&9sG{J`UhmSdUMQNlBMuXD>H@%IA4|m!M z=I0jSaTZiVskTuxFle4BjEt4-7ERro5A=yQ^Gz511Lq9@Y4AUU@4p5751ba(~7{eaDYJ%INCp8`$+^s$9pX&>0~ zJ+Pr#5JzcIo0vSjt*rFtQiHEvfx3XHi$z)VXZVQpDHZi53wNH>)6PxsA4*9(4qs8C ze}9(#!<2U1t}PO$N%^#>y}H5KVfZd}wH-Ac=)0KSk~9t-J9~qb`xm+ciO=stCEo8_EJzVF=osLJw&_wdE5zmYatjEr>wkh~`L2ttB45oE>LxneG zcunvPe5PahGmDOHNN`i})PFcCY%zTI~MJxw;N2Tpu)H3Zav8I3xddcquIzKC3r9`(t zis=MudsoA7c&K_ql=Ua-*ZmO?Jh_!9akqH9Z8bqPg(U=DSAR}Uwv`P10YoOhhU7-#ro(;lRpGghxZixhuL*w z(`uSa!9dy7v9T#!gI;F-XRApi8Q!4us)TE@jeg5D!lo6cRM*T+R!7&&KPQx`Z94Xr zI(n0 zo%9mKm{LYXt)YVF1inT)#}8z3J~AmoCXJLyd(H%=)a|YI>V5QTZz~yis$?Q% zumYpX`k~j=;YtT~jV9g9-q!)XUkz4P|MH~C1~!8RRoe%{Yw(rS3}!Vk7tnYd^BPw0 ziaZ-#X?TLy?`}$-|FO1xc#UoJUe|DDYXh-$)BOHmtN++uaM;ydD^5oN&Ktdvxau!* zokJG_fU6C2v$bNu)tY&))9n*vD<7FgfxU=#$a@K@_+&?A@pf<)vTVX4=SUd!2yUe4=B?L7xlNbS*~4m_n!3}r<30qNWagliF*ETT-M-U$x)?c|3$ z0S+eQMHcEM70*HZl8H@H2d*$9IW%ZV)@qosni@~2f1@79rtPZmA55qiRBQM4$W>Nt zs&Lm@*4NHH_Lj1$7Oj`0s$hNXJ;xf#ZmTUo8Nz-v4^v99*I}}jg8Zz~(YsxJVH1zT z9V8=ONAbW@#S?LO0-w_GDX#(*2a%=tHdH%VglRo;?SnSet6Y?N)t*F@c*`91YIH%6 zILEi4(IElp=fqIdqy+A*&>51x@qeZMz_$Mz^~d%9|G)an`M*+sD9ATxf92X+{pdf*(ha?!+So+rzg!*Q5&G4UVKsFa&+koyOMOh9iucy*OHwMh=ZXxB z+(%(hWUXjubdShd5k`_yUvbP(B4b#oC6S85U8;?{RA8?#V^}eX^J4T$u@%}2UOt|2 zKNJ~lAL%hr5~0YD=E9>ssV_yQ=SVd?9g>-N$m;^5=JM=@$uSoNPVl#B{NzCzgGwp{#`(6|QoCnuY2G+(Jk4ySl z^ZI-Zv51tfol>Wj$`|RhQu*p3h|h}Rt{t1V1O+A?x3qen>uLHa*$`3gBlAm9e^d_|?q)h675p0?j#lt7 z1!z3ZY>3AML%-j9I$q>UUO>O^BYClFZdMd8q<$}INLTU?tG<%25%aFJ)enN}&`1?m z(rTKGkbY{Yo!@W*Af>=i&rdfW*!G{B4^Sh@5`s9#+pG~qW?51UjrEtf^MO*#+_hSs z@14QKptmtG=xT^&he&n29q@0qj9qCrGQ5VK!3!=y!hu0}o zu~d8rSs;+vtn%2rSEUH`lbfeA7s-GNkv3|4(QAkZ7%IBP#wN^%+UN~QJ-iC?Q967d zX_0xlT1q-3cc}*y$W2iaG)bB}QbWho&de$_d8{=58tZkKGoh%Nv#1+KJA-D1w#TZO zdJ2(!<7m=Tgb7Fu%?wR?bQ4D>?T(_GI6CH`5yg&TuQ10nMrx1Lg@a-u{%YjU`Y%zA zs7X+&nbPPIKn(`r`qT$5=S$r~CYCWXvdYm3aychr-s315h-_)bQ3|>#Ng`XHH^9{+ zTPd=&wa8Iq^L*BUeumjgRI|#j`Tc>8?)^A*jJfnqQjC4Y7AVE6GP70;MH#&+KCLgF zeaufftr+7_DHy~mC_APl1z`H|5Kl~)U`9*HGk6`1dlxiwI6ZS@! zfB}YB(1eH8*U%JV{lR(1-l`b1*?ov-33xdBpoI;dl0vBAt-}m<;>Kdh4ADPE zrK?XKB~Lhz^XmBKMB&&u9yJ7Nyi4fXf{83F`w&5vTl+3CuMI^cF zi+dldi56d)#XFFK(!_X`3EwH|gr5Re}AARTP7x~|y zeyqq-A8ll@V|WeiU(j0rX$&m}kFJ;d6#DXZL-g{tG_;Vr5yHmeBdpG2bt+{xZ1iaT zFUqLFJ3o4XHTVK3b5;NsPb2>o{?p*MSj)mPin`ir@IH3&kGew`4p}qFVjxt^Y3tn$ z(E*68^I}UH>%87V+E3@j8Ql;ARuA*7v?$!l&Jiyi6)7uWnZ;W$`qB%#vc6*M-DqVE zmUvhc!wMUW-jr2M4qwvC3uux2U6mG>LKa>Z_kRK|!Wiig+sag;G^W=@Rc?r`%5B14 zW>~3aPpRfDn}+%Q^er2|>ugmkO2?|{`J*?ul8)9Dxdzj+xW%(?ZeN68x2cA9nH-}V4~^=!(Hm^OOUzi%v^obxFD={T z(lV`;olH>{{SC+}>VwwFH-wfEDlH@P3OjA)W4SJA4OOVjidUh99SD{{tz^?@8b>Q) zlnC!dPDgZMUO-7=wU3ero(oGp@2$MqER78Y>&avNFizs$8CENnx2>6!4cnOzZPA7b zlrCiv+>KomS<9!fx4QiU-QLQ9ETinLs2IqoJ(q_JuPEF0oUOW1rGlNA8P;j?@9@@t zIRBXbs1f~9+HKSyy)8COaa9&J9qE!dGWj~FZ#w?){Sh}c-ZkN#35&O$U!VqTgZ3z% zY7#d0iFQi$Gvwnf6qZ0~f!AyY)bV+9xt@P(G zbFjyT0R`2jokW*}o(EmhQ!{A4)Pnv8^@mk&xm_B!58@5FA`|TPMnv~R#@4al)kF3} zBhe3G-y0nfc20TUJGLj%_m1gdns_}C2)p29V;CKheJZ-AWtAh^4KbA^ZsO|2g%hY6 zt4({8*G~46{{ks7(?ZYI;{DY>{X`&Dcxx&LBycVd9D+JoH&JjD0uCF_@%hrG5wb z6TO?!gXsI&9NZ2LZe9Guw|Ju4)r$pldgJGuu_bG+}hDVOKFg zZpYUYxq3?Zs+pS^ZC9b&CLkFLy7(iJo%o+{SHL^*m%~ea1+)S-#zgllOmSh3+{_dg zJcThGZMq3dS>AP%h34{JMFqydPG+S;VUfYMe`HI-+qSUBpiI|Bs8RqY^gpFucoo4Z<-XdJn ziX%Rd5R98J?-czAn}nNr>l1Q_P9G9w*OlTZIi#(47MiywO!&q>ydyYxC$Dz~>1;u2ELVr+H9P(g9uhYPz!b;Xj{UM9De!rdk)1+docM@6uN6Zg0*|Hd2 zTKs-x8190U{Yf)@LY>5iN8KOgkho2OxE=lJNt3cFSgswnXjwlrQnjr#d96f%Y4mZLzQW8-&U=h= z0)G9RK#@9nz0^0(hh-4X3GACYIARX8PK*Xcq;1%VqZ4S}Lq}V3_`KNUIw6*ON&2R{ zKS)%`K8s%GHmxtd{MfthFisLsgLL>hJoQ;)*gh5K^d71js*q077(Q64tuLin-FjTi z52FyAekt``X0{L7SzpXX&JaPn%{$IfU(6QHFlJa_DTVEWZO}%=a|6;X9kgEY`~)8U z(nt6F8w8Y&MvwzvxHXi(!*f`S;VR^4Js%FiRHz5371|fvpg40e%yi;bFxES*6DcvB zGK;;FJHf06?WzfBQ%X4CplW|7oj`~}aZ+H$R@R2r^NBHp>| z{S}TUAXAKVC^B-eLid_xwPH?_qmKTkYcPq~IkM$WlS3y6-N&j(L;`d5Y=eFoax)jO z-lC$lsc3C%nUxz;+947ZXCY;11T&T|7Kw>g7-e2BTjBcP2ROg6{A7nAraJ-00XKIX zVxr&V>QD~94)kqO6wrY5E!US4TiCz4xlaD$_OIU?y>!l3^x*$d(~%#pzpKSXF=t$# zt=Q9$E!hvil&Jl3<`3zec|6P0ZMn*Q=+>c^u)P+hZkVyddW)v&Y`lf80#jn$vd{}rM^pDat&;gcF}>n;)!LxvLtjLlf=o7M4a$YPnk-6 zSJ2>Yk`{(3(yDDz3Pzt@PAkR3-2g^3#E3HVJwy3yh5xtz;Qaq?^gjGU(3|r8*;hRB zL(uy@+JoHoL(psb{`mW|9~r$ve+YWNNBKSPhoJX+l;0sg1ijxQf6x6P=#Am8*lU3q zH%%@u;x*s`1wU)TJhiMkUWxA*z&bGky?rIt;EI#VlwxS?n+nExCuLYw9RC!vGn!n| z8Vjs-^|?8s3u|Od$;BQKrfbkBja4B!T_g>2<$N3qvP4;oeKjUNyo5=4`9tloUW5!V z?3!r__Mn-D-~$TTKiiZSH)AyR6}}1DO<}%DKl;!l?W%jPVZ-w3uoENl+-OT`Ri0F) zl=#38+4N(k$;USLIS12;_7;ZJ#57tErPGyBE7q+UQUjeg!x&$doR?>|(pfMZ)TYy2 zq>EI7R4%l#au;faRxRZc2i2GHWrZ2FV7AhlWlU;Yk)9tnob1$3P%Mvoej?EsIZcL4 z$0KP>LUl!~*k_>~EUd+dDENhgMD3Lkc0<+5>OvHW8 zq(`|Am`Q_b?SPvgiJm3z;JxakNwZYxOFnrMU|>0R+%(xXDrsTMKPiV$toTiF@tdwEfv0S%kzy!7EAYQ#5s zB+8FYrTmcj(W#OjGCw*M@SJ*@`uS5+b zG~S&i|4!c}|ISgmj7_TzeD&9;%rWB1`IEk%Npq3Bbz(%obV{#IT+mHK%GFI=p!t?R zkirX`q4rd_O*E}SFOR!x>Ixi#YP9;txQbD`%8PUl4{y!DwYQ@>^v-lZ*_}`wUSKI& za!>4JN?crIOs2e!tP}trO6^WlsR1-c%0*trnN-Z9LY?EzoKPw`bIOVw-;Gi>sQlnR zmGbdsOg_yR7Najp^_F*S0>6GahQX{qyAOUvd0dM;aOn?dSCbr=@3QW&sifYP!lSm& zvh-5;dC+FXoCnGhuPp`YsjfOB8Y#>Xt-0CMn64I!p3)ifb!wGVhyUC2b!zlXhqwT0 zILQOft5XL+^KnwuRky#JZpv|{Cx44Ey3l5hFj&Pb0LOe=Gcb+j5O+dR^pyRV(Npwa zMo+OS7(2P8;XG>8!*y6}LmNh`|3g$Lz45G1$r>F|FsUt5OTqPs&4hp-MA-_MSWmP@ZYVJ7Glo94z71M1=n-jTZzN1!m^!QIZN};R zv-yg;5p^(C;e1)em5df`v)&f;43-&- z+YP=YL2c2KLYGnL{1GEQ*Pi5$Zjzz%hnA$+K$5HyWObnUdUaV;x=yb}WfezN7LDI+ z@TWC;X!$2fl5~2gz9P2*eoKOwo~ZGJs_lPud=vI+G4{!@C*teq=~@;$tcmi*u<=?G zq`Xu+q-vk2{*Q1t;S<=n_&-in{U5i7L6Q4|WRf`W362GRI2?0 zw|2>{hE$*lbS~zC=nF^(=m#olTs`>?EXA_~ydq;$K2)(lKUCq0*cQFI_IjWUZ-63; zrd*$Ur0|GRJrUxit_{;)WmSEJ+P79+`!&!iR2Z?QuCc*u^OX(&3hF%y1rZqK?owZA zS^Xs`mjZEZIsODm7u3dCI5T90ru=|f_2ChGRjW?zhcoA*vZ=K&xD9V>gdvb;(eYtq zoKzd$Z}W}q<{h6By3TiHx6pXXmVTA{elj4Ws=i6NWt3Ow0)%3{JTwG^f+nV-XPH)y z6#s%0Vba(h!BDU1nx>h>RkS(4?8X@9Jf z(+x;H%CrEz8BY(?(tXXt6sveqpYTb(c%}xM72fe; zlWv>0G$ptI)Egw-eABVWz5>zE8ZmrfPw5ghde+#28lyxcAnucivqz|_X#y0k1z~*U zu;Q5|HzrAQ0dcfKiVZn3&m`gwAZFuXbv5;rq7%if)&rWlye2s@*b5}%ifUg{LBUC~ zi%xfchOSfuW7u6cz@mPa*>(}0@I*6u>120)=JJDt#vewzz{(~v%>KlM&!O_i0?BM~voAQ3lu+uuhV~T z6rYh>z#9T|G6-)=%+IwuywhMaPN#)by6zHVlX|qq?D{Ew$=f<4NKzjr!)gLRKf8fK>IvfDq z22atjqr)45ze)n~@pi7KkJceZF4zfLa}~VYv8XG4;8IIW1&GQ1!$}Tbe*gN$Ft#s| z4{ViLEB6NyWN9%jfs&7L$^`eXZFYZP7Nlq=ReDz1YkLr9L;SQhRBv0FiEQyY$t%?> zX3|T$&Ify}uf6=(devK8XguSTX!lu`sM-_NGk;Dvlb7OL)0RP-Ns*f1%u+{hiMjL` zl}YP8=!T86gnVal>7Y7iG5r}>I=ar8gi?ntA)JfQ{p3~DTZ&W3P!KoUVTTcSYf~E0 zcPYzH(aDbB^I^(La2poL`~07@8}yFa_hf0`Eh|vA)!Mvoo>o*xv39?gI%WUdQ8;V8ok6m#syU)7sU} zsykqIj^n?%DpVzfVUBLrJ{M9VWawyJx-+%Zd#ycqjO0Ty5yxGz*tOOH`TN6qR;+wA z5SwyHAic7&#eu7{{lRuf9B&s41%nqcgDK9W^|h%iR?cxg%j-zfL>J;|5BZ)ZnbNkD zcqc8Iqz>BQ>`wB8CBz0^LWH`HzF#Olw1n7FgBoE`5LMDc~Qb;F`AVXj^P1>2V@}xr}&TYgkzNy+jNXQN+ zK)B56pntg!Cc4f?cjZbg@*JIu8!?@k71bZR6nganx6>B&sSkbt$>X0Z%=ig*T7$dr zNpH!xtrx6$ITOt?N!7MPCWkkWRC1f7kRFi5LK49qNWD9WU@T+w0>m;#5br*0c3w(< zdeWVV*H95BaS>IYJr#u)Sb{5~nJbX4nj|JyD4R6isuQUk*&vz{=*$T)9#AaIq)7RK zM=`u{A=jaLwM}I(h987Goytl_FhdhU%$D7{l$qe)d? z!&Q&9CJ{1%qf}rxL}5S2p)y)o&@l6Aq`7n7I`lH!-D>*=?G>F32|}OJ>IPRzb=XC6 zkY0fw*r*R41RuB&?O}$X+5Ft!7)CuC4XT)#!ktodf3);;{gEyVXUHa!gNqDdKm)09 zUV`Fb{fPP^otc79G<_kyQ&(i%HyYxLM5+G4C>bPbfJA$vgGOkFhM|+xYdekAe7vLp z$BUBiJQ|I*`luaG-&U`LMy-7cBd`=L=)glijoJzAZDO^y1yc&#%#U5CLy5RVr?s%GWzn!Lh8^ilmulHH-pN@H~1gctJ zg=i*Ho-lV?H}g&!)4a>@lh|@K7m>PDohv|kvQi)|r#ONIy8LO&{%3^u8;g z_w!*srY0o@RmxWL$YiQ08H_g%i-=Ve5!j5`6_^m7I}OSNv1yccgvgOCh=@-i(~u`p zejVGr&1ldweTISrlbYpA8*2z5f+Ng{#~ET@EKy(~5<3Ittj&&nwNa2ZyZ zgU7HtRgEF;F~T~D(e-_NkTsf4G-waW8ht>o(P2zi3Emi{^gz5=8AY+0)fm>9Ct@C# z80w@~4un$ma{ZKgA0ru}J69FYOyo&da;G6<`btw6oxm%J9_W;u&OQvGg4YIh3trpCz#HZlD@Mksc z4X^EqKcRoZG_}7w452+&QgRMus&_AfY!c#-7v2&7If_*RoB zd&fwkwAvW#D$9OU6j(^Ms8r%XFw7!@c{PQ{?WMYl5Tlp+6LOOEP6QhADkx=Q9Fmx- zmYEV!=p*&+yy&|zJd}GnZtF`SSOu9uIu;(oBSk9@Pth$m7Y#AJ1ZY%;n2Jk=nC1Z< z1*`&?Y(q?w0Sf?20UMzc`QiSdbcpFy!2M&zH~PL6{_8G@{9XZn^zTjh9f%4agE;g% zu0E%qhaO66t}|`g0j-Jfa%@_YT%oZ+-E+T>T~2G67F4w(ff4`4>=jaT57oW4-5*S+ zMG8gnT#1H&S+(LRXAdU!=K;kXNO1PW1l!qDRn~r}C~i6o3@aEr?m^ME2Oh@b^}%6; zcfgDdlw+@Axx}CB@Rj6weU+#^tsd)dc%nKH%l9*(7kGVCnREwH8YreIbRg-Mr*J4+y5TWmk*7J-5h;tHY6{{c@qRf`yPP9D zjjzE=!3eD$<v?6cV)Q zP~nH_hr{<^>CoNOE@UY>TA%3Jq19rQDq(g#T9GJ_yEX{~cz;!ioWc6}uQY~1jVPSK zWUz<%cB&+gW09>AutXts4xdX{;1s6ZA0|?XflaIsC2PUuvm&MUh|)8wL8jGtJw13y zIfxn}CWi`?wTIG_MeWhKKuTy;#E+$}E?fSJt9DpODi1A0cF(K;Ba4>2{v6^&Y9CfT zcrj2`@W#@lL?}zO=!SHAEt(L~3yxP_C0~}tBZUs_wcJXiqH4GpV6Q_vY}Y=;#BpA# zvT_vGCCs5@W#v3GKQ;YCE|Itv3Ic@sm0aQoKXF;)IqaOK)%Qz2g87emD6W!AIac2h zKU|lMdMI}Z(3EA%(N55zbuHJnV+}i@T-%_m9Gi%De(@qRHA1Z(dlvhxX~(r4fm0t+ zt8*rU`s)ylHXLViuE@hgdC(uR9$Do1Sn<*ef?EBs2A*f3DLzh33`<@Wyw>$6`t=%< zVNsURF$1Eb`r~|1gtvaNx6g8G`tzSU3L{4 z%Ct8@;;%7`C@VJw>5(?)EQz>~9i!u*qmU<`uqK7a2LM+TY+ym9;9Bmu4&DoRwoM#)o%{7KvZvhK< zy`?181fdNj(YIV><)wKg$|~E#Ju1AGOX)ivw!?Zsv?$T5D&25X6TO3n%L6zFFL}s* zL`SDx`5x39_$EMg$sI}S50)LPDNBk3r)uZtwqi$0!`b2ItrpKDpdzi?8=s}`tcvq-hxtrw(l%hKhh)wjp|CUHjCoJxX+zVJmvpRm2=CJ$Xy^9$1bH zBTaTFNvgpumB}|DhlvkM9QyjD%8&W?{iDMAGn@ z3U4xvW0HDwiZiKGoQqCT?6*!f7B|S=0j02B1*^pzyH>@-5$#wlZ^E@EuCvr7APqYR z8;L~Y$wpGxID}&mOL*j*K$oB_Nh{OHC=mFMP+a>Oi6s zQT2p_J%OmNya?BQ;_g|A!)xm7Q)_V)Yuym+L}?a(qy$wbXaj{&G{TrMEEYrFzXx6w z*|oQ*v{>)?jMz4Tn3z*O^?2EB;R4k+9uMDs;-25tYR3JGcUv*aw%+(}jd4ZdOq1i?jx{q6(z32(~OSPl~!kVg? zsH^c>upylEnbT?xWob$8!;KC3JH9NjbxY9PgpT*+z3j0+y3vwl8Xk7|`mM;vW5>6B z*^%xEReE{A2S|u7^CHdha3)=gGY)&V&XM$|Gd6EsS2(7kEu#!0I(0OMMu}hAmhqb7 zE3(=ci~PoGmi2+>E4~be`s>IgL}0r9>pY1>ET{sW9gB#$_Nh!6=o%arG>Q*JOA52> z;rifo3|VmP=$e#e*Wm}P!sgKe9L8)^L}@j?pe{%dP&=q9SFcE#If4PMfa683QMpbkeTHh%IUP}&FMZG;!$yHW?RjHFQ%c=GRrm3#{CPCg|EwaYe#e7U-;@?w;XsT zr&T04IGijz$lyK-!7?JoUL#&t#G~5%9Y-atC4N*2p=r|vD7hXzcs8*inCv{8SUE~d z8VJ%*N+IgK@gvk(OX?8)(Sje4atkpyNiU~kDwh-N`}hU0&(~#vAXN)@>$1N zdhRlE*egPs(?i;>k%L`eH^+GzIKiFxW7oP=Q|>}+;)u(!R1z1kXZ!Pw;lynqa}>yo z79L5ek>#5=bD{o_$Axm=DLSz?=&Rs0(#URBsNW(~FgY=Pp<2aS|1n}y0}Dn;x-8nA<ya%&&cT;9JL~iNKGzt= z`*E6M9r|Xoa}xa-OMeRJPe*Dnlfj@z)6q9ygzk1-4_sJP`$Y$8%YV9q>&vLkJNGRb@;}l{;`qz z#`+cR0p{fxCn^gsa*M16`z-y^u9p#vf}bOmU7Xv^x72<~TbS z7P-dD!2{d$Swp6U21Wmz5$X~Bb55v3^v|1hxk!kX3yCrOV`Lb2G*S!hNK)?GO43OR zMw#!fOnp4oF8c!Yt9bGe$R33}GzQV#VcOWQ!kgU3QQ@<9N zAt!wV#;w3W5|_!mE~2oj5%v{6ekzI*7(gFO>{Ibk2nq=Y5lVVaEAsJyCBtOqkz7`m zE*nYVO``+%>UGY&Q?!Z_LEB(=Z!8!cP?n9uv{-5)&`nq!5!#86<+_UHY1a-h4Fr?{ zrUNv26luEoLzvtcl9TpnJ7SLnfjt%f>g)1%FvG58*2=1-_FmBALf3Ko)L)PuW>4G>^O(R{iD>TpK{R*vF6l8;D@}0+ zrnryyno|z#g(7UU3{BP82Q`UZ`=dZ~-NAbu ziW2v0mrZzPfH|yqXvv%=Pgi3@-tKji=_ID@PkZl4@s2L+HRpV_GI%2cLjK=BBx(U0Xu+4l`24^9mB! z(DX^ohOaWr05ymH6k%Y6K-e{n(7mHn_iLwKc?=Xfdth}xYt+~&&dzqtD}={$Y6XG> zesuDcBx7e|)#tj6wv;PCMRedP^}5&(mGf?j!cL711a?)Ja#I$Q0;_ml$6t5&DrGUL z%;?WO7mb)Q1glQV?#qN*mbg89AT|Y^jFjNZh!H<5E%mN^=gce(Pih|aaszq5Vs}=!mN-Bw_g2*bXf>nX5C@G7gwk8GYV-R<} zE|=@Ri(X}OYg%Yo6bf7g^|}Bqi4_zTN>Q8t_sq<*Hc0~)-+O=W`{%_@OzwSTF}|4T_tNu~eI|JhPf?2cBgs4RV;vJwSKOWz4!MS!{F z5G~4JrwgnK@I~r~&awrrW^GGwfKF9yN*ag?f2_)!jDcym31LeZX>7GAnTU3V;PfX~ zuBmElsH%ovqyBq#v+pt-+}jS!DCxN}8YMfKl_i1m(`qWBAegZhKbCG=*6fXk?l9O=Hn^H>RgGR=z$&XlVN*XkEveS1`EMGP@UqITw8Eo zs=I7GQc#Q?F|e3y@ub&zC>tfD_%xBylfI6}3kaF!^a4({mL9qDS*q0p5C1SEg@7&M zOA#Nc#+boK>~F;Jri+n)CXT@l?>^4V*L7E6rNg!X9Vh76^kQ2pgrKA50RKJklEmJB z7QbJJ-%rKwhT;7CUh)3D`2AS?ULoK-D}L`4zZZ$$bHi;I{Qk?+t<_700+Z1QlMt>! zxB+1f!tDqP5$;BK2;pxC&mp{quma(I1gaoyeOZ}<`mM4-dKJ3{te=zDXR9}O>X}X) zS=$jN;5xUh%Dp9AD6Ozp7Z(m#=R4UQbVGcub4!D_P=rSsT;(26H~XKUng3wacMzu> z%C3#jdD>j?4o0KUR}QyLF)3;Co(*MK>VervK2&z-?hKMxw*nKd?3oGwvXTqfR_Ikr z@FCiv{eliww!apt(#LyXmyy?Te_UxrT2U~6BF>?KL@zsZGZw;c`rchJcqX=vWXyx_ zm9M*d`WC3}j?-(RXtX-tDbn(cDI%DW@3yV44Q!xk8&Yb* zm8CQ$b5#U3u=%he&f=t@xvwhnVx&QFOOXU9CQL@fk;MiA#9s{D!L;rQG$-+#4TRj&kQ*V@EoTVALmQH^u16$_=SIX7+&%P+u6;>DXw9^H9m(LI}2yW}BRYpQ1c@@d0PI6p$- zcdObGwpFnl@OPhH*{R#QLiw)6buVD9Ghl<{Z;RY2Jvd%#s-`#KqzJ2XKxIj*8vBX9 z`eT5&f0See#@whG-JqXZ4A?SfO=K-v-GBQSUdt~|I107oY_vK23{;~?G2W=^Fjj)M zHiwr`2(Te0)NXp5IIY|%ye3K!Apk#s!JLjOjJBk>M87|@103t#{fvC>q(dO_; zKsxdnkL1bHCeAcW1C`BEpbna6c>ay3_I+OD^xsZ4 zYlf5*2mls3P^*p-*8Y_~k0YfFW)%%JDKLycC>=lcAVFfbfN)HljD{p?yU6xSpfJ?h zPn>aeOoq`>Mha{}+7{p*M)AaZkud=2f1j}7J?XvUj)HtpxUC!`VX{5x6Rd1%X%)VX z&ywNijTu_*Npp~aiQCA(&_I}P2HRv_nQ84mB#U%aceJK-U{9FzBBaPs*GdIVNT9v{ z6zEjS_J33}zeI|Bks_yyNOC2n$OkBLl!#0dk);&r6p`dRM=7UMWOos%^x==MH;|y^ z8a-poVB^3O(9DMnk+-l8>%YA-=Cm*23H-mI-C?x36evM1l?&Olo<_gOM2hBOlPsFO z&J_}qmZWrRf(C|u818LGP_@pfnW#qOHu|DL>(e_4Xcsqw=Bl`EYNQXMv7SS+$*`#T z2O2-FHQa#aKKQ0JLzCJ!vYozgG--^8`~&Z@;{iZkO}?bY0!u}KU;w4B8ZABShPDdGwSs5eDWeiESj1K1Z zxfU8Fk&q9Dw@?{fQHG!tn-r}*nCVzODbu?4U^}+T{T`lCp-f%-wA0rq+^HT-qX@Sw zyhJX%h|3D43t#>uA}?i%zGDu+txl&(a<-$^S>d=EvBlVjZpX6vI9^~YU4f~F0^j@| z1u{lLTRexC$fiPSi>b({gSy-?nnP-_&3(=3L}ISb*2rQABiV7B8E~s32TX(l;C=wC z>&dh7TI|U&kR;szQ|&K9L{gmCy!O;S0K9|&{$qj(@K1<1Lcr8&08CCV zy4sfQ#$;|@oT zF%60U{1q+LX~V;HM?_ZYw19O#gT++BwZCOL#-P?~f8!Ei1gAinB1&89dnY80szeoqZAZhUD!~#znbs`;%;Qyur|7eonV~9N3prA6)+f#{c*!YULB(&o@ks;C_ zOsFI4@jAqgJ#xe_ifV|Rakz->n*zj^Lch=v?waV*L?tcKco6%bnjWkpAiQ+0@)c;tvdJ=7X% z9?Cf^#N32f1C%r!V)u{MD7FO8k>N(xcj><8<2f0MN`bRt^(-jumPm#X{Qgl|@%!+c z9QayNK$O|IqTrrQ;9oJSCg=8TQ8keQ-(U)7hBh^yplzftnvC3`L-wCZBYRRaWHE=i zHey4x?6?tNLWa$*>G()$a^(77Q5F1Dlo;?Yz z6l4Q1pQ#X_tLIJuAX0?fi2!xg1L{G5T-r#^Y@akPt{I^*XeFMBL3Owp)Q9l)FLbzl zIuRiE^;bD)buKU>kULe7D;%HWndT09n8z6E>(|3vKrkO?Ftz&5x^61!%Zw9=>U+K( z&>#XdLIXte`Gm^A`IQQruAvgcF4J1Vi|1ro0_SKo z#28dgMMWZG=!-TC+@k{@#B-#h@q3x>`>jb9AA=E2)6+0`#bMHLydgtk8fMbc){uS% z8s0Tbqv0YvCqu&+mFTFi#JaJES&4@X84_3GlIKy0JNg@6xKEg_zp|8Yg2Aqk9eUG_{=B=QV>(Yown9r!zw20u9#_^t&0 zA|v=Ob>Kfs5`2u#lA~{eM@Q)?nnV*!Gh|5I1gAZNN{qyatD{j@T_w&s@=A2lSK{N5 zhgpedv<&g5enR;h`!p)Cq^F@0{k$3<^}=&}p6e4zKP35q)Jy?;xFm1_>OSP1Iy5Qsq&Fax=Qc>Iwg9&IYHhkef zb$V&R2oyZ_90IrdVzppy%KjJ;%#^Jt_O0q))m8s}d{zu;Z{yieeP~3}F$W{PkLlh} z&qps(o4@&bJIwfOS5xF$Y_6qTHo_UXPS_Zk<3-Xb40!&Oa3r?`X{*GSzSC7)pwJ>7xqlmgn#~6 zUGm-(Z^>H<9PB}rVV1GrNUU44S!%^)zQ~vOAQ*V=a+N$(f3e~apYOxh+=!-o3+V)a z=Rz;?`U5YS1%elG8B1T@->}tL1Q6o1Fe1t@C8=i%?kpbx9XNM}FELW=GfGaJ{;mA8WQtuKJT> z`4PD)t`ts6k-Hu(>pDlP0NxX^+LB0GsorO}RCl4wt)R>}O`Oc3?9 zZoCr`EvZ4aQY773u21>l0u?kxi?s2%CY&)$pMfz$g4ACOMVW6MZ$xCQu}sn36F_+w zP((W@G)a(pnjy79lLQ(18#4%@l^}x~6^L|%0-#_MZgm@CDzG4=#suzA)&)FgK*SF1 z?8b4~lf!@6MkCBmVAwvlVQD_-$e|y9Q){nWL%Um~i|WEJbi-~b`EIrXF>kUZG8jVy zoDLT-;dMPECO^5` zqU;zqL>;%pfO!dGFdAtCrrw6q#7G#~iB%!A6ZMJ35Mz-o{GAK7fsZ5ReSOS}Pax(M zEzgFPcz;}(yzi_Jch^|ArzI4Iq!Ky(zYxhr4D{mDN;$P zjH5#lsda=TSo?zM;6mzPk!sAq2)Kg*Qyfu(9qjU6$vImd|ebS))8h-HRB9 zKBoJni1`J|umCgz6Qsy)?fn!?Z6n+8&b*ec7^r$JNgYcq_!nRQxM`ExTQ?b8W+MTB zW34XA9CIuYCh zk-%XhIC3P%eqe_jI(aKLQ22Mv#~~v)qGac3p<2CT-$hk)!IW>)U63M-c|9Pw($jp~ z?Qwd9UczzB_Dt?UnJ+E;8jC!n+0IpT3fbYm5WXv{m+3DN$2Vhl z_3>J29fhErjhoP2?2k3MriDiiQK^?GogT3>kR|dGTflN$bOCDI%3R~Vh*cbZy5bov z8sFikx(49BKb^SO@#7$XW1>e-z|Rq@fZK-Wgy4Jx?ok5A^;h?*?%BmNue*MhkGpFp zS^>zTypvd7<{P1|NL+|gm3iF&j)8tb!nnxs^IAYTkyq$=B<3p*`U=?*t5oO^BwNA? zJw@O)WHb7lK;X_XliQ&K_ghQgMi97LIJi0_Uft6S?mfgR*uB{jI0u32&cR(r;Ch+C zjn;uHY6;x(H30Xy7?NpxrZLBPzcPnCJ`19?+YNcp52yOt;%ufrT0VKI0Ir7aNhAkV@A{!@u7F zAiH7H)<fG+@>x^nJMTv1J*LQhmmqS!h*St%Is=hA zTPww=BIw|F#1A!<_0$wZzKO)n*V+CL1&584*be6tQ#`sMJUrW5ETy;i)n|~(dr0t8 z|C$i`5TBXsjckMd!Ja?{R5x#Qj#NGb^Q7=Ql&-q@*T9<)<>AEz`1%aKQXvfgNG;;^ zv`n9kBzFk)#wu8A_FYM|6^BQMKI`F)`%4m8DT6|wX;%ROD-aOO!ITRK-R{|E_EZKt z!^}CHwh=;o^C`SsCKkZ}edYj6Ux7?3QIFFok|xSjAbwcCX^lwPQH|aq#v?Jv{sS>I z$SQ>zMp#X$!1lBcQ?Zdde}>k3bhC`eGJK@sz{sq)zk4w-Q3{tyyMjJcF2IsF4^wrI8)UqW1%i+R#&PJkX0wKzj=Apl_mo zCK{N-_g_fWI&iK!;p2AC2qI7`v)xlz6!$xL(`AUJ`_e~19=VBT-YaNQY-E@_@F4+- zTG3v{lG9o11z%&?4ZbIQR$6bv99!R#pI)F=HgQXau(^&hD%kd7*w)|J7UJZ95z`%r zY!TCw2~)4UUmX*4TutRDZP`Cr1hY*DF2NK+c3ccxjM$x@GY(sG#>6W+AfUIv`_g;IT&qJw>Rm8jvJFm&j-_>I#virjhh@44VAQ0@Ih#_bFdyn7+L7pz>w7_@eZ(-FM;(NxDd$>5GTT zVP8%&efbgQ1pdWt`cg>cusq*mB4*;ub@Nfm?aft`Wfbobq*LlIqklz)3uaX!50oKt zkSX%?Qbcw(MP^)w$m6Iic62BxOMPJhG5a6Tc8Jo1CPkJ(o<+ilbgrUuMADOKNZ-nn zQmT_n@Lt7I5$Qy#{TOs3FSA%u5Jc>k6#F1zb*fZ&T7No)hIS2i<+kJx|3y@u2wf`&=X`%HAnZMX=YMPK}<5FNGy~UsaJh&k`#FHJtGB9V(9(zIx~7}5cBV&r-=TXWYJ3pdQ25( zw~Z)W227bfQBl0(@4Edolek~ZMVWe1-%`9yGxmsFy+&;~dBiGDbFP znc`QP%eHg)>UAe+;V0lIl5IN_*~Vl_q!!WCM-)*sr4)T+8Vb-ywuNR887U&sMVTnN zZZsnEc_fLZ)?m0uPwhS8#e25){(=kdnRstD^DO~4VQdPYFa#;~iXluXhWQ_K2bQI` zyR3>B1#-S)!q4?V`laZ|m}7@Oy$CP&;YA*bV`3do?P+6`mhXc-WM217E6lbKDK2?a z`Fd>ny=Z2-)r~_-u%3puEAibcS7J>K$K`Ac56{GjaX(*(P4Ar+v}^AtN9c73#=mql^zkF5xE?V!-(<_cXF$1 zH37D`W{q@5sl*pb+bnm3=7R_o-V5V%V`Lh}ES4`a5>L)mZxR>Px^lANcxZr`@;YEf zGH9j4xk`L=aN=m zd7X$T@KNCKdAqrOF=n+jBaC0-l{^Cl%y8gkNK5P6X)a>KQV?4=n(71H&FjxV|wmTOMu z!rP^##|=Lga@$lKS(r*WmqKyff4U%J=k86#ITyMdZf; zrArGRL^2xxX1*hI`<7+a3Lpc;0%OQ0lO>!#O0E~--p3g1>As0ch~a$3TXDoN$>2Ac zDP4u6v%m-}i3);4;|tmF$5TY-PEa?ZlIrPqb$1YOKDdYAD=jt*kqH2BqnQq&@FWx) zITuhstnvd=pc@`BaAtSPw6Y<#!?}1O^1*F|Ncdx#frL`v5Jak4`BT%|d`XXZDcGP;s z%`CC_T>1tb;!ZQ${?q~d2f_WnpmB-&mnz(^ufn9R=rOpqWsu~b$?!U(8D7Vl@uKt> z=$CLL{|dAafmP&V*v;R;4NS5=PiqzuzUs@i`4D+XjN6I~epTcI6^}*=T<X+FBBfR7H?cZ{sD}kuT|AVYPtF2&12;Z#KdhmFgF>3nPoVkU0*@s zgU)K@5;yigmSJomibup%O>CecMm&)rx^0{p(Q3pTJw(q;7SUsXDA7@A)0-y{9s4#z zFXyPBr|@9l>?G+p{Waql{n>am`P z-48Qxa=<70!y?U*v3MkTg9Q{m%&oFNiUPtDx`b%SJN70`tAFF!E%1UBM0MvP=q_eA=U zF0HFS-r2ANQrL=je^bMJI;*S;eZy#UWr|@m^3D8ru}wUn*W)rBuIo@I9dR|a91bR= zYeuf6Q#0uT9Cj<%q=^%%muxJ?8Q$0AT7E-#9pQ#+b1j(&9q`-4F9AHi}D(jx4ZaklAQxt4)AAMNpJxt3K3o2KIo@EN(5od^dI(*Kfc$wugha4|v% zVeO(^OV;(dmSTk05!&34Ynh4Q1)NjyI~n0lgr5;c&BVFl2yJf6wVZ*F`zr3o!|!&4 zo;T%M<|BNBkUJ~aax=mM;I|X*YXd9W9Q^rUP5rq&9%IZ zFk)V=We-A|n{zEQ5H=#5cuTIO1fdS0^ZZ=PY=rj_(r(2)dkC)~97HI;E!Xk|!lsvV zE$7{yYxx}^REj#6m8X0Z$ z&BMSCzsEkJwONl~uH{06Q3#j(mDBzqJb$+scp1qdS$iVcm|;!LE#tTlWf$dAHooXu?W{8%tKg*@HxWc_i1_5Jfog@A!^Tgm4W)8N#Co7e0$}@cSXcHwcFiB-AYj;da!gKYoWI zOhvdE;ZB65B9uL+)%!cd5g!!*@8e!aKgaJ31fubS2rnW0jxg?N&<(u*0)DgJ0Ds~6 z(N}UU@8O+rsX*`o?%gQ6TEPDhzq=3`5R^9Uj&>c0FcD!E!lMYg5e~fo{9nwqSeNBm z&IO(N;rT*@DG22Ve?@p7;p&$_Bb2`tzr*oM{gH4vh#&)>eF&|9!^sH45vCy!J*p8R z2z9T4{wQNELK6bj`Ah^C!W@KuA^$sXp{)=?cpro^sNPi89E7hC_9FDa_lN!g9PxWE zf^wcMUCTuG0${!Qdz`2|r~%rhv@in$s}xv+k*vqX7^tMct$6f@Gkxa{dL#|+<(rV8 zbeJWW2q87tD*Olhc!Krx5X^b=|9rZi#H z9cjLzvf7C>j*`v-XW4B(5CYa!NOd5TF9m3&56M?i@?G={^fOH$AK+<9D9w8!O?#>Q zHhPrV;n18Ef8psyQo0B63}WMMlF{smh)uVc3St+~qdsphiUu2VD5Vs6T)wpGC>1isUBh2TtH=CQ+Jvkp|Q!Te+Ts zfgfqg6&$qvIHb$M#~x7_45h$#i1r^GE0u4?184uW?1`xQHsxtf)u$;sIH)gy`jDPu zP_>k&$)Yqbh%_lBC+bl0O$Lma^u0oSx0M{P|DKQUWAMFx1{Gj8emoN&Po|GU>7%0r z_ewBUQ#kkn?0(``D~_QvxJePC+LhFo&TF4i@(ruim-^DS0^rZbVi^I)P3P0KdTu(@ zdYFgb3sWRFEGfwIoo6iy&bF59_XIDsMmzXBcd*jcg$_9F)E`?Eya>AJcDKAPyzYri zXoNpW%cauBY+tr}wH3UFWhYB%W6qpbZt1BFH>F2waQ6BI_+Ik8Oa69njlHkM6RjOw zI`9HZ30#1Jv|-JITdHgy7UGtYnSdy>I48fRM10>=WABV3;adX}c-h+r(w?+oq=)9y zjlrLxNL*B8AK1F&4EL0B0*Un5GJAskj{nw>#^2ep#3dgf7#9r8DH#at-pjZEr>QnZ zOFByLwa24e6WxG_fqB-F`CjIm8lDE@YyAzu%P=VnPo51IQ@bzEYT^P?j%tmoi`7CDlFDfxA>HlgUWSs! z<90vM$l`2z`iWwl$T4Ru&hB4fhXJt7%a_xAG|K7w%J*G|l(=-0P51(i%6ON`V`w-%YuLNG-GLT6^ML;7m9qu_&0KD%b;&JdJeb@%47g4`gCc zD4k0VlK1|EHqjj|@5|t`qPq}{QZbwJZ5Z!wa^PstDGOOq!46A@w6(sSO>Ie@{dw6k z`v6vBzlAXPJ?xYUzW_#5cKC%~f5n~;4S{ob$>oHE*gz{Rc)nJ!;o0i#dQ09ZA#r7a zdYO*l;;{V7NAf##aBGnbcWLuW!}yiG&eByhLgH|F>My}TKb?;&)5@z5v-))W@xaxx zLjX4ep?gc^FR}VCEajp!8q9q8WuZgAMx$ko`|(X$ct8GvX#-MTExS%;VR!tpo3+6B zM8=x@dEis=c(b*>xUBISG|rrMzAwrmPa%QtV}D~W-4vF7p`R(4}GdbS0^~ zPgHK8Tds<6*>wP4z^@QCTVY__o+)*;_P3RE!ev<7v+(Sxtt8I!L@NvO2BwrWc;rpd z4hJ0Va4Dm&b+pFcbm~pj_2;R@&Q)rPw(45!&$Ia2(2bmxDgJ2tn|{RYOq>qIwXV5c zZD?lo#y1|%M3{fB&r*_Fo9~l=SlO*QB+_% zqWs}39PQbTO!1w9}EA86ycIB!0GIhDkfrG$=MnA>^P0FO-@Xt z^jUFz*zn?t5zem0=qBgz$VF&#mwaWO)Bkm71DNSz;L2PpQ(gHsy3Bms(KmAdH;ad z4c{g9?_b8!G+5 zf!csEmNs1#@332p;-)!lE>t1u8IX5E=eymr>2|6L<-iltDf!8O{Kja72%QtUD0RG7 zA;6zp^UkCwDz`Vq>7_{GTJ%ob-TzMi?+z(&C#*C=5P{8YgP7$%J{?wqN?6R!3+=UG zJ==wI7#x>fYr=|DKdjWl;}uwlkHW^xv56Jaxl(HGz-=eCC2i(5)|jnTn!odc4l0 zcQyE{2kBnEWBp;=-~B!Mi2vZRQu)J3RVZJZjZ3kx?Js4HqflN~k0IjXERR3bv#jZA z@UpK>SyK`HItqJ#U2k)~Nz=SFSjKkA<3m}v8Vvr70D}v@oS9B}V<=)9uuk${Kv8nF zld-n{t5mvxZo3CIu|Rv=51WmzYa3@*7WO{iTI9;<>xE}lo{QYGKuuRp4n>~jt}P!4 z^eqr0wdDak(N%Y@Mdgd|=&C5Eu?lZH@Kan{K7oC&DW62YwdJMkH5#S6>DTPOHLH?t zh%BFs*uucqzVv!e!#GRB4u0`{6azKC%v(t;@f-Fy2kWHik8dQ&1<{pt`Qt8e-Zb2FN@b-`tIOjgg>FJ$#K^gy!u*gZN~-Gu2sWHl}% zR>c*`>e{exvC>t=+@A?@S~+z3_u^7#_O~nhdkXv8*6D9L3~4Pcc&d2iC`fBNnv2%N zhFzd`)?}si55fxFG@8aZ+Nj|! zOqk@m$>5XtK1I>8{9qqp8*1W%FIS8pXKsz zf6Ml!#&1Jbj5gbIFbUqp{<;N z35gVlpi(_P0Ewi46OaCIcPT)ZMf(q4DwThWBQh|hu{)Q;74XU||3TaAe*Vfo+`-G- z7;WitPckSe_9Rz-41dEjF*esYaYbq2IyC=24+hVYZ)C@c-z6OW2Eag%jc4c?G?omp}CsY?( zkT;~kR6K2T8;v2i#MBg7gswfH@eE0}^gpfH={% z${J=7;S0OL)93`UW^nGKlcERolh~OdWI{L(&)~x}g_BzwnJ^tK8`*&)u{blof+sA$ zIHUzn;YlwDJK7TqLhzs>2!HQKR+8OdQ(DbnY(X{1oujabp$08+{YwDMk;_z(YlSD- zaWF-k<)b&5e1ph@CKHY*Gnrh@5T*Wf6cDXpCz-)CsZLaUBLpW1TgA~aNa*)i6m&uB zorG(DR9hE4ki9FD49HpRzGC@P57s|ypTU|1t@)Go1F@Lf56vzX)o9VAr##~m9IwfG zp0+rV#TF+PlRb(}$T!jY#NB?J()a|6o3em@YV19!cd2U=eQ>xPjS_LzCVHbY`QKrE z$x?EPIM>7tudJT5Mv%v?%(O;Sjc+s?tKWqj$&6q$eDPyaVhmq-3;yllD>4d_ejrv` zFUPNoUBcVu$}@1c_V`b-R(1g;`ruA*60EKPl~RE0+OW~z<0`FK}2`V+GVljYw+f|o;Huog|Z&+_~eA@$akzj|H z=m*|*k!1kl|E=NH6Uu(WQ>o9!z3=?^9%0KJ%o*=_dM!r+w4oa_qu*N3W{X#duJ-}l z5_*^}N|qnWLIbk(lRSTwedQ%E@S#$^Q&FLc_FZ#Pp%5zcgIv{nz5lD<1M4MMRed|T z>UFF7W(yXi*>*6DJ6Hf4i1)w`mChW~H-$%i`fGG0F$x5nH)z*)94YV<1e!uCdP}?-*PGABp9Td+=rOBA3mN*VgvK|lqXzMvN0o{jZTBtq!6PQBO;bTH9HOeh7Q2L@2 zXh0!|;ADKKjLlKhdx&Zup&@DK5npwiqMsB6-=jvbZSt>85e7`#9&sP9N8e&kp~@aPH73XEq+rY>gJsvZ zx8Z<^&?(PA z{%=y{4-@DpiOeu(pDWBT^*C;mnPHy%8vIWt^KW+JflTIK(F64Y`7`PT4UFC}m8yt6uM%>p{%uGSu1I?!5Xb= zNncKL@-yROMn0NpFKZ_I1`=PxX!ILHoI07UWGYh<^$K_sztXC3HeWCo+!~w)!TPgX z-dAKh;I{4Y$Oply`#7tbhjZ>yKviMx29>v9IR6_T&e_sGcQw$7kcC9J1l?4}lyQ?4 z$gTrA#*CXz$DC>!9n-lO;pFYGzhVq?!ib84Bhgh@M~~rK5ZU!PsYXH{nvs)5LOgr4 zzQ3c7%ZJ{;%G*96R$aj%DMc{b25;b9enu$ECI5jbi+cE>GxTEypW`?iw!=-r|D6?| zE#U`lgHl=xkE1L%POx;_)(LKKS9o)V$*q}kr3jArBIBH!H7<_JTU`MCdv6U8#U6iCO&B&rK{n{QsDJ=Y!H+e_Q-V)x_1@~GHt5OkFE zrVZV=!a3OHK4if;c)AVUWm|v6xUJ)!rI7ORk)?UnI~z#8I7=I>YC6{B+Kw=rVzKWY zQj^3O%V=eSl%Ys>Qf|3?0+Ow$dJxsI=1}^2J>HAgi|$j8C(rMlt2K_{d{Bq^C1nmlYNN7(RXW33-0Z454hPdRl;mS{Gn#bm7VB(kx zg{YghpGqxJ*EOjVLWa$N41*xMHnt!$>Qn0YOMbwfDNIXx15B_3j#{KEjT1Ulw9=?T zg}dKEgRgM&F%HNrjK^DNYwc&~TzcQ8v+xqTbIFBzA;zf|ldqJmIRZz%!WVBe8Kfa) zWQk;v5{5hGHk7z2HHhjqa=idjsa_RkEtr2fTCAtqVl;uwN1Kswb<)O|4iw58|>Y%Nu-))K!n%N-rS4WZrSHCZOa9mK|Q`<&&@NsIc3O-RK zXStpP4*Y8Ib#u!$Z}43zp?OC#G-ti7NN#fTDJ|NxC+sb3dP}Re?19>p0hWtQ?P-`H z*M|S%Q*bMiYv2S*o}Mw0gR>5%&A#;;LwrsjVP&XH_0>%VZVJRVXLx>4r68G(=T|(6jY2)ka*#p8x4MpQs5UFD|mm; zFFg=L+H%s+M4FQ(j%YwKF`tYpJ&+_HN9WTJrKZtQBXTWJf!`(gyQktJO4X2mb1RCd zXNtmV9vh^0Z8+toOpDX{9--#ptc!j}<`^M(+|;MQFg?}oWCBqge*Z=S!3;VvKoHwV zfmbw?TOtx?jyOb;3*AH~#mOK}DkM>6C@P&|4EKp>>5>b_z$csOi67!@b7kBkbus)Q zyYGR`_?h5B@8BMUio)$$gtg?$M~)&zk=(^-o64u2;7TGh4Nx%T>sQ;n9D+m%`HEK8N~~!du`Y{6S77k8TbT~ffAcic1Gt*Wj($x zlYg(qmVb&?4iQXM6YWxuZre~K|LBG$iCa^kI|g#8lT5)3tj(%tpiJ>aD+tNX5R$1R zAX9NK3(3dM=!K3EorQv^sZlE0HQ}K*FpM{m`h;k2&Sc64d}R->H1mkksbIRi$BDei zNMc^AW=V6AMe>Mh0B(}=vrso09_jiR57K(%rXu+dlaNy-*ixkA6a3gh4%|td80$T$ zKw^T@q5`4FKk=<}e$HHULvVq#Jg?-$@@Pp1DtoYKCqeQ03<#}rcSA@CGtV)2CQ=65 z412nb)eHG|b~=>u&0Z!5J`A5xOX_tY?QOUChQ_Y6Z9SFLt>H`6ev-Hr^{Glib>qPV zCq`pvU9Ci$stUcWB&HyzO|_cJM~i7B*42NSd>^IsCrEUce8?5N7?Z4Mk&QM0oO)Ke z6(SzozdlRe7uuV~gnfa3{vX7GXQ;w4AJpmn6tN+n+O{MkznGCoMxwYs7~erk=Bw*X zqQ5m0miIDPiG^hWb(VMsK@kf=ua8 zwgLAjqv1D*Hjakd)|f`a1%QzR?uR!L#vL*eNpPA^xJk_!rc5O!sw^e!A*wxgES(w? z{Zaz^z}8(@WmE7ndiNs@j0veb@JIzQ6h>chsY@xqS87Pco&i0r|lxKP%aYEByT z7^8k}RLzA|30)(ipIs?hh{?)X8=ik1L^@v^4!%pnkS*>!1}@ZS1xS0WLB|unq-y~P zrD~o8J!6lqXT(ecYP*EMkM|v|w-iNyPhuA%K#=`89tfr56-dkH@6Uq6TuB?7XHUg(KzG-+;A>E-k+?4?QikC#~Tl|2Njsc{$i3B~H2`6DKB-&WT{g$-52Ahz)$$ z;*tb2${y}7!wqP0S#e*n#){nFZe~TbdrJYDJAlAP%8K$uI**x{4fQ|Eh}g6R_S;i( zOZgt~mGoE}>)_zPb2;l(o~Gy##Cp}AGS+(xKZ@*I_nuMqog1@4<$L(vGR|l9?VJr? z6q3mq{f+aYFeMS|L3(3Ijn8^&L-@dYLV%iBPh}fb^fR48$bZFtq_c+$F$V)UZQh8y z!BuWyM{)&cS)-K@qDE;K{`^|aob-#^c0l&-*Qwv^{7F^+Hd)W_mtOzWrI~+oOYhX|o!H#%8pm{0SO~&d%(xe+L<8*}-1n6W=uoiZkPuL1IB^ z8^ypsK{o96BP~zAzwj_@L#&-y-_|veHa=6+WbygD)--&n!q_&=Y<%u(s8JY?G@lab zCPbzN*>_dk2GRJfv&wJg22o~2$`qAvmjrdyAM;p0X1dhIb;=7B!PK)9P=n&^3;{3j{R6BDK4nBTe@eftJ5jQzMzf# z$*msUaivCXrp1_ctSa<@0{>sMjMR)m>P$sx54PT~$QNz^sB#DU4Sw+uw&_+f3qT{= zJu8o(<)N+4hOH}$?%BMWCNza-Zg4j2bjqP_Ra?R~Tz2M|UfIdjZC!!fcX46)))Kp1 zUEdiy307vJk28DqnyLW}*w48xeO>uhoUXSOGaBcXFu<04(~S;Ns!V786MOK}?F+Fl z0tS6jS=+6G90)ot{fMddNIMx%unv%Ch#U9i?psN6LUqoO0`D-v(xR&b^8K%`NjV3tyd}DeWbOjE&3wc@cjzz%&+GAw{o|l{RTpZN4udyhER_oD z*d2{{AAonZQ5erB)AK_-_i^+rtGV5jE!e?BKgi8|aJu6KJ~+V+XVb$~csPb0#`5x7 zQPNM!D+S=oo(aC zQ3hb4@G}#zH2gSOhO{FIFes_aMB_GV!{8{`P1(?0aTy$PjjOS2^`Ll(2Sn|S&;=nI z;RFN=LWA`j%U*1iKxhWP@ZOgc>V^@_4DzNM|7Blhx6!R8Xk_Phb!^WfgWId?(i!m9*T!w z=;0zfY^8@mc-TS@eeqzS#I*Z=FvXmKhu-u+{tJ8PfoQ%gAp93*A*MOa`4GmJ<9m%a zEypu*vf-H#a!HNt9LqoiH^OBIS0GG5n1N7&a2vuxge3@%AUuii62hAZ?;;Q#_4IRN z{|>FVHTrjVgs6Jn>bnwC=3s}kEs~Y(%<{EvNtP#w!ioAm z&K0HkR{hBG&wOw>bNqz^L}7kB3AiXOJkSW*H>4%725H3@QCmDtQ5KJtLkJih_3ZQk zThGc@he@(I@YSp_G$>CdcM6QRw}?R#%T09aZ?uvQAjuQsCs|{A7WUrbeweLK!M1hL zqV6C^1zBEktbxUsi7Apz9+?(?bplMj((*9E)o>GQC>-#+6rd$*wn&C61F;xBpuu;l zIIE$!A|ubw)U^~5qf^#!5(w9h^ct()UTjj2wvIKimkt&;_48pmj#)~R;M9Az-7}T z=jT%`QS}U^y7?_vw?C@88(bBqx*=X&?6OP9O^V*G*h_WXBo?=*GNc4!eb=chm_i8_ zE4)O8WUEqOYPsHodJnd-!s+jSj1)Mv#p)PaFIs~(>)EW$YQm?C(%NiOf;RgJjOGop zgJC=}wq(Rtz*zSUW-v|_^@Tr}2adAA_HbLu&zCP|?I&LhX4P8nDuoYi2Z;?Yry5^c zyae3Z{}|u-^d=cobj1c))^h)w zsFXNR6Y-V&VMLV^3$1K&S1gs zFZ_bFAgP=rw39xtr3l$^HU@qV_W&;7zP~3TrXZ2;FS6UEzzb+4Jf-^|6>umfhc}t|$oMN;nP+Wc33F29#$g2PJ_43v0=C>yifD$Q z9+t^JnK=v4Bz01x6JUu!akUk|kc-B_YXlnRDZ4Ib{ZQ-+4l?g(&lD?&cGEF5@0>Mr z)=l+k^fU!ePT7hZft?jru@(w59HvLG%Ao;}t4RI?l6(?UQ9(%LT4c|29;iz5<>IS1 z$b1%8VIw#;AmkM*$xxO^xv~_WT+-kW^4NX3(hA3AH?={FwO(ZJzsinphAcD=uFOX) zGPrD&$dlshi9Dy@f~#Ivk$&Nsl8&5C*+%HtSUD_HHoiI4TsVrsGsVX4(!$p%N^)*t zVKcq~bs{lbFy&1;qAkZ6T`qZSTG=k<&44w4o-_vKky?=NEcO3w)w;I(&Eg4t>+srs@^yFm zZ)@M(hrP?UWp($Z@(ehF=y;*oiuGzb*{c3}_EjKX(wnWIODi@Or>_g2H-bj=pYVpG zn|vp^<;)oQ(QF%6l9irvICu_9euN$ZVnPZ7uhk>u5fKitF><; z9;tC{vO_#EPgFD?DJ=O~3#%5g*z;2;6p&1$O#HNpmOr1p))g#*@se!M;1(%?FZp!ReR*fRT{^(RqNc926(c|L2(8y9Qy6pIJ4av_XG`)oUOo1QM7Q{e2rNrGkA!IdIR38M15JAgLVnC>M`VfaV z)f1Sh`u?W2zDv;4s6&N!4ue@yH|ynI6@1o9KGAIA`|_n=92N)13O1dEuL66gCH|IX zz&@Vy7|@4{s0=IkzjrdKAN?EPNF?}%x{d_pazCkHvnz-;9G14?YI!@E@iJwtEr*90P>Uw63 z;{h4XSP5*NrJHYR_1{>9xiGIkuXVWaSwoHKvXA)13*FOs^sv;Xgfa0Q{5$PEVC^OF zec+kH$2b2^#&;eqh5JH`v>x2E6>KvaFPyW$R=9L)UHJ2-4a8pd{J zhix_T?Q2pwb!^;^RH=#w=s!$8JcKBc4=GMR(}Qd}V>noqohr&@!w-zgLN>(U-6YMB zNJc6r{bTkch{W>G=8@0NSqIu!v0IC6(>eps7(8w#quRxIhOL7&W*Z8F3 zUl(rkA4Q&xcjI%iN77J7%ii2K!`EJ2{AS*T6C%a9$X9SI4qb&(2lZ~gQ122gfQJWp zwe?Bvdd!cyO=ADqt|1u7m}f?_^ElXCpP4`s`Mc{@xLtBd9+sG;039hN)_HNpPRsu9 zWSNM&V4tsHXkMw;Fw99j>3@^?_NhzH;+V?3_)E_UWOdoDx$%kAHdsW+2?_mbf~vdG zC_((nw-WKCO=@+VGRqo%pYJ5K;qz79&p9!2O_ibfX}>cyf5Mg@e6hL+DqotM|3jhL z;AV1aS}Yn|@35rvQ!==YkuH&>!3x>O}v)1Y;OgB0*neG^&E z1MJi~OoI|8BOeSJuM&Y$oR-uyI#UXE*ZqjPaj)skN$jo*Jj)Lrp#G3a^vhEHJLT_P z!J9$3J#g=Y!XMG<2kkj9><$G@H z?&W0&RFL75x40ca-VBMzRKu4L6TS+W_4suWIXp6aJz~3QtMX8D-VxLzJB9`x4*$NMc2M(T}W1MG_dfQcd9L{A4_mxD>it= zY2jG?H+BP8ys0+udk_5@#a6KTJp9o$@cWF3_%;hP@WFqW8+Zd^!ez*;N3V-O9@i2i z-@uCZJv%mEan90)x|lBbYCEHeu?Qxbc>E-4;h6oEId2O2i`I?dFUQ>F;16dsHiutz zs_H23u2}8SFF)$q(>=ws{y2OP`Yek}aJW6(v*N5jLIN8W7X5I%wdhZ^e=tmw20AY( z4_i}MkD=`;>_HGR=y(Q+$ki_NZHn%Y(b@;7rGNScCS7aNkkW*d@bdTl!)hiR#LGV7K`(YxzHw*9Dx?~sJcCzrmWImKpm z{a#GoKbe(m!2m`6^6i&xO?z_s#$}$vMFtGJaL7+3l<4ZL3DA2s|(g>KE%G$%2o=-;hXLwdC#|E z4US0^YdmB@qAG&Kz;j9g_#bt4*~>j{8QPZ$m{X z!&{VWk-B;IGxt&tQ7w{5+2@X`-H7I1^iQtx!bnO->%#kvtr@kYu}F5j{it`u;7?_{L3mK4FsS9bTM%m_+tLO~v3+PWrI!L>(5RlAmvUguKUrK#H{g+b{%|jyS%CmYUcCSivH@HO`8eN3&V^hT5cD=qm11nv1C zOhrbOeuhKsjrr<~oNR1qWO5(=K5VstdEXcI{tTWBaHR-kNy~BEg-33XJ!$SxQ>y>l z)5;<*qYZt>_#35?_RfD;>!skuQ82B4{^qQ7r*waHJ`VYnKi{^|xtjLOIm$6yJr6K8FPzdSM@aPltbQNr)cRRi{3M`+d8?rP|mmu&Uj5YduIK%br_JSNS$y>Pp}ktv}Wo+6gSTRpK}VhIM+#{jg_1EpuC!%AW%Ag@Mm}Cj|$$ z#sSbUqF%5Iog>&`I{ipPwlMduu6V(zTy5FHkz*M9bZH%IgtX6i-rdw!R7F$@^kN(u z-@2EiNmA@Fj%)&oE-Y#UJG}N1Q$(mxySdP#Sm;*)Igu1 z#eGs)Cr;vfz%=;GznVoBi>j)vNC2q#!6> zZp~NsnSC9)p58NDIsYo&{)nsk#MSo}E1q#u;2C0OY54+LouYNwyUryIb1{iSM6Zi; z+-z;2j&_QnUqSS<#4!>AUpjbbtFz*+I&K?@Gu4Mkb1k|{_@XtpA~iAOlp( zLB3PI430T=91v5`(<9e;;YC&iw;Ly1X;M7Fi&HKNW@M3TPEU9FdS5rOpS9S3zSUPu zF>oZay5W)oN3wOyk&Il=@S)^ih4QahxFA^V6j(^KgA!dpIs21KS_-+R8KAHPr*e0+ z^(CLxA6r~#JBbj%()7Oi8vNajCM;(yI}(e=L2C8zOMTJ6+%pYd57yXw-NIecq9Mg2 zZ9O6}{o90#t|&`%I4&#UhBn=K2m*$3IAv}4=bqpFpx5~`_4n`r}Nh?i^Ye@PF(}l@up-H&^HT}zWl={~tz5b;Bb#D)q z)BX?jugAKpwf;ZZzi>YvI}1fIK6Lg5|IQ@(r}AZK9ytsfuRRAAUg7Q@{va3Z7krl) z%tE{E?kQ4H@P;g}tsb{^%q36xnKkwAg>@j0p=v_Oc0&gO{YHMAfgx(eswbvDG)J}IC0PhMgwo~6{?9aQN&D1 zmyygx(nSF#>{%Kn=siJpD73pGkW-3c`1xA(>0bFqZ^hFrijGx*QDdgCckt6x$W+zY zBDWUS-Drr!KM^AUAQ((yod**>(1qwh9!p=wrUe}k0n|M5=U(~coKgbR%qDIe{g7Im z3d)W$k?Dx|Qpy;u(j5;g;GS`~Ux?2eNd05_@G*h1& zqwjOx;3`sz(DiU`CF^}2SqhKr7L6_n zy%jI#EJFreM}(2h)Cptr+k&%+-#leC&H5j+cX3DOn0(QU$(r-w;q*OG5bYYGg|J5w>0;G!uu zi%jXnNzlCZOL*-)@*iY#fyF<*{XocPwQHIQkaX{iPXWOvTomWg6(LK3U#xcbo(S_8 zs%?uakZ#Cfb=C_c(c*XVIv-A5UFfwqE__6FmLhrmRmw?xbTV@SS(HR=G04OcM`KLl zDE9i1dH#y2E4Qlt_d%HMl#O*Xu+pMBF2te3I49y84&zKwXkpXS zBFQN&jn>%}BXTm0YIioYZJ`CQk-w3R{EE^&`b<)~*+G6#v#-Va6ih2&HqN(&qK(x# zp=duus)Lj6-Xxn!;x)b}JECFQYC1Nch;#RJIyP-;Kk{*Yh|UEg9u#Gls8GdOGNXQt zgZ{+GmFAWAvgJ-JBI1NX#+O)=vny+IRCA+V9cO*>+0&@*q)&gLTT0Z`TPT-IpJwMC zw>XA5<nb}M@1^bs%*W@0zKAF*ox|T`3 zcB5~(gJq-;3gw#A zNCK{5{g_C7_=1aM)?+54h^T%GRVEEvt#7QEe=A3Z%i(M-EAtnH^HvtU*k5b*{VT1DSP&Rx4s?El6|=PcG*dPs=i%yJo?Q4 zJ$-v)2esP&FX-E8a(sPz@16f4efzr;{seuycY8F<|5|-p8OP!%-2IND$|q2`#rSoY z3iqF)h0<*iuwA#Taod@pNS*KN^zDm|Wz{{Z`nLTDMl)KxNHDjM9Tf|k>DzM=_2=u` zf%ZpV->%C9)&GBeoAhm^JJM-EF=i&uN<^t7^zE09T;D#@zWJvs+^pNmUnusvSoB%Y zmec3Y(6`Z#|EKkBx_&32zWrbuR^NY9-&PhB56Aiue-a@(ez-%gZ-0fiBh$AJ+urt_ zqzNZxZ=Xm3kw4d|W0rBlK+?f*J^8y2&%y&(2-k(~E% z!+)%$YeR)ejF7!8*8KINW196RopDjMwTcZjMqV#@lEZV%6UrW`-Z{~ zri%Uv*iHp|0v?_T?$1#PVytlsYpg%SH3An17*l>Na5R%&e52E0+24+? zK7dwiE~i?sw&~BKfl+iAPNN}5>`$=pj=cr0Ww^yddJPwLV^`F4yueG^X=_wB7u1Cp zPx#O6ED-+vd>@fZ{uC#Ju_HaM6enYO`B8~bw#rJueDEC4FS1n*t__4V2j^H@iMY3u zOYAoB$am1{gyGyp!~UWpEPpUiQjhS8A#{^1-+$$LiU;I0x+TgVoXlBKVUQ@hupTRVpo4}p?wa{T3}EXxjO@pc;WE616F=l z4$MoyE@r^G&pw46TN(>qcNHFRnYhS3+#}0`BP3_n5$+1-l1qHsy~q)BkmA{Tr&O zojsHt+5zHgER?YuETZEdZ?Hq-aZxZqB|5)1*v5N&)Y8A5PjW^pv6&*%0}Oux`+25R zLS}emS5=zAd7^(}Jzsa8uxbB?TmHF7{>m-i!^!#yPADvr_esldhMVoplcnX;hU4%E z^xAL-OD52|kCNe30>r?Wj*Fl-g@4C^k%hgt7Uqr4mKI!&s-VB4E3}8l-!8kywq3rs zFRoyh0_64PZ%mQO=`uB!T!7@w#y?h6`Y)H%V?UiBsfw~-PwTQwU1_wf!C5{83{E`y@ z)fl~(q9Z8P7`+|QzO7m`hucaAHQycz+qHL5uol6K^(`hq6&fHOEd^#_i{*h3j?$fm zhvuJgiYNOVxFqK1e(ZBT4%}`28L`K+&p3s*jqx+XnbD?r$tj>*^vZKA$6m#MyWlrp z1d5LrC{4U?gYb>QXc3fm`n?umt|?UDeJKL{(l>h6|LUI!2E9{SB|W|C!~3RpO7{iA z9|(F}5I64W}-KULI&rFAz9LE*Fo$jY1xv}ifjesXDw8CacqjiVV zALZ9Iw8N#fbX~)047oVX)=qz=6`R6WqLtn9tz$fN&Uwi&FRsFrYorx*;jB`t1qXHp zi+YBGzel5iN+}Qm(AAm7{HG&7G9d@@0Z90(+tqv{MZOB;>$6o?=nv@cs~rF&t=QpQ znX2IO5u%GjUtz^wz)Rmo5S#oeM4Nzk9$|8d5tE0Io1sB9pnMNbRr789jn^Ow*M-&X zSw12=qrfEORvZ3Q{{h!at<}v-EB0+c}z4T%AU} zwTCzr8eeEmy|Kv8sHdPgW{O(9pvV`Zd?xChj(ohZ2pzm_rd|p@$E03sjS9H}{8g0S zM7=6BxB;y#w^}WccR^Eg%7>BCEl=Q#d@I^%qgSq_cKRD~2u5Dh$O&)|qoje}M5i+oQapMk3!=1gm}O#MZszffUm=+2RK&tU#27mabsAA99OxN&a|w_k$l z0#H`L6S_#_^@am+;sLpicH&o|lE#KcnzHPwAP@Qv;$GK z5qa||#2B$!OE(sEx8jl(dHO zo8(pw@*BEQA1&V)k?$_#GZ5rQw6Y;n(`>b{GexG+R2WGGozk?zoUca9SN}67N5>eI zyxp8{v6k;2BHwp^Z(g|}=6s`&FH#JdW+ua_NJ(S_f77_jD#yh5KTFh_c|=LKqNF}s zBT>i_b8CDI7K+&#pKD-J1ekLO0iM#XfWQ}$BFgx(&m*Oj{JtkX@`7~ z8x?Hp?>8fTdOW0e_|&==i2}<|paI*j(cF=dsDl~mMtq2=Hf`0QHvGh^(T%FXc|{ep zGV+tm(zTSd;viF5X5!Q8vy;(80qN|q-i`YRE1Dy8wN-7MHAQc8x4sXGHG*Y5Kiqt?u~&=0&GxyWQ5 zC>ERZJ+9@e68R3mG{{&el1ts##Oz)`h$)F}8l<@b(#wEkU;@cp{H7aJvNSDb;D?OLv^3i@|_~`4WoRfN-i_!yFttM_4mATSxV(1vvB#9 zX;Km0f&R0*dHh4$5x)`fX0lv>5+U=Nn~3)RMXl*HQSuX%--K}!8jsafG0eQH>&I|L`V z%U~fukYK?r5Zv9}T?U`RgIkzypSri})|H<1etd7OdPz>z-e(`VQdQkO9M_$2N(-Jt zKhZ zh+VjYzkrt2`yH+|on1zl^y zKKCAKN^#JZ$|{b=P;{)PCk#bMhte=BY@p$m^yl_YT`oOf35W~4RF}>G+ZmO|OI?^z zm-zPdA&-~h>{L8$cYJO-1h&JrM{*F)?BFdL#gBt)I7P9eCurwH?ST>nVP6r^m0T3S z#|f0&q@Z~`jc&hv0ru#yt2yfpAI9N2upJPGk$nmx(ATCFWJ!<{k(8#(W%%HsXE#SFyEuSbiFp13o{ZH z!!<~JH#@`GDN{+?u~YFN0sf(aKV=BI6fs9U6P$97X*q=7Ia2qg*}&kSX%@*^1yPU1 zl~Q^l(S`=q5it8veUhCrsa}UuhCaDucgh1AEpbSxGFk=zWt=XCw{fz*>@JJ+#&5tY z(@hEBktEEp{PB2Y;H(9-;Z-~(_U9>;@bo?R)ZO6e9BMCly3^WG7?b0Q0Vid6jtW{O zKxgl;uwsz2Sk&8FV$dq|%J3Yc4tR`dYApDMa=wj|6%i>_5!nT(3I`1V$X=+eshD%s zEMG#e8QtF$FR}tSQ(@KpOn{}tEfb)V;VcKyeC}PN{AU%{4LEBgZHbi97V#(Vxp-65 zl6(4NlHNq`Q9kP?_L3^`Eu1jM{Xh`M<;35ESgQR3fTg(C3ed&dEbcg@Cazt3T7<24 z^q^OXu7N)h%>~~`&bJjm^raRrm8#=P3*_;8ta-|`osg#IR$x%fLzXw#rXWuc(PqQCsvi7FXaP>B>Iv=un3({kW> zRMp@E&vZg*7p!<0?$66O;bqNDmb-i7mDc)!xe&8n9Rd24gZ>7{HLchQPaveN&w@u9 zOu0Sl3@|*}xs9$eE{PB6WmbftS62gJ?1)xC@Q%28gGCje1S(nS47@#Nd^cp@3fuyY zyBMYiRtPvd8vD_q(_rafre<(nCa~A`^{^AOdSY*&x_^$c8s)!j=EzUYWmF>>iu}KU zm*nphxVzU`*vWxIPsEDkid{2aSKGbenM^i8Gn><#9tZcz>jkgRy>BthTh5W)lH>jW zF4X>O#F(sT&;1GgVr%w+`eAjjnh-s;hqW2^i^_y>m|i6p#}$e_{Y2O^!%p*HO5Z4- z2?uSW@7ZP>qRL>??HSFcJ)z3NiZ14>YF`IGzoRx@E9seqBi@@Ey%CsZ`juqaDW_VoG z1{B7yIt!{Poa)dRT|zchLLq@`$Z-=1r#$(2jwX>pUcK81ITOd#C7e5rTN#Mv=%yLo z@Mox2E^NVA6IiS4TVUz6XlvS~eH^VT=mawADzN#U)8-T!=3ZgxJ4Z=(JL_Hz+6~ryyqHw6u_45$6UH)Sh0p;A43nYY&zbHHph{xv_Z7cR9(t zc$ozf#}EkhE0>bM5Xg_>^ow+QAi2fqGdL{;5-iSbAgC*lf%K4B>4tDr+!)9oJDot{ z@jyzCLPe6<3n3-Oo>}Gt&jTq>?v%-LC_60{vC<74+Krc3eyow8RZ3M!&^}MAM3_gM zJBM@b2$Ny$QzQI}elkY5afc%%7njnMq$m;Y0-i_MlH4f~&SR%VgiRYbwC69f2xA!{ zY%6HvsS#Ed=U#pzN4S-C?uvwOaJezU9zse*E@i+7M5y$@4b&GAiV$XRcS1vC^4#K%~oHXd5el;m&>{XKat@>^;|jh0v~!^*z>{ic@wT@o546A;5fs^w4=0`KMvZ zMz0BAb`#tC8pqKO+>yd~8#T2SfQ&Ksz;rHX!NM#z$|a_SjFkHrPzl2N_4?r z0ab?5SybLYw+-ef=yHp37Jin+o0POFN$d$0KS^wWQ%cB}Flekj|LGd@m^CJkTI14s z&KNAgHFg`KbmDn*fT1QkU}ou)2235n`1lNqIvp6*s0VShVZgM+DeD_Uh(D4Ly{ZLZ zj-m{UgrEjo(1gKCh%eEPh7hm9YzVQYV2s5Xi-S=OaW+RALL7oqme&wsTN0v&SRLjl zLcCK4O;N=#=cP2$MT?rQJ6>k<-EQ{Ntb~mQ>4R)L8pfb?5zL09rKLCI>plUZ46dGL znkFzu5%Tlej>h4qn8wWmb&V;^&r$h=0Yt;OnWY7&Hz0#|Dm#mNFTy%sNP^fnv|1PBvNHATgK6bmY;xA z%3PL9knTRg()PMP8=1~dvaSQ;YiA(=8plDq0NQ3F?0Zam2bvBz!-$SW0;BJN5Ps{q zBni9q96%gOXI?{N8B(+#<|vw>pb%&sXHlg!kPkGIw}IJ^|Jya4qE6+cM}F1wpM#?f z`HzoNO8&=z)aq|o@9v<)hQN=(97W*8g~pf1Sm0SmqmtDTX7bK38v=h=0~&`JX3COg znrvJnZRe~423!m??m2piVzY6koSei3hMa8TIBF;MRTUNl-%?~J`TGqs^B^-_+ozLU*fHC0fgrUMdO(Ls2rq97Ur}5pF7QH~q zyXXQ#;KyM$1YV9b?l6qB*=Cv%FgqiyvjNxAjH}|tnMP=CGcGB|`5B=jt3v*Nh7o!L ztzpQ*L71aRab3J_gk#F>p zb4SW;?V8Gt%yOKuFBt6?Qr2x+nv}tC3jJcp#%7qK$VNrs=H>yGjYQ-|85F;O#ZNZs z;*^q&*FQSi$8gdeJ(O&uC%JkyVsl4IHWmoR!kn=K82L9v0%-O*OUs6mlWm8LIavsE z6gepQ<|uOF5jokokLASrMbAkkF4Zu3=EW%`Co4q+%{l2* zkV-juk8&Gw5)QK=Ck+H+0?t^5WCl?-meX3KWMc-=>$h`5VU8jjuPQplT)LNK<9ate z8^yUuLpCztl#-1(g0vVp?ZOF+km<>58 zA{d|UW->F7%s6&V>`^nCmMJAC-N=calLjzHk&|OTI5`>2ovrVp=OhW2YRJh4)J@4r zFF~4%lQspZl#{)H8FI1$WOqT_l9R^dM9)cim?8%HhiLE@1qk8eow+2MJ<|&_pPsYvLLf}R?;?(nDq&`2h4`F#S@GRIOD}m zNSl(TLT0(?IH@(%(nE}9#ym#7qX@B)5R{M$DhEMQXDkJUA;ifr8$ygD7YY%WlUh>^A*M59V!<3mh%?GyGgu#V%IodYV_+|5khU2OZICt}W?z$984UaP z!Dd`LH}1FrSHX-6;W$5g+yxX?*dr~hN)%S-4tmDJQC~w?M`4a4dksUK`RK(qR?f^I zml|XgG3#TXE6j!li7goCaK^LkAvXyvxJ7AkRYpU0vvBIyD1E58?QK)N8baM@KJAg9;yO`7Y)+gmwqwx1mt&VSIjS<;KsZ|SN*2hR?m<_FVzof(1 zk29_YBVX;E2dVLaW=lPP*m7g|r%0;%k|CqIET5i(wFVu58-0~<@s zdSKmQHUt(V80T}w3$2~NoKJrg1X>F0_hAU^54utbEH1g%N7w5uQ3f`mgp=P?Tt-!p zOOwM|P#6N639})v{DSfDMwY72t(?FpKlUT+MnFq}{WuhX?V>A{!19rMJ+Ra;N730U zi#vgp<}!L3$SyY8?6D z5A~~||JHrygjazx_6MVD#<1?va-nqDaWsh`+zl{CQP}dr*|l{{egbl)kasbY*Mr%5 zWSD)wH(#Hfi}5o_Z7J$RUX_a(`m>VD`>41fmnUI1 z!Q@0AvF%`vB9|YFIPxcQXZxD#xy)oH4}#g4%U5UugP7|uN70v^gqUbtOd*Jo=EWJr ztoP+mm<_p1Eg09VWx2f9%*iFuSU=LzsN}MMS^hU%zMnnu>cUPg%W!AC$(cfa32kD? z&2E^Dxm;qteiF=46gGnpvvCcJ+-j=ivI;Tlxhw>;A(wxH(R%P+&sGexz~?Ao6aohq za;uG^$1|@K!-bV2{692A4KbG8oq^@HNVB z5ZDPJTXhTq_v3nlz*R6uk-@Y?SMZY_Z%;E_lc?!VAzmxrXPqvqnJz)pbc2a5?-%V3 zaq~XdD>v3YmR+h3>;+&~$IB9QhaowWV2)xg$xy(l-o{nD{~IaQt3u3%{)gF6y;J!e z#+ID%4>0n1IVR>3dyn-Vy&~l`OD?2J&uZ z@&+(lCk?A#Y4i0txfnmI-?n^CPJZHIhBs8Q{BX4~%co&BWVxMS{BH#dFCQ3PS+-`- zVx;79C^^xGcn6rH$mQn{NB(5)>_7v(P+836@nJU3*l*At1~E5bjzUZ|L~d0w4ClpW zx`|QKMItt9wt=p$nXXjSbZd$3nSm~rneHXpA&Ovs7MV}JoR#^<`g-P9fW?r>-(fcN zPCU{W>!aQsEzLAlqSm<6>vTu=WlZCedb-A#X7U$kD1*j!AhiMw8h7J*L#WGOjv|k# zgvL`#nZ^Kv#ujGs%4UrR@Q&F0Qd@U1gHkizYBk#VcSo zBr!7y9RFG`^shvtPXjGsjv|Q{@;Cy=E@4UBSw}B)S~Gb}n5`I*x|nBZ8iSZiFq0TR z*{UGKd|AxIgg}h63I3g!^@VEy%!X{e{TA6;VaQe$v%o@Jpr38-643E-HsS&&)z-81 z0;M)Ye+6b^wsxDZUj}m&*-9nEoLa>DA7Z3zwI*ggTh(ATWb1HlWb23_Tj|UKV{w6g zveg%KJX?9Vz@KaB+1iV~Gh}N8%yzbvw+DB(L1at=Pd_tH3z(zG;`v;T$T1697I)NC zvY4Kj^(@AQ*^tGdV6^BL4%LPF3R=bx=w6tk7@_%vz(;>EfoUL6CGT%0Zw0fl=PH}8 zFUZCC8KH}FI@xN-#Z0WBWb0ql+K{blFdMQ}3yfAw!>!c{qS5EG-(ij-TY*C0)&(qE z&#LR$s%j=L3^U7?@|l{nI6>lFPa^2y5Pk16Koewdfe+y;5PxKMvh^(&)11U8!@lSf&9{dyz;GDS5mz3) zj>q1NeZf zDM|q7_^kBDJeI%X)pU)y{gWreDMjPztPW`zPTHGDmBd{_7ce9*%Ct-lE-uG? zPdNLQN__r$E^v0C;i|+1OcC z&qiAESRuOpo(6xEDn-a>|O?^V)Z$0JmF}0aQ%+^Q&iJXv5PPx0Rf_9J@5;mR$1DOC?#8g zOXY;{lKm_cT>6uxBQ7aWMn?zc$~0yDgi}g7o}v$|ERm3*&}8;c6C0GtWYEY_jz0JgtXf*%a9m(Am7T^r&1xr7w}S$XL)@u5ij$_2QR>dwE%PAk(O;o$sC z<{%bVM_}t0EKqi<1aEeJY5m86;6GJSiJ=_G?H-k9);uuFgAYv`oeeOWvsH6*e%xXOJd4K(!hU1^=7^~Y`!@k?Vj(FRlyNcR04!DB*w zPbeyxtF8XQwZ^YFj}iKA{=xJm;*r}Fv>WRQu+&zsJN*}FUH(ByP*s0EvIrmjxR2EU z^LU&mo$*ySC)yyIZmOGyD5Wu!od}+9LK1T~KL|HYG)sV&qPa+J;?R{!(gyhRR7-eT zHk~EyMtPPE$4x2K%`I~C7cNr=(ZNXkhi{Xj0M-t~@QL1lNK%C{&rFGUG@fcO}O5zVu*O0v210 zl>v*KnuVW!#U;bJBkBpugR5w6bW-{hRW*3M2s4xiKN(~H^amzG>mZgrwVHq9GGpJg zPU+0GyHu7&9RaOkTXhM!xdfUoo~)N*OXyGCAA=k( zCAgPv@M5d8vSUgm8v1y*J+B`{;pOZ{B*!mtS-A*e-;ZpG>$`RiuBG3;vBCDf*!lfG zoY@wit`pnku4GGS+Z={Q#IQF!Xj^LMT51TIGfLwW2?@GQb5of87l{T?KhH12ddZQT zoQUba?4Ol%?wKN|=^CDpP0?@}Ha{A6;1p>H!>^l{ug-p6=|f*=_y!v6{u6&Q37)1>F?sOP`ir{ZWoCYlW6 z(5gi0*obu;>;S@;w%%YGHBnjL*No|TzOUAGJw>iPle4-()+PfuB6jQ4!RsM zpIRabwYQS=3P2c>UM-2!c|9hvq%Zwmk17`MQvQ+yXN~%*d%B6n!l-2XANQXayPw$c z6o-2%Y49`$c-xcjN26B(XKg1>N~U|*o(w-{oJ)9`H<873zN8*g0pP9OpLOEYHnHJH z)y^hzLim9b|7swZUe^E!fD)xrM83NZ}M(5&h-bfSa?;VhZ zBAmmycr`9IreK7q;??mi1@R5SI|DCG2UP@a0moe|u2;Vha8i-p1Vi2oTq#Y53H-@> zAbOz~chiO3D0w}FK9S_D7PtV8D@-_hdtyJ9P#DI8ff7X96Dx5fGOk?E(Y}DKg;r4v z6lD?Z*d2lGE~abC?`E!NU`}LTU>M6037vsZGK|&c7jmGq_gOTKG?v#2Tnvu;4mhc) z{sf3OmHP+aN5YJzievae>kjOc{x_C>X^Y4Yey0m73WTxgN+oatYc-AqHUoI6B|f8U zQs=}4$jW7Ka~4-RrK|W+AGK@k3k;)nG@6lb2yTq!<6qU$!>7ad%a=6;XekF>FN)x4 z-|l)~R~$IIhwM>Hi@Ciy$pSMH?0R6g?+hN;&7yKBb^VCi8Pj)0q%SL1(0~*uGxt{D zr3}sxxMyQnxEXjQ9BQmjQD|eX_Q!K#PRTV?A-odvD&VDDg$Z2vC>C>4!YMKL zRB;93Lg8t{{Pzd!y9;SI7tyD|z7%#P-hwWO;6Xt>g8KdhdPQH17|C+G zh44ylQv&aJqus!J5m*(D8v>jZ*gX{45ZDQr{RH+8JEaG9q%#7mO#P`e%U~cV^LA+( z(vqcI(3D>Q(R2-h;D6z^b!?|J<3_N^cNNehPY1l+jlS(?9)YXLaif5fBDYX$L*(aR z_7nMLcFGkw|FeLnIwA5JXh1cvkw6&d-0`uT!2TJ|0(+2O53D@!(wrM8aQ!%LHE>d3 z2>~($_7N@MC$L-WR1oqHZxw^=KgQDU*lYXmWBvqwWpk2lI^xZw+b`h*GFDuQLn-h; zI56g+wkXu{VJr_f^RalG&1PwUA&WZt!O_=j+P7xB)U%z!_F~xiJQrCj%f0mBUYuun z*U%^2%V3`u*B$nDcAB*&Ntq=$Ukqi+GlNrIw}%5~C`KokQH%iB>uul7c@1_-|2ud& zXzE)PqGvZf5XS7ji|KS(Wv+2B;gyNwHabb_vRwj~gySj@PT7+z1&+stM>5W&I2mS& z&DTxmBl6-yJJh0-Y^$eXhG+taac(Xsl#Ct1vb@u)XCSRF0^bDiC597u4UQWLoKJ+k zcZxtOKxYhBSiYxrCvnOU*(QbvaAsNGoc;`}pOwfUYy=R-z#0jGYX`Hy?&sA5D+jz? z8ed?U1+Fj0ts)$i)Ou{V;SK-;4PR8l_i7_JI@GoVN*UIDa=>2Mr@~r{yGwN-Z$LZP zzsPKFL!GB^b6`d)1L<~$m0fz>I=8)3js1gIuAS159k*Njce7VHc@8i z>o{qgL)Ha2S%@`|)vh>KXj72Fxd2NO$m+HTBpNPLI;=IlpRsal_B{BktaTQ4d(gS2 z-Ey`p!<3#z$m%wL$yx+F4RB}Shy^eL4&W7|MEEN66a_Wp^diha#1sRZuka_TKwyY2 zJZWRtQyPSafyubRZV}DN=jQ%Q_>){rxRcLnW_3lFIy^y?9??v001Z>Yp(Zbut-+AI zTOLP40j{B~s^J)l&EIWd$Loyr^)Mqtv88Tj?j>xx7<^6c#_7@e)Nar<}U$y-Jf+a@{w?BA{^Gi*^x0Lf; z&#s4C9C+*dNS!#7KjM%7Inh<)#KS-=MfU*BB}I1tAghMqq0e?)X>8Rg!p$QrFZ3tD z)2MC+0c>d1wm$FT$HL2z|0CJ-b}4TAH$2`>Ed00S{$~?jX_wC^uoUUFFHU;A9M=*! zDLsc&&|(4l)SCsHmz>d{v|>C!l=koxQ}75d7|Y&BFs!hE6HT5UzEJzdI`U1E!Z5S$GLtK7#xS-1ouBPZ2J#Bk)vrdxoO*{1h6(F!yhU z+0WenCp+bu`?Tyw%Ht+GeO%@epcJ(#~7z)3?VOa*lipxqqwI+LE3S}HETz>Vg(?S!M? ztSNW&k&y@t#vykE`vkt9EybxjOjDfv)>xgK@$!35|74ZQzmg>J* z;J)R!=7dxFW{-*+jQtEx7AQasIA{WaVv;*{|NRCliKHML&0tjE%1=B_R$5iC5MU{( z!$eXqcVo#35(-GXHT#mHps7Cvg#_6+PPQw(l7oz@0*?UI;h?buVmYuCyu|9k%j`>M z#8tF_F%4_qIPDdK^LdDd3Cg;havUh7zIldnN>w}Y+KDkE2i0-uup%z#<8c{C=tED*?cR!p|Mxw@qJEWE zM>xYHU3`4)yim8L3k&#ZT4nk932?p$x?d(1C4c6ZiD}s>{bge93|M}Cr0th7lRZHt z&En7EjJz<}nW9hnCl}&BcV^dxiPFHt;EI^~3PRfB`G#^E_iZ24d2$-$ zO<8%O+jQ*RgL79;v+}kVPRDyYv0AnyJo4ne&DxJ9wRQL&!0o%>;NEv+xZJ=|ZtV$y z_D>T5vNJ`G8$_}Cz-%|Lo~_30l-|JSF`-+VQ|nEZix9@qmk?+CjJ`VmI^v6Q@m;_z zi9d^uF^s-#F#8#O^Vlg}{3ZGn-U;kS)VAqN2%~uFS3jd~#!E;1zz!_)|D@6rlgKak zd(>HJ>~exLC+BQJoJz0m1k%u}OJMf(sTk2OMQ2@X&veECr!@LHF{EMi)zn4K1EIAF zOTC)LY@9{!r+7FM<>-5Y@*5($05foYMqhFg@&sEmDVF&}Mbn7=xRKTYd&U~esW8~k zH~3Rq@~8Pz6IU+ZtmYaeHEf(=#KwLq>fesnKZQPG69F%c*o0>tTzQV`M>t#Q7Q50k zXs@FF)RSU{^F1uwO=swtm!9WE?3C-zvh(|%Cp2S50-#Pv-GPuBoPXv#=MzWf+_o&d zbA(qWr2N3MCI*fsvV3P8TpNy?MK~qAPiRFoJoel!oX+T<{K`oYlq4pR5xcN!alPT2 zuQOqmryVLgdy$K^GuJam=I%Buyw}N;si!V6(*!Qho28gQ)2E2Cuv4z7hv&ahN=!X9 zut!qWzd{Qb)L(~LE(>c~{--@UiQbFG)fa+#m3*3+d=SixPI_>gLXfU%%~BGc6r{@J zQ<|e)o#b1pv*MI8qwN!IRF9K}fm9l?&(SA_5qlYCgUoJVwDQnMRT^O_(V#(;fj=2$ zXYPqXE5Cy4$}h0jb^D{>dPr-|Ii8Y*yJCu*Z?fQmCeb0HZl0z3B0xQold;SA8{i= ze5M5pCeT3Kiind_mXs(f+r)+s*#!vVKAd=EB0Wn%z)M*=_P~j>6vy=-oHD(hN3kW` zxnmA47RMDQoHD&qznZ7lp>#%{UXNiuv~D44WheV;2wL?J>}soi$34)1V=rWUvp{;B zk(=0#fbLjYiJq$TGb_VDa7(j6I0|p*;iE9qY=BV;I{Nx{+hzD@VG-;sRB3bRQsZ`R z1kN~fLEYCnw54BYB?dLUPo78}-<0NBWjH7E%k~+ybA(i;PFA4TaDh37Jsc{gD<{1% zNJv5h+jzfh-Tkv|7A^W`GghoK3G_w?@yneYXIS$(KgZBga8~4;1HdUYz-@E}g-&}o z)>+nCdWEcHXbZngZ@{@Y!@r)fibL-9T*jTE`x57@w$>N zy?n#*ndmkd226f4U7D!rRuSDkS|gNL@1ZFS>Q2Dy8!n{FnvO+P#V*A~<~&W{a1op{ zWX|1%l12u$24*E?7!{?QB}l%FI8Su7FafIK;+pARqiy6?mC`-}biBb*HD(P~HAo+V ztHEN(+H{y1owU#MlEyw?bd7DyG(SbHG5n6Bu~#Fead}*5RJM(AxER;U>RT|LH__&a zFhQDulhy{QG*4^>%&={o53?ca?*!wihD>Gv$xMk^#%gb?3(q(2a;lHw&CZAft#PAOAy4nexJ0ZYigcw{7{xHie8 zd04)eE@_r|>9!MlN6t78jQrac0idyBVntMk#tRhKkc%rYN0I3E!r9mQOn!cHrc5YP z%;f!HHY7T!AYIN$Zz9QRqDykLA<>y|N=fwYTTWVPbJ8&&l@k2~Wo0ma8=YDxNzXyG zNQqb!?VI2A42Rh$qW(O*Aj7Q{)=WFqv$60fo4M9>-|;b~o~2HpF_fSV%u$r!kO-`Q zJywD>M6R@DFjy$phHSk-n<&}(MUZCWqzyqTWsCaN(3VSJHWW2I7_Deu^v3H=H2Mf{ z26GfqpSkIjb7Wl>^;T3xZM;-w@&L2O{(>}wleQvKC6x!z3Vu>a{i>ugn;^YjhbavP zsg%m@fEiNRh&xg~wsheJQklw-%G^Ywr!pzbQKWJt==kzhj0^07cL{1LPoWPCl#iZ70H`Mnw%t(W^%^+t#J77?!7%JWKP`}LMO98zw}ToP zhNY>%o{C|Ov!G{tW@%nAY(SQF6^9?l5ZWxXX=szs#!dE5z8oCldD6=3iPy&K`LV6n zvjIn~c3#i9_Fm7}4qnd!9Hl#YJ@s)6#_*E-oo z#&N5+*YgfXf<9hPKwtRk=k;XA@e7W)zd|RD1vvUZPe6b0;b@Oz9FD(mlpWypEWxo0 z$0Z!G2YNmEa5ThGeUR6421l{MUe9|Ry@z-`$%aA)j@LMv4D)(=;h2D<<#5D~qw@%_ zXC98G_?E*>90NvqJ)>~k4flHH;-8yvyvGqd+Ut3UW9JyJ=Ln8)91F*KJ)OpRJ=Maz zo{;fg&lVh|CwM)DCwe{KPV##C<48Xlas1}>Jit+Kiq~@mN9*6co>w@!PxE>@P6ziN zUQY!agK?a~k#wfl6Mq)!gTum+akkgf4acBAk>@#xe=ce}4?5<1JvSD3Jum-)zlB~; zI~=OvcfEh1XMNrPq^Y zmDjTjN1@eT&psSO|3~o=9AnobCLGx}Am2D9;#h)X@J96E zCa>o>j{2Luo~1b6;V8caG2xi76?NN&-o(*tJNjb>Y&i1n^m?}AIFF;}F0UurZqyxz zcaPUoai8yB9h{VzH9`bu1 zF|0wapp5-|9;wb+Rx^Z-P2!9LI3n#Ze`~>p6=fmxWy6 zNc0$fab$er^~}c+`V`mUNcs#hKF2?y-h=C zG91w&fx(f)6XN+BhlQg^v=C2s9D8s~4G8hv#W65?i03$t)PW(M_Ba;fc#We>j1bR5 z9B*QVc$&lx@f?X0;t9ubDQ<`-V?10RKg1J1L5OD+j!!toVh%sy`d`Jdjk6@IGPX*V z40Y<(3#}bmC$w&8y^6!1mM&l5-Jua#hG5N#7Q881m9WQ=N6O>vU%9b8vxHO(yIMZ% zR_G4wsyxF##0nlg3I7(lB{I_EsW>6o(TLNL6=#HvAJ#2Rh^J!oW07})H&qS@-c&1E z#o_y-5C533S1R1G?Frs|BsBBs11&nfzgi9=LaY)XvA@sI=6rbAu{M!M@K5cc6u78j zGkt490Fhn)%y-jp!xSZLVZ;dcgy4&NK=z}=7Uk5-9(wo>GtA)kiy2(OZRe`wgA ziqYwf>b~GjNy-IpDvN+B2auM~;`@U~?8eTi;@&&4D+L{)e^d-QRx$cjYdNe;cG+ko zIVOU?@+4{KcI;j}Z9>oA3p>&#H1at8TbuHkZ$l^k^$BDVFLXg&aQbqzPyOHZ?JtMr zH$)X#uK1bY5vh$L1Ig-2MsWK7#b2eci%3am7~;GVys3EbrXEO0M>`=A&niYn+A3Hz z@uB&VixF|yNtT*Z>>sBoLla=Po!?@WXcJYuS6%f$lHeaXf`2cvvFL^@ zL+F~3m+=1}w0l_zGIB4)ISUuK;|xy!Kj{7cjF_}+XK6}vZ^9{OxLx+4A(&MI6k3;1HJ$6M^qi&cpEq$AXk0p7W_gJn2$}cw*w8TXER)RYgofDKTfou0vB6O;}-1 zF=u6{8uqb#*vp}xenDn}NB^)8mEDI4sp$RFk(iFY-NUCN_nl4Hsfev_U)%Q!xKClv z`+c9^IO^=Imy~B)|F58Q-6n?u-5+S&fC3X{e>(f~5eL!mu9UBuyL>52uEb%Jhs z<&T^nB9>AmoZf+hfSu}DCUa!5uJh6l%3$?YdB z5H?pqbpgs6HeU9E2K)J(-p+H6o$fr=2 zftut<4(Ig0auR+Lr~@4J4WZCgRR7(YQ?|_qv`W&^EP;zhPQBcp8 zBjLU1I$2W;TxUx7K;h+8X_ki{b!~@V%6X_DP&+s(DNyc&PgNjE1!OFT+?flRlyIvI z{!Mw{-ijVlt)eUBKuUnu6iA@p&&m0R5?bz@uP@|4PVIM+{JInizcNtnK#nVr*??F{ zbiuVA!TuS~Z0zq_u}3O2ZH58QhS0yG*za&Wp^N0G+TbEnRC&qSyZ^M;5kG{(J`p@h z))LTXQF`n4cl710rm(vs`}a9!P|AN8K73{Cf!rG~vd@ZOY~q1y2`;*@PWsz(IEw?j zlH{47pyz4o`j}{+lk8F7vt-};Qlrz~BQ1_~v zS3qiU$Vxzz=yE8i54#ZEo{z3icVl2j_Y+!wT+BmzS&W5NQFn3hu`H}Sxo83xcI;1P zC@GkZ%S|nqKsX!Don6PRm%Eu70czn@u$tAfHl;p9g9K#=ryK)H-fYo4Z1Wle=&&oU zyzRXgNVD@Z%O0rWjR%a_Enb4z-dwwPi~nZDBwFW-)-=m;vFo)0+lfwvk-7+bU`(gj zMg{GsgrK-#XCmrl0n;i>>x#-|q{g7K0@**vKAT>jvj1+1 z|CiexNNWz+35cB}>)bo7B|_ZNu1>?1@<2@JN7@G=?Y|;SS{+5&Mf^!3_dq;IsoAQ# zSdHtD8TRFpdkpK}|mwYtV@XwKvZ1ao}fNpFC0Gn_Q4nj|T zL(S{#t;=X^p7~TSADg%`r7cPyD&gC3{bGo8jRSHUfxqTs8m((_Jul(K!YogD;LSZ+ zR|D$K(?9|Fi$gw5bw*<#AB}w!R0VON2c-<&Tm_taAI;V zO@VfYbL)W|PE!FnUx;NOw;s+i1(idf=5W;8-+4Gz+&5Yuw*%gk|L`r2;5wXVHSx&d z=2E<`5UBJV)dwhdnD6nofZSEdF)zl=U6{P1(}U&V;#gp>8jb5%w@2Qus>)e>5U#KJtAffrj4io1J9F=6;(KTJEu% z_b4;s=}Z%WI#+;YCYSDWse;NbP=9jNo8ROT^aRB9W4dh7Xa=LbTDW(*+vp20iQa0X zHa{*l1-fFB6KHzwybqi!fxfvb2ijAhto$s{P(sPQwo5^MFHq|_Do6=53=p}I@SLVM zjP$vt6!r|q7wMoY5lwA-Y}53l2%OA$}tI7 zn931LkPqPG7l5WI%12%sPdmoUqmSw_lC!F+GAcH_>F@FO_?+L+`!7vmGsC3 zj=XJ7QJ?irik^B|u;qYeYM=_i9sraDn~R+GdagMgb_q^DP0*Z<15)0)VF2{9mH62n z7EO)r#x(xH{@)w*@YPuga?Lbb~ zjnlGJ2A7-Wx40rp-fvl!MiW}<+K52gnRuRkVGX?8z|^7C;>LBemqoaq?}d-%W?nMt zUgiSr-dJ@JsNXs2$ym8fIx3Lj0@9pAwgAFE;YiQMtWLOXP{PaVNA|P79odOFTL(qJ z<7=|!Z31#T7mKtA39z5k?#3`yT(1D$RG038=MT>FVvHPnSH*QH0cph{I{=ZF%82h2 zR2-nJ@z^9NrA*{U*x1!hPQK=30oElia>JazifR7CGmUjS?51#s3)W?v)uV(v1WCV#a#6*@X8u9fYzp@#2e36>AR&{1YXlp-wFJD-29ek6#XD@ELdp+;q&wLGWSE9%b(%OI&Ntd zzKV-X6<)B?3FT0B7D_r1iZ2nfeJ&!R5&w8>6qHo;^TQu1_}g&)T_fcI^F5&M4oV;( z1vn%O5Z7cuIgIT{>e9to&M75UCOqs>)Lp+s(d$d$!WFo_i{6ea?d$dXt<1Qd7k)-I zmaUf~w6^ICwEKRG-d}N43y#`GC@Q2VV-cWuU-QahSCR=v?S*(+?Ch)ykF+S?UNpDs zPT~JE6IY@<9|fn2BA`Q9*4 z(>2zur`lAL^DyjtafLF~4808da@Z-4DX9U_%OyZ>fAh@Qc24-l6Oj#8d;XwtJ+>qM zqkM=pT&GMBirK3!iHU7DR3K-4c;1|)rs5AToX^a%l$+2TN59;*5>PgEC4ygNFipfs z_jql()XCp)&Ubw%PmP%2>no@n0#%ix76ZiqR%88EFomCRZZC1%2Xdmuy8El=WYNn7 z>Qp9{glvS8Q@Bt;Wsc)Kf1bfnFNesf>jnr*-KF-g`GZhv0`_FA+}5MVTCd!sZQC^B zk-cZNy}S413&kHKNXh+oBV1A{x${u<*;${2T9BYr?~HS@FrAbK)_Uh;Dx7o=^_k9@ z$aa9)GnD-^f!5PI7@xB6PPo`KKJSaaO3)x9OZq>9HTiiRS5wKAyd)=bPWGXbvivt^ ze1SK_Nw@rK&Y9AR{5LN(`KxiUNq$x#e^v%2|J5MKPiAL7I{iNeb63aJ#kQLKnmFkm zJLeWU&0B#}&I6^@3b$uUQd9U*HA(ytf=Rq?Ijfo@*pl)ei0vuFTfWxIlCyqhwD zg1asba1`6u<-3cfFCS+upm=N<(YPC_Ibx||*42W$o;*g;@*~rZ6+XE-Py;_>ytH&fs&0`Rs%t z%quWzVJ4w4(~ulF%$3BThB+NZ3KNfO_)~a0*h4{dgMSpgX64bx$Im9FDp4^F7F}EL z8&=2hziJ7K0}9hy)qjtx3GtOU7V~oF?j-8c;DSOpVPJMSGRXeN+ zj9Oo8S>TXW9y0SY*3=yAz z(dzg~6S2W`@jMv)rstdxF*+qn&+Xn?dK#N}E0Bnjx(Ki7;?z-z=sefSL;x4jP#1Ce zuptxsVAN`qR`9J$!GelQeDcaP8c@>=)D?Dl%04;A(bt0WZR^G6jp($LVAE6#AotDZ zH39K*$Y?;=&jfGbOHV`~Q1-y2$00uBi$kv?F-1>E>Y@9l8cm@R_f3@vEw|huT&NAJ ze_-@m?fXL2%;YRF|Mt{)yO?+zz^Em9s^F`{`4$kLoal6bni3rob~(}Iz-LX-7oi&m z4Ury((Ql-m{&Y&VCK-z~mLBN{6K_`-wMbWh&swHWZDmXhdAKrKWv!+i=cFu~Tf1w0Q`p3t5k@VW0|Z|p z&exv!lJe_oqf z8vw7RzZ{HyTdU?yMxz7KWNScXza6puJfjVpOvId=7D?awhC81H=@*ubQvEAnI*TF7_pHT2E=6wHkmct(ikQRPB7`5>CPjkYr&&k$;jDNcz zfaZ=lr?n)cC4Mytv0?O^ghs;8%LFV570HjBgoC@xNmvcLoP;33H=px;=p-khFF;xn zTEeI$Vb@eA3AH%cN|5o#J+vdTW}MQJkdpY-Bt(bNZxRX%(NE&DB$OpTauW9JG$&yh z>~azw3f;3g-|LQY5_$lnC7~&dS`uaovTB@c3COkuQTV@~)WT0i%xd_7F!~L@i16?< z9t*!5d62{3yTcs*a@ghYAK_zwe3t%`^S$XHhu;$*E&OIMYT?fkWIu7Tr66;^C7pUg zOF~lOSCbIAJ&Gjc7k(ZEu_TltKXMXwfWoxsErMN6!rduO68_+PFWSpV=n9aQgoZF` zNth&f30!Hv?RnOel-bix3VPAQVu`XjVBuJ z94^stI~82mQw=xEgd53m#s&S#BqvFo#X-NtbWEnVFUyvz# z!M9rs!G*&}$vFL33+kZh`n53nom1`!9W!FHpkB6-gX%`4YEX@s2yCFKllYgUrwg*m zoNOV;l%O)0Ly94O%gu%)T!+zbP!2pODetWF{t0 zR7?ekX`Rk=e7zyMO)ye)eEEpDX)7L0y_DIxry4Pe3KRDxMfq-roz zVbp@5&;Rj#;RsH4qq!4|PhXWc-@2L z#y^H&4#TJglSza+*EP}D~fy#^r)E!KTlL+QQGcA}_qQ6Ev$t=SC zPttkgnRwr?#q;!X`uMvIyC&iojDAI=6(ZJoSQ6suB1W5dyOW6Vx`>9Ri_1qPV#X*Z z6M49ZkxjJ>2bg%Dt$~OOx`>OgYnj*squ<_2B19~U{A&OCU=KvNdus@hssp7Xj9PCU z8tFvTh?A{v;tUjfBA&lnTRk$ELNCb}~Dkq6q5zYWP)52N)?pD$;d zE*=G=-^^Vd;RM@-i#XI+&fE_~s%9=9j9TW#3$l!ytRKi+pMJ60?9wv#aJ3=AvoQK? z{4B!H*8f=M5|JM{a}!Ox{a`d@?q}1*Rk#S_N;7Y`levOi#P~*X=Hd~lnz{F@44JDb z$R2%R5tRZN&m2)$-|o~hw+d9+K=}hkznObH%n?19`?=gu%Uo>}Zz&i}naggvIB`@W zS_=`MKC@tJLWFy?o?B_i+)fy^p8EhYtKJ7KHLl zl9kOQ>t~WRL6`M$g+bPR82!pBB4nNT#Ilt|k+q0O)jpd9qn52>AhY)CvRasARgFs4 z5MmmmzZOnuVu~IWQ(Qc=Th9WaWa@P*y)|@A6bzGgV){Ck;@E4dJLmhr1FC7+6P9KpG2|`5yr%1 zK- znDCQ<`{_%5F#0XuLx`~c)JNtZ6I1)BnEoUtOJ^!*VoDzs zQ%zzjtdH@>iw&u`2&3QVVv7{-e9QVGS#2%FQ%t-AVboe<%K#`de6^ywiJ^E@%DRAw z-(Y3t%KF#Rlzmuai1;3inzD4HtfT&=k4+|q1u*)}*#&%ZkSiPehUM%|O-)%-6K^Gx zvJv33+Ud%^F)_sA%8aADm{9iOHB(jr%G{&;@IoX^UEJ2es3q*#uaH$n|1R1{Vo=9% zHyHgUY$2FHbYino;%VXkA38RG%JE$KV^O!Dv@)r|f%uPBW;`}R?o7@oL&do~T zwcJdHQOnKQe#lL8JvZ%%LCsBVF3UK_jRq6XO$jb*YIQ9)iA=m-7MOE$A9hW|X&9+M z#@qx55u5*Ixe0~{cWx#TsoFQc!l>nDBR=|Q4bpQ{)g-GZmu1XNM=;~vfRX?4WsX4 z84-P9H@!Y=&UMgFW%a5~pVp`EeWGF!n|eCAsmw(ztO5}-Zw5cSv0;~AOSTbwpP#Xy zY7w8jNjft}-riRK#ZhsPqtX&8nH1eDpxC#XJcST{hc#M*_Qe&HZwyn!DWZIdPcreL z+nV$5tgJ;@jQ9;d5|#;eIm#hD&;*rf9gy?%;ZHL|IP9cL&wpVsab?G!vV3LMmCg6V zI|g=H*~9J*Uw_Vb{zonU)q!*0UYzObpvrU9975T*BTjdv2Ffmp`;)FQU_>MFPr9}( zfWn+ztrh0>Y;$4i3CAa%u<)~xV>zu0fHoCoEbMalkI+c;D?4gon)zX< zKUX%clBO({AKn+URAp5K-`&S7(qhCX4~)&gxeHUIi&L0Y92H0?HdO`iyTzeEX@%(o z94YrIn@}t}~699r&yg@63GM_1KD90%8JfD$VnmY67ZY3|b+2 zX%65@6T>Rlp{u&@=lu@j`%!H42N2WS^;(gC^~2P{FVhTSS_vj)UG^-7eM|-InL@ie zuy@n#rEkMtU$-xN0DEcO?zsnh4&A0m)w-;Rndv)E8Kd9lcit6?)Yhcd+JMHbF^KM@M2Nk{v z_J+P+)@Eg|+{tOk`H$EL`cNJXNjQ98m>!$-1=RgDx|D!ed+4Ir_DbS&QQf|-Dt#g**<+E-rcof3+y0o%SrS|j*HwjNxR z!Vmu%5qTizZ%pcJ+?JTE5hAWml_PJk0a0XBTx`HarVy$K7YpvQHqu$@!F;@r#cK)Vx_L~+rBTr|Q(_9W^W9}U;xL>a@0XoqnkC#UtL zcE|5*jG%#}y<2UeX!$)BcQinGYGd%!4gy;KeQTHBRjWefm`V|xWk`(L zTrg5h=ymqfSPAU$+7b(+)e!`?1gqmheP(z`0aoNbsQOlAT;)#UsVN4BTVa$O2HOr_ z(Jc0o^V{8y~Bj%^a-wvuvU2@(>%%(F}w%Ky-x#Zl67>YBB9Qr!&uZJLK-}lpKztvtH( zow(T4zlGr3y1NYxM->uF*aSb<*AZfWz0Jg)E6K#t=pnH+0d?;ZUbTXYS-41Xk;`_W z|6tFn7EV4=a2H(_7cV9vAKV`XERt~(7F0YQG}u2K$EQ6s;C`Ih8y-jgX}`ZQ0Iis$ ziH$R#_UX9Tl%~9hfiJzo@rnk2E^5T}5?Vy{fp$m!K_sgxM=b`5D(iEYRe>C&dK4#W zS=fIQNSL0iX~MOL1k)jMjvi z&Q#`$xBxCTrTBAmC&d}KroP3s6u%uWr}!XH)(m=SCgs}_= zUc_I{X+~a-lNWiEw6(qH4@7P^b7HB@y{syx#gY?f>lMA&ky#VjtWE64Ebb|NtYH0m zooTPDvz`x=GgJ#G%R_JIE-%9z!?64a~`;S++r^;emAUS}; zecd??SDLbtM|d8_Jzp!T>8%H}djfbbDprM~776 zy0DhJDnPrZ+@~liUqM1SY9>(b)=dS7+!|=zKo~LWrhv%3kK#D%KNhyfqj^)if3tQY z-7VzNSyjWaMrtW}nxm z0_qQ*ne1G`V6eNJKXMdF5c9x10eN$YsjfnTVj@f8SC@|hW%nFCP>oKfushiRqx-pC z(sY=FkNu{p9gpiw3Cki}_v5b57KCegNLRB3iw*yCk>;`-H5({*jA<0eb^%GqA??VK z9OHwLh8WMl=#DWYEqVw)kdR9kx)_(zrj%|U+>i9rHgJkEpQ5I7ns6|K)DCh5kTahYR7eh4pcll@W^K=u~8gF-K`$Kn@uJ%eEnGUvKH5w<~I7g6|eN1vn-|f>(6RRyW3vG z-1e%rgKEoByMb~K#8QB0Da{2V2BO^{qC2icB)08AXgz4bo0aY<+3eK`q)Mx&pdnC7 zx1a70dv=m8r+4!ZbKpPKbwXHlh6Vm5uRJ{u0F>RY-%WvF>O`}aM8`!d+)zlHAqHcq;`e6ZlVaGJ&QEvb>$j^#jURhdeDKG?6j z_C5*_b@?3eE6&)D``r7DWcLv1&OBPARdKPY#U6-eDaMseA+(&&V4&UkTq96{9Mzam zay(ZD@p#{lZxuU67Y+Sr(i>rFR~-wFvsPqCC<{Zml)d+2&_*SQ?Cgn#vwOj=@6A9v9(nG3f#t|5qRTmqi%r2a z6S6j(WWmJK(PM#j2a{8v265D-+*<8wDX7;qofK5$sQEy-Q;-1=Qwm~}T~EQk0}Ls6 zinY}$=#yim!%rtGlSS&@xFRuKL6d?Nf0|bN86f7rvuZ!}v|la_x4i|@u2z3n`om@? zxQ-`SBKPM4`3<_Ow>Qwf2X+y~!Gj>hgv9@nTV}F>+(9otW5@EkPT~XPFCD_ ze8XK9SK72RDt-49d2P7(gD4Xd!wYt(V>sB(5@L!;VEfs#?{BGKWAX2=I=23ElHpA zum9vo3gME*08Qh<2aOFVYQp*`fc8=M0;tk2``I-SwSo~Xa~0;j;W6c@Vd^Z%`bL*~ zV>#@By4^6jWf{Dhoym>OE8PH4R|7#5idD`Qg~zY%M=#Bm!ue>xm0YE; zo$I+;Q_aa$Aa~waaekvOoW~(0z7YrKhhaqXQlj=g!WNV#7P(rDGuk7|BTFFbWj0OL z5L|4^NlGEB^AVPlgFsUWecfN4WJ!gBtPtCId^sm8SHO7>z?Et1^-S0s>2~^iu2xyy zUUmWOxpn*Yxv(eE?U@(C{y8gxw(IE2QAAiDHk4@MbB~M6Rh?S&J&jXm`hK7pR0B)eb0ksv>&IkTC*s^8gF65IKs6@ozPHfK<`HInzMIGT=?MFD-bc zah_+Hv~W8BZQZ5c4wMT}(+}&h3QihIan?VGRZc@vC8ntY6^EmK2Fjg=J3Zty{0xYd zlc?ozx8gd}ZZIER|BL>Wgt30Ek4D#b*1y`)z`kC8mUQ+9Tz^5oKBs-X-YBvfqb&E0pkE{X@dsW;t!|6(r-vj*`5f(I)u{bh%*IctLp3fEM-E z_O}&$PkOhAFz4)K`Fop&g=wb{w;sI!mWL*`2+hfn@g3CkWXJcHjDk$YTq=&vr1q<)K%h-Pg&Xjegy^JBU~bv%Ig_DpEX`)4jvfYx(1* z5j}v@GSC!8d`3U$JU)nnZ9P3U?Sdj1>B?IL0=&TApeW+3|LDgNra9Sluy7%36+L*f43NbQMA z(L=EBNre>2t3`F2ioI!YKR`P2z0>w3x3hXpBQ*NhHEAaX+KoDw*+IqPsAfP>B7I$X zyMwyUp(~HUh^|Zya^=nGTAb0k@(E^c>vc-4eTEZ_-j$tTHjkq2r5(NXwy`MJfYzRqD0ke4&?JMQzUAmR&jZC4XVSu1@kD}Hv z%cH1=psUa6))JlEf_Z?`GLRBRWfWxWp zmazqlfEvXe+Ble_8buv&UJIcP1DQrqLvlZ77+WC%spT=BW+f6yIyxbtAhEw7Cw&UM zCDC|$BMN!YU2n@8QoOul3rDTuPI-@PX64O*P?bS92Wa=8Ym&i1P2s4=$$*MRy0_T1 zg!;BXVQfg#I3}>_WcH0b>CInZoYDTyZYZX4s~@q;5yip9Q~*2&klsxXE#_!@w~0km zjnMKma=Z;iBtA0`hK(M7qOgafQtA;+1IiH5AeikD=zfYdmS*L>N#R*aKtv5(EU&t# zX$cr)eOs`tAw1A1{#cmSzZHMw;;!$4P$a0fk zSGWcgn!;HyYTw6vE4pVK=ewH(5zC{w8KB4-l~4K$MipR}XNSdtuNdc>0zUV6PE6v| zA@N@;gSh%2v)0g1kPC1I7i-~dhtV0%hA)}V=I7OJOH$Oy=$H*Gqv46Q3^XB^Qv0Ij z6=8HX1op%hQ3t(ied(nwr4#nR-ivtUP-6H|HL!@I>eYIt>PKDG;g$wf>tIw=?fwql z+d!4#eKamLjljslj`yD2`-w!*E+rtMlI=*0z@tD}k@TBobe*-Shc<_$u>I-JePkpKWonZZY9m`=%opm^|uB4|IGHXYhRiB;i6>@S@ zpR=w7QbFed+C4k17N|@d^(&#|Iqm(=GHNq6lzg;5{f9+Rj!^O}y%#9MoVEgHZBE-* z5|w!ttUZOkc?R~2uqz$XnsFz$mj&Bx*eR?4)nKN^(f91NMdNH2DhU#Xb?^F%R^zXSRGef^NljXD4K{6r&NyD{wnuZfV81k^uFVS||7IC^2yN~V+5oJzD*ZhoETm4W{__^Cnx>m3D5qIaVkXGYZz(CV z`JFVP@Fq|pbvzcI<1kXk8@CDRh-r~N1g4vqhDOD7p#Yfh`9!sBRZL7pI1}w#kRdBv z9{@>liJ?mWHTGBT=pWvGd%6BlGm z@9z9g=hR-sI%ic}Z7k(9@g{{)+l6%npY^x?XNn#*GQ@ZeM!$v6DwJ(o$&@7~W%7P* z5-3mvEG7KDoPQXg5A5;e>T}_ zp%*5ip&|V9F!~KYoA9uG1q(k3d61`^$tK?ZFlve~g*f4N?*!SY3FZOHBUDAL7J}7; zsYi9yVX_vQtE-651=|KZ5FN06+9|ISwT>Tb7fR#uN#9w88h0m! z^?zhI*h-{?e6a1i;$6TtBipQ<-_zX;)2uwO{fHulmHP;h!@#!VG_RY@PI3vVGhw~KdCR{vw<&I9^LaH2N5CjCS)=BhYjExmpPi^e%yic8?v33j8lG(HV|F7 zN3FBy(RUk%71XS940lj4PWBp}__l8N)2ybst?avq+v%*Fl;Z8ymVd~tlv6Apb!lQ)e2!n)~^TNin zgvDovjh_;3|4`W2Ls<3Uu+c-fe16z?g0P*?Pxu8~*u-dVbirgm63I16A~waJLmU%BsW0TEfIdVdHH=ZzOD- z77ZI6gl}9BHtxDGY-}JbiG_{l2{+V)jn0c`>tfnm8#d|*za$J1=3N{%PW(vNc%1M$ z;iOB##vO!DUP?Ka0n^KY=aR5-?-h*km0=@!RoM6y;VnYf)nVhGt_d5j5rzo!t_>R> zC;XhSnef@`!p50P8AHMu*N2UJ2yKKf-VipH-WWDcxhZV?2Vw5b)K9qcmaws(@aV1d z=eDr1o3QMoVdEXb!^^_P?2pkN!tV%UZU-iWa|ok89yV-3)hECcg89j?aSh=+goSr7 zZiLU=88$+n0>20qpAH*8AXME&dcsSD_-De#A;Q|_VPnz?LOg7ImGB=4+J1M~s96~{ zx(P?$1O5>bgcRX>gx?UJA-ql~xi@T_KscLFNBAh=KEhWCKO#Iyc!{v^vteU3;TwdH zevUCD{F!jfDqv0c1L6Gp!p64=zaspeaOwSF ze4DU=&_mcuDEdd{522rM{x^6>nD@=F@h3v%KLJ-l@Slkz+(u~l7wV=hGyXMf{3~JF zx5073Awtb}!p25I{JZq$d-RJi^ZSe?VeF%nP5AR;2nPw) zFTfW<8=>r%w2Sb)bz$T1diwE1*!TqD(hb!2E9l^_!^RcA0WO5OzYQC|COqZ)i?uAR zD6eg)t(bnrl~-9ytShW5t*c_mKUYQP9_VPSsAr`LnCk++gTpe0x>{CMgroLAt-Uv9 zKOePUO%9AU*F43mSZdPG&e=NjTTum@)2fVR=Cnp0dGUz-(CXSvAX)LIq21=XMMdVi z#erC|y*N2AJz+kMm%@-WqjTdeD-Q0;tlZdp@4=3tu8qB)IoRsO-W(fhud_KHtUYRP zvCMVl_9n|tCwD(!CDWrf_8vOeU0b}pW~jCPaQ%v1wX@qTyERt4(_D8nwbAy)MN(U| z^7ruxvGndxth7siZHg5?PqW{izjer5S3J}ueR;5s=ExHG&5CAed~#!zS^%$S3A}+d z&}qIjeY9$NrYx_?G*ne*Z=t=?tDOoQ9z6c*?cdQ~N#p#mkdlv}yc+u%Kw{Z+7^qa5 z>sA1jPb#SNz4Z0LA%Jk;!&~7Q5=YxlYuIejUt0l@&5)~MRoXsP{mXhN%xMu63Wdkx zdEa;d66$B{sGpqg4<2@HMOcq%9gQpA8MQlODUFww-4knxRLqLmjTMhDT29{pf04vb zH`mRMwp<_T`@v;HLy`HvsHm4TP19i6~Aw0ub?&dU<*7`|3!HXI|BGe?PsHQS8efTfqaz7T$ic|Saz3Xx2Z|g z=1!u&SoH(-D_-*8+Yt>K3c><<2gtymy~ql__ErVni!L2vCq07Q+D~!|I511&f{#>Ou!%!J3p6um;ny;#RUJf^&N^CCZ5|+8hg7EoH5w zZw&^lmL;trbpk;9+}3tY^n~7pVl8)6l*fSQlo$g(-MSKjH(glXOQ3o+c3;eXA!Z+1 z7HRoVP4ZCCTzx0%vzWcQ93mLAoA=R*SW~yzcr)4;VdG<{68ir5@OWM(eQ7!ygoX%# z%Z=}7_?g7#Ms_wlK0@N&LW%oENPH9^8dmZYi7e2J>OzTQBP3p4DDgcbB>r}x#E*@T zxTjF!og*YJ0v(2RFeH%$I(Sy0#Pdf;d`qFkw~vtc%Y_m@GD70ELWu>h3$=NFp~M3t zBt8j@90rY95?KHmmlaBU^$3Yq7fRebLgJqlN-PtvP&0Z9CGHy`@lmL-hIMd?L>A~^ zb)m$u5fU#il=z+z5`Vi;;>Siv+*2s=&Jhw9l@#b;NFob#@T@|K=Z}#1mO_bdA0hFV z3nhMJgv4!y5_gS|cz>b910y6p35q&wxMxXZ0cc!SDDl-JBwk%8aq|d?e^w~5oHtsi z8NG!P_l=PFD3*$09h@SO1v*$Q@sV>@2Jf3@u8YDr-xpvzW9a}tjP$N4?sIYG1Y+Rn z?kn=5e6LxR?m(fF8aHR+piv6%{&WN$%HGizzz*Eh8b71qbD^csm&EbuH>W0t%tXkt zJNj2af0IMwl}m{kZClnkDroe7j7Z7fydo%Nq{f|BIY{w4`qsTAMJ1lkc{$;wcht+T z>zBXIdHL6kI_D~0M(kGFag(Zp#t2_vHXdSygL#K7xHK@BZswu5r!%;Nh8i7_9l@el zXJkicyh^l4@eXhegRRYrg7BK1!OgUkben^LNK1TksQ*X&%&GsC@9X;ihQolWKT)6a zK3=Nd|G|B4HZ5g{a?*V3QQg7ENz>G7HgSqkZi0V#PAB-9lK}riNdVx!_mx48996^c zS?6VfmjYQ~JG2%qEF(8x_>!s^YXd9n6HcB@dzXGhR zRMn7rS!6aQ<@Zo)w6cA9XXA@jXM+K;7WnGJl{y-N^4pAdS}hGB9#sui<+l4zj-@UN zz+DGxio31Z+myWUerPg#V4G;gNJxH**7{~k{l>aoM9#JS!$RMHj>Q#V`kdv zugUwp$-Z*4aUpRFkLH63N2(%o(H||lYH2Dald|jrbKR1_5({2AG0IYBfF=iwyJ2o) zOKH>GZeUYqe=|Ms=Q9Iv#1EzS$wO0j`~-%(I%rjP#gAtEHWw9{O~+ElP}-{OUfu`G zA8T1HgVecNMp4bC)iQoXHx}<_%IVJs58`iJaA`>IHO$YGPew+WbNl@ip-M zf+Q#i>Sm{N#;106XW|XFGU55DN!8N-D>BBCpPf=}|Iv)T+|PEwp^^=dlH|bI<{BJK zhd{!{z#}_Rme>z9Jj6FRIJDdDaBxh<7et$avf#ZTa%L_>lmP4MH~tRbNnAM`H20s9 z3zow8J2HH}0hn8UCIjsP`~K&0OEjm|%UB#4yfYW)6?STFVI$11y!O>Fe%&&Do4^vA zOH}<%2cK-N|21m5>M|L)3MLU0dM}s5U`6D|UW-*~Pr|6IGXmCV3 ze`IGvR%T1gW?fmiJbD@&6qFrucN3`=tg3lu~!x8Or6Nfy>#~%+qYca_m2|kaI z*b(h=6W=~UVn?*gO`H|&{PEy(p=NZAP_iT1`AYzwM@a05cDaeOqMbh;eAY6RKN5WQ zWGa6=_*^J)Rc-Na0Tl-DF3{r zgGS%;AIcVYX|}lJeM_atD)Va{eXnX!@i-~=_$qVVvoZYfclJF1$3?mGy-J){ee7S7 z7t@ASc>35OqwjWAp@@GVE6b4S*iVXO0!`i3M2v|dHu&l)^uW|UJh+VhTGJo5)vG=nFwDEU;yy!D}E(A>ZUse$oM5N&n}XvJbP~eN1oXuse$}aDk%kka-?n+ z%f!p+%+%!Du=&4X0CMu4I9sIX=lcGE>=DUtHh!HnF|0Z_MeH5RIs-ui0H-b;LUb9$ z*eyAAN%D|!cX7)VOYI9ow0P+WTScfeOiYX=ThU%@ zM~qpXv4H45gF+a-;PH!FV=c9vQ?$s6gp5RrWMY|-)|SZDDUw#Wpq$2E`jklT&-Fde zDIN42Akk{o$I+;^i}kd+-EUiTkGLCIa_0y8m774hiL2aTB&un$d!mF^2t92Ep2 zrL9&&7f(lJ{>|=?LRBK5I;!&>)DNxHA;~FnSdP9uyR}kd6y?&;<_o1%p5G$-qyONc z(XX9kf7ED0GTp1-m-NVgllKA()d92V97L zwY5>(d8)Qxx2`VIE%m7`bu-Oc+tsXeEo&OY3O=LX1wNU^_XQtSUfIgqr8(n1a_rV2 z==8+b#GPRKQ16Cn8lU;VhDGvq+=hsJ9laqcUu7E>%U8*Ui}`{&VpSA9gXjpw#Ha_v z875_26l-CZ0^{1>yo%2UVKbqJP)>dM;dx*DE}mTk&6wHA7p4dcta{-7bbuHEcAM zadQWoN)>#jy$ifI2Z!DtK2BTtVL^u4RF$IzN-NX>{Kk(44cgPGlz&!7mBI$gYN_%W zS>JQ~fAz!nKmO*s^zW1Jue{{pX)Dh^&=yFX>vmH0PV2kUVA=LQdV1a(X{72W2%qhu z>a-8~Pd%mPYEw^qR!!=XfWj&U(3!B#n0ZqTG%(t0fGh7=kYrAG2Ge>rre!v!L!{7Z zRhLXCePqPm1YSX^OMWF~Sn2-J5&MP6jCL!zdzzKpW7gW+?HyL~?Oc3|hccx^nu!vv z#`hW7tHsF9s#lvj;o1f@Ae+=2r?-osSers1+NNNDj*Ue}8y}ZETofOtsdcDblyAo4 zLO9SD$HP{#FA$%pKBs`*fy9X@A|HqKGoC;eFw96gQ>JKKrbJIW(KJ@4CW`N@QHxej z@cp7-U2&`384P`jBFWdO%9YV|2e$3a1B$0e?XtRv|{>=XcdW&@ybTIv{}Bh z_+z&*cQ>W`LI5DSYnom)_0Xou0*yWK(aA&8?>;V5B41;yC#KWU$n362<>rXp9xHZRW7`4-S(0CS9u54vuD}0Wa7i>}lva(hA>hT-M3`~ocV%-Xe z-(LGrmotcBW0ZLVB5v%Rb8xe2z)<(xF6Pj|?d~k95sdVvl0qv7{yF+)CRZ$V`nStP zs%*0lTegU8JDF`Axp{EObGg9Ax4N#(5?WjUsxv7@1%HD$yX4p7QP7h zS0Yn4&icb&aCd&F>Gyoaik}|ZUGf$T??R!VE2qo**8S@J<9w<2spr#06%CT{xVnebK% zHd)Q9Hh~Zh`fL3uj+k0U+TST zU}SEm#hC^;wZ&M5g(5TaXm{ymcj)w}sR7KKq0*M_^!ny45q5i_ZrPWGQmeBA@_;ns zj{j86xQ#E}4A$BB0}Y3jQyb*)?eX!?c;ySvsXz=i6{_u&gq z_#43}VxIbfXZHFZ{NV48JWF4t&#J$e`V24p5ACGC3-Zi-j6t=3PH_MJha+oF^W8qV zJXWFg(A`#`*2NP(KSr&K(Yddr_m;CZrr#)w+WVq*pJn&S()jvR#h||mbNQzs(=bXN zL)#@xjdIYo?7wN@IXN(SvNhv{Z0lNR zEBe4)Q&xaV6h~n(q|eGj#gRyq)6Hh-SEOY^ zr1?^MyJ6R{W>TDtt>mDIZl@@;bqIN=ak+H4#bWW?WJb4$++)q&6t57u=Op1Xmx_n| z9k|8ASfe^yRpD)kU_S=TO)FyQjE?vj*6cQ@As+Clrf88hNdn4|_lNh4gFXrJK{c%k(lX?Z-)~w2N9Yr$kzA4v|D9PHqmS z_mq*^-aIVnldS&aVXfaG%o@I8FagSOEcuRUHqJr?X*q6Yi80A{#+!|kB+5k_4;}0$ zS*sZYyvZDXXtUyngbfyiMBmg0nv} zXgL0L2)xw-A?0V61)okVqV~1&RLw^|<+FRxfRK#4A)*}Z;C*!F2 zai9Euhq&&?E2eu}mLm40p$O=hesi+DKmEoO>)>-$2cET(uLXb&ZjtC9Y^*+$fK1g` z^yEZl$|Lq(EB$)N-W#!dBdHaEs`^(0R{GCy<9p2HpU@Hz8rnX`+-Ez01`W!g?%>uT zOX&%$hQlub$dxBoLx?6kG$e$mp^-22dEX&bthft$)cAb-D5R9kIFi3ga&wLNP%vP% zsY&-qS!6D1H0BWX(CRz*u2Ea1HuO$e9s(wlqGolvs__60UBY9Ija0rEFNs#ZEE7M? z`(sv&2Ct*2S!80%w?vw&BUBP?dfjZSlm|QAKbLPxkQ7qfcvV~p#d#%}t4&G6ENL3$ zWEzwPOC?yn&?HTWR=#C6^%E&2?$$4T?Uba;XG=rk<0&UTrZN*Ru`1tCRZy$hSW3aF zsPO`mF)HpL2&@HoRty6llF8!Dli$E-+o3PL^hlWIYbWdYLgT&OenoRH^^$aBG> z%$d~qNoPTGD{=b|Nyg%{l?+>ThOLnE<<#}{&v%BCoVAfzaK9?NFVF6{ZwWb=L0h4N)}oE2iI(G{g<74_6scetnYi# zud%WV^CKP!ugV&(ga#~f5p3MDfQ|0E7H6N#rNZJUt4OVEtE^3(efjNTfAiG&FhDRc zH;~0@nTUFSNw?^(xAJh8A%Tz-KpZ)Wm`!UVZSX>E}P{_MxyWg>HQg_Pk&+(@0BuYz2T0H*LNy?64A z9d;X18eIJp`A{BTlQ&3~Ou4$)Br`_gccuu-V1cSsJ&d%k7B87vF~v*{sy2R3mQ!%w zZ52(|tqSC~N-&*~`oSR?sr3)5jCx8ryLzR%Y<6XE_v&=aXw+FCQNumn0?l?|QLJiv zz6UyxuW*NAe$;jL3JXNoC|rZ{R%fu)X^^{L*nYNeC$3Q#HpdEFCyU8zvbTJT2&_gx z*&LKetWB0-9lf?aILFvVc!{u=@K?ehAyhKQIEpZpa55oGIF}G1Tuiu{a0}sNu-XU| z6$eX3jV}M+_ZJ#7wzO>Ac+(>iRaa@Osljik$6SX1CnVu{SJ?8D`2mdSg4|+EXM6uD zTq1;EG&U0F5;xTDU`GP%zy`^&7B23I+lNMwd}&@wapt-SxE7_V1A}cb_Px{;V^;@N zO5j>E2w6L=<_RrR#N8p%aitG#vWLiFP)rNWP469L zZ%X$cB}>xoVk_B;u4B(MZEHQyHr;Ic6sQM1C^uK%#*^KKc4wctkPZdRrpt)I>}xjG z@DOX6S|JarI}MJ1iKv?(yHiq{-nv7{dMC1 z;?1lq2~djyZ|t-4R3{x( zeV-)VjW+doMXPcY4D=9VD3<0jkLAn5KF5BFDVUM!8>7?$VpU|ccB|21C>>uOtZ9wQ z7z^=X`~%}4ZaX;Pdh4PdhR}-72uNg`S8iL?pm@;D(ycrY)V})=;Cz!a1S|`B3}ge^ z5mo4ee_mmAEmSTfJ=6|NLo2X5;-6xL{zTF4Oag%vn}7;Qky{tuc||#;tZPdS1Xs?Z zjDwV+{hT}pC+KfWWSejew0oO_R@*=;)dKY?hc?JWhJTR#jW1w*{?QGCMmke!w>9iB z>J4M2ahGY7Vp{D3+pu1K@vW1OdDKN5ym`mJH*1>09J_rTHnyxGIKv zsxYm`>ctjR%r$PJvU}f!{=#LZgP9)`%5Qhb$U4XeuM0}T{;GwA>m^VVJExSuHe)w$ z$D#Y=oE!Khc$ys? zXZnh;_2~k_mTrdGC?3&SacQzsj63dQ*aB}h28i{Q>_|&?=X;Jixlu39eKAK^inc7( z!V)Kh54rOX`o>JtT4}V{GQLQ#ui@C|y7Rt`bo3zWPD~RN&0vgy#s$Q+G=8&YABJEb z%KwtM{6O2j#Ki~OjK7&iBG@#9a!QdL0T1N(02nVM-C5)jNfrC7oO*L7grXeU*T|ce zv{m^&E5veF23LTD{~vP=4uv8#1A1{Lq*x_B7aW_<<>H4oh{V@&YM5m#8{ zB`Pk8ZR{_IrTfMmd;wt%74V+2YR8GQx+8)YCkBGh)d0Y(-cJ9mMJmkt)m!oR$vhHVI;I?1DKH#rT^@L^5B@RY$naSsNQ-AC1G{j7M6&m3ZF zQ%$-T$Mx-&jV*6-X&084-6e3hL&c?C>D~!xxM5sRZ%rTUN$)yQ?Sid}-P%QAqhoWo zTj@QR2}Kzpj#ov}xLEqo=-Se@hTVoyMcD%+>#{nkgGIHaY1PEKmTHHqW4L4@N$aL^ z+M5Ej29~(^))nJN!}fU51kFqDouD!|^ukHNJynNJlX-D#k8Eo%rEWvleRxz&%OzM6 zt8k!<-I|W22Z(^x*6&rk)$my@pfVxB+hRDE;X_Q1)EMUuuPcIF21~Cb5XS=u>7x~Q zan(Yr`7-dftc|6+Ef|OjO1UGGb+*K*lMMo=&)$plo$enc^gvc=0b0O_ly(VNtdPAQ z$do5v#cNm8Wc_6jl9Eqw&5c$1mM}~(ylP2L4qUVHb}Rw2zIm)z0-DzHXwFcRjgU0_RY&nazu7qf+_d(< zt_qd(u)e9aGC6SL%8R9;!Q)gz2fT*jSqf8_x>S7Fs)EVhX+DxyB~AfXyjKNY*>~x( zZ{te?fl^i3Xh{AGW!p49IWR@H`wzP8ZN9RLRoSEdD`hJU(87DrajvY5-&XQ9MphY% z%r&b)as{X3HJrTqh7BbovI~;k6|Ct*>q9mp6FYqsMaGX#_66hPXLpKjq(qLmDB*~U zVfh6WuJ^P?-mvLGl+-pm#z1%fd2by;P2B-jDJdlC6#`Me+E3I6%U1-MA7#oZdSma+ z2U}y0M4Kha)k5K&=8MvbGc}Y{Q?6klM=!5jDsb4R;qVGy4q_i3$Dt@NfA}(J5!)xM z(5Hv4(9NkuYC&W{78E_$wqQWcaq%Iu@coZ#sCdyisAqTP_SAC0d}I6CImgT~mJpf< z>I?*G5l^W6ulM5}<(ZNwME@;Y`vT?fB21jD>XAxR2*^nb*^l>Aja!6#XG`GeL)5W= zaM%BXy1q;uj}V@Ex4Q7jDw;CKs3zP+(4ALs_C0EVD9FnQ6nLZJoLAYeBLx`+=KXtR zNL_CAM_L@|6b}*L9CI}D<(mgK3`H}A&_?ZPo)GF7^bf6l?A;oyP)sV z3p#%8o16u`UoYsp#iP8ec^72MGuK^9mc;?h(+`%{q?QMBmVirT31~hs+gR7rT+wC)6yfyC zlLHT|JVwFbj*~PDZsXg5!MKF5EqOhIJUiW<=`IfWDQN4J*|zH4MDE@qoZU9y^Vhd*y)4Kw2Hxs`MG)$t-1WyD5oZ_8r62h~| z88Emu0fpS+zv&de)>ph@syM<`#^8My|14)8z*U)R)=Gtf<@=l}Uh%4sg6TlF>(bO}fR?&yS0oMU{L z@KJ)0Rz4Ix&OW-7cjPyD#Mq(G`Q(`Bynj;YwEoZhYz~1IBCUzGyPgzCsH2>udC6I8 zZ=N>CC?kk>3$lo?Bfdxd0w zdg#?A!=e6`tvzk}9OEp)#|UcNG+c9;pF)L^&PgiYIlPihSzjV_{2j}DgR4+evX`b&=^N*KmCQo4=NgQ?Kt8fAlV zdM_v3pL4LMYG+p8HGGF&|7@ zc3#NgAe?6-{jfM462?(Y-aTv$&~mxj5+S1eg${hR@!WyI=3rnE+em@KB6p=0P)Md8 z@~Fv3f*1=eDqtM(@$7c8?oi;9JsO^MU+vM*6F4`WWR-CghEsBQI_pJZm}_+AjN_%B zZJJ6ww`W*a-Zi~WEdx(CXs^%fzouo$X4)|>aqRGR;Ks5!l&O$b3YE!gC5?2c4DeH) z@=~-kRSmMz<7xf2nzl-(b(NyMXfcJ}_K&hKb}9q>rQTXxTJR=+aF=1;rAQ;Bt)$`N|WO&E3Nx_GK>*c(X0E zC>6XsQoIeA`4lc->NF>x=df3$5JItEB+hX&LJNdZY=kx7hWE1u96@4*KX@_ayGx+@ zm1bxOBX9Zg6hNTShz-3z+t3_!sPLxc4jQqyU%R1rOMpZF<&aG|&sHr0kb*vpi0L;c zK>tPWmd+g2@LD~{fV_PdieYF;H%O&DA4C+Mp58UObO6D;bYP~56dtwPO9x0CIM7xV zpChLRH_Za2HBmg_u^m~|(UcUvcY7bWu;}W$(EfhFNmuWr^OgodvFk>l=8U)4sW^T} zJpcr=ii?cdVte4*#Z#BSj5J0-`C=LUN+S^#c87cNq>@H`lVbEaLtWq2y zdW%^yI10sV`e(YQ$HYha)o!1cwlkEfdx~Uf0!H_$WgzJuG|eS>F8S}4QM|}oGqeH2 zA$bk~lpR1m$!T%$30ZExiab&F0omt|^%;tvO#)_HrJWm++GCAjoNDlj=P(%M+sHx&7B@c~?7tk+=Sbnus zk@*1DqZ3ztYLt8LY%>%(P~@0utuqplR5XDVGdTcaDtTom>au>-k!%PT=5V$r^HWV z+~|$u@m6kTan59c_;rWKQGf$;amP2q@e=FyJ8((i>E20xduZ%d-1r72UgQ}t#V#ti zqzts`6d7;2D0{D$S=Hwp1(YhohgVqum4&aSC8nx%;iLTflvAIVTUm$MSUKk0K?88* zT4MoLb+xp}g@(sC3LGy}l)~$-!^psADnq-BhgTme2fsCXSVh>Mo6pHL`)cre6}rZL zuevNZ+^*q~YhTXoNOdQjkl`BE5r+dVSgZ$dXa3?Kxd~iR-4d~qskpbu@dHPVDO764 ziw*r5+_vN#o^jZk4vpg6tmGklKEI%m1v}CXclHY7!0b(PSo`PatMiOB2O!pOV2gmK z*G$JJtKK^hLmiRid4GYcdTI8&k(qhHOF`IthQf9KDsVCqg~Yt$t<~{1;%y9LgE^d% ze7dO05>IdFx! z=4B#4zf+&u!i8pyMa^f6op1H+e5t$FxGqav6Hfr7cs`5w&UO7KqU?6!XZzzvW#iBB z$G-uccG92akAF5BU*(VgZ8rW>{`l`_K4vZSiC@5gd^cLE8Sa!$Shvtr9FM~5asPIaR&VuGQAwuL=*KHS*nT3KOELT z{Xhq{ckUdcXde0^!f}L)2)7VEOZXAN814TH=pRM;t5|;p{VCq_xr7v>JoyktLG8bQ zJrK{xbf35zLDYr!!)IYnKoc0aLg_37XHjaNq32`iTl!#8jt(-LsDJJAnw0 z?w8#f=@!gaNH>))g>>w?!QV*ZM7QuQzFiFc-@>q?6KJFymf!&|fyTCB32yKbX!ISH zV4;^lLeWD{WRXon4$78UjyI~^ z$~JZI7p8Wb_-b*gtDxym9oqOO7fpYqY2)}#ji$diSE1>{d}%b@;X~8w`bQ%#ut$V} zanS0z{=Z_M(@_p0UDv^~)sE865<>uKzJF%0a2?`oBt)@=BVm zkmwY_f+>PTV+4tgncFHv&kEfoXrnOZ;||7v8|QRv8EWX4i1_?ue{p=S&^}R^98 z)Z>)L1>w}=I2mt2tjFbpNx-_p0ldm64zZbcxTq4Pn7#+OztmDoH+MIcg>OP zf?k=$@+7#Iu^Rg2JARHJ$h_eQ!m`Jn_lwR{{F6_dMU-$3eZ^iqd3m`=!XZofGU8Tw zP|nd}FN8YFPK<%<39Jd$+$slfXuYPxU&_WEwHz`Xj@S#|)y1l&{rC)D)4WE(+QBIg zW5}}0ux0NMf+*YjaHM}l#QJgKMlbHA*;Fpz{M3i@J?$P~FKTcP`f7bt6kl^GY9QcJ z#zXNLZ3LguiAf^(xFet@tU%sUC~^d2&~du2qgtu$b$7%u$Yb-lLrJMayvgWi^Sw^O zX~I{cCY-J5MfR*wRj_9}#sb0b-8IC4}7g*s+YLqi!4Sf~a}zhI15_7@IA z7h%siJH(7`f)H;HxhIW+H$`!jwe8N~z%r>sca%LKQ+ez9XeIlf)E*8Gm^{ciDEMH{ zY*l6enwZ`@Mlcr$LAtEe>f_XsICp?BLI2(k zXUZeSkBGm^)|S(VDFkgu&YFO+0jsD5(pcxcXS-Fe_$4WZed)OWzdxOZ>qhDy;xy#@ z%j$a-zYnu7jQ;ivj6GHaus}9nqXK))v^&{MvWq=$J)FQLQLl>guUgYkLYqymGD5=Y zzornT!dzpM8+K#UZ!{0}w?&GFdWA2=L+Q26?hyeA_vn0P|L52b)l!E1I6{)Ol0+?l zBPO|%By0+KTvoOx)UwI0(P(;v0?(HM)jB(3fm2CBr~dQTvS(R#XrJcdvnMQq&YvAg zRve};Ah9}73%t))8L0AC6t+ZhW8!j8$F#o|H3QwmIEMvCIe|WwlYkY!h_1PBoH`G9 zR06>gQC_HtqVlPdH&1qVA35h?igqOi6)fy9=GV+B<&vxVeDD1c$=(P2>&cO-u=1$Y z`_fEeBSbR^c$h^C7os6Eo5bRPBGul8mM*<_G)B2}Z*l217sK3@la2qNV9(5~-pX7* zk&6RlKW^4(I#<<|i(cYD?5I%lOiOwl^cCe~Y+q=pCfd?OkAfH8r$4N8ui<%EK5{~! zKo{SvVEog4#jKhRJLC1xX_jiPUn8wBhdmwU`c3`;74sTfbg^s1l3mkt6};3CRLWm} zzm$64WeR+|YuNR=$*+Rb^}&xQx~UZ;>=)U?zMe^8X+B8ltoHgY0oFT~dRf=2^RP$O zI%juBbkh;7^3H}$tta#?^oo<#P?7d&{$p~jnjb847?7+evaMs$K#aWbC0b;%cYvu}B^&6Ob>?o7iffliKOV#(XvaAL)VkigT$}dws8C6#Z_fLY#7B zi}8;2uH8}nq^Os1Odl#$I%SwLSC8#ZX*&%! z#dKq$If4Lt_`P)AV&{z$i@kHqhq6wipD@~K40G%BzYbKI>IGzz%+K#Qa(e#&N;~t z0Qww5oLui!WBIUJ9DpzKZX)p&%GSHhY{F-ztMeWAauUJr2k1UN4;%VN=aRv;gF87u zb7R}R2e;=^L7|ZLrj5OC9qeK=o3g1YXyi_3W$#J%PVpD2slntUv!8+G2ix|ETbsMi z=d4rjGW#`Iafpax(N*WRLr|uhjZHGV2oMd2Wffhy0-@%Tp9_<=uJP!3by{jUjccl59dNbu|p-d%?e6QSo_b6BL;@$+nT+=!Dg>BXW%&Qz)2 z6|h=&l|;t2K0ckiOf2?X9y)L3hs9HB;g`1!a7J6Ly)9NOx1g}%20NEUxkz}X60C>1 zV&aC=YKv8FyZiT^8-wf!P7Vyk-{1m|$X4{#<34)L04x12rcpXB`XMG1o)zAS zENXr!bmUx&%}Q1f%H*2^E}A<1$vK}u>14!W$mT`a=*dzcS9+-ZjGW!ckzH!!EPFs5 ziEBm&IW1LGPO{-ngw@kW{nYhP(T9~n*sOy+^g23YTcjnpInvD4;jr@2eV^cLTxMf+ zs_Y6GXMH?w7e*;qaIr^W(xCadClyd})+vICP935jRa@e`(v|N7{BeAPdloIn*Blxj z|MzTGw{2-oAKZ+YU4chj$hZpLcL=Ry<7|NgoIy+J?X5hOX3aD z*n~7U?frqI5?j zx_pBuM+FqkeO(_U9ONKj2GMG{gHdenf7W-ZTH*Q7rVyRm2<1rabU)B;m5smkirX_~ z_pcmdL?q{U%+$wt^cNG0f?J=qjoYVv$bLgvEyZ7&Gh25gitLP@FX9!Xk0-_32}1nA zV+W0vsar)a%+~U)q2{H-4>FaPm$O%1ONo+-90e0XiP=x@yj5k2%Hp6pF_aZ=cUi=& zenCuSA+EX3bDZF|7THpDe1LNb1vl-n^aXDb#!Jv8P zdk*Ls_K{%A)XwImoy@P!ko}~4uIDfckezdRy>rrEtDbFpa9j067Y{S1;_M2+pz-2}*TDi#`Iq5zAO!rJiXBx@4 z3-blS+=%3T33Fjfh-+%LaB<5PP<??TpOjm#v2T^%nV(i@WG3j98)`Jb_d68uj*hd`ah>=T^_u}>2bPsC5zyH=L~^# zPCUj{Z8$gu=&n2x^cNW4kVW`+pCoDmkVIyL%q5vE7YOS9e?2`4P-k`UqOo zVe*+FS5AbWt$G@UQ~9(#9jaol&M-q2FG)MJxkYws@OXO+h{nLG)__jA2w(8k% z;=9ZSnjoIyFE!lf&IWFZ*_y41YM6Z3qNMoF$kWOLtt0ZZtoe1mnINZ3MCT4Q*9BWv zJt+-(lEr`3lhBcl%xVw1etr;m+J`|jwew??+?%Vt%8@|fW}|a^lvY@%O{Of}hpUxb zE7vUt$X_U;-YJNBiA9au66bS@7Rsy{+pGhv;rNA6qOesz5Kes1(#KAoP5ku4v3Q;$ zutCnykMstj#XX#kd7!o2yG2g>ysNTGI2tcIE{^(N?1?Ab@Tl^{RJKSM(#A#N(8&20 zcsyvUnCo?~O%Om%xB*L8H}}}eeCG%Vk87`RYC5vSiX@5$avK!N=a8su6vA}ID}6=B z)CCO69HKAll)E}b9}yofte`p+Tg<>BCc~6CzK@!j^zq4}B=q?=)mKuC`Gm8)0ly>C!pss(& zc=*tz@Sz`k*bP2(zdJrKDR2HBgRchI?X5GudaJ3kcjgFm$IR-+BS@`An6eR^a}>;s zF#2hCgtf~rmP0kd+-g-F%pYN4f>nKaBTQB`!iuCg8gOabJ%ZJ0KCmGFU#i0M=&4@+ zmME^ne%{{SppI^nV<|^*pxEndZtwu40jwu#k-;6GVHwN7fJVW zMFragF|M*#CBv?SP0F1B?uR`}=yeaYl}F9!M&ZUewCw8dY#EB0>wmFQ;B-N1>M>cO zyoeh#m1nxzSrciA!(}Jmo@TDOnzrRI^YHRAE;mXUwW;fJ@;MxR{1i8bLNtf_|Fm%b zjsPapu;6VMGK>WiLK7SpbA?{WFRhW53IxpCHV2hhCmTNI`%Mw|T-o8_;tLQS zB+E8UcZ3FM?)JAnTx=IyY&V|@$Te4MvaSNoX*3=XVDsL`xbj2oo!xuW)?u|Ty*E?SOrr?GTt0nVudfV zk*F=&GOsJz9Opb9wTFlnoWq#93SLc!IPs>+M~Gyl8Am-z=a5H+aDPorREHsXUe2Vv zPbLP0FW+jJNr2}nYv#Fj3m>FvZr-p$k z-SGvMx|t|54-#ZH-OOtxreR1C$^=8h;>CW+45xkY-cs*fg2qKnYE;gC^q;p3ElN!+ z_2`rUP1b$Af36^q%{4+!3j$i7DUh0oCs(22G1oZfc6b;esta|()ri~SM#N&@F0%DD;yj{$?`#$$2x+w48l~@4fH)(TBj@Q4VGxYXusox?p zcrnBIcOU-SFN}cwObqSV(U#@l^)l{Yf16-G3-|z_QP}?`4+{ICi<@N4USR1H$2>30sGq=?Ei^+kBFuhZ8nYm$2VM-%^M-`M4O92|98cfzcX?vhV8>%GhBu( z54%X^u;jz>3o3bZ4hp~51pbzw_b|*PmzstYcX{Cnyz&zx=K?dkJg(kPn+qVDrmxiD z+hX#*kPW;m#6Q~mU7Sn5G0N_+_bQ$d?y+>IeVBDxliEL-u#IB$6l$b+#^u5@#uUmO zD=yEFYc>cMgL?5}odcH4#vzD;KE;h~$X%SbJ{OlY2r?-7g4MVm>z+o*^AsI^8DwMi z-lO?Um+;CNl(OqNb1azzm1R-a2}i?_X7@Iy&My15B;JtIg zkmXWZwa6cahkXS=`l@vp0vDeOa13Xpc*UjDvFyUI|!>3!u-S&POIg&XoL=OvxHGB`*Or-6?4uNc-pH+1{Mwyq0Y=P)T>pq$qYY=A^ewz)DB# zmqq%MDQRy<0Q7`AStfWdS!6n@G)Ra=Y|&fuRTycIL^dhtb=+GeL^%2Q5hLpnrgpGZ zscs4(>$zS#Mp!013GChi5}4wrb5{y!*EJ(E)aIHU1(yoRcBy20H2) zoP{grVD|=CS|X)wu=7fdkGFvRhQru{My0|?Vm%$0CicO8(H5bRKj|y3jaLnSwG#g? z_{pDa6}OQs%+oO4=A9%=f6xpsVYu=dgqcfgq;iy0q~rE_*H9vP#Uw13hf_-%U2UVQ z@iw2)s<7Bqh~B8tk%5unffVG9&))3#Kn3&wVQ=>j5Kf`PMo3e5ZMo$D)zre}U)my< z9&QFY7phr?nU!1gu)}+XUY%N4eRZaaC}ku^UMj#$LP>R@GumDv$su@Ru4!hlvjyj6 z$xDwtbg66RWmvdlrY@URw+Sg-X>;DiNUtsc&_?<)jP$jRk^Vi5h`|2w@q(CW&_H`- z_rt1(sh5je(WqwqYuzPNBcpQn(z-;5xkz1`lr=36nIMUjrtnGoOynSya>p^FX`fQ3 z5PpdNKpRZr;q)8qQx*e*(yNrAY=nbJXF@0!(I|o({M((s5&jU*bA7gT={~Fs=s3iv zFonaxdINIXv042LPIqNi<=fnG{I*zbp5bCntOfM?8DZKJ7_1w7ySSBt7Q5#&&g^eI z{EqU~bW|Mb*s0(RR?BIK#&>kfwC@(TzA>|(Vfz#}c#Q0fK-JW%s`OvxF*-9Eq?Q_) zdagx5&2Y5?qCj2$L|vn$u9D1`DOApaF>^~4&Pn?EWZ@$3&uu>YD9pwvR?o=nC&iJ0 z9ZjMBv*owbCYELwDU>0>?!eGKCR>OY4;3J&j=d!fd(=Lf(}ap}x3S*G1$&ov5Qy{P z*+P>Rdqq9?-v1PC337@Dxpxevam`fM96-r89psLp4SVDa50#fQJmhTo>P?(6#M$bL zTWZsx{x4{!hIhdyXblJ@sI<2n+~NijjZbfaPY9xdOoCQ++Xx7?b2vhci&XB2bLH)G z0_B$&R`CidfJ$tF$)eIZ0|ij&$}AY)4=PEWe|J=R>Aw?|UQ)Oiu~C5f58inXRMK0r zju4gF{iwwLK@XMM9aQQ)B2-cghOAYxzkL#%Z@Q05i+2V1k5smL{)t!}oa@D9uaX!* z?qXjH7Z$|0uz)>nIESi3^Nk?tC~=Y5&4UTvipyYWmvFV+qCC@5trd(CsSI+VMpuKp7z#(C=VWGvlA~8|K ze8>BO9gR2iC%z)bH3@T5!uZd_Bm(v|<|LvdC#<&+?c zcFV-g%}X{1W!)@v^Q9>M!*cy4H(%y7pk0;ix{12+jQL1HRN9-qmpCr;plW!l*V z)gSVw9EbPocrPCgv5AS2Z<^%0TIZAPTIB8D_H+E%

Xh}iC4ht5%_J~qGUPb?{*|Oo!r|ojq9sJbY+4XmWcS}CJj|C`ZQw6Mv z1M?36oBrSatPsqn3hbt9*tsx&*q?F)n9q=W*Xn#O%$Jf+U~V=(CLmC)kmI;q@c-g~ zJ2PED4=SV%4agjRb@;5?FlCYwlI zRnDnp_=FVV*%~iV?{nNOG=Ib?X^E44c^uCX;rgk^ExG?eTBdz}Q092re5b8nZp0|W zX=3V7uH5G4)yO`w0(HGhBIcU*dl6Co5~X+W`N+5#vt4$ZPioy7aZAuWbrUO&qh?}(Ab-YQGP6w(*o&Qws}EZz!QoH!cvNxoW+L;)g{ zDN<_hE!~%XUGByb9?)|10nc0Z%i8Okts_D|abP{HyoELN7slUk=MlgX$6i@eu7dqj zZp+$LSV@OaTr;}GbyQZ~jgCJTx7DyLOaHNYv+jw(n=LWgX&5A!_<$Z&rvi9+pU*I7 zgyI726#Zih*JJ0B=kK^BM6)cGc4wAzMeS#$3_9vKGb0LfDPK-KvaDV;azD(*^H{K? zLgz~8Gx>?M#aQ{4XMu<PJpsbt&3>DT@F9YZ0J)+e!VYzw!) z{gSoEZ2F-?X?*ZjcHGDn>_Ix5cVCSnz{=R{;E!z8Rr>@S@7Q4qUT-^!)`9x0@l^1h z<^P+MuaGE|`R8Fpd8>sei$>h`+{0mPTMOvj`)?P7Qdh}e<>(UT>MNzx zwg;{og=?O|f&>kU*c@#O0&zT~xI|Wo@F>oVi#W>QeD)D>_oyf}IQ&^1_lzYpxc40v zsiLSE;f`46?8D|FrYbrJs3q9l&6MsAW@hi-b50C*GoAauTVvq`8QBBQ-j1mMyEg752(q zU0eVv$REGeyQ@#@#4gXP#qmhYt<79F)~BRIlU8KE(>#`%_CnE7j`FcE9Sr`bIo;}-2~fOaUa^>Mc}iob14_CRfo*zJ9Te;8-j zDz11lSHHEW$By89gL7l5ZoJ{TcJ@$-?q|}ton!If+v-I3KYRB6A*Z&eZ3UC}+-AfV z$?7;!kd_NI1BnyyXlo_sisn*(&To>FLgmdhxo=iWnW;&Yk#YX?cMxkGu#V!!>pLoL zuWh-lVty@8;aZS)R$b~dN7af4JbSoqT_atqOWk`E?Z3`ezlK^{)OYL==~Je-&K?9f zAqOm|$7-BTIN-7~Yhy!C)-RYf99B>E^}Oi9s?I)G{B#buGIv<@_m&%XpJOHO4IYhi zu({qEPiOWoRh{Yk{=EG|&=I<<|^GQE_BqY7;OF1u2v&`RG6B=9NGpyu2zG9E)awk^R$eH+W)eLo1*DpBBNE~qSsd#JD?&$mJ3od|aQ_GIBinru|C`OGp z*;j&@>TpU8ajrPZc>Cqqb4HMb)83y$_(Pnni&QkY2Lv#b^r6=@mFTYW@8H z9e2q|yDK%I7tY;}&Q6sBMC%ZCHr6uL!t{Q*bs$&~jDJ!Za+m7zG1BGJPc8>RQzggC zml^BJoS=JtjOuwTby^iKPd;ymLqPi2BdO-nZ16+1@fl|xt$SWIQ%xe;sAf>=f};)? zZ0ZI*Yi-b0ru^+@<5ox!4Sx86oN3W?mQ0KFYOej}+MF5i3H3@(!~1hzeS}va-Y6JT zvc`|4+}lVYh?AYGr;_LiQB?ExXS`ijnO;7c=PQS$G)U5~KHC0`=JlLHfi=a}nC zzRGiRl}3yj-sH9Rgmr7xxv5qnF_euQI@jYL^Zs%oNMm@*%Q z_*6~OKdf_G@4hr*?_@SzRF}G9iaD*ySY}RZBo8cn^4wzCY-g_PsY_ip#WEw?qUTg2 z<3w=0>#Cc*Gx1VmPy8sWvUSxskmJs4#sz9p(TSN-`6S}0m&OL_I6E@d^rDv8Hm2_> zk4^+mi*Ay~x(Xf_-=$*b@tCZqQuQLjFMF-?E4oD9ean4!o4osp`z|i;TAg1_((YL5 zE4%n2zItCxD)q2>E+511v5b^eE-&~fubIx%MSPT7VTt3TyrxRxP@Y+r#9FE^v8}6H zs;{=}uL?wk`7Hse4Tt}QUuNSWK5Oj83NbvW85+(mAyxC|O)0R1{OVbE))#Nq>jyKm zs(Idghaxi*dCh=DC)!=O8$MPPN!=X4@Uh#P{~`0iEwsU^{OhXQVz+kGrRt{C z*-yso=VGa{s=8Der&HEeT+;U}H;PffsMN&)Ht?S7G*SlIo1ZRivfVj)6b%jhi(3Em zS|PJk3K{CC+_x%~xrW-~lcIKXDwE^Bt28}%{fzxXne*LA@pgGhEiayYn@M4p)bQ96 zIVWVUFRA8n8P8?z{21@f4+RN0m8)g?-z1F7?Q$lYawfjsTAFv7{ZmgR4J zA~P}4a$H^N;#oDR3&Lw-=iD_VKCRX+uVZ=|-hH8e=+}g1G#l{!S zrbTq4#vWx)d`zEjX0=RaPo~*4n|RUePN_@X5V8mB>_rrXA!xixf4rJ^MLf%O@f=O| z3NXo?7-jCuZJ`2z_{Y^} zB|2ynPz}TaAZylHJ*-LFqY%<#UHXY7bQySV#m&Js>)dV2-&}S<%S3C?nk5-7BLj(# z(ur!VQ{(68RBw=qpM%zA?QX%Oo5*@vsJt>M&q2$q{!MKwbykNO8-{2@~7j#q6~j zv^{ZwL$y=7?q3>sO{@l9s%!cQ$+5qmMphweChL4FxCePv9L1_JP$0?MR-`p->( zV#|3UP6?CTOdCvP;isI6JkAqoZqd~{ZzOsGAvY1^|GkcS{ZX!2yOiz?5=~RjewKw#>21pwA z?&6a(O7{lhXUa!O@^B!rlQB=6x(xqzRqAxuCMlBwCuw7sD&cXMP(!ez|aE*omorGA|PI7!Pb@ALdrgRv}9ytDsCepMalxXEl<&eO7FTanImTW+Q+Boo0< znNF2oOlc27abaZi9G!>i;iloieqj+b3E(E4@ zNk`L_on~@B$znGB>~;}ww5lUhmxFxg3f`S9A7%34q&WrjYt?1{8|6@Nt5fVZ_^Dc+ zDe-!3r4})$PtsG`@>vql4r_LI|0Q^@?-VAX8qyd${PhmtMf||Ss}Ni1;a{;*-3|--_EKSUr)(6kOU+1 zgCWkP#zHecI5zRGRc8(L?*W4ZFT94nNkne(FA?K!=z>61>zl<@2cD~{e=X4eZQkaM zk0@X56+X=BFq7i@m>r+`-q!lVus*Aab+KmoJp%VkjVjEUkK32uN zXyAtODsx?Drs%9zA>~yu@&mpKAB8vk>fk4nG35*(T$n}x@G(uy>mIlhkje}3P2x9SF z%G*iULMYbxj9>tiHiAZwKgv0j*5U~KgG+|Xd&#)#>^F069_|Zdc!Uo4+gAW%kf9C&C_criR7T4ncZZ;u-1fGBagQBJqD;m^5 zsDc5^=0%=`ji6wQRV$X7(&|+Ty96sr!X_r$hpkv`Ywz{8+S*?GZnfn_tZouW0tf`G z3fk7Fec5$=L9Gx_+5h*=>XW3!EGT(96+Yc(g^ZBMw<9CvCozs_&w& z+6wRTA)@S}u%2V9n0LJ>&DY;@zOxtwRnqLlZG(n*j93AVY* zwnQ-pABF=$$JhV)XW398KDvi-0$lF7046$+l_@S!_ts2)SqOlN z7OF&>3d)!UfvNfF*w8Gkh(O`t9xH>>{7djjrPEW|?9n*%evR5Pm)PNMkd+g47@`ax z-o=?M%-21hP(eEyF|Ak~tQ^->sSx*AYc$dof^?qaip81tw9dx*t3YOYbOy<4XOO%D zGf9Sq53~G`G@wbEnA!OtsT-2!%y%AjUwb?PP(#$uZB!mUlPc>PcP~5D>d~@?`sPw! zWDm8K8!(^d)}b?g`=wp+w!Z9hX49TjdRx|9+QA)EY%7(Q3dqiOp#Z1B)-G-eJaniO z0eO;yn7g>i+W2CrGo2Vh2%+GKiILL0&r&~;3>*hn&6aT3IUl)Bn_|#gR>BH3?W%jt znbK>zlf5R-S<|%b_Msac)UOWbCaF(djcboo;AoqmP~BcQ1lH@UZl8#@$PL(M@^?Wy ztutsNWYY-NH>5j++)w?KGmhha?s>Z0e`zvLa<+CZ#AekKhs_wFeMdf7?>rB!vXd8C| z4wTBftwyQ+1)KPT|L%(E$@IyJpO;ecQ|g$H4_fu(v9q){{EU%!`(XS`wc%%{=H~+G zy&mK$s-CJJ947ZU2#2BRBfWyExf-vgu`q_L@H8H7A>KD54!au0vY6k7Sdun5*ZoKt z0vZ?c>v3(1zbYv*$#kAG`hiH?#A`Mds5*GHydMLT=GJoA%zGqvc|5552zf(^TZD zVyQ?@^hUtaaMJfunypwyPi+>U*~X}5L!u4<)eq(L6yy-scKhShyzG3@bCB2~zW}9B z6QOORW~{GvBEeomg7qN5!WmL0Bv^Yop7~J`K%W5ef>hbKryp_x<^0&qLS`8cVmAsa zVl|P*IMb=I*EF5MHm+_hd%^u8aIUu6lef+vKsnZGtE{Y& z)VA85s_f?oM$CC)y3HSGx=oS4b?d?pO>*oe{Fx9TZ293N$9w$735y?|YIZR-V=E}?(GCVtHIFq~K!-qSEr@rSYc_EUbRwM-)S{U^-F$ODD*w}E2*4Bhg zY;6rG(JtJJ?qXPNGQhzhq6~|maNCky55)gnLGgJdD86nBipl|k!p&BI(d({7P;|MA zXeL}aIV7xFx<6uLh}E>F?+p+bnF-cKO&OJBU0MOnyLI+BEM79# z5KSxvSQfx+y)wzpm)qmsrS`Zt*&g>kZI63rri^>z8orL6k{=Lm9){jIfSD_qk8H>p zpiik8k;ruEWFwUQ9g%KhDK*#sbl2^s>n5-sr%6zyWaR%K)>VQvgOO&vsx;R7j7Wol zvUk47UbJPAy>e1~QufXn2j@96=m!Buifg{AV81@2TbjFG`gBdrkg91{RiTW&Y$+dD z*Ex0z&9qzS;z3l&EcX+cT$Mcas?jS>ajQ1ULtp*;#Mp566B(!#PdGV6LT0Y(*%^B6 zL_DsHCNVathyRoZPAnbG=Z@g~adpmY#k_hREEFOr5*cg$C~TyLs6f~y!qW(BBTCVV z@n0>kw7pgc6h$cAMK7m|4wa+LxMrulI#`wZjqbZ(Xa>VE_iv}?l8!ypmD?U$l8VBz z&(SE1@Figx-{GrSl&zKz#LR0C?Xio}vY=b&EGh%KMIuA0nqoZD4rZ$2LI*_zZ3j^8 z_c?l~J@;2DiH9jccSpFqN9O(5;OLOd`<*iHmznT5CstDh%pJt&ku|;;TZft_A>V5k zXR=hUrn+r1h4-Y-`5V*b{9da=&vH}eSTYYuii!0d;fM>fLUwU>t4#l8-&Sg3ynED~ zOoU2J>vb{>yRJC@hUjiAwuz2t|Mv5%c+3@25$?~ztRsxj@WxbQ!&P}uLZ*x5?V@gn z?W&JZGeuM_U3Y~5o6di^K!x7-Gda?-Qj?&KVYzZwsS~wTx7#f1{_p=kiLPLnoF^x>y3dNLrnEZM z>eO$vUeEpKnqA6z{0Wpgaj+}o^y|t3WBpY!=3sZj12KsxE8l{R-`A$@SDhm&YZ~Rob3H{kuh}oh?eOGN|+~dP~nqU87DNZ!`7CRiX69 z0n*&K`P6rQ3a{Dm?K zA1}>g8OM!9IXD*HWZLT3*mQxQ+6w_trYxUKiJnW!KIU4YMcbyLasA2&q)eR`zZ5HW5eZn{<5;YGUq%eVHk>s%P+?=#6sXebq`CUuKA8j%{qXLQS#Hv3f*g3vo`fB{noN*58t9!HUu@Vxg)F-ZpLk zu~y8r358R%GH_3`NmOE!XuM6LAwr_qIf^Kw6;TYED6xDYLu?p-ow3Z6s@@__@8U9` zyuXfHUs;JO>R*&Mt(Ph$AEXcE*G!Hxv+`Q++7o7N5$;(wRu58Q3>=ZHFJ?;ojg0kg z<9U@kdsiHfVQjS+X`3GSQ>inktY>PO)}L$2g_FA?&94a+4Q02?PFS05i-<)CT<=ey>hTOL(2*vbOe$^)x|}T^`!TPcbDG$j)NO z~=NGpKeAzp}(%AKGy&D*!hOW#4g`${bHxITiaWifxn(5 z*kpl?KkN5m;j&TEw^0g%1{8xjd^aI@oJ@eOFT=OO_qiJDwSNC?tIHe0HKqI`$mlla zZejD%&E1B%xU1H+TlNslvet&yZ7pRFM%Y$f>veqtlB)X$+nkZ8x@6i1VI z*t|JxcwAld|E6X^qP2S0SOHpH-o0w0&1LR`Ou90rYW}Y`^w_eX8LY57vK7k$NGbp{p0q{A)3V(k20-_MGez4 z9R88I3V#KT|J)~~OS;SB-05WP0{JeXVA$}ww$8FN){#f|#N&9WXW}R(SKXI8{2Xec z@o*5%^irB8Ed|TEX1TEr>W4#Ta{>tEu&Kx;f)}^Mj|D<6y^iGU~HKg zn#B^6?gmO;SC{uK<7O^wce~wI7bc{H*w$_u;<&KBEm)Z;3ttX>s7+^O0sFDE>|#tZ zWfR5?U%39-)CJf9`VM2z(@HXN5`uMQKF04%Cc&AQi?g-ElH297{xp=G960a4ng@?~@@#6}=PBVgmTreT~|;k9log`R(|vZ`Oq!RAq2E1M+5rpgHE^aR@2 zp){_vPTae;5UIXy=0P3IC37eQuhDc5F*x(#6vjcoF1)q_cM1eK)ggP!YquX_7@U>U zR3Muzj173piZ>=Fb0~Ew1*_hRbQwF-ax6V_YBI;ud`Ydx zq6a6bGX5hiN5xD1Wr%Z0YL15eQgh$G^<%VdK{9ph#?+(_{f7YeRrV)cy8V&_DzS@G zlZN*xsHdhR-P@lu7uxogOk>O}_!dntOgcv!c&P;kIjx2V-{<7d1a^M=h6;B}Uq#W~ zFgru!u&bNLra2996q>}BO8K(Q-SBFd-h$^CX&MfP{V%AL>rzu{7?M(@D8M7t)h5ZR z`je?;(QG?RoccA>4Bfua z8~WNjt#1fmlT&ko{yw8w*w~BPa_DN)V~vQ9p^G*zWfU|m=883D@c}tb(HqR3Ug7^Y zdpsbWB-d%HNy{~0CLAL!{{C?TfsGen@ob`Fogw#2Go+{0pTW}m=;?AC0-_;f+;$w! z*RCnx2U!q*)r=c4ml-rbvLBjh9f;=(c6%AFO^e&Pt~S*b+`(+KylRQj{0M+Ul_Qw^ zwS139)2d;W@9KF{E0yox$p@zMBxA$j1G43QJCSH!wzbB)`r%s}u zm*}2kwCGC`{j@}HN=8#L75!fl{ljFm=uwh-okUwYy0dDkGqRcpT?tooc_RK2XXMMt z_{`|F#CKJ#1camE$QO-fnXIPL)+XvUFtww5r6u}FPBSm0qn;RhrZyc=Y&GZeW5UFh}%M9GSFe7lsN|(NVMG$1?+sxLg>8*2gYbScY(R@|1*!h>G z7c1O3g|BA3YM~TuG?zhRwB#9VUz~YpPutA!k z8Hak>`m%~M^D0`avV@jV>D>)S?lGEW;ruuxlTD=uYZgvb?JH~>g8*}Ak(HT7^TWKK zxa1QM%74ZQ8yG^8qRkaBAEo-=Aszcp0VYRD!>x`PVhC42Cv{tP$YWB2Nt!@o8P@A%F>-;-g z=ie0-O@+y<&Zjb1Z7RD_)1J(?JvHB)J6q@6rH+Wh)7QTeYG*M+zKE$(iDXc7B)6K| z=%P4@D%@GMiZigQ?ko#4rrnj98JmsU|5UdsuW7HE73nNEBpNl{0ta`%);X&e#{l0y>dluq6L$@p8OJ-MR@|Cpn%cyhSJ=WOY(U*%-yY!G87E!TyT7-eBMUx8q%z z_{ObUN4@3{zDT&8@Lz1u3} zM&=*39HaS1Jm7~hV|=%$x?hz)mnhY)8gbPXkhC%Y=q`U>Bacb(Xf&Tg8j+l03%|Bw zKpLHy6b`!|AEG_~NorCgQp@d`{i&t*VJh~_2)ue$^eQ@nbmP;!ocm#h?iH+ps#>Py znHRl5ea`gHveO5mIX-bH@)fFz-3(xjn+(C&n;1$}J!PPdo|1eOxfsplRhP0rR@6OO z!8Mvc4G?Ad5fobk50iGfVKg7&SCc^{pEIwus>rVWKlmhxZF^DG!s%1}pV7jOw05H1 zBuW7*6)Ow(6H?Q8`lZKa{LbJRrTOfPhTkn}(oW1aNY9(nFjW}%uNOft$|dm zAcGy>a7VerhbCC=NTkr|wb)V&l2pnE*rTx4GhYc~c0}ndnuOA8y<1~-dl%m)>}RZh zDt}$UWIW1`WY^zOX|4U%KX%({Fdj=Icg00D{QA8PXY32Sf9mHM91b;nc2%}Bc7=RD z-6`+G0$I-3Ox`EW9U|}lzKHJ^^8W5H{e369z0Q>H%^YtO8h#qlu@SsGKg^Q%^Pi17 zn4~j2hJ79;l*W2R2AQK{xpFs5Z*}-432ncIX^S+Ylg6G@%M^;O^$=CEEU8#*i0t;` zSYaEO^?qfy>!I@Gz zMBs9s`yAh}1d10bOG9jm#w|Q|2a(7LBD0Cyo=Azau}9LDK`M%z)<=3@J5XCFloUoN5W_UdUH zgcJOyfkngN_x(3FJk!YgI{z0*#leI7V%Ibre$PLYw@i7PW2dW1e7;on*X|FzQRgd` z?f7FG->}F}Be9F|%(}p~jM!-YX2uNu7R3}U**xZx>ENua9ADnXS1<+Djo(Kj=5TB4 z4=>oo65?}mfM~O5kqHEcYs6mnQ_a%j-p9d3xH(16XL5o_S!m5#sfHENw5a4v zW9?p^tnW%K1*TZ4jP>_OC1p)gEOY;qGlSQ3+2g1bRq7v-Pmtmj7-qjHgA)v zZD1=h>oC3-KLDAy?^Mn%lXH(;+iIr%c6ar6K45=wg!w5ZNB_JVC$k2yL6#m_MKOad zvLs30M`9-GDvinDr>NF&_*a}yDs|tc04TB<>qj&k##HfpqJ*`C-*yxUj)GpkP^gZh zs5+{r)i3goA?`p?^Ire(hF3poIQ)=5OCs{saa3{))eYF$Wu6uUn3&^fUzTvy-7B6@ zi=YeI=5Y}f_`Z=+T;fPLh2FsqZryywrVGlw@C=Khi?rYnyBa59O;nWdxZa8U8SgoG zX*OfR+Iq+QOPpc^o^Hms;cZpIn7zEz*s!2@9#Xk@X0}uO1xcA1EbsK6TIZg2|2>mW zndbCez(HgQ?5S(Hj)L7a}u`Ca#SR%2t{-H_UgXVa(7iS36>1 zn{|xlze1XZnd_K$^FTksS9!0H9)focx!0!T!pLYU(m7&+(tu^klUGyL9qumX! zX5b4Pel?>wn`!>xOn+usIEFlLb5#|y!OR(~n&1xix~%ODuVr&cfAz3-WqIG*+loJY zsN%y%5BYDjhf+Sn9k+_uua-Zj$#Ae#7FbG?L$F;Z6-n`7S65e{8*D{03RacsRRcSb z{vvfrNq$VCs!|f5MJAxAv}tfs$*t_EDd&$V%c>l$3GI#M2^0po7oP84((110bmu#* zpum;!SqxLuO0WD&^{!DW><4@~Xgp&M3|w#(g=jqI|Tw6b|&qJA(mP zg>PUKX)1zFp~{aQ{m@^-xie(lzEOI!d-JFG%b3CGQhR;33+qjmKa-?;oo-oD2i29j zgPVm}-L7pxYYPv$g;*<>cIm9T%c+ixR?EuOm+rw$1tmGC`i*2S&W1p0KdIZ*5ex`` zn6FFyj+W=^aLH${nVX~rtd;<@SVy58Dn*hv?7C>1xSC-jGetnAW^rC=kS|A zKoUhhP$Qk6p>Idz8l}J(P170NlY+yphEPSwaGg+Ks{A=!b;EqpDk7*Rwb6fEV&Y+q zfy{pG_$bM zI-P+drx`8hP&TV%9Bi?EyxhaUS<8PC)o5@0HNmjX)flGG4tSWI-+jgk_USqu4Yy}G zd?OLPA5C}F4^`;`;XJjAZ$L`>8~$Kv0PN`E<3~?XkT%J(V4bT?(ioJTt;?3In|{&% zNiOVWGjh0E(q)q_D<$1;6X_(=lc_J;6E6*Yu9OTfC89M@ufhcAw{%FoIaG4-A166N zghvRQ2{%ElOa1-|@7bh1n{W|fI^lD~B?b*`ui0_p3U9!sK<_Iu4ep5dvbBLZDywaD|HcQXP$U;tX<+GF6zcAppe2#f zZ<1e9NZ;4V&sS|N*(3W|QAo`piK5q$!@5`cO0{*b>hc^rxz;3>HsB7i^Y;eAM>%^e z&qeZ49AxX!ro_x#qmy47h^v8E^rNG{MTi0cYDA zj%08A6A5aJS#4yFEkR!EV*Rn}cuq-qIBVlyQ&P^9G6ZSKHc4JSv|ow=E%_Rb;JUee zV=lE$fFH`1Up3jsqos`rv0L|5UkJGf3t;|T3hFr;ii9~P?2a|au291>ko{VIK#^<%N3Hr)OhRxI`# zO}Eg#)Ec$*%GEJf>y@jMN*wjmM3CcM6*a`aO$hOCiV!m9YW2-tFHY!373uohFw%*R zRFSH`nWA%5EPEEc<1?anaqiDk9ghP4Xw_%*NT`(}76lSzpb^QM%7Wqn@I|LT27ao3 zXzh;OoB&ecI98uagXhPUZ~(4p`k}F5ckGOW$&pEA!dc*4t$Q&kR85P|xx7HuFss|j-f{;si_5qAPO;vL zjr={MIp?)MEXiU0CmEFP6o`!eDVD@I z2NFx%eB5xWCe&IzwN^Lt{-M_VV$PFd$ET={)^`6`r97S@Bq7D29@#e@nw{?svW@z4 z&cGXa+_s5vX(VaA400rFkJ1(t2L=`3l-B z!S7eVm{@=x!>8QJ_boQ|aeDZU$Phaz1~M!FqgzPEEdidu(ILj#OBrAf{rU88^zVFp zJTtcY@toKWRO{8Tt)gH{_Ac8X6eb0v2;FF?@avVKi_S5$++}M~D%Q5Qg%t zkRauJm++s2KM~Hg<0M{!2<(R2r#Xx!Ih51b(AY{PW{CZuzRYNPnBNP;qi4p${4rWY zC!%eCUYPK-c{8FsZT`ZK^0b-p3_YlRlF{^K$tm2c4!QlT&bK_7?}4bww~im3@0TnD z7%jrrMpFr?XMBX|s{Ur9=}dXK0NaB=70;Fn!W0qc`>N3*26(VJBMEhjhWbIJ3b zoAIJTU2Y>M@qtqls84-Ep-{??Lg9j=lo;r{!f25`K+>(rq=hk+G@l=h?e~X)&jm(P zBPlQV6{rXL#?|}Cb8j-wQk`c>GSBtp)B_mb}wgHxx&om7PJ+bq2aMpn94W2b{3jv zJEwRR9F~6F#>{X-)<254{AO{hEU?v8201#&YLI7Ks!?|3$$X%)GgG|n)y>?2m5UHq zKg?4RvSrGq-~~a)l!C75FG!J|l1#fK7Gmv^ zIC^c+W;lKDlCsiDdjB8EDkVyKjVP(p$(8gQL^vF9yas0wNvYHIyVKc;I(dmY`I2T0 zUQ%{iNyf2tI{N-6sneer#s;ZVPFhJn1+3jgY=-y`yP%U}2;blZ@g;?LYadS*lxU_q zh&p-V4I8{9$eL2p*N-jfE1#&Ohak})#DghQN?P#wVFQSFIWZ^Sn=To=AVftK_#hAcNR&@r{&4mm+@+6jLRQl;T3C8Y|rFQ1&~Sw1-A5raWKIdM65aLC57kVOvr zmihaUW|B9kaCw@JJqS7SQ$Sl;e?E{-`1M&m#GHH!Up;t1veb|mOsuTyk11&GCo1So zgyJAI8kJViNAC=*(c8qFe2oHw7bHhfCTe6_SzjMe(uS;Ch|x@o=)BP`c1UtK$UZ@f zNN)BR zq()=Y3YtEkpbc3U67vZ}=eGtg>9n+xUV1aVN*l7CCFT>9G-2?PPERSx7SiUXx*Km< ze$x%NEuS6Cb0k@tYq19vdtE57gAi?8N&!|@JT|Z@?-KI~s&f6{C7qF0QuBb4)@Rid zbMk!f512pNYs`<1YhaB<%x#}5dp z3kHe#8Ta}zJyV-MzXV@n9;qB6OLyN`@{vr?+T*>c%Em4IW;gZskmSUy32G3X zJ|p|`$*CBl2Z1M(rnDK}Nh(8fLi4~D6Z{bL4!kY17LQ7wK_q+ai7LHx5TG&*>aeoj z`FoPx;4w9)`!i9(VkbBM$sYv1On!iW+uVUl?v2Epd=LE%V2(!yx5dJL0UaTebraP8>{etB;-gM_l3UFURdevL+6_-BZir`mm zyjXplw!EK2iUCu~^?#yrIRH=}F{7nWXQPzME!HUo4;iH3)ShHg;V=EG3l3=#h`N>( z2~y)!kst-%`mZhcSk{q3A%dfSX-=_78J4OI+v);`NBS$Q9=64g$8oc+e?8GF_ae8O zdm8+?LnvF{;|l@}3ocV0~CzYWw62_39m5<2`&=dA8GR z>&?XCmDs;;-?z7CN}9q4_-fz(pm!8>#rQOd9|#)%H@GvDz(jQd{ejq zb-?=dNT*r0#SGS5BzvycI@)5n-capYIiu;_wzso6#iH$PIY>V6dbX!6G9vId!%YbM zon6sKJWuVk1&y0yvHhdSXm!?DrLoD0`#U}HZ60fj=TNWN_6EKe?cv^xP+oqkn^Vy=|bjBL>K7ogK*9bC14@ z^K$J)X4$im4`<2oTn`otyLqf@OFh=|3Xk==+97$}4Jn=invuL#P-G=tpw?2y7^}O@ z4ub;*^om6+VXu*G3s~6QfmPuJta^9wT4P-o=8kFE4s^#yJL5C1rm*^AUu7V?JJ5HR z(eeYGzsY%B=49p~Ya18vt2UWu{fy;eoTTbk1HZ}n7yJ7k6W`rdWzLN28K3IU_Fb2? z2Un~>-);35tHe238kmD$4eVhSmIHmh`Z4NzgZ+JF;=8JXpx#v-UO+9Gtqb141>x(& zxvgT6{Y^AdheR)NAFWu_(c_xzm*P zPVhWKa7}(aCRKW_l+XGx^=}f0ohR*E5)QG7KI!EqKI=S*Hyh${0of@BWJu;b&Vvoc zmVxpkp818!8wsDIOpjdncbE%IL!xGiEG}g%bG^(~zWum07|lPH=upB}~>;-S#C>279>kF1~mhF^3s$<4FgXZPtEw*-It+SDvOTaha|}CO;5U)nlquaIXM(^a=eP~~7xPE<4zk2ZNIQKVcRl|4ihUj=|rAQeSf6n974?QcT zerL((EER(~ZH4ZT#~C-%cfW+k;2)Gq<)>kjRNt(r2LhE5h2rj`6?kA&Mu?VA~h6yr=38NvxJ zk&)bF+&9E`eykLZjgWXL0fYHQ1)^8^hBroE08_3zKJ516GBr+IJdxgM zJkpS%c%)H&gh$R-JaU?;sCb9O!X%p1UN-3`808wiaH)J`|F4gw=JV{|(bTkX1!A4| z$QPU$->az44Wr|h|sJ)v>)V(#it=IJ&Jx7A%ETWph1a)~L!4gMG)bijSC9|)w9 z{gCDN4n-EQT+NeB9cUQ&<1ddT&^~;kG=aW}16AF+Cx%USyib@yjrf;nztm?Hry}GJ z|8$}xrz9T|ng17m(>8z|zkU68rM2xyY1_xCMg3$b7JOf~>w!GguD$%IcC}PP1;T7D z4eU6e-$LUSLhZTnVZwyu9m!J)wQv2!vDE(R!34F7=yczcLI~d>{E*;qy5zr0{^`H! z$9`1Nd{Bw_Akl>6gZ=$~^(P}Kd*wmsil5^x#YODPR%4BAhG55S>3cilwz=99`tIuA zO+y^*V+b<4w&IW%SH2l?*qpK9x3lK`Y#RO>O)dEy)0px8t;oz}yhy~cB* z_ZxTrL4Qd|fan(98~=vDcDN2kckp88wszq{`&F5FC-Sbi&f3*4e_~f?1kVu!=L&+2 z(Rvwou4s%t3K-w8Ky;`KLRtQmfE06^0(t7XB)q&-c=7Hn?YAG=rTYY;>;**GlzFk~ zc7-JWKM`d*|GVz81Fj89ioHv}I`kp^>ZtUqO*~c8h{okT;^;Z%r}V2Aq=m-455>39 zLbQQfM{WBc9*_X}L}%myND_lX!OwPJ>r4gG1ihk;9$3h5K=& zEKTYud`yt~e4d5WDH!AJt7L|5=pArNG$0I~mH+XuM4Q?5br2)7fAGgzVUbIM3?gcY@U>PwDhbs z?<>!wK0=gT?BJYrx#IkBMzZy69>^mmjR#VjPggPOfoO?(ss6T$ z60NLfMhpb@Yhnfk7X65cMZ@Z1MvjLdm{pGnX!M4I$iQ6;emh(Tk$_B)0!I(6;*7@8 zd-xK`dn6$VM{%)0^hqGNH;GeAe|tn}$mqkz`EcM}KC~u3q&C#^d`eVkFox4aj$S4J zl8x`>775LXV`a2eLv0(B6;3QZvtK^`f}11L*b~h?sK|=^?5$*a4a{xr z(TEJ5=O=>37eIrA$%1d}2Q+BT=!5}WxK{dH0g$Y$wqb*@%1`-nLRR_Pn*yMLWa+H3 zlo;W{&kqW^@}GgW6zH+XfF5dRJP{Y7_)5nVF7$~snuyAzn?1F;uaQq9`IH)2K(ShG zd@8A>=NK(-ApM1l)+V^)L;tLPcG z+>)witmy|N-~6fH>e9aX)AG$u|CW~TLcVE2M8!&CSM!*n8`Hm~fw(E{TYAx+^lxeT zF5nyWw#WMzy()Gq?^-RoPM9UixUOYGGJcA*Y_iwuyeHDs+;a0-W z2m=3ILK*qJgqsLKU1enC}AXE`HY$ zJ|Yy7W(r{*;TFPa!1EKtUZT!(sZi$=Sua{$<}|K1xWC<;<}~gPv)0kvgFrAX=hhGN z-T7NTv6DsOyXxu8*&HiCiGDR1vL0tUW6u|G|!3)3T&)vRPS< z*YO6Qko5crHL8P8IQR&BmR`5Ket1lm6I^_w<#HbGFGJ_t8GkW0BtH6@pF(Qu38^tz z6|u0oOgA|Z{kZARlk^%0rV9Zwly#f<=#j(&K*3?|w^Fv8E|G*-^jXg#pXu+b!IFT!?HWuJVhX?;&hb}NIl5VOLq zj{22_H`Dq}rjU5kwl9Bn%tf(3oNHP)=a})Gd@7B+S14!LpJI;RYFguPIe3|)t+vI6 zSk`a9>Ts0r^5sE<9Qhg#$Nr>GFcM;u&^N`j?h%SdM(ji#Z;>*BEqzi_SBu2UKQs6P zLAk3%8bi#3!ZG&ARVh_e_Qr&%k;D2}A#|(rxzt52ZtE4(I>OOD9NS>hIA@4w1Pg+~ zM)9qE^$CWwXV~TMFTYKaeYU22x9>_thAu8?nee-dJ~qn_$Z2kz)impX*XoQk%^2=z zT&2JHK23}yoOgb0Ve&|{FOq`WTNVa-56qAc{$(uC98;#;$hGyOkxn?+T_nYR$;y}^ z1^TW{W}IenRMhe@$_#f50InP{gHGIzg0~kO^O2e|R2^GWHq)IFuPNJG&E;XLojHX5 zbr%;Q2VUb2oLXx)^2JqaZRf_|JN~$no7~oRuG=T(+V(lFwSV5YpL;U)BAi&H#}kQz zS)h)wM$SHQ2f1COt6j*;nrt~2f*jC1)%G?Qcz3g$G5!!|G`Tp-jE1t_VE=s{NHT?s zM>}Zsz~74e)9~pTSI)w$+v<>OA;QDhal1m2q3Oq?vih>6^6;S-!3M0evBkN(#;^C) zx}K{k+3h<+{)~W<9PvJ}+~k_0*hpi8ddi4#@Ci@x4p{SCH|a*ppIkSIX}5y%*lF@- zw6UR}+-z(Y$ra0i9WdDyls6yr1oP=S8PstJ7dCIN2`(-2aE7Oe$5znHF)G`re7^Kj z5h-HCIi@+_+oZfNLdMCxJB@7-gl@HEiO7sxz+{?9bF0yEK>C2J{ZQ|X)Y}GTpVJiB zEb`RpA7utMOZRoq)v$|>K)1C5(x1qA#6sr;^f(MZZ0I6Qgx5C>!^CUqL;{`eEh9GYpUBUxW=K+ zYrO{n>G1w*xU?&0*?cP_*M<;*rZg0pxCo&ecO_{PTI6xKUr`Vjw6 zv#X6MNSw3kxmyLV>el+tgRl!s>(`lqb{Ca`QQ~F^oo|on>NDe=a!~2F0(Ty8pcn+= znfk^q(sFDJK1!@rYXInMBoJ7HOA5ddH)Tqjjon;1V_c7Yl^q5^Wy-Wk*jH9)^ zv^KiK$T|5Ux*3zyh^$mDoyemQzGd$KL ze2={NzbVmd1s|Zzy+-vLwbsSW+Yr-kEBvIarf^uSSLDgfSP+`IG+H>4TmQI%X8nRm zNR++O?_Wzut31xn%yG-12acEvuS0bgQRj z&vZm{DTb>FT&hetxEo#Hv|hj~D>9evqx-`Jg@Uu&vR^s%UJVEa&S)}C)*COTfD8>dUa3K9r%kA0VsDZ1vp?XTc5*`Cx;L> zou*2OaQm9e6L{O@DSz8&xrsQl{LnHkHhIr9Dqo=BugGab7m=HzRjIaF@*;!J1fD>h zzQ@`dgOJzSB~|bmGD`1@-OAlrBs9xkf{nX6o)qrl2CBF}&ph<9dHTy{;Pv$}kFkD? zs{QWBV;2v1#HM+;iL<23ERXbOI!7{b>g85(GO+WF^zy0~UzU;2wEiUIHCp~tCY6C_ zM6BT7;0fI`RhnGL`(kALDIkU};4)nwnywGLB_Gr@|HWu}iYy+hMP#B`vI@o%7t|4E zd7lro!>UtU4@fP$CP3=UWixo!A}rr7BJ!OAJeY>~$3w|XC`lh^Qa4_jLG&Gc37uCS zyJGo3eM5+m&4b8UQ3-_2OH=P0=vO#wd6YPRM{$1YAw01BQ^gNZ-&*T{_`q7+qrTs5 zMcfu@!y7eLZ!L;lj>oDe+?H?ME1f_wFDIlFH;}J+ulq@H_2(KwynwrnHMdDO*z3O% zF_5`z4o-PVIX9E29AnLc%F=daW~ef!yxmx{RPi%cRl=7o4ZL{a`4X<2^Fqy_E+i@o zAcDzh9(^pzR#sg!r^`u^%1r7F2Ex(`A!{nU#alOT-q4&P9(#Cf-pj*29u)drPPVY- zF&>KW@0EOAfeF-2Ruf1k@|~X|e)v$zkNm3+su8Ly&`Sh-&io`l>sxqdA$S7Qmx!r$ zEpNdoYA@Fg|a;}Trh5g54 z^~4r6&b;K2(l>o6QMK0PnVNGo9^xP2#f@1LVv=+`>po3`JeWlhz$|I+3QV!lMfuT{ z5!}t-eL@XXK`0;u@>)CbKEBWlT0%J@6)4M6Kjnvg7uKR%oR@^#MnVB#%F)Q1?JNR^ zH;qJ7aRcSx5iCdA(U#0l>{D%4U{KUpHwh-9y~(Ixvy`_4-XjP6n7ANQILx{)$$ZUw zRm;hpclR=|cuGD_^adoe!QDyBO6eDiM7P1g%{QQjbdXw9xY$cPa5HZ_wkObc(EqGE z@R8HsX@iRWUV71h{v#d&6;`9@_}uTO-22|3!$_weF83Z(mxY7sE4SXtbU-`KijP}$ z@lqkR^}J1o9g!PFTFbOjuv{ouE}|c+xu%*AMji@_l0id66r_LvWMzS}WB--t;eww& zzgCT8;@{0UX4=l z&ZN*k)+|44G7m8-yFBGxq7>}rvZ3J5Cu-D;RLN3GuiwJd zo~s`{)(esEmJWBQ*@wF;vsm^C$)KRSd09C69DTfbTdmcl#&t&Yu&2C_yTQBKl{^jJ zw@#6)J^C{ea#MvjhvS-RtUYegfYdmSBBZ7ruL$F^JHf+szk0@T@CHYYfCjsHL_hJ!ZFHRUr!>4aYY)Ty_!sTb zo>>N7fHKUVPvRP@&%(1AG|KyomO{yH32XKUX2H$U`aw%LNThUrsFFn=DUqVYnYnrI zlaj*sY0JtXmbogNPKW*ypZp1v*cDl@{oQ{LMOaa}x*({gm&rC(cqO ziNU3j8p)jKe6Tf|8oF#aLuBz%S>ytAWfT#lF+3ziz39Z zXcn)Sr$f2FuaC*Ww`d7Sk)4sNFBA`U#o!+6AZFg+7&O+_6F@+* z!Z(>0L38OaM$0{93v3n=W%_T0eTwj0X=>o|`v;-6CpbcgE$DYi*RBF#{iOPJ+u1w^yT&Kf5ZHUs0 zln&#y<%XgulJh>P4L3z{scQTBUxzP3-MU2=VOK4k?D#q1rb#;FB2=mgpCP2m)1t)f<&AI3=0@B%>Q>pCWSWW> zNrQ)`=Oa_O3q|H~#@$CHRp|3MVC^kITYQc#S|~~gZqBD)0?Mj0?vqrmedxXwX9?M5 z^GS8F*CdA=0O=Kml_8SBa#7^|uZlD~pmTnooYjmV72KM47A?=KwV>D=IKqn48dY}I zxF2V;`{C&cC>~yV00QxwIj9`WaX4Xc_?SoVAg7Q;s)We7Td0HU&tOtLr5}@dHYU~m zn5-?9X?-L+6`7GXGSwh6#c0XU$jl2I8EUkAKx(`AtV=0ViU*T?(St(wD_{x(P+I)M zY-i;A9SKCt@%@M_un{p+5qU@uxr>|Jl2mCWMyO(f$atgWc3yc~5a=6Pzf>VXDgX8` zNHE!u(ggxeTJ01pYL?oma)w603{~aHWR=PAhu+XP$BFtDcqb191cMaMoaH`uvpYhvvG@XlD;*fe=^#y zU#u$5FN1^k%HdI}Ft(krJIQo$3-h!_QM26KXImX?6jQf*+9uJ2Hi=T?32qW`pmbV} zyW~{{S5L4};44VZE3q>WTRGgf559d*eKerC*&^j1f8BxqbR+eAl8adqbR*R=6iyk!dfhF>Z$^3 zjTl_XCIxc?aSq5Tg+M3)|o? zis@j!+E8~jJL#m4cr5DjhSwT}ZdGfU`5w#6;qqhCx+>pm)j*8t_`X*&3XK!%yo^kX zycXM~Fv+5U?3*JJMP?}16<5p-WsVZ{77a?6bfwqo<@Ja>&*Mbd;;B^JTfS`t8jGF* zHf|9N)M1ZYE^Y>YTU;bb_>BLqt#ez3Bv>kg_g_e&&fpb0f_jjvM%BYl(At#2;DQ`s5^Em#D5d`A z3wiRCY%xosW;v7ik5NziWbxqw<~|jClaa%<$74Mkx%bo30aaFAx|jB>(CE}Q|HYT% zb^To&BsqV#z(7Y+Wt4x+)gih}QDW(D`3;w657{r|7%)$-b!`uMf?PxSRyZ>pG$YgRwrtR z#MfFwOk3RxDP$r){<{dDzFO<3*ZS+UC-O<;JIkD=7HNEA7*HcW!tItelI(I$uJk<_ z*ITZ{geCNwFF>t##1LHJDT$a2FblmU?Qb>n+jS z7wR@=_9taTD-VT|n#+)dD*r!3b@sG=}YDR{E8#1Y081*^9*7 zNUPTn_yAFKLN69!3>Na{Ee}kk0!GWfk=?QidBzAgQnRWu{sk@3RE8lD-L0Dwk>@fR@_2-+j)mm{(pQjMmymG+ zk8*K4uNh=mb_z(!vMcLq=&te<8%D)d6sC^y7nYslE$>=ZB+J7~O{_i)`-jaL4Pa%g zd7Hl~E|w+iVG1lLHaj%&60sVbZe|s684~Pc-2I3o)hn*idlf6FMN<)TVX}yrdrW>4 zVonx4)p}_+5}BLr)l%tNCE!?}X1(;hwIV+Pk_miOwSrGbMUx;C>}Tg+t9X&Q2l<&; z?~IRr+X4h;Bq50`a$hF`LNDfeT)S9A)ljVpNf6vDz(tL4oSpwy%z@cR)}LatBlV@kspb-V4_VQgO<{!rvk(`$`fxhz9!rmg^*d)k!Z zO$Zh(lI6OZa(daUKC?uPcxGspD=LPO0prJ2iSa|(??jng#PBKF+*GfHJqHr_#4x%e zGA}9k#dEYaG;yY=DK3~3`6Hb@_=I$$m?trstp0_N3Hz<`2jM4WH2DsuyJ%4Ar|09* zJ9*XsY#d~?g$AP5a706b9I%>M;`Ee^G?n6hB|1yK=!%|WloxOLJN_Bo@-G#y^j{ng zh=WaFv;56pb%D415!L^&sdR-OL+C~0(5;pXqloyGM2KV$J|XFmGEzCzUH=W#Ohiq! z6 zz{T#w15dsFgErcC}KM-EFL&8=ezm~g#Mbpd7z-wVJy0Z$2f9EA$%Y%Kwonr=iQ3^ao zG$k8S+gJe$^j_w{1ESoWQ;(tFjpf)~=q>MFjs?zL)a4d7r=#!njU@X7)(%KnxIDYl zJr$1)ye8a5Iwh$m=ot}L7kJ9|)L*^z$Zf2cwvlD)k=0lt#!+}*{#}z;2F~|}D)STP zQEX}Z`fU!9IOG8h?#Swje3LzjwV{e4PkG0(S2Pfgpy2XWPx;>EXQiLV!p%EoyuB4` zhKISw-evD3CT2EKls)`&m}=FUJM-!No8fO^E~6GZgGQHomlR?8xyAH=cYwXL+{n1{r1Hz%zw% zNNR9aj{hQYl4dtEMc=?o^=03gQusbaQSOGI{I05rl);biHgsmLCCicnDyaPBDv&3Q zf)O|e1w$syEJTE;*sVr3U?^89{`nR022aS@64h@XfmRo+JLX_UsYW0K_yfTj4owF(haeFs6-oc28_ zvVM$N{=LU|SUx;b4Yt%(L5*C(3yQ^3p{QMh1RcXZED}%-qh!1%k%7S`K6*B2BqHq2 zWAh(UA#sQW%fKuN_c!(a$gEQpt7Wq&0itDlp>tIxrOuVv*qj1uRv{eD`z-#9tSYi* z6$h&(1eZ@_$z~iM17Vcaj1}2x8%S(e;Ia|ccH=v3@iw)KG^l{0@OVRcQ?0;SNgBqTP=mg>z4^eE`QF+uet z3_DeNrf_Z14IP1_I8X9sJlGy@58fwtx217a%j#*nQ;;#lft zfL3v0H&$_?hS+g(j--mCfMeo>ne22j5gnLL+*c$n&(5o!VKB*~(#qV>&hJ3b49pL{ zI{(;|Jkv4a2uvZpz-c@Z0gcsX`9?LqaW4h=mU8@@@8-afFZyrjawm&!Y(JF+(ZCU- z-lOUCo8K}zH?4WVEA-(&M$+2V>EJPeC693bYALA8og-6Y9*LCFJ3L*EeSDRV_`g3f z8=q>zT*6{PJ;5Sm(*i%>H%@qlu!Hal;eEn4`Q{k@KlRUv=Xz$=knH2b&pCdy9Xr%D zEI03jDfCBLhPq!%J?aQjpRW-vI!=)9669Orca{B|VEDi$H6(Ci*{COWqSEZ~RWu%v z1&P(A)uGu3-HnIC6j(prv$#$6jJtYj)t>Rd7JfZ)^PIb@GE=w>Kd!Fu78<8R^69R# zdb;oI1cbQ>2oGMNA>7Zef*{J^u!N-apX=d1q-YlGVDs6TzPGIHjcTW*?{)D!`g7p$ z7k&FFO<18Lv_`R6pHcsozK7biWUek?5x=T{5^((#L4K2`N&L$Xgh-ribbP=kE*JWp z6lSEN?UzxH?@3*bbAr*oCQ9MMpW{OtB-&1_@*Y29TI_(jIE0D%|0Vdd;%e=4Sz5ao zE9IVqNWKu6WHg!l4OJeT5hkC}(uMT%hO%Zqwll6d!O?S#;)I4Kewi=EUwu+!FK(3w zBC-VzWxyd8afV$nbbOusGUA7w)i|Q8y_r{hdyC}do-goH6C5VWEIQEjtndM&2h+g- z7_(DhR2yEoQPpd8d)lH!?(%Kb#ueMdW%Lwn`>6@eo``0vAqmJ3E>|lg3Q^$d65xzu!THm{)un>FMuW>60Pf2PaN)jV z=<(@vaHpn%8>YeK3;?$z0q$$Zf_srcFQu~Gye2EVnHMUHzModvuOz^oeJr@vba1z) zg1be7!^zSH_atjons?;9ngQ)TGab@JsgTarkXWcnL+s`RxZtti-a#Kosb?>*$$CD= z3-uhAtY=wR_~zSTREl6_k>;kfxZ*^doaTckOB;XP!PyhYqrW`)Py&~aan~PEwZ-YU zEJ(#=md0gK5*HxDuMa1{{pwh71?k|jQo;4npQ+lH22kpU32-+Y3vMe}QYf{a*CeHW zs=?hd0Njrf;PQ_Jw;~Fcn;`2DdZ~oOh#W zTOwT$J5R0wQ@1e}$KCG8;$xw2LsF#FT{dne>;6kEMLfYu*|UPgvPaYDzH@D@ZG>oT zL($rd<`9V)g^lJW9@HFy48lTT#a37wY#0fZ&S?2ODG|1R`WeD@aXT(u4flUuglst8 z`(zZgP6^0gcJ`~96~CJCtfUOw;IhIyXzoa_Ib^FROl8R_#O$}#=1k=10v$eNnI z{n46sl6y=|kE+oky1w77$r`C?bU)ZpY{wuMHwg~&(? zkGxr|X%j&vjv4hSN7rPc2N(NF_#};b)o4v`6>GZgqcuGXVKipc+jt!rwRo_&eM>v5 zX0)>X#mY|oXk}eTS9bl_%C2=QTXR%p2a1(Fi@D`7V+4mvQD=$@xG&#y;H30O}yog z8Ro@DR~8>z*=$}$S6b9weJ9lxQ0%+KI)C!fIz{`88SMd;DlU&d@xo{yII4rv_?T7O z_|eM#jhtgDyLW75Mw)8h^5EFYv=7dDxFLJyZ~S&?9~IR z-0Y@DhKm(E@{tOvMk_e6SV4d>i3cA6I`sVSpy%D%3dFtpa{Dd_`4gJXF1eY%UHpA| z0Y0q!ZRT&%SMjOk@0yFxF8MRRXI_NgD}PV%H-ogFlJ+ovJNa7<8CY`Mf7O5Req#N6 zA7B5(k54Y7iu0TLpXP8s`UBIT|7#bXU2-FT8qW*-_Vai8C1;nk@Yl`XluOSp`8t39 zlfQTPvlg9Q@%^~P@dN_jQk<+~-Hzhytw*Rq# zjX_>QJ#}TvC)s7W@v5x#TQR3hRe!1Pl}!hqo=3S0GczXQchGVgit3W~WO(l~ylW&U z$xVx9=H#QM7F8Du^`vj893Lf~Ha>_E{~g;x+v+axE%(?L_@d$NqL>m!}rH=&{*#tv-*-IQ%% zlk?S?NZ6<+n7#Z4x_(o0X`{1?B>LdmRX9zR8+D}%JwSA5M2V5Dhi=;Lj}730z$qUm z#Cp|iboDjPh4{_-<2}xWK54W%xAS3^c@OYD%e=&TjK#pr5@j2N59P)*ljRZVmaV@WfVEAazJX7Gg}$TT#4 zOHfFO8mxd5;hK__Dj_SJX^jCp4m`IeoNGvbHG26`8ibF9@5RxDZfw9LW++SDtB9Qw z(Jd71?9mzY^}c-YsYG~3)EUB7I_bP31$-jBwPjq~c{VqJFG+v>Zgd4m&-1KR#FG9v zhV{K953*-G7+d2%RASai>o}uhiaIUCx21BaEDj!s;&G7qY7pa!t>dlGc(1=< zZ_a~e!`agLqI^|fYV^mRrf&x$~Kl`#_& zrZzPvoo;8K@73#%A1GsA`RfPZV>0E>(ojh<)ZN#+>EN?iXf--REU5vIg?_Msdrf#_ zx={aiA}9_8&A=J8+QIPt+$wpGX1tMP#@ngkCs1zXaQf|$xo@-OxwdLaR0iDJJ6>Kf z9Tj379we=wvo`+n7w&(!2g6nqg!mO}_iITHFE3-n*>gn#Fs6@8*tqCNk`%XAH9fLu zKH`C-Yrk)_G!YzUq&D+laCU8#1=Wf#g8W|Cri(aqaL1PQofcAzO%ar7;6f8?KmGb_ z#Yw5cZPmt>}YdA z(0JUdBGJ%XUox{2)7ZH)_|xyqsC{8g)P8&>bV}5|shY<=6|)~7Hl;D_JRx3p;*D{O z)ri%r^pvuyx96az=(P^MkbdQSMa>LfF33M!&Ga zbE=mg7wh^4BK+ra=!>3HE|!ixAz@##G?}@m1|P z-MgkbH&t5TS(IyZ{@Uo|5;8f!AXHXPnewhgcygojlB|7JET6b-&TRC2{pzp3(K(#3 z*S1rmdVFL2f7iKF)H%0j0EoFVy-`o-WM$5$dOwHn4((g4K~;>wSKrNOt~*@LqF%`Yd^)k|Z~l1qXTCk-H~*ZlFPxolE^Id1 zydJA($5~d-K&4eXXw~8lbm5YO|Nh+|Akvc95cXtGOQgGf$=Y6&f68m}DNm#Se$Z4e zC=wUXZm(6_ODZYDiP~YS=dBr5t)6noXymt&{XBLjpg(&qs~M}6t=T;v0BZZDW~UL4 z9Eb^Hk${}Bejqo_n4~yyUkE+*+*v?4bzS<#$_cBkeniR;Rk!z##I7cDEa4>P3A!9lC%nteAGe?L5{8P3i`v)|k`> zlo~Oq-AZjTsifX53= zTNebCYTBx=QL1U{f(X{`O-NXpq9$@z-Onw+lKQUm{U&}p32tG(&M5M)>I1N#)(1nodagLxzqt%fP-(>2(h;QvPX(h(bNF@OFRwHhZ0t!n^(T zJM7!kjkO)5|hiMrKicY~QNp#9nY>1wu^TY#WZVV4MVzw5myX!E8TBjP~ z#HxGvKE4s#-`SxyLpFKl9*?oAPPO(6GHnKpHneUa#lzku7=0LsfQ_^{lHp=H`rcbDQ zSXUXy5ASz?`ZmFoC1{3iC=2_}s=bsoRBSVaW*kjo6nj6Y`k|~JtkTog!-3mwFLxQ^ zfl|>o+l^21y#||U(f<*qqiuRZ0mkyDv`vmVf2n);K^9|*yK??q0FjlsOWomy1pyPI z4T0Wr?w5`~<`@^02!0(sA{u7nf);abTR}#`X6kUSk;{jS!>W^zzAUM>?BxjcM*Lr{ zfJKqtnkPR8SF}$V+DKT`nOB{}awmkBad=?a)Q*+sw$toJDlWMh>!rred5qZ7;guV(u`Rzj;EY5f_%S6FN=695e>B9JPS^X{O{WdMX|{Zpp4<$v^0uTXOHIY&(_w*+|L%_R*5vQz)P|?=>ao1l%Cr z)DI`(j!NCusAAN1lQ+g-Sj}dyZpDn}b}C?cZqqgd`nPT1oj^p)puLW$N+r&=^b>dU zh8@Dga^vye+0B!WCwtvSz9%wqKCK((L{FqY%%{flk?cwPiTxxcGo~R0upSA6%%t_9&j6r!Bt|0)UwwFP0rB>E2du7hUOz? zf7yQcZhAtE8~BOY5A3hNmZ<$5{^b>jv7 zvsadlc)|Xyv@6&eXUXKui9r3l;qp&M+sv^_3UiS(^F5~qyMZDdDAK}5xc$P4z#x8v z2%*1B?jGXSK!g~ZxjB{obcAlZWF7XI>ozj@^b;C)*S9Tolab~(JsdV~Ftt0aJuVY39VV~h*`{{rf~ zkzNTnHS@DB;QmzVCo}HQ8xys%eZ2LrQ${l#{p+d< zkM_f}mC-%3{A)I7&?7vd$l`;4<d(Qv&CV}n8G`XLpS7=g}@;V*? z;Q*Nn=Ql4P4Ir`C{5&CHEdcqi>yfOZ#`I_(J)-pzW4O0&kWT!Uwyxkwqf;yL(|1O9i6oFBS{w4oA$$5s@2hM$kW`+Sl5*h8V`#k z$yF9!MA_sf7hZHA7r3*e;}X1>sEhR~@MxEhVbWaw%nduTDE-Jgv=Tk8i-zePx z-n8|Do$nd48uGlxAKPynvC7)MARhd07{|FFi8izm>=wclFrpYEie@5}Bds{=Hgdr| z(p|=gL|hEzT(5ZNOQyp$YrKul7I5+dJV7T%?eAhdzEkq=xP6ls|NS5zO0v(PLX%BW z+bZW$MC9|Agf3kgzN?*2tyt0CXLg~}#e^e7L;T^~O$yQoB${?wTu!LRPXCHu+vK&= z8})tN19S}zMr0*rv?_2tgy6Q*hEn6A7>bKp%YHsr?wSECDtNe$GVy38s-q502Hfc> zVXuE(g_cF_b`C=Sn&Wv!S5f9)ZKM&INFFX`bwXF2X3B5Dh`tTo&JKV2A%+4=LDt~1 z6}k#eB7cG@p2CGZiO`F9fd>AtP+E*tdm=q=rPn?V#yI`qd-QN4FH>kblP*j?u?Luqj15lc~| z??HKFy};o_3`iPNOxmQ-;chB$0+d8fk^Pwp&4qcowklF6@x?;hDFU0^ zwSf{;&bl37-DcNjIjfv?1EkXX{aW7XZvN%Fj~Y9>)ti2l9(@QjdiIrN|IQTPk{vb2 zASD@{OQEodt(^v7^JFySfF3l`_pF99F_Klf$b7MP#j8;57+8lf!FLd?uybq!0^% zJmn@OU{cCWO2DK{H!1jFk!QL|sWd6mO-iLnnPE~YP09?D5;Q3@OiIwCRGE~ZNvSd^ z)h31DK-64qQf8WzYLhaP{S+~&`%UWWCUw6_dB=__(WJaXiXD9?kJ;jlgp-Ui%{8pbY@Zb?q2EkG8qe*C9t?Cp>LvcPMXe!>?Jg7*_X zmE&CS37-OXwEPo3O~=3M6Fybi(dnP?X$Br)pYSPYM`wJ(rz+gXKH*cf9j*F=Pcv~N z`-D$5c68<^e42%Q*~fmeqqEotkpzZn{?3>?!`K6-Unc|yZlma4aEWsk)QI(RuCBIv zhCRYy;HK{dbsGKLpa+BTyT?mkR!zJoDcx$U5L)#QlQyBbLhn0!xf^c!8k{&dZ{Cjj zAB((C6fNsWbn_`xz&+`KSZHth(D}=!K!NmZ!iJ^uG$}VF< zRnO5&;R?8?5H@*?3G$ej^+ zZ>y(uT%+@3E~H}#F<>#@t{CsZLjJdxdnq~)D>zvuQGIEA62y@HMjRib)3VT18u&12 zPS@`_39QWB8X;+wWaeOOLd3A*I}=KwwIsbMQS>GmsTluVks;_gZ&Ara#{BTT8o46h zaq7*Uk@W(TJF5Z|wK7xAq#`SHXO)lF;w>I)s@hHVYf%eQcu5uGSG~==EE1IXZE{;A zG=dy!p(4LSz`!(7&2l+c3TIuu4QfSQ@AjBRu`ORWY zdWMCT%i-itUgC9IdF38KtWV2Qh) z5lGX{CA34@q8U`eZ&R@$8h+Y<-q1pteMNZEx?@9-d zGaP+%7S+b=d)*B;3iw}{jUphbM)ZCKz-N~kz}ErzBw|eMCKE$Vn`X==aJw-Aamowm zxfbmkx2+=7t&C#?JI+AVxm{0*%-tHkJuU9^F&_rv7~0^hcCHJFW7ht~fLu{b0DxdU zy5P_IvkPl?!B-r)lBi@%wQz$JK7zNq@D0d+HFm8FD1x=S)-Tpt-)&$G%%u*QEkW{_ z72e>>&i|_my92Bu=XxKp=jFEDq*Mov@oE+;N5VZ-i%2n=^RJSe`&cgTxjL&O-_9sn8i-;a={m>CbP6_&#Do)w2+d6B!U4R!qZ{|J4zn-)9zs3z z2g|*AprcRIan!^`H9?Z2k#K1~{-J{7IIcj!w%L1J|?Wmr=o7HGCYIiwPU-TSy( z?OEv-u@)E#mdR#n`k=4-<+8E?K&yIalL;xT6A-+mUPP2)mIN>0e|OdC3)8Ts%B&+^ zAQRjLNQKcZj8QNnVhCa?CI}-M!bzjx@Hq!+aG0*|>5ris?nWsJgP71!nV-t<+wZ=`$e<^{t_)0^xnq?Jk3EQrOw zE;xxdVzVW~PeUC{uhUVGS=~-Tcwl)YTL0chx=9+> z&IA#)t)VwGV9%e)1fRfyZ73{Qvr5~^<|@K9@n~>afi8BE;?39<|< z2?ygu2`8Kot8Sf+Z|qeXop&3F!p8ia=CrRT4NCfl%vo<)Clb6LZcC)MxljFxbUzC| zZN!U?)1^_hOUq|>=-*?%Nb_fR=-*?%NE2vx=wH4pr5gD1W`0`Y$+}RiN0PbZltFul+o|FA#ZE=BXuXl_=*0lD=k>fgH4DPnZ=K|P==!(RQ-OCTQ^Sm zliZcW%9xJTn179oy^U^pcp5Q0@NGMU6J^fyZ?if_q$V}o)aX2`-$j_mvAE0<+uDdt zMfy5Nj1#llJ`r&5)#=ShM_yieh!Yyoa}x zPtkcwlzycnq>_mmi`~zrjnE4*IH&3N5(E{=O!-Ahe%5#P-2K-&?!u&(PoSEO^5OgL zhuus6Qirb8G{sCaS6ceS6-sn;7Z-dGt2X8_cil0~vB!hs}W*^MkCnL2U;Gbnli4US|3k*+akOj4$1+4~m{pz%!f~!ZV`1 zy3MbP2aiFp&})}Oi_}{B^-9Y*DXA+9mchgiC7o|!)5mQW-wHqj@t5#fJx8FJ#5}M? zu{Xg4PwRBRq$My;OJ**F80!^Vyomd?h=pU~YKnN_=%_5x9!TC0%LmYBSU$~qbL|^a z3Scfj&0A%H`D+$q&c#(;R;bUJjt}J)_$?xb`X8Q*ob_-?baQcvE`3Z4nhX^~wgM0Y#W)^&CPp`@$8(3WD z!AvB--80boIdYCvv0fVuLUKo;gfnP{YJ2JB7H+a1&tYi>hkQ)-EY3sc8> zk+`$L*v=4Eh~2hQELt;hUx4{G+0vip5jx})R;Sv^VHnF=LlI)FG-LH(TxW6;O z$&!9tRh4a&)rzq|^(!9QUjJJ8@kQS2_psagdsrDPjh>+@68qPf;&}=vt}|S&=t6|~ z;3li%10(mDm_2+YyzW5mIBlJ3BhSg6{%wv#MWQ=oXzHG!-vJXVyfZ~)NmrH8FHBl8 z^r+HVqCMFO#>$pMXYD_d2G6Xf%jW=m24An@9L8+K`C86Pg*jG;+ioWVNFq{1 z!dm6WtZ#ufI3mb&50C``?o=YItnRs3fQoE5?j&ZQhl_Ii48kGlvsflW&V^RY-`Fh{ zS=#3l&_3fVBOP>k-Q{?8nVp9l#TFe=dnv;;bJ{n9JYxAOCOIM*4ZxMl67-VPXX0m| z)VoaA6(!;|p4B7h&t^YQP~030g7}>bv?dQr^tM$0tU$uoZmRr=L_PLT zBqs(H5j z4PX`B7nsc4W7Z^oSV4TO;GJ7Aq+5x==v8+jk23I1I=@fYIBeNCW7#divG@uK>sN-4 z)O5Pk0n%wX4I%+>c7nSaotNXzKY0Cj^pL7Cx}JZCW(c!pVQTIWc(R+TWdl!yXGiA!P zPvzs-;MO}k3;JD@Lr<((5JZT-SWbB3%reS&w^B_>z6Zzmj^KxNrBVO=-n%SM7P-vw zC#{}0e6*YXu(UN4&BTvD2(+ClK}9=d5Itm1*ewj0<%%FKb(@!&d9USpBe$T)E{pnf zo{>o8oJ9I?*|N_!VgXU4hy4#tVEF!r8er-NEjTbPt627$GLJW(z#C|!Jz4sIpP(zL zi*7uPhGT$h1HYE@LCmRUi+`>Nz(mJk13UKClSL4rY!!IUyBrYyjRE23j{+fC1;RqM zOMr9{iUQvpdE!jz{tf}3T=+F*kAa`|$4B8eT!7zOzTD{serFfqclsFk!NEVk*2@k) zEiew7%R2z$xqwj;DgbQ|NBBTXH4@Kr=*1{KKoFzxiTpM~83nT3?1GbBGJIg!5KbEy zoV&}@@_dLi>2uMIv*=9haJu_y>7EMw zjtj2YxpyNy2 z-M!pf`(kdTsH9Zt{p3^ zq}aPnLa8Q7H5aMME}~h)KTvg{%&abrUJk$H((|tVmE)!i*$MI!JYH2N;coNKTpXj~fC+C7c(OxumcS2QB?*?&kn6JxLh!Y9}SIiImSf3)n+ zBtp+yJs)@!o3cLY+>mtfaRTC>6V3l{cM`6ii&LjY(>I_vosj7076}4rj^PfB%+6)M zC9e4!Kmn*M^EH;%!%EOXwC)nC6?ytx7`3g-CUX;3+xY0|-$~|(2KrT`AO%Vk>J z=(xfv#YQhR9_zeh4u6#owOY+7E=o}si^6ZX@N0BFvpAYw1(ljAkB0ND6U$s8ColG`8qQj_{s>@SxcT z)ndek8%XED$oF59W@{0&O)Ea-7a+;#O@<~xjVF2zfkg+ivuRsI=tjy&6|XI;OFLT> zU0ITfAs;j?_IQcRg&!uJbuOm7O_)+-B(hrJJMCt~doC}evul9wLUd@Kk{S)tw?_>c z5ViGy+Q?jr@WjxVcL~pC{R&X61Hr_32dAW;ct9LL>a!%B*mAOt(ry)mCauLLv9sG{ zU;XjD@)#j&x~`=4oFp`AljznnM{LcwBniA~dd^+j2C3V|GX$Q%zD)xfl7y1Yow^cQ z&TLc98kZK&e3P3;{~%eNxh8Z-;}(K5J;}`XERNb-5xuo18;Eu_lx1(|Mf_y0`+S0o z$Z}mWhshWpvlsh@Zd38}2c;>xxW-gcpDBL>0GD`N?+E`x0o~)-GNRsT=>5eN?{*nq5>V|dD;8jndxP=xA$S5_vQ9dta_ye}< z0eCP@P;hZd-Pw~?(jfJ8Uvuk*o#Fh82~TDBnS`gf1hvMmyx4jCHoKEVXkHcAPoOhBW^PkQl1?`JhmjPw#QyA) zN`WqJ`!;jZ)pmtB5x<7yRG}9Zz_J;wC3P3>dp&IS@qD=Zhs`*h35}WiRlViBZO`Z; zTs7V#4LBikuhUlGVTHC8MxFjFJFRfuiIf2aEFC3bxMa*6c*eeF>?J|wTE=29fECQm ze!(U4^I*V;KbeVU5gFa28cQ2gaWJRJ%&!N5NlYTsP3?kC=KInZr9betjl%{rcdjuw zU~d9qD+5D=3s2CDEylEDeyGgq>=JPa!a~{++VS=Fj188P(Ry->5(Tudh(DB<0i%d< zv6A_>S>pP>o>kMv>z}#Cw{AwvZthT1uFRMjiJ4@+Y=n} zjU4iS=Ukdxd^_jmz{mlQ8^w;)l=RK+`Q9^fT<%=9H%9K-?Q&OTbN6^CQUhN^1aXre zVhJX}&EJdc4Uyk7%YMtQn3#ls4Zox7*4=T%*lj{Ei4fNe?aiGUbJqWR6;o-sAcqwD zcg-xzS7SLs#5k4I1Q<9#y-BOY3n+7^9!onB8G+xEog54u|VOr ztzB?Nrtjk={;^UkU6Dm%v3{|3*Qf_y}}ZM)S94@7Y2EnuL%vzjX+s7L>Q%i z?X6}7{ZNYobij(Bmk4ziu^LtzRoyL8ySX&RiV?BQSc8hOqDR*&05s}Sh9)BW`w09{ z_nS*d4`grR(lqxp5n^#})e#{Ou(1$^e+Jo%jyNe!hUB9|D2>cob#Ca7jLFLUlb*@M zX7E^<9~qTuLFth(b!DH@y-4P`+NKin?{g+wwnxXxJm1i-NtAJN=2p#V(phWh`^>GX z371-+&bnSZa(ZfToR&!O#190sdHnP_A0s4d(rh3g z8}-NNczrJ**&T} zd%QU*IhMQTmUUg|8H$S23;5F+V@rslADXHG;ak~C1`Z# zBxj$?Y1<+0fIGSfjjLhzKtoFl$}#l9?hKFAy9m$=jY+d-X@(3P)}-~<4^rS4)#dvMXnM1(Uu8Dur^D|r&)ckd~gs>flFL_bQKa&EaZw|2Ii{l zEZfzM+pg{!gX7s2kYj)ba+xbUR`{jSi_I&6pq07M0{|t%a()LGv;VkBhVHB#j9ApM z+9$I&+)GkNpB95zBV%`~D^G`PWM8iSel~`iSOR&_hv%#nFuM&QnO~LMw?|Q*n^SE~#c7JY=KH!2rZ>idncX@W}U_KvrqBH7#xt@-tPKbxM zwSHO529$r>#CYAWZzs9+Z%p3_*QJRefi_GHsR`NN?ncBqE_);O5I%&3&4!(~qL?B3 zZPIDH(yE(l-1FuJojEh<+{&5$`mOeynf5i{@Lvv7r_qZEgBp1V9K}-c5fX+piIXs_ zmx%6w%SaR{hlu5DlB+gKEfIJdsA-csBZmk`0jun+eVw$vSFS%O2ao%BF52dHzUW_b zHQO`&c)3d8QGxXp?}p&ooxR{raG+a)gEsR&WCCM_KX9dr$TqfOCY%0nynpo+ZSgRH zb$)ao9Z6=^x_gg%rRF@H$lPP>D;W|CI31hQMiZku!19);kl?#!|H!8@;$ZW8G6=?e67&B#ur*EjK~OO6%R6D zyfqAx;j?gc)}2P^iILGti)%bo6PZgq&@_@AAU%qIX!25D_8q9Wk?dksuoOw1_c0y* zB_%(;!@D0WcKBBEx?!BQsBVzkjVc!l)qW z!O*YpDU_o-t(J`3p&5rk>1Lt-%Iuq=DRP%}nMrVIF3z(^5Ixt8N&jNe$g!%heMDk+ z(GpcpPKN(u`S||vnk(I+=xiIqmW?X3Em)1A{xZbQ}>Ci$9}hFS$D3LvQKX8?S4sj{4&-U^04&6Zb|9 zS8j}e5?s(%?#EoM{k2KmuXu9P^c;73-B8s)dybqu z<$Iw9&yqUt)B49RZQiN#?Q-Su<*FKZQn`~C$3ssp)|)9?t{Vj=G<5Nr$8Zp11LS@M z5f92e;b%8I5fR=rKQ8|~W@Da>tk#-1?IvscOlE`m&H(yX%g158~rLd5^(FkJNNOqe zCo(ANAJVprIT@`%m&=Bu$iBwfRWIyLrDO79$7iNDiwh}DRX_>JLJi#N7RWwIZWD(P zqAGQMBIBJU!B8fxE*dU`>(Ye&vs>8UJ8|J8H5V$*$5x?$F=~J_I*@Qx{22k3?zsix4b-w zBayQ&85&MF2X&@liYPCXo!KasW+=m2&l^b<^AI96eRB=4X{%|)CoeZ1>x7Vamif&D z{Hihhlo6LK_%u2tK+;x|zIlf4#&ewchwn+<5Nj!jt}C+*~%~1&x1msWvX4zMmya_1{99m zf4)%DR3H>3a)ELKgRzBnX7AzHa2jS{YBN**zdrxE)5x66jCn<^e;Z-HzW$W2 zW>V{J6VaEdb{e=`tM6Nf4kDDFH#@udUpaOPg}!oiq0o0J749?mxhFRT6#qHnWM-fr`hc!tAAmc68!?6X7H`0OvJy%q54V>N}G znZz`X{QB&YtN800^Y`v=&Mq1Ir!8NQ$Gc>7=Gv-uY`xp*9(?il4+k&|!w@*$JTEf~ z6H0^~+<43Bi}MKqTtRI$c_zj6pBCde3;W8Ly-CI^(Z^5WlUT-C$*&8t@86m6AqJ)ANoQv9njit*!6RydKtbnRZPL*`c++u3_)SS(ST$Q1J z-Fs@*^MQsatu^hb-H2(=^xkdH#0;NEn_w)rmyc0UZANHwqJQ1L8c@PB)3Cf;6bc%h z-opJOJ#hQoInwefO4PmxSZZc1`?P}{SbYEDy2{q$WDwk4mOeCV`TmUz#L)QtQM)q> z(W}125}w0!ch+fccLknVrn`+BMxb-W(3qZns?gJz+f&(RN+qqHb|axvPiN874afBK z#V-_Lw1<{7eWxw^tm)?lvyjL3^|Y~lrGIo+@u-rShVo>1n}40~3n4QzKQywlvP5XV z)8O5d&wrRFr%cl7vf#PYnlr$ z?rmPaKl+3K7PlW0gWybp1UktI?`o^aBVg+Fra$m3do3B#;zo(AxQhtg*vW;p=QK7; zN^tR=V7-n$ZH+NJOSHPnt5Y853a<{j2WW}yp8Y39(Lm#>Px^94#68Wo*Z{)V^5gqdIK)V|$Hs=cp`W$(v*O zhf#Z~j@Kj1fu{X#eiLFDfG>{CF!k_kpFq(&z8wAZCAE5YwAfvi>!%kdof4^paE! zx3FrRS(z!f&cr`3?Cn`zZfY4%X3X#Sx2$!1`i2^!BiFu{8)rmM2%|6|2;9<671)Lh z>IXqVGjeR171T?h9pxXa2=s(dn_!-@8Q>pcd0H7;B@tjLZ9iEisv!^BZvpa(uInbvvnn%7N@(xI`maWK_PWxeZ|j0c(=X%&K(8!+u~5yhTh9 z%Xer38Nyrroid2=KlG#5`H2&v!MRm*l*@TSsKn~lN?sM!H8ptE&+k3B_awqmw!a*V zm2p<&k0TKC2$MeaZ)B=lD?o~s94}T9PHt|Om(wT$Yi5;RnDN%gZny00J<+ZJx}CH7 z#|v*-p+h;;@_)cE0BSLv_bj__u^rkrhiKrECZyl;6a{CMeDyB7r64}bzPuWEkYS5A z5&A>F+*T>^LD%we5)^#Sa&9%;3oRaxD95lj68jFYpT)eSyhzEyG7wp6s2piY+D#P* z0txj|n3!Ya0YyyQT(sbh*PC>;VwKFU}-#9c(h{>SV451{k<4DExgmfer^O4sJf)Rc>}OD zKEg&?wln)vcv;2gZ$8>C)YycMS%n`v-VPJ^chvZniw?5T0ztsVwnOp(cV-AB1SH!{ zY~Add6WPn|y|A&WCAHfzvsy!L7L-)}Rsf_>qKg4C|J+R)`mJQu3idvE71KZ`iYSZ- zdEGaTn|2bTl9GWj7p5fK0cVf$Kmz>hbLJqiRW zS~Ygp;D<4PLr6e>&amSmJix78z-G2&*~`D{z}rSHY#Nmx?|8s(9x{ zEUn;g6E(OWU>?5@LbC<)JdAa|Qj!W1O02r=Bnyp#JqN7^F&|mCQ!RUPcHVz4FUg&} zZO)=n7Oo;T4_!_xmOV}N5uCSq(`*`(>P5$~)T25aO^|iVzQ*@RL|^4wd`%$f*)0>3 zyGbFKc+z=M*9$m1wL&w~E2A41nXIoW9_y)W`MRm8fTFLXuN$wR?6xQ8o3qUuEX7Fy z9T~1W4c`8A7sn1AV!AF0_NUkLCVXLK<}H!eN=<+Ic9MJ~#cXE-j_OI0+zum!_i07DMCtB;@{EDW9m3m zGTb5IdZclO#DC}xiHKJrl6L487dTD#3W8qp5P{j3=y}DxA0kcQvq`M4^G%3vB(Ymr zs0{&vYDCUaA2CIKA>nz!*cQ}C0&8Lh11#<)&P`+w1e{f?@MLJ?LVHaj|18o!%{kw; z80;5<2D6=^8VEDj%%+BvkWr9o;q3z90CTyq$cexNcHQc`X^27Gav#6;FGTp@S!Vx6 zk*~0f>jo2y+35lIqLG#$$LZ%-zg%TllD}(A{V|FOeV}k8aRYL{Ic65TWoy;;%4jz1g$-hb&afQ$# z0h60J6*LVDaZ=Oa0mK0-roScTjFCzHbbL)qt!}+t`LoE7@-y zTeoUO8oiG~_QGp{&ccg<$v3Zp2uqzD-6Z(aXq2rv1p~~f8(BmpF@FODdf_5_iCk)! zN{(busR;5W$Mi$;(x*ua#%xo)3wamdJma9tGo(g#S3yN5Y=U1UlOJzF{$%#daKKus zo-c)VV3UZ6aQ6+Hr?77Xe0Se87q%TTY#K=HF9ZoR6&+oc5)sRZG?6U|(u%TS3n;1@ z1ZP~aG!xTdNDbX&s70(jcV^E50A>MVo@KT_Z24nrV9Vjzx`ZD(`h+G5O8ift55XlW z8+8dJ!5G&`l*UB)&|qt@NO6}#_FDm(+hgV~x^b_`xHo(CkMUodQ^}D$G7G@@S~iB6 z3}$_)rpZhQh8_m+%xYj<)hWgwKFPit4on%(n+i0cLR8)$8P^-TDJI5^{6h-e;T7DT z{fp*F0{+f7%*99k*pPjn@T%~r#^YYB7{wkcNl8`Uinj8P7lI}i9xhYFPA9N|%DA$v}<=%Lf)`7~gH z-TTdrAZ$nGQfHTbDuzp^sC6ibPWT*G4v{)@v{0oSWScqdOd)rw(|t?70rxNJF<%K)YKci&n>q>}<>%{ zpU<=4V zO3_J@v1Eq^sM~F!By|3;4n;iz-34xt0sau%)*3HP*|nBJ`Q zSBmb?`K2Ozqg7N`am6KlQ-1L^oqJd%)#PD=5hBO1tIwvcB=m+Eug7#h>m9LFTuoNX zxkFu6pc>#sXJhsqGc-k+a+Jf4fneCg*jhe~sZw6T*(3=)s)5>fn1NQoDQ185vM`?} z6;Q!PBgUtGDlXO-elz96<9_HfA{6bkk5;HLz)yc#Q|qF5M+v&j#rdUjBmi7!2!|D- z7LLxKbB7B6ELV3+wYc;S9WJJ5lGdeswbQD|3cr>5vIgfi#E&YC)tND-{BFa7*iaW- zJv~)N$Ylf`p$Dtl`IO{WoJo4K07E;4C}2p10!e#m!00mTiff$NF>tg(W~t|bBkM3N z;AxSV??!&z3zm}uQbf95OM(-#2htLp$l`s>c18bl5i(Fw+Dj+}CN*@lGw#k;ij=lG z%Q+qm@Q>~CQXTu$V{`+ce+eC(z*#{qi>rYcXOjx(bQCI$->!3!a0Q!}2#hJ{ zs6cuNxS6V*75v5=r&(n|sm(%8)r4?kc`h>baTK9tr!p`yl|k%q&SY1hoM)z0A(fkh z!!Y*p&!&1B=Ic_va_SQXNSLA!w15IIbsAby4Wjw2$EYEMmcI&^B- zar{I#Yjq&5N}>_T5A^jMx@nh=#$6a{y{CABgA$xjILYlX{M082-$81uZj+=LsV`br z8u>;tQ?Up(z-jzbB0Rl!`D83C^B9GNpGi_Yk^uQ)KX_^Y1N2! zeN2blqmsGG_8(+85|Xlw-6sFbGeyq0U%pg8bfAEk za~uKFrT7uOPh9>{&jUmZ9ZRXW(Sz_7o>}|?qKZhAnFFg3eDUI{D*ZD{dh%)^rHRDC zA!{)A87sX>h@qsl+_BqvFsVKfktEVrm0+Tvc^(Oa?xUvZDAkTM(+%=!0U;Wm_=Wz6?4Jr?5$}x*1#iYu1w?=3KSK z>rCGQHc0t0%RECHXboB~bAcz``6onT+*ALj){~;)-=!)X86rnLgRM8n&F~VOq4T+~ zMZ?dfzF>ARp%a}0aw#O_`dgBSFN!-y#KK)1%Y5%cJv8Ma;b&754AYVuq~g>rRYG)^ zZ6?h*ko!j`c4w0u7BP@}YoxrhUjqh|u<5`v{lrqXP)X}I=VZ!HOOz&j#zMutt1aOy z@EN;aE4;gH0xU!jzt8j&3N)uEE9ochQ&FQPX&q;z-|}#gKDo!g?z?#gvNDIWQ8BYwP>hmFY9TT#)zv&5*F^Zt(F} zgTxS9_HvE|`E2&#>!2bWEijNmjaB;3Y72e^tErOZL_%06D^)9GZc&nbs=dyOkhk9i zJki(-Iik>S$Y>VZi%`;iv6g&q5+H+QS^j3(FSf1mninf=Duo;y zDlBFIYK4&lw;XR~ap($TIogfMR(|Lis$}KP(mMP`Ed0CHOX9?6B8FZDJ5|q~7{fn_ z%czf7p6wW-6KAp8nYq*PDjNUAxzjRpOUaS?ls-kBH}$pfiL;Hh$QpFK(n^9ujoT!9 zhZk+vp1%hhri1X|5u&`w(Pn}sl|ACXtXt#gcQAWwpO zsxh^84uFVsRW=56FN)zyeOm5al^fq-Y8x}eM)K^0O*p9_S^PXii8B3}OsRdS4|1=3 zlC1F&NDp+@he{%J2&*@|%yi?pku`Gr1+qr-Ze)#mKT6g(r|jcpjS*yxC&}O8NFKiQ zNZ#LwVv>1~AP#O*xYNiRjbKHb1$}_&cuI@~oV6kBieiuZS4$^^GQTL^;0P08XYQ;f zCl@(bMmI&7qiQ&97MIirNmi^ zz3=m}P(v)VD`6i`%&(|@iO>2N8?;#XDSujwlJi0=b9I^PAC6F8+s>I@$~}(-v$gb* z@vW1rjYZov4AKUpPPeShb`U7tJAW|*k2mg_zJ77OJDT5u{kC^Lp~VQ>DtzvZa!KP{ zQ!kp!|HFDA7-U9X>YY!`q3P?RdFm>!iiMw9J`I3+s}O`t8y{z67*5A9lwUnZC-%pW zvSn^GG!%7qOOdkKR6NGN6(xpKUdDJBWr~0b_wUSkWq#N9En<)ouzhhu>5Ta%O4M(o z&hc^Q62`NqwU)K*KP9HkGJ%ton14}cpjg8eQ^VH2Z@qnRAm7_y&sa~96gR26<5$haRBr!7oXi2a(&{-WAHTuAp2f7Pw(AMG8F(gPR;4^^~PDho?GRXe( zue@4r=gprwRdV$QjpgOmLuVer=y*B$#Y?;UUjE<<+qQo2wOu^S9KuEC&6x9EEcC82 z#r$*MTRvSbZck*_^gdP;x}}06xpFP9z+M#WDf9hCdo21-O9 z^XXrwKOX+DjboCFkB0rL=Y#Y`2ofx9*q@H_mi};D%bDr({`mcArKSG$Eu@%ZI$!a* z{pFndctKRGN|dA08OZki?Nj+7T`d_Vnttr=?eYImW~#mTP&X80r(bMEHKqL4KjExEtC}* z7P^Q|lJ=F5xh<6jq6h{GdRY_ga5!eKjEEs;#}WVoW8Ib5hCFLu6Qi(Y#ua~qaoOlP z*{Xk+KJOoH2jZ*FDD-#Zn;P^0z5NQk&3^4mBg6bB_e;Lw&*ov??0m(muXBM3#QZ!~ z#Y*0v;k}?qCc!uKAP9x96h??=*|P~dh{kc*=Zp5DNffTS(JA4S_a!{#-57?jw-a_b zD$QNXU+(MOeQ<{%eexCGSItsi)91PA^ETZ!w$I*?KA$?5KL2diNS|NRP#vb`tdTyS zNliluR$ltN7HTOQ8TsRGUPkU!Emw@za&NJg91qSlk!TpF<%@{^wlaxM;|;5BWpMe8 zt_5%$8`;pjSmMzlz8p34U3|L~%t`06Vdi-Ha3bS9J`vv179NX#P^$|6^x%_~8V}}q z(#1cZ9?WWmg?dzMPM&*|!dsR}Ef=bxTBteX(=PO=gu+dF< zzgfT^#?A7>uPwW}b_7KIf~-I^Rikw6SGEpUgHiYwT%t3qsbFCQl4*hCEX4Zyh=q~C zSEK&%W9{!!Y4%Ta;}loaYX6F({_?S{XBVxWXf+rUPt7hKomd|1~nVxYBM%gOlExB zlKwf{lJEdu!6IH}4lg=0a-m!*5EIGLKWkJpS; z>nT=yfqA&6;BimnralS%Mvm2ET(Y!YL8RBpKbG@#^l0sPJ;20DBv_er>RiE}<$MiU z{sHF76?Q_-MHS;UX53->dJi3Zk{QJ6Kr2laBL>$#&lOKd35aizuXv2-s53uS`(9t~ zfrCVbd$|mAZ}4aTR-J_TihIa_F*a90_}Bb5YA}YHKQIsIIBgzO+-!}6bLs59Zyh+; ztsAX$NVng}y<&$kZRlda^bOsPP7-xQ3X*-KN;gq0t+>`;s@h0e(4MD#LO>1r0 zn)?iS;~INGO1r^nn1ZJQ*$cejp?FQ?DD$sT)jY&Y|x<8ED)HT9h{ zM%L8*?w5SUd*7X>-ksnfEmoc{J9(yak=bp z5&q^mJj2&CwZMjR_b!Z_pYx=$<#e-6R+AO|N4}y%54OpWnrijWY0`orp)!X9`g^Ts z7UfX`*|wEq7lKRNXmWsvw4Ezi>(_wK-P^cNHC=fsUvZ*oXji@>U{apUS4`kR8d~iH z&_Bkd*F^qv^p6y@Z{e5_&YAlLTmu;CF(6D=+_!bb>5;opb-ul$D4;is2Nm=8JyUVg zFbez35?b8ab7@{D3A?GWON!0~m0Zl>P1=p^TXVfn6Q}a(dEEi#7cNLa2B$_JlaXe0 zvyXpq*K%HpJD=4OvLv^e8h!L^ecd=X!Ts77cNUbJXjfZT0-Pmr=X;2n_87}H*>OZ- z{@5U;W75@JTy-%7ebjk78hSG3d;pPh@IPYCGhz6>(;uwbPj8_D2Jzkuy{pWZIX%1I zBujqVrs*`A@AlunU%uzqDa42onFw}nr-ddk&LV#d#D_@w%wdM!OxdJA-NHCP_g}iJ z47&aLGx0R|J5oUA>0x{_&gD5Ce$~JFB=gYcUpr1N%$p*cWRf($*P*rEgG zY77&d#g5-uP=gbT&5qw4?|jdR$L#nLqfQt-7iV?c5<2^}A;vRDfkyjb?aMfQ}p zJBeO_34^_m6LH}ZtG{!DAjW_8!e6;^`-NOtepBP^{1d+iu*A<*>)T7W9y+0MgL?CT zVihdBkLX}W%2u6c4h(~M_rI!RNDRPYhRI91b z$apyCU-ys}?TSF-1JvwUHEXoyA5l1N_>ozKnrDsHe0{OzZXO&-a59bE7|LjVBt`;> zT&zWn4JnJDX6s58aJ31AtmA$%rq&}qp_hqQSyh!RNuf1e$khznvYY?eE46o$$~X$% ziG{DKiul*Pq%L2Rzv}i)mY`R$@MVo|*!26X!V&uND@Abp^*k3GH=jNNjy^sba7_``wt?M}t~HOx^aE?%jja_fp|^JiQ31lihHgi>Ne7jv~2!)U0s+bU!Bbu;=K zYUo9Yed)PWFuzi$*DMpOzadak5<$P>U-LUMFr(Y0y57MvQ5jk%%7L&Gy17JhoJfg( zop6K1oFZGCI5&c%hd<+A_Y>aS6$l3k?|2LEJh4yOd9w2HMXo7-_A^-Fm{sw2`HJ5# z!qB*`bdjpT8R3X`m6fmfF(2%4*YQE#*DgVGkew+?=3juLOUZodTo-2Zsz+dUy8$v} z^K(4p5fMex{a5Acac)`V!rZLF@3^^Gg;tnNIC->uQ?dMA=0S&UzT%EQmLvA9x-1O! z?O*#vu&0FNG0SPBJIndV6E@~?5t&T%Ris4ITgzgI@+|+_i;PF{jm>7z=Z-GeKkqZs z3;9%kh9RGRe-3@Q`ST-V>2ovWD<+%1+}Mms;sycJN#Sk#L6?8+$t*Eh3Y5FB%~uTl zL3M7~x}w_MGNLuKwHXF%gNqe0bg z-$!}TnQp&;-Z_HaQ=c2@@o~i-f6YAL=7d&pe7@qVrdxuR?1t7|`t?r_OeU>-_L;{TpYeH+DsB z^6&^|R9Jr}zJecs7+;|z$*m$-IR*@d{<*%johLuqa>=3+YG`!a+l$6NN*P?gEVWtr;qrS)mhF7 z9p}h>EOiE9BCQP8=eVVrOxf*mFf!Ubh2}B7b-D8X^hS!Sex%i$9ZhoW0_i{(y4ubW zeci{vgUqh&7)mSTj7E1lWYslbg4>;}n;;DqcS)zNMwAGA8e9q|BH&CFa3YWFrES17 zd6RjlxcWs+2sb(rY80w}L`T{#2#-LAgR)DY&VHS#GQ&AVs!O?vyJKk97z}N@lreCr z5_>!Mm$CMDtt+YCoi~{`P?;gIgT-02oQbsJnj%0yX+M5?)H;rt-EI0$*V(4Od_m{{ z!YimO-Nx$fIDMxdn2SpbP%xd#SKLhAV!{Yy-3M-I!L_WkdnUZLc z9fHPs0nA1{YbP2ct8W=m4@)-)Ey5;{0~h^*b@QexV9x&Exh7?3Qf+M)!qB$>fW2*=YObvJlBz!ICSkFy}OdXh5R+}SI1w7zam&;P^r<3H^5CC=i5==!51V6f93qXR}LMV z==4g)-!oz>r!wd+o!;~-6aE)~WNB?dtw|k=|ZQx9#d~yNZ`;5&{Ge4S2&#E27mI z#tUj|0torPKhHUHNeEzn+x}kruO&G-=Q+>wobU5}zTfZjy+X?Z&N%|8U6s5T?Uvv= zu_Na%;M0Sm^EIk#@@RNTG*}i&gkOkYPGOLfP-m3kM7FC*0?wAiiva}VFpi5AapykBBSh2mi|X>Kyk2y5ljTsf|n zAbH|uN+UJPsGNzoXW5;5%Iw7MK+^Nwi-opCt*P7lcAnmm*j1$?0ro&emtLyi{Mq{P zNk!;~$$_?{+;$J3aO2nd6(pq#P%-J1(Lm*c_Cw4Pv-aNXtf+e+N;x{UdI(v&goYRL zsPm1JvY)13c0RfDOfNL!Az#JA6IQ&UE0v>I%}e$}{Nd4jGBsMQ&(Ra^bJnT>#?d+G zB*NH6niMQ}j0|Mn6hX>M8D!=*e2ShF7P!0(9d@yypO}{aX<=l-pBo zHahR7k2xuF2L^}?@H{M=Pmbb=R2@$KVhv!626~-T`RB8kVX@DYmMr-IA!R@10kJsz zG|$E|_(wJ+^f!ziGw;*Uz!Uh$tyY6%;tqaIao^J%YSarK*G!_>X?}iUYaAA$L}x8_ z-tyX#lKMB}fkQ;JA{2)MR$B)h#@q&o^`mk0O>jn+R6!MJ00gO$#xQ%jMl@5pHdG{X zN~lh+`w1fxAe;L2WcWb_TOX%e|Jg6E9rR2kIfm`yk3SyN?w;a4#$9cmiBp}*%*>$P z^rWTvKbI80nY}SLStpfvPz2kXRb!ZHsSt1FN5z$I!$n?~ax#fKp^f$Mq79;O*$a)g zD4!)5q{^{g@xmkNm#<-`RO{36lH%*7Qt>q@cx(#_|Fzb1nRvjgOj8`EGOY#CPg+1{ z#U3pvCC&Mn{@68QF=ok#Th;N*N&V9er>pHjs1|&k5&O|jF;zt-1h$*ONIa+~FoWaaUo?QIwI`cq;_qVfz3SupBFmw%3EIP0F?>_vqw z6iuNj6R?9MYx7nkz`^Wr?}+m)2j?uX3AWIW*OpNCoS! zOGY$69%gI!G*%%NqUhM~y;X=?Q=joyA*==Xw0?YEt8kvT3UTrxtZbr#VHe>vR^>u( zA%+9}2teO>f&u$y=pq(+p^!;RhG|HzPp6>UPv%IJ4|+T`_WGcY0glvngxBHZC!(oI zQ?k?jzjL5JDF=AM*(Oba`e$om!521_2}R;QcX{vE2n)a~lg zTM1Gj`75L7yG`l)Xu!dNe;E6UH%#{9vr^?3_^afv8;d2ywX_tz z7^ZGn*xfR5$5oI2A(E=&n(Wf^YQAB+`y=eAh~rX~?~!Qm`H1@>4g#l|N*0#8Y2dL) zGQ6=8r0C98UKQFvy&mfBK(nqQ)jNKYiO#Y}XjA8QWM1 z*ZTywXF(&!euJCQvvIl5{luH4O^;<~p*R9q_V%<*p@nduQ#1Z7(`xHjezx0#3s<1m zK6^(*uY{g%9_{@ZdV0yb4kAv|3z$bWy-4V>`Ykc{e9nVreOM_am%^_dN8va{out!3 zoF{J?#}rmf^qpN zc6;r+ZutWoI{TxV!GlQVRrq1gmq+LzVGw!H%TJrD;Fr%)JL13dfh`@{*&q#b+edxJ zQZk8@S}R>d5rC%X<AR3h_&i!T3Gi^AUbr#MpX#Po)Qgp z_f#Y{wsgKy5qOK#tI5xhFYQDP9Z2m=qPfdJIGUu60-^iSg@PcH{FB+M% z3(hs=&Ph;GtMwjpEs@46ikUbx&bno#>i?t0Lfz+MxKARwdzf-dH3IW*GrLP z-BZcQ`s97Dk1Tb^t^`*&|BSQS=Z*na=91`UPGyXajz{Nv>01n&92Ij9!~=am*Ex%? zl8lvlcs!pO4L+(3b+SPDI^z3!f%5gz#u-#ovD%g}ZVr^!m}?J|%6?}+nHGrLi#Thn zUtI*h3Io5bdZ^D7{N_2L<=inKB<)lBj34RUv<|@5s^jS$pv^OR%Osr&gw7BUZh6~) z@S1l9f$%odtpfk=C$=q?ys;`vEI#-l$4&#mv#eFW;u;7};8i16`v6=@j|PAj0l>5D z_R9sp%K_kJ0FaJgTRdj->D9FdVu{6Z2{#1gPZ@x9|A0G2jQj-Vga4cfGb6~d7J4@fc=_MPiT06 zLg|b0GqZ~&AAH3?cM^%8Qzst+NNK@tfn7k(1@ zs-lyf70_-RK6fl>FvHDcf=wTXm_i;|v#MpMGdc7FQMVjTiH=;DB)8P>H4~IauyGdV zd#bEkwy>Zyph`wZRsNAKYUKfp4j|E44U?%>2QQcoxLWe9nEPxj_>A|lpC}snOp^9s z1or$58UMKA@v~pZj{tnCmVe3&oT{y|&T3&A@;f#&<9E^MQv#r_gy)AH(gHkZ{8?z|()@l6dONyC~PQ1dV3@-engvUKzY< zm+u}8!1}9}|BWVxuBocv&vWGYQ8T&zMSQ7uMcu8@z>a8WbHhX@xE=f$?N4rV{oCtx z`;4M^KkJ?{oU3!w-(3IZ5C%L{-&o`?idJ=UEcK0Dad!bYPm2D(i3MK8NtX(WPHK`R zAuTw!Di+#p$|5U@!AxG+mGTf?mrB#S(=U z4AOB<$XOi@&rd^qiz0Ex8EWU(pCk!v-2ED(k&T9|K5;i4Cn+p|3;@y-I7jdmfbjAv zO3#t?YPYp&vzdy#B7z(Y(Y)Nn4OSFQGFf$3{=5Eix2F|kC)oJ_YSHcF1%lZ^|5iJ< z1haa*)w0f5DzdZ6;Gmi z)IU3C_c}@H8P8HuvD)S{q0xVOWn^g-p9i)YWC>c$BJzXo*T?adh=-nL6%28`X$=pHw64pcW^v-%r4yDh#xe`erHD zJM{)}dkZu&_ZACDVUiEl%r$q!mBC%dYLy>B%x&vnHsIN&6%tRiJ%~0rFM0kVc=U=e zKe12uLb&6IhmpzYe@ANwHETCiK&Q#fm8Kg&Q`bw={`5Fw?!pnpyHSxI<=sFyG%d!Z z-vy&{{^L5xM*30gUebwJUEWDiG7utO&E0X_ZR~`gjqT(P_#dfo>&wIK$h=OnX*Ew{ zon^%PbfO|!);=wD{^*ExZ&gIR&@MZ4l{_t`hOK)~GFM@)#&)8~?+nO&V=iw`4REo* zJe{t4^X!&=rOju87W(9L6?HopcLM7(ncw5d8CIQbrt%r)@7vZ#S~oX+$c25(+b|xp zaNkZxYG9BfJVJn)ke%cCw5q3#f*CzbPnDkyKPK=1H52h@sV@`!`y2)xC%7{^cBZ<@ z|4oz9M!JhIeguQM<}sh1=id=&eYf!g_*9!oUZbu9dj*f$mVvYCKbcszv$mPAoR2=k zW{SH{#FAI;%6=r~*6oUg>h@YIUlZ7T6)NI-bxJg$0cz1MX0^E8&M+f^Fb znSOE+*@=^p-pq4C-PA`@yGNF0ey?j_SU<)9=fkM+v$ncEpQxUrbe$@Hl6gQ&I@G)6(_AY3@wQ3Z1Bz7PW-55cUIZ)L+$8;V|U9>lviuj>gUK|zz8u3~aI9ei(byerj z|LTCfu8xL_*NVBzTCiwGgE*Lrj-bt)XKI>=^pK%p)g&e%E8Suvz-@|QqjI;S;Xgqs zm`*m<#>dhJFA<}G1Z9j1BNWhmjPi}}==5$q3LHQw?F8Q;o3-1tmW^|_W?LVF5L_T} zuap^*yy{TZ@=tR-h4@Di_gV#G&0A0Pn~3g0ycsz_LS4vHX4H?04kCItOhw$2v*`3c zJ~GgbW%VArw0(wzYP*b5arzx-pAm3d|H%`iLBZ1GjB;mT>pw}5js<%pMC&BWWGb3} z%%K@kdLwEOq+^NBoy-`a5ApfKNU%ED&m1DZdK0>hndd$XQSlH$^cQu!NZID&isZZZ z^L<%I+VaIJI0XU#=2$ASMw|d$-xGSYH0n}mN)~mT5_ADsAv~#oW9cVJ+f8Y3lJ&PQ zxh5WXBk`*qrpUoD#%Y$f($18~E~{-nM=;SFt8K3iV{W{|jf^)q$HMg_R~Q}=nUGvj zD`pazob>ofaDP1bhiK@%=94*4NodG^G`eY{cnRSy*;8?DZ6rP1CT5v_hw&uOI1DzR#7Hrlj3iQo1M%N%!=__E{P?lI*%jm9?_0asUf ztQdg1tHg<+B6rZ;YUym|LcQ;{TK`0dENoW?W(djNO{;Qzm#re!d#eH4DzRQLIPTEJ z-1I~xityR)Cc}0=YN;FitjM;UijPbGh`e$!<0)%yj8CujZiwxw#pLvj++dNaSwOMY z!3?*SyOWFgEejc$5cV1F99gLriQ`iA$NhQ_92eJxhVWZKXikCO?oD6n_2e9z z-#Ul$TgJyhEU9_Sr)R?RYQ=C3zulWYunQ;$NWcO(48vWNSO&jA*g0>}^WvgU!HP?= z^Wm2mDC(*Vv)G&dBd=w@phEC*3ZPDQ>%?seyr{?LMZJT0QAuf}KOMco@S?rykx|MR zMSOY=eEJl_r}w6>(xfyXd|K-gc7G;3wG;2bs1+z2cIUUC7x?O%hEeZ@QTMxb?UBIx zL3~;&12I%uxB5)=iyl)QN0FX!1%{q)7SL zOT8Y)+ld3UsyX1n>u-x-)$;C{QmUGUn{^2mMVp& z+q6rRX)bIQClY8~yu)!H(#DOa&Nv0nv$tWdb-fsstW_z)#o~997aq6iN8_n!yWqhv z=?i#IZyzAZ*y32|8Ee&R&=2_Ar;X)YRe+$-#Vi=RDT5xF1%I-L1&6)2eg1U>{tJ!S zX!tLhd-30k%oz}RBlf#X8e4b%9UO4c+^Lyiz}SUg!0Wy9@{Mt#n{H&LKFj?ke-kha z%ZWHKm-@hLEjR;)FTHtBV5YLQUW51?bd z{5Yt1;7vR68Yf?~Ypu4qhRK39+S8d;6;kKEY~4bTPYH{=+6nG&oM@I;fs#6hZ4wjB zj8#`2+pK#Xf)GUSysU%HLHT$`c7$@SJVuwu_WvRqJ|(<<+FV+)=_Yd?1ujB&!>7Rc zSQ5YK^(H?{aLeq}8K2L80=f`U!rwFItC;lI=wuA6L^B2MY|Ng(k z|7C~a|KI;P_;2U%AN)2b|G3bcUZ|Qn? z0cFId$0eZjBHxr`FE#Q)K|uKuuSr0ekAT97cBp`Igu}8CP}Y9Az--k)PC7Z=mri<~ zmUJ?|!qXz4n;I&i{1KdVm$f6@{PvY%0i|WAA|at-~cj)Zji|lBv+AoUYMphfTo9OW9?jN{0gzkRn z7<6}HG2JaXKfho4tMklI`D1}niycG$7zjgumoQ&n{&U*r#; z?n?47B8U$3hZA6^u#hKR@=B51@hbBeDtD|XmOHX|TeHN_Wl;*Nt?ey#aj1>}oPXp> zhaRi#AGjhcYL^>vSoOPEw$;el>EtT!;6Eq1$~*YaO`6ke;$hF1knA3vPVm{N3_l1F z=M%xKGyh4(NV6^d`>7xVUBv=fN?%A)*|aJrqIk#X)SVJsOc&c6N#XlA+4^b&B2>4f zze^Xq9wq%DnJjT_^vm2__em3E@*9)J7L|e20C_8qf=i0@1y1UhHH%UCp)FW#&I2PZ z|8_1WQCb5}j}JkW9)Fw)v*PPTj4~2sLM@{#N`D4yin-G{_?jC_(;xP3NZmjSQ-v^nytx;jLomFvkYizl zlwFNAbJ2O8~$J`8mu{gE+|_ctg&=JJLGPcnSr0&DR7OP|e8uB*@tq_e?_~FLBE0gi=E*hWkWkq zl-k#Hpz+v@JLH_wh?8!**l@sFGji$+pJEtE4fD`xe9%Y@wdrp^=1t5qZmjWlh?2q0 zwK-oAzqHqC)#);oa=MgG8SGzZQw1z3*`&8d0wWUnAfV@)Z2)|>)V*+_dKeB=^AGaq;qDjBtA ztapOzt#OqV*0@+jEfhPA=HeXL9oES1aJM~xM`>g)GJ61yF{_H&HpFWJa3^tH1yT?O zqPDLn`J%gwJO_{C7py*$-bB0$!yUD zWf6B#IUBK_O?*RVx!JYWJ%1bU_ar+PZI8drhwkBNsYxFMmDkv1e>9K2$`*b(Ie&F- zBY!Hlkx350rwp@^XQ$4cOb_YIkJvb}_r31#=D)%IvBq7`8Jx_CW>XtYq}t}Je}i{+ zePL&JJz_@lcXlY2Hv@hkmbzNZ3o~FWs7;v8o<7^}e$Z`W5gf9^%~Y1HDcb0<~~fxg@?7hU&hAxlV=Ot8&l-a9X`z$<0GlD zRcyO(;Bl!Wwez$y;LM9SA`~>3TS)`sw%$~vmRvwn_B15g+tvQ@0Maq&eBcucZ!hB< z55!Pi=IP?`d{JQ|*Z$vbm9V&GiS-dRRAA>5bsCjUSWoXOXHVO6+n*OKgBWJ(m91bKpksooI4W z4aPTx_g5-o8i$c81!r%GOH;%U1yxZz^+SnZI_DFoB@g4&q|e6?O&}bR-k5t`FD`Cn z<_vTG2jjtQ%HQc#ozxUCs$9tF!#ld{Vv(hhRh-K_`-NowC&Ltnfy-2P? z@yV4Xard>%KQdGKYq*d4N0&)FFh`e1P@P5-2dnC*AEqu{9?Tt9-iLlsqsZ-*zA74~ zp(K?Dlq{?Em8~_{-HHqBtJC@n(W8l8Ot7`CR=r418;y=`@Z@ihGHMEKi@2m%rnw1V-q+8Kc@QA)xm z<9jpL88s8=%XSi#&^VK2~E z?dI0|ME;CYgb0`X4IrBnD-=gk%%OfQ_}Nm}1G$VwUilQMQHwUha`aA_1!hK2Wn2nB zZz${;CxLSpamX<^cgRpFkIG(AzxHPc7{Q|s3`5QME2u3|05J&PLOcF4`1V_!xeUSm^YE>0 zFtHt|THc()wfDh4BzxqM&A5MnZ6ddMbc51*=r+NS+s1kJT7W$d_SyJ7a082 zQDVIlP^o3a{a7fYvjpm!qO*hqODQD+ojO8DhJ)rt1BVP1E*vp(iVkS41W`^L=70f? zw{DOy1EIZnLkAZ+Ox*mC)QNt~S|~o(YU{5+2;y*RwY|YrIM_rkOQ^g#d3=gH$mPob z`w!HW!Efk4^RRu*lSsUiB2#$V-@^i8?!>5juVg1kG?LOr>!w}$+~C`dB!16HN_(wU zis|uPm)_eBaDwl~k`tZ4AwFvi2d8NqhNzO8S|u6DmzRu!$}Z@w@(je2laQLkEs&QC zw-{R%Pa!5rMyfObA1Wig%M1p~NHdNhBfbCaONDS)A*(57(NJI(OFml=j5g#MgmL7W z=nF=ZKFx0ZKiYAgA5Ug3%sINr_@|KjFB8?D?#7I5cy`f-KJY1DaN1@BC)mf#!vrVm zmRj|k-^(qm=`r`S%x#1A^EHqD&-b(J&A$;w9VS3A=@Sh9IMoPHwS4W6_=FpamsIE2u&v$#f~pDeG@$<(obd&Y(I~+W`o2Oq~MY|MFJ19{$^q7 z-7)vdyYnK=Scx>aBU;A9`nDi!L>e5{U*r#;KX@X|Y}2VY%J3o$@fn^-Q;5$vn*0tn z7Gvin1?(({GRN^vQJrIu$_sdEDRCtdAyeWfa7UTG~+prr#CsggZqc;;E9iW9mwN)qr6{D9Y~i*Wflj=*B_q5a}wCH zz5IY{*|3TOQslpg$>`deaen?@kMnW{=voZFSMUG_FGY+ zA!30J&QFe8Mtnd8bq>}$ogHV9Z+yKokz|dXr*nzEa!;fF&rA}|0F&f7}^<`O&JJTO_ zCU%ZjDp0g>J{JyEeuGy-^xRJG;)}&!_nJXf*VA{V(G#8IU`po$F5m zZ1j6RfG9r+G9(T8(OqJa9Fnajh~{2&i!n1~C%yYJ8)mAVj0W{(F!Hadan z6+Q-&{)TIJ`UL-eRnh$_?oambk1M)Aj{CL#{pzCo)xqU*F9_`1G~HniC4{UnAnuUW zRA01K=``=SvnygL%#H4)RT#|2#oXD2cpJwJc)e;*X?r2j&t`JdD!kjh4(r4v^z~Ba zMx>)b9CCVhoJD$V!f>WDwQ1nh`fBeHsMe`Ru*unkmOtD4ea%S4UmUsi);gizHGBZ7 zLnLi1xITT&he>;yP5!+jYBI-U(KCSeS9D0cu!$2fp%m_^ij(+lZefbH$wPTu$pyZmtZPM+57jtFApR8URbyliFi^ z;-#~gaz*`Q_i;yr@tQ3p1bjyNm#B*du|peuo7rs)FM8D3aXPo;m+d6>lr}vRy)Q=! z>8HH@L$+JRYvr_g%9+?jbJ4;LQIsVKFoq=GHU4=Bl|Pz<+EUii?|6(lHkoE#(h>nO zNKGTsHY+*-3J5*yp~*Hef@)E@&OH#t?R2o6q%#mqh+>!cf{_b`UC&Fr6(zTYcBlMR zRFr8aR5M0@*6cm8)Pi!i#A-Er7}=*50zcYX*~*sgOjn&h#%fblRFcLV$8mimeil&@ z&i7jPE-zO)x8zhT(4EoXc7ma!$(1eI6Nx<|QIc20lmFGupJ+cWh$rtiJ{~x0Su2&F zLdg-VmFIAUr!-e*nXCO=84HPA;R4)>rJVj~@^7o7spb9g)XtWwbnf|MjhUeEG|PDI&?Z*%jjV(=g@Mx`W!{_o!-Qr zQ=;w(EF$CP2Ayjpl4!DiQ8f9D#qs173$kN;6&V$*JA@)&!L`B#c<96hh%4zY8eLH1S=PP2czTeEYJwh(e@- zc|*WLk!-EJpDXT{jJW)+p=J?@ow{E-SkkkT5GzPd_wJ^W^SbUnzI4M|Z*IoQ z7n4%^9ME^e{^i7-C0^aTVf&k}8~cFm(qQ=p{yoaSSG#}ot>tHwZg{b=cSGid?He-L z?hX6id#?LO*FSYeshx^e*d$c&+vqK|)0>C24U-M&rvkdP3w%hG<2FQ(3+JyW8Fv9M7oE|?MPgQ zq@pNZwymYqTT5MC9(Uie$#Ba*miDb^%4Y4St&XQ=RTG@v9wj6_n*35rGSrr{Gw>!)W?xj zA=OW%H^Ad5s?y7Sw}-MaV?ntmWCKieFV)GzRD0XlTBCX+C8;l$w%=UyELY*wWd}Jd zs8>}J{%OrRu973g#TU0dxBP5U7XnYgF{fW~y8*B*7KB-6Gl$Pu=n) zUs&8;+jW2yC`T~4$#%mxO`6``I^hYFB?I;(%Ilc`697KedpNcIX7i9IWdlFtBV zJq+j}1X~Rb9oB${kx~&Uj3G&gvQ>%0G>(JSdu8axs!VOd%xM1RD z;}?>=*^Rcwl}E`-&rusTY@)XH+#xe1T8Pm zJ4sYBNvGdQR`9FBBwi7Re6`SjEbw@Apfeuox#7pQyR-21Af~}l4$!cix%NOeM?7I5 zhp=+%uIvB~Slkb63x{_5kTg&wgR8tYd1rx&2?^y)>AOL=3ijQJf6d{B~JIKE@6H!gL+HsNCH@ZPYLXoOyDD<3@DFQvjXk`5>Du5#;hD0v+2dg!r8~}(bPIMd; zp^z>tmi%SSWPWqMLLRU>xup+mcnM(NOG=uH%5WMQm)_&u*u@QkQm?E|Kf?{{UQ`E{ z;hz)fkGXH)R+Y>A5)Zz{(c|+x7#|P584Ywt6R)co<42Yx3K)hYs%lJs`>mvgqasjPqaLKH4)7EY;Cj&3JAPC;4 z=^RqIbnkwvuWqdxZlU2kzoGkBI57Wi|1o+IyM2_}n`Wjb(`Wn000-S=EyyVT)E@JE zfz7zN*@ZQ`>9}lCLq*vnRB>tBFzw7&gllNX2d?)!jISN0C7)xH5g-yENrc}H=nvD7 z&tc?nz~saBfH!!C>M79c!-jZA??a9-LGvNunzF)|uo%Nm(0s}a8Ww$tX6S=3ziXrw(l9Be@{N%>V_Yz!LZh%;5W(PVXQ}_+THMG={L=)ZR z!k9PQf=72~4VuR2tuVs zRx&bXkMH$B1WgQ0KqDvEE9Y+-5+<>_G}4}4diFMkK<^l7LD?31*ZOuRFe0Z;M_Uh7 z%~%A6ASo%>LKZ0D-xj5U>fZh9zD_7dc$!Gev=QMzq#a`9VXA3mT0k%S2Fi@erp%Lq zEqX2@#r85-NzNG>uos2v`5w%kVY7A=?+5LKOotd?ZgF%Pn1j2)UaVJDS}84(XeTSy zP^)^Llq)njtcvATzD#4WQ@q)j$p92HAHF6!u#xxcQTcU6gWZsE7W5;M+#73Z;;H(B zUZ%~0d_}sv1=NB0l{jc>#K<3wEH%q2$!JmLBQQ*}-lWWnug+X9Uaak<)jq|n_WU(P zUzGW*Y2YnvG_>7n{UkTE-iNL7NLKl1OZ?prYl$N}9c>1J>hnNj%}q|7!e*@}Cw#1C zZhFU^xvBJLuhrwlW-m8YnosnQk6Q519$}yCLV$SjVKXbnKN<}|K<<>%L;6qEnqS%o zkP|n@L$3_R!5<3;X~&_rfP~wIM?#v3*%gpz+i++Ix5?w7X>b@GLhgt3Q9wk-@DT)p zD^i;&2Nm-eXo5}*n3_){scXrdxN}2h7G+w57JP_D7PZ3#=|w;EA)UpZo&zN7-N@c% zq{Bd(U+g2p^Jixj;3>jq7Cm)*^AE}AW>7b@yWv90Qz39j)F|Mu2J|-{V0pmjMOq{O zgUf581KrTR`X_NJ-bE4^qhr&ym|K6xC2txhbv+mN^G)_LTu34}M~ zy`ErB==!xkfJpaezshZD7DU#GwB7BKwkW86w;^roAZ<|mA*2n(WtV%%L;H0@5UXxo zY2@zo56?7y+iQhV?+r#N(w~+f3sC|T*sO(|8PfJvUsn#RItG)ryAgy6_+W@d=Md61 zqkvMwlQvQq9g(yZ__8>1rn`Vo*X_z)W5CEcJ-#mcjXVUE_G)eV6W_-UH4{Q-fF!iB z1-HYXmB*U8;bB$(ArDptT~f!-`o2)*>rlDS!G_NeA<*|MbwyUwvrjK2S!8qgkryjQ zMF%$VM*Y)J;xsNtp6m;DECMT(>$*0c`sTq{>I>QL5n^-}B}^6Agm5w0%SWGCa>iSX^sE{si~+$1z;pf+;)yEb{XvtQPpp|I~J@jXsEXn+*m79?S7R|8t? zF54hvBxqbbClA3BUJd8~F(F-lhQ1&BskdL4>BP;^(4P#}P#>>|8_HlkKH@$C#<-6O zbHofO54v82W-!`pD&~h<4<|&$?9eYRJdf&f-Fc+J(FrbT44}BK!8-g(ej2WhK46ubx9}2c;s1Jnc zd)`jG48AD*TkMsQZMQprJSY$Jn{Q|z=?rY-jrylRYfreb#3GxHGe#|Udlu!dxjc*o zHH`?noz#t#lGP_3qqR?(%DIi|)kBpL0Hd*N;^wo_zQ>o^XZN=C=8nNuxCi?kkwfNG zE8T?g_&^z}qp-~T#x_}eT7E=l%Zj>umR9#Q4%;oDEQRwfuEuDwIOb-!hU-Na@%ziQ zG52~Xcn`u=t+Q^MZ^cnDyxvl!^Vo=-h~FVerTSh}J`fa+Xtp1TqL}31>#X}uP4wIP zKaZ)EG#}}0i?cn0?>v@tclq2sEu*Y7L8;Z>;pWMhABYJt{tAWQ%} znKRDg9N3Pjp>l@Xc~xhog7t1cK`TzRVa%lI^M*XLx~J}=1}=uv!=H`OGs?@Feh0s2 z( zieDAFU%^xa3V%B77m-e95PW8p9eGA}yVoy>8E+qUTJ5s~1{A~3>Y{-9es1ur{Dsl7 zaH3P7x&c)C%)sE8F}QhsFYDW)!4r`d%3%46Xx+;Srzdy1R$IRtHBdGb3JcUmwkX)VHyy`MSfJ zuPbWKS@BQS%1)gwgY5J?8DM&~6e=K!{0^sYcVV*=OUbtFf-Lm1?+qasvhB6wi#B`P zdGrmrnNLBrDvGSWS5?=-hMiz6ED}qR%b@@ii#>6Et$xPwUcTYPI?O&x&<2Wt<)ZEf zyDQ#e`CmY z`Ws4;kh%y(Ap|k?o0>IrDk?ph*x#GJLxdxR3g%QZgaKdr9ZN8gEB4^k$^JvAEKD#tfmhSoc&Z<1PaAA-$k znpEnlgI+w1(v*y$z=`dtB8WxYR)3<~BjoGM1h6+nCho}EvCw14F#X6dJM2VPS$1OB zg(7a31jBPA7%a0CF>0ucP`TJB(ZfMfxc2bAeN9h4%5V47i96z<=dEvdP24Pd%x#@* zoDW}Q!VKo=_GBuD_})`_8TvO=g_o7u?PHGmbXMu$$AtNoUq(TC-VW>SX{7!=`7_@} zb>WGzP?N2EmIf)mNJCsy$}!z;pT(JIeR*at0tp|v z?WNI&yEmIO=JEji{+==N0Mu@=FTeb&gPot?{=TZ-82A&f&2_NGt>NpO)VU{;z@9CH z+lAc!tl8vwCqR2?IXQ7%o};BQ+U~vS`)ac%s`p0+|} zED3w~SDn|qT0*^CgZb=gZK*qWPtI$#a^jp5OI>%+WZD@Mcb~HFGYY9M$3sullinE1 zyO3CUyL&N9WiN<@o^Co`ts|#XGO4pH`)L|6TZ6=#^Ef;PHsX0G1vd$Uw}Ze`(TTdJ z=~VVRU%uY#%hweGoZC@2=nKbkM>3)D*cn&=;34;fNenB666u3|5z~{eg|z;2qfeSv zjIBljH@y_~FsAN(cRuCu~HL@u0m(YwP!gBvODRH2*aYX0tionx$ z;Bkl4iN=>E)YEv{Rq*l?sqcv`^WrK~I5g2&4V`aFM+c}z*W1+LxQqY;94D9(13~!? zP3A4B-D{oH#T3pwP}(#zlKR&YMjbkQt;Qcs0f%avvSI^W47}M%&P0lsxs!jp_(v}5 z-X{DlbG=*l&f_fWedD0+DsuM1qW-Yi((e&EB{guaQ^v4bFN75708PE>rt^<5VFNFW z^;JO1o9}kOvX_7Tn&*oK0GR8TBLKAn+Y3|VZx7xO`Dj(3i`Oxa+JW`Vj~FtWPHfZ3 z^EoJ5t-oYPX}_n5U{_=%yeTjp=&>2zz`M}i zjNe&!YjNYG*E$Qy^18+2rL?5txxeB%^VAO zp8zM11~4GsR@0)dNR^8kAj3%o$`5DtbnBjT&(=WA*V+`>Q-5YC4F@LK0r?z4Mh}!V zPUB~JjIjOnjwp)%=@>pzPAROEl z4tV@N9_Yr5JpqtmHz$Ke^B84FGuTh-NL2fMKRG&`nuPdF+$k=ci^pthO$8fG^*(=8{qNGH962 zgj-VGL2c*NgdNn0K4#hj>*Zdg$vKJFk$rNQLkGfvu%{Vl+k^-t^~YK@d0gPlNswx zF8r|^qY=!FHOQYv<3T^5_dB9gG?ag6@?z-x#pwba?G(K?d)9+>=C<4zZefh*pfQT+ zq5220)jyx4{=rz$=gy`Vb1R-(#>|vl*Auw#cZeu#&i{w`vaLM&+L5D_olWUXN$$ly z7PIi8-`>zi+C%9&o3fe5Y2&G;@OO(+T!jjgbsYN=uPt&*qwX^*){QzG7l$6`fkA_m zT^>s%7K8lS$a8d@5Qn)FHK2?%;;R+co?~tRJ(aa-DqW!XXNq%;=w*c<>jRIlg(nYdU@K`VVa7 z>G#aj#mE|V+(`S%1QlesPeI4z3SETTTTfHCGoERYP-p#97;VE|4|edNN3;hX zvqNt+e=3&3pz7CGAdAivrq|tdeP6pK9S&@_lU3B5#AzAF$4BdbZ@W)M+*c{9G0+7= z!fVS8Jz*sd@%4zEP;GhiFTm%^xu*XS{4EXj#j|vWO+K%i9yah(n8vNTa`DD)z@xr0 zfxqR-XbQy+=_y9ULytDp^Dykb3rh(H_uBWJNOJ+!oEti-HyrwAd1AxC9b39Pm)}^q z(oWg^LvP{jdRQa*lMa11LN(=|heI11K1Sc}qjsxEzvc}NxV5pAHMQ*NRIsO7w8l?$4*65%#O2BLa-MR9IsNdTuXwjCM%oJ?p+g{ z=2sbqU992jRB=~m7H)sAMjp3#Ti(a7Qi!TH2si;9C%d^kco!j3&!_mN@1;5TrmqwB z_aD5qdayrN4}!*Ih!t{$=g%dd(;@y`dOp;jYXSEh-;Zlt`b2IN{J1LOuKc)Wdd^!V@!)IGKsPR2be1+gTqF(5 z`EP+RK$rj%3e12w3>?9K3%4{*v{W;Ty89q5yTZvUN#h^i$;1Ewxs)N{t;9xk`8nD}O0N&5Euv)_BqKnJ--)TPrmDfhIP{=F0tw{8^`dm*sj2&5L{>t6e^|z_br|DVvW_$I%bd$_ z5Y6pRaA3TDJZ08-3&_1;xBRN)NKUaXC-R!{x*#Kt@-)oJH+Kd%w+rp(nD%59#(ThT z9=~H~>rr0sku`qfemY;8?|kv#=1IRbP5im2dC}Beg6HIT_Wou*sP(ZXKBVz6<~^wO z|9__aXM%f3^Z(tLB1%^)8{>qA<2FTljM@nEzP9Pj%WzbesVL0hgcftvVrij;lm3Qj zu@oELIvfDjHdNTZHIK1Y#_veScpAnrg#5}pZQ-fs6=u3$oc^SF+`;2r6E{O{*q8mj zMoIbmChj=9XG+~tE4*D^>mA%VyLV#8lt_;i?!t&ApD*Q447*qE#X1P(S=Qr_q93x* z&uMJQm{_Q(cZieM&8LWLpvWF^&N9@8!Hu>l73)!l+e8o&?~SomJubSMn%T$ccsyjU zM5!jRa|0sp12X??XmSp2o}IfoJ^u#HrXyP~fK4_a#Uo;W?dcuiRBc)Ia-;hUyJ!hH zGDqDWn`kKf_{i`HROwOG3L8eFNem~iTS^RtX-|V#u*1Hl3rY)RWe$N}&UfR}Hy(V1 z(eSh7UbSWl3`0#NJ^%$SIe?wdM`8MpxZNo7`gVH8+-fvi*mWQ1qoh)00;-Vk=$Xy# zy?7*)3}4gn8iY5sV`TuY{$JUimAw2PS;@hlF;d`=f2b|8tPe4wI7_5+4RI z?{8h(zV-idUH|RCFzebkWLbBEEyFJ>w8zV#dKkga0mWlh?_+r{9w|I1g5ogfFt!MN zrj7)$#|L^y`D@_LA6PR~bFzRyEZBcs|9%#10Y@N=(;eAmnzvR8rwFh=+gKo2^~Ncp zI{ore&nbe(W^ZvWYMjnS8??u?xyYj1d(4gXvHg!2UlOyanD3#b%-4d+c?!;5XE)zhTzkK8kT0sjIx*Z1wQu zYu!;z#~G0+(3|~$9qMg3$^VOM+nQlWrkp7h3vLz>aq!kW!S7``jZVkZLL~*kh~t)w zEPY6AL*@%qer{OFRypLPZ>JulQMZ{1!Yq3Yv+Rp;#52CW zIq#-0(}m7!3FH}=+jq_|#NG&X9<@gfWtY!^9Ly;KwKIg;|F3;vq^F7#(XmJIEe2+p z^B^A4)b;z!L;Tf3O~zl%tga=8wYg?(kFc!YZTx?*tQ~(UURJqodo(`ptoAY}r?u3Q zVo1*MZnK=j?9`l`4zA5Hp%JdY@qU)|V&qeMl#t-aFXYHPqv+%fg&*nBdA-7oB04`j z>I}b53W5^(z~8XPWJWa$7NHn3J8VQ-1B6%GFN+66P6YL6zLVZt56!>GY#p<|RD(F0 zuR)yOWt5ccJ?0jhM8(R&786l|-uFW9JyHR^U+B|&aOur@;Zh5$!}3r$`PldrVXA+1 zGO_rb;&1TqNfh75Cn?~e3k9NZxR{W`pu&zqQpj(qDnsuPv0W&SNAu%3$I{$+dGHW} z&U#1foUn!F^#Z#@_J;X`yBUn@BKiuN5*B)7f3zX=kjw1pT91a)a(^2pqFZPUJz8pp zFqLbG2iW9E{WJ4S;J;X7q5}HJk-f%~4^57FLRdx|Se)kuk+s?DbH^Ry27O2R%Ee}V z(&4hkIs{+ zvTjXgp48;2ddPg;8VWMjeG}&vNn~R<2d*^~{;;*W@9+PbYn7!W(<2ZjUH}=3$%Qc8%MuXAm#nZ_?kQ=KLSP! zw+^dvvikK}39|&M_O#(T(Qh`)HTexAulGCBldgkyM}_m+7V*$}QEo}=NJu{AHYKv4 z+(+9P%ibtJTU*=X_HNToY_Hz_hH|UG5&l7kz>o8o&$001U$6aZ;>Xt43p4iiaxsan zwb_m!hR#byBRKRRm&1tsRxkwG+Y4typT$Zc5KE@!2=ky0htOkBQ#VXk^w7M~z|teh z%XT(gKB%L?xav{lQKlm!hvx`#uL$z~+J;kog52v93o2toc|*t}0HP)k{*-ayCcN<|in}=#PnnpxOG3kfx6bZX};YnT~!oy# zvCr;l+rrsukz?hxEB-Bdi4U_7$SG_qq2ra(dzD(_I;4J0RnjVNx%+aQ`ih5 zOT0T=Jso#nRilnlUW&g7Lwz$QC$GqjUX1m_j{d590V^(8{A!%TP%^S9=2q5_y)hQt z5-o%WfpU9(cB%nYYAT^aUMs}b;l>NQ&oE@PGdoTZIy+*4 z7d%JZ+^oC-O(RE*x(FI_0>3XFkPs(^WbW=hx^g<-9G8n8QZ19*2bxx6)aotM>J8Hh ztnG>h-pRMRDmlh{;bGHyZt%1`U=5uXbN3>sJct&6#jH8aMMlqaH}@{D_?f z5NR_na?N(d173iW*O@mjng~w&6|P}|dYsNZtkUBVcOGjPNuG+w2OmS4KHNhixAX5! zc`OpK}%>S zkISROZWb@M&?pm%5G&UT=S%Z}d(29AG0}KndjaE2ppT-A9PK)FU?PmLqB%+3C@qdG zy0dsS%*u|Yr=mrhy05QC13c>wzyg@iAa4N3&5#kyo%|4-Gz#mOM;u&QidJa5yO9Md zbkDY3b~_5MZ|0(<*yXE+jG`OfAXjAidho%|u`Z+X@Z|%#ih90v zXwTfpPhTs0uL4n4o}}<5w~4&KM8w6Rf@pZ^ULYC6tHfOW8@b-`>9{L1_JCSN{tj9y zs!ClesAO%e{(Mtc)%>WCf6R(*QDppP$Yy5GBa*^%NT(hsX^uRyeK%xVaTty}qV7yT zEGbf*tGIZSh@{1SL=yBp7mbz^Ba7P_!AE4k^8s z?AC<{q$}5m$1EVeq~h{i^pTW+iav@d`Y7hU6Lrt1i7Nc)H2RLhIEgs4*^!g;NMB@fG~UBZqp4<2JosAH zHh+N6luJ>q{Q!p|JXZE)Z-|BPG^wwa5n@96)%h~S&}Y~s?u@?h$PqWs*3niTf|Vx9 z<2gIAzAQ_0IVO-^S)R$*Y?DTWERvz^4V4(iY*M9RK?rW=b}ZOwlc&?njl?r_N3Kpy zdIBt-Z}%dXp7SG@uIEKC-X*f`tv-NEtu)2O@se9jW3Ixt{*{|+CQNA9$&jc{6SD4^Stf8A5C=N>GXQq%nWrLu zTDZV7f==dQiQX*N@%iOqp|0^3>OpIZ#CU5J*&7eT!NYs^m(c5pPMWu{ zmm5wSIx(=Xd{sNX=>#9LHKV0x)WoMus`28_L?6S?jFIbIcVx763E1D3j#B_j zpHQn5r;fa$=g21=I@CSEWVrQQ8NXzc+2l1wT_7>m-EE5Y^%CF)J?%)RFQXGfbMGGk ziFG5j@wS)Ux*ieT7U)SXs7-#0^0JJL_if0t zCLL$Id^a&D@=m-0MEp4FqG%&M34w+91rRaU`!Hj8)Nhc(O{5opo4THK6(uuammPeX zhLf`mWUx5b(lh9Opd=9z!sT_l9eKqM^zbGTxtk14u?;)Fuumh-=} zaT(uk6!3;B*Y#wsgXl$5P5W}o^2B9FTb2vJl)w10T)*>J%QBU99d=nvwORJPA9#0f z`7Iv*3E$#K{-+*&f#7a+GC&`(F$q)iOFy;DjrSPisc9Zp#II+T8-DQ*gZeFE zHEe|A*$7u$s_aDUfy?uIKq~f*^!7SbJkx~na)yEJAJG|xeGn^hFw5b4HFYwJ@IAjT zVJ~4I`p|`DFJF1c4w_wgGLw0-u4wr)|44(POxJ4>ssGpBgk_Mv$84dCRDIynJYlwMFZA^yL>g2~aIUfy~Kp9XebR#z9{uO7vMd z_qcdR&b>wJd=xz5{pQVPsoX2a=K?vSq2Gxsh&swIy@lTm7t^=h_X3n8@v2e!XoyYu z7|~nW19r;|w**Srl1-z{G|TXOIYmG{$@}xZTKWm}l6hb=mL9QG53+aWf;~Ibu%y=Q|06>vYR(mqT9J2&}2q~7UEd2lX-~HZO@rUiowq8 zVJc4Oh5AwJEUvPZ=n9YyI(L;jeSH$FC`&Wq&M)DL)ZtJ`JwSSkJr#uETX)4eD*1T{ zxq}0-4&oWdcIco(6#072t?r{C^4mPwFgYDi@oB?^TFgl68zwoyop`N}N4QxE=Mz7q zYY9n)EB?5j?QvQ9IX~m)k{G3Z>yP70)-m1e1x_H%`!Lz1)lH}Kx_K$4H2>-%{nLjE zJax#UbN>ApJheDrpw?uk&grsDMEMBkME@`(;S#Lq;DeMf{3GN=BK||Chsom0OvTnEAhias3p`IDkAj#9T)&?N<5)AQMN9@IXg ztI!5#Q>T{8v1W8;&f*qU3=$OtI?{L2PuQg#&wAV4llX&`*f1h-&@#yrmAE>iGG=!2 z(?++{eZ|Fn{qR`Iy>JjJ8Q2g>U0&+h)0K&-RUZV+>Fc%bPoG6r_y>FJ?HSDUmGw$v zl)7kNVq*;j)|ZSV2S^}$QgCM^RZgC>4$`<@{vPb~tnMp9eT1|R>46kd^wH2YEj9Ky zT9-{tO`5F`^1xf&UDxz&NxT>cyk%1cF`<||LJu(t>};+f3We0R@1a6)7WO!Stxjl5 zvlV>c*NW}9PF1&PbUfeqOY z3~c6?efAd8LU5i6J!ZwWlc;&=h;Z;(^4|xZWie5)T+&oBu(552ZQZsp5_)0TSqf)f z{>^u6>$mHFTMd{@JasUgiVSpLaed!Drr!|HP5s>ArhdwxscWhyWn`Qk<`XiiVy6Kc zh4xx@QUHYh*sQ-Ob~ljyFrnquH@>7un+d7u14&ZE*Nze#?r?&fcqs0mN41h+zy5R3 zEaAnTdk6mcCU-*S^neGtZ*pj70d~?R&_>U3pSR2FH@h$t1!rC9bvnBxOagTXtFD_VOu2!p1@! z_1m+6e>xp^8Ppf8$S4*|v6$`rR?wk>O0Pw5jfvDib?zVFfp*h^E6}t6= zgPYCo;P&pWtH}^b6#j?9Kx3*#apUD2E9UDNHLeD!N~vjizc3qK|1f z!7ZIq)~TnOsnzxq?qP_jaR1?4_vcmmBk*?2{do&tBo0>XBqxzhx0%f2l)NWV ztF=lYruKuAX<$D*PCwn}!@+*)E8SP(e?>U>BN6cE10^NiXG;Z;+aHo{#<_=r`vE`E zpUy+MZ}aUP?golwp@c}6HcrrwYW*P5MQPJ#rQV`SjJrO2o~qK2)q%@Tc$ZtbJWCDo zYoSE_+#GFRU7;29B{LAkbbavkQmqLt3hx+b3(~PrV@;KH(__&8jQkp7?$;{ZFQ4n)rzMI8o{zczsU=dx zI!h!CM5>`oZ{wS7t@;}p*$>y!z_6%@`*bi(qJ${0@fIW;yiY5nbzwG(Ng5IfJ`X7) z?M(E++=4g{U0Rc=vUH&z`CK zgO){iE3O``WpOuX8ITkGZands?P>BD5YyWQqixxjdR6oO6ebVFCM3S6DCU`+vsXS9`}iXDsg}p`0J91>RF?5js$<_ zuFxuwt0nA4#}oIRrkUfeXwfhB=>l)d@}QSH?h0{9rIX;4L76a!l^yItgQLzP!JT%f zgCJe9953zH%heHUIs=ii0w6}L$g>k)cQ@EzJLMzz1lIg3bF5J@>lG|d1<8F0FG5y+^sY%37p%{}q zvB1m*dK9+Z$`(60wk7Ohrv(JbQzq^R6A3PB{LNo#KtLh zsdZbI-PUWhnK{Aj=Q6jF)%p2QPwHU$76w!XqQwqSZ{c~Ekh)qV33rS$Rcoz#~rD%r=zHCgsgNBQdMK_;u0R&t0$xlp;8fE4;3`Q znAKlp-BPM1+$H~Rp&neW8*Kf0i`KSYt&XQ|tVTMle?h}%HUd#WpxQ}Y3ay(}k-mgE z8c`FPh44h)m9YC#IQR7=o_i(_e>aq_w6UpQQ?)|}QJe?9%W8HL{u+EK?I8#Pi zZA$%H1jV?~TMGfxBi}8CCZPNSpadj>CSWlzdDFneYE45d3;O(_@U+@`L`;ti(?>J^ zW~eQIji&0#g>$J{<>}Tx4Vl49k>DTVA)?2Zmgi=`dYXVqg(T$Ui6|#8B{t8kr_~nE zkI(Ceuj!+ibItfCMBS&;pZb?W15W9uoE02`N=llkJ~q7~8XT#!q@A1|vo}q5fFvjJ z=@mA|^T1WfMdXW{UZMO47aep~{D16y3wTu3xi(=22!c**X^oajtnrkdNi{Z{HaOH~ z$33vO&S12tvGqdL+St-#gd{+@usqL{X?Xl5lB3Au2;ieSA3 z)OJEZK~#cV=6~O{_MX{uNeDLy5TC~|vuE$M*Y*A0^{wxM^$A>?Q*Ygq@+ch;@Ly#2B^Vg-WU$(LoUBVWYK2cucHTf@d+Gc-OMaDWqtKx7$*7@;w&-!$*u(7OXMr_IRa`=htpH{e$y zc9?*@GP;q+8CWTkaT6cpPbdP<##V(3=0q3bcRBB{R>R}wn30P1xc|OJsRSD);*S_O z7S6VfII;BCZv%eQIreon9eW2kNp9Q;=(5X)9hO>=Voz8>KVAsr$M(`4^~)*|IhDMT zHC+~c!n$0D?*ZSw=^k`guDzs?3d0l=a|2=pv@jg69K@Yrk7B2~4^>C-Aw!OS?*>FZ z>3Ur@JRtTY4+}IKo;d@6#GL?O43k6^#-l^rM2F;zdgd&H8jNvz74z95gr)<~Spk+E5g3_;h=XO0-3x#B%* z`B+mlozJY=p%%i&#%Er@3;PhCS+$+*|JeD==yxfR`Zk}bd&epN`uR*U|2tSd^W|;M z-aHn3=4q&F6a19q^yA<&H$-~PFpdD9*?v#2-*!y+3{~bm@|j=RH&}>m@tM)`a`${D z+Zx-v!{swS+0t7+^H8U1N(!HO-MZX6K2w75dHsB*Uq3@i?PQtV=x1hi9Ei`1!W{&; zkB!f~6YW!cW)!M(4ERj>Kl(nOdHQXq{Ojj4hsS4beaqRK$AZti^=3*9J{CT6Z(Xk$ z#u4B%dA)zzG2t`YF$O*InN{`;$$VypyxcvXDYwSu2V@*7y0$ zTdz9hUq7EYJU;UuuQ+@2Sn!zLE{|OfS3mRa#@_Oof3s?uqMy0gZa}a2%z~LGFP~|EQX(L(g~@vt?Pp|; z7imTo;K}~~O4~I7qp>;}bU+iYYhIX_($rKL%xEzEh53y%$EESc0+e@IWDK&UOS>5) zb?IVKC76sc!(6!+IazQB>TTk|TZs=2)>Sa-7y_FaJj?S|Q_Si@5n5>GXc*%>E>m>C zipCIS*#Utgbps|M_gMY_^J;M?zy1#Y!t}%|g8*03<9ZS^&#Vi&*5TJ&6swCH-C|xg z4`OG)C;OuS?l5$38|pL;8FXn;qeqx-3622xslxAS74zA6*vdspvn{I>|JeJe5wE&Y zr7eIxRdZ9vF4%?c*tNuH+&s`|+%ym=T&nT{Fp7B?l}en~mwIwX!2GPC1c?QvzDKuZ z93-A$;67F!`4i$lH%;A%P^7p6=0UIsDm0KwEc7~TI1ohx$E?wtHo!PpAnVmKLqwx5 zzJ#TM3d^tCqkjB|O-L=ulvlcMZR;z!m&UV?o^ z9X{*Ajh_(HMT~na5E=0p?^z(P4}U5U8Tk}U@|w{n^Kc0t8}N}QoStV;7!rTu>pl1? z7I_;Pb8-s4=b_tRS~S#%6pR&%z4yqmjy3uM`QxVLzy?<(95LVtJGpZRO!V=gT!YJN zc%Y7Ij6+X*8)J)^rG9oHih_AjAaXN|Ts`$?;ww!^3z6rC2e}4LtlIC&Ys#XgHP5o2}%ATeZXWp0R21T1( zo;e&ML%0z1X@IBx5_B7}y3mMRg;&6`=LhSE-dGmW`+1ozI(6?h)3-(0qAZfOD6d4o!ZeFI>_Pqw_egt`Wu^~FKVTBCY<#vT8=sXOBX|Q|IGK~COdtEW zl>q1|R=9C13}Chzt}TYI!!zes&Z^%pzc7~&s!rNm$@;6t0GaZlWoQYF6gcVp-mSX# zaftzJ2%XdC{3jL@Z!bejyRUyW&8BEilT!bvUH?hEfmN4{@WVag4&j2mPu*{11()II zlL1K@cW1*nmv$P3OkM;-gYjK78UYe)^vwP|q6?^WMt}loW$OJ9U`r^ZfdLVV88=$> z@U?Cj5;UM_ry&7u8!#@4E-0FYm7LmA;g6C<7#Tl^w_mH{Kca!V*65t!$hCFqE8 zNKx3Vh277>v1*PQCACh~lq*5SoKtRSbjX^dDd!g$t8G}9L7%iI!=#b3PR$rk-J2+& z`|)bQubIXxKHnb24ah*_ssA%O(Vk#aF#li#Smv3t0GCZ^v&99Hah4(dHJ6N>Wn171 zVv5%?Ofq|uXr@s8 zI%olZ4@TVQ!@zGkLMRTl;a6Hk*4zTyFWVwA19tmu>~_SXvJ2=Izge5kVJMjR{qOJ) zO158117cJVvuOhC*Mcr(Q8ppje2o@mX-^Tpr4-|D%5-T$c6J~#W|S#j5BQ!|d}!_y zFyXZTj?0)fWgpNYwwz{R8pegVG(&^EKTIg)9hNcK#Qo9F*+1iYiN);iUCBpOj$t!0 zQRY6ho>r!0-^UFwA(JQuPS-x4bFN(MkhRvRY5g84#U{A(xy_2H6lU>A70GBdD7>MY%StB6z0*n*;RrcSq=t_AR zU5>Cy2!kTKi9h)sQ3Ez-1>}6kK3EbS$ez7HPJn(se*Ez9wac7*{1$w}#IX7JpZGP2 zk6(f-{d`<5@82!yD}4NyxAi?fzNIZ)ydIx?ya6qV^O1f&-U~i{H+qaHV)60Yt*LOd z`S|pfq$ziN@$qk<@_mz!H#9ru|Iy>)e_50?dM6VffBoh@%*X$Lap{4N-*5j+vT5=0 zv*ooO`1ro2W5LIFH6A7(|ME>on2&$J8m05`i_tx@%lrBGNv9t#ZE*7O_y3l}$Iru$ z$$WerZs_OZl8@)U&{z2QX*cveKK_m8(#7lX$;S)Pl72pZF#7R#{+h(c-@sQMl^kt8 z{?ET8O}XQXk1s{#`z9YRM9t#!|LF1YFCYj~>Veuxq931F-iP`4IT)87`1nBkX9pjD z;?I1f2RCD}4O!EBhWFU;1Racs)M(_yV*f&PV$7*79ICu*TB z?ka>o-jY@IY5AA=oU^Ju9m^NPz-1S7sU4rgR;VKgu(3^DP$`6rTIX_YeX$6spY#rJgaGulsbp^Gq$xpnWmnz(YLG*+ic zJB^57T;@j{K$sNKnwbXRlbLqIm>3!3GGVI82&{-IUMCHxH8GpdNQ-tv(9*pf-X>q8 z?is&D3;kg90Nvx?;vf6nT)%i57TSK#gqw0{x&-^CO4=8rEkY4GyYWmC;ZekJkwL($NK7c z4L`wJtP3H@5%wHkNMhLI+Os97D)JU2flQGsD(L!v4J-4DrMmYXIf{s#>h~dRYa?#D4&nD* z8|?tudU(V4k{)>$!f=&C{RKVs6gl{gwv(fAMn`>iG>-XCcsT+|g%}^|-<|Y%Sl9379c{Sa9UZ)AB5o&??d>yKUc;D8;u&~GdC`E;%G$P-Z z=JV}*7vjx}(}JQIi4CG#{rh9Vtc%TAuw+IA!A}{C7pEc!B7mS3Kadv@J#GdbOjr_*A)5Q3*t_igdac?!J?3wo0#)c-9%!vruGxdG^dfUmSd z$M73;muZUkHhT9txwz5g=x@ZozKy)0LEkQ$li`wQ*x%gpYL z;N9?YlhB~&Pg0phBBfa{d>4M-CRn%&3?SBc(DlCV+w7V1A-af`<8oqj;0rwh5)%W@ z1R|FW#l%R=3S^dvPYgssWv;t>WUnX95mPLQZvM43MG|W>mnyb)>pd07%@BPaH(`C! z9JdThGrOq4?|l(LvSGjP+eQ#72ldBXQBy~bx~Fb1rm(&KQs;}OKFadx|B!jktn6sB z8;XvEL3&kwMKE%s8y5Cz1#oX>Lk`;dbjC%1o1$5E0~2fDbar6HWs%_p(Ki>!1t43- zRp8dWXpL;ge%Y|}b#Ni#;{$py|B)CYIo@naTlQP?pVq~W1;A;~?v*Rx!L$`{TiOcv zPLC_Vv{!&*efDbp=h*YVWIq%HXm+mwOits|1Wd6-wF##yXxrW3#y406JT4IDsG$b0~P?dzX4D>UlSWD0a znKKkZb5--^b-R}M!|r>r4EM(`Ahhzmko2Cq7f={vyr+(S2^99@VbY01MV4r7?itPeGZHvB)!bCd8#p)KIjM-RQn{DPuu)zH6q5zltq3Xa)!|g4V9Z0xWaV z4l9aqI!{5PATCt+V1ug+vX~s2ocAtHjO+R5V*VM0DN+s1Iq0js_T+%6jZ9~`BDPjG z2xmcPxrJZoZ=$;NkRq;8qEfgDD_v z!I|K<&oGFV+KnzW6f{;IDvCN+mELyBmsH9|D zVLlake>|T`@9t0JSLxOL_N?wjeW(w}ss`dhSUY(nrylGhdX$I=KVWUNA1vJD|O#1o{;1_-0W*IJ)EE3!g z=G|^Qiz_nk%;gdHS?2RL0GrR+^#}h@`Bdb7H6?ckc4SPVvJ{)Z&M&IZAo7i!=ioC| z&MJQXl=>|18ER!x5v_9d!C?-WPqcGe>E1c~r~dHBpK4et@j7YY;dNS@UPpb$05)v) z9oQmqPgp{?B&^T7@(aT^7BKIIA!qb;HzEZ!9kuhQ9moY)%t=bVHfyVtN-B>H)hsdx z3VZmYqFB*3y6{(M;u|UkKu}E0_KTNIab*sYQL}?LX)$CEf*+dh+e0l#K9i}VXA1$} zP1LSTHjxPkZ#BY?$Png8`otA6nnPTMho%h=M23Gd&W|H*WH`HWByT~s3U?7dR6@<7 zo!jPW2t*3zSV|gARD%Ux@3xdRc*S)LJbpi%tOd-PaSIiJFP>34 zW{dAV&zyU4m72*4(W;%>91yR$8Vuh)h?Y0R{*V$3*hS>e^3*?r=TMnZrmw*h`d@qj zL0^r3#@-`ignMQSd?Az>Ob&~|7#(mSk2v7Ybafh{<+8}gvzgqLdvc~-rTAhV+P5F# z*n!3lM;0aAU416?R_!PZmqt^FRYn_mkE=_%c?L=2&`#+QZ#T%Q*wnAE0+aD#%sXF$ zgz>2^jt1&68a{?YE{lvf+jK2M6{Az+i$Uk4iUOlSKVZHWlGH@n%o=2IxTM&9_O#Dx zVf3@uBf~przFjq!YIut~7@3mq?#v4pnF9H2k>-g%jnxEF<-qSAbFf^FM@VH~iBWK;&_Wzn$< zNwycM%q|1*_&J+{*@8ZO(l1J}ATU2PvC6xcE5g7kAOyq~V_*3s?v%I(1sq|H%W@4g zgN$~e#o&MmT!5MjkL5A9%_DN4WjGCl?9hE{xK8qsK+RK%6x{B7E{l@rW4s02PR+2O z>vjAz5^2z;egaaxoo|VZ8)>+(c|gPobtT|?t>zAHXBOjU9Z$03bnhbF+p3Adu?FOg zTa8qIS@;*-zR0`A+tS!R(ARYLDO$w9O6oMj$T@LOeghu6EaLWIp;RLaCAt7hoJ(>B zakv7Lw-$GB^4@sEHy7DYz`K_nTeI>K?Tv4!DS-1Y2*0mY%Z8vkjHyKrWJFI`XPPEfT!{a zTh=Dl#(DM+X^ZBz-~h*>`JYIO}y+E11Tt0d0%E|m~seVN<^LNeca5Igcvni=trXmAR0|f3br@2*fJnn0BH*G z4;Eab*r|CJ`JoLj<@E3^LkVS`2|KiN8(a-VYoYzGLs`R778l?y9Z965wp{GjeXTVY z3C+!J`;xD#=IrnlZj^u}7h9!^ELi{_$9>Z`cINQ*VZ3*+zo;P)&O#`eD|F14(X8eu z_5oVBNXN1seQp!}=D8Ylu?l)z6OP*Ax;l6C)Gi*mqSmoCu@32ISMzZ-o@hNOwvPVG z(IR&Y^@|_nGS|;V$QpQ3C-ZU2~6cv&*KIJGIxI` zlI7wPM$wCJ^2H-YMF+`3HWC8ZDM8=MHIpGeOEj@gw0heDNW_W=0%LsaIWBA+XDIMQ`@XyI|-Y3i!FpGp)>TpSetpi+|M zP@GiS^GP-))EcuVd(~Ju?bsLP9cKZMFti-NP}jifJByG&)19x2?O|8v1x5sG%UO(d zC#F19NBMf##b>UtdxLv5u4zmk?C)%_YQfqs#P(dS1=yTPgbRwL(N}kIco%n`8Hn7H zAL#t4{i4nVc0oAUGDTzfGBD*wWMmdVW&<0Wl*h$p9I5$=bCFxFK&2?PGC+#=nD7yJ ziEvw$x)qr3iTnSz)W)V0^wcAUiCQR&g0GmItj~_4P$z!29e#EC7 zoSRGK0f_$v-$qUg@2;a4Y4cZWm&yxTBg2)U|v?&A zd5&CBt;o)bqhYB1ZkJm$sX-t9pVS`B_X`b2ZRXxkXI5myFHrLVJb(y~cmV&0BBcY> zKQ63gns^n^aarT7;}(%8hv$P4}6gJnv?pjMOSqLtUuug1mgXvn$rx6F}6eR3Eca`SR z+sxP^*W!7nh(^=ZkZ7AeZ^Y?|_W8qA^+>kd${v~hY4inoZb^8WR4|~!u;q=9m?NKO zGG5Nw`Y`&^5QDz`fCsscn@KckaRsUz^m~VjC8&$dy0~_X-}}$M;wOk1ig95U`^Ae? zTp-LFa(`--FDR6oxoa8r`BJYSt^&hr_Cnc!{j9H%50;C1&WpcLjRx}#XacUw&ky}@ zG)l!uF6=mP<(B+ns0pxeO2Frk%x`j0Oj60_o9@`vNnp(z`+NZk@zlQnjv}rv;7btZ zkeg+^q7bTaBsBXf+u@n>5dKCknam#%_AA5`*E;%UG|s6Y6L7ApMW*2cq$12!?qME+tgl9_IhjfugC;!Ut3AHp9l%tj486E+}E z;)K=E=J+;FtLDCFv=*Tq4+BEJhh2<+GMLuqkq+*{&b0OhFy+wT!Ju$vtQoCkD~-@Q zS=GoX?XN5Xw+)W5s_d6#8nVW+ZmgNCl&rtzd({*A18O9zfK=J43VzguHx-MW9_oWw zAE;cgVm3qC!3wF#Cbl7Yv ziOLa+a`=GIo0uZk{h}ls_(e%)o)-B!%4wh(NR$0+K!BIxc9y7TT@UfGh;t5kE9JDq zY{Xt4k_Xzk*+?Re&dLw9dvvi{^SrRAW%s`~U_&*dp=EbfmL`_&dKr_gW%q{Fosb#W*3X zo)%lt+_Z4#;_4NUeEFg+wnWYPO&-i<7uG5|WL~yDZ)BG67eKCrWBvjIiQlhF#N!l? zKgYsKh5qGzW@N+#WA!iXs~*ES02{KEL$6>%+&e>Yqomss85-@QHJUqD<@4E!SuIx+A) ziGO|pEqyZnEg}AuIPnkbj~m=F3;%e;0Q_4@{42KcZ!+)?SD=L>{vobk68=@B}3Bp_s7FiCY*|VeY%Fw1!nZOQNt}&qy7IOAXNx~dZR}x3L z{3C&Kp3p2*BNgc^e&E16jcI1&x>apQYZbfzg7w+Yq6`7hI-{h zJy`1`)=Lupy?uZRN)(iRPC1lR{;*20EaHZ zA)5mVIAA<>)-aK6A4Nz63N`@+R}%%-HaFf@<>H^O=Kur&iW`0uMoJ6&_AX!o$hL!#4?+aX$E(jfX99K8P8Z zgopDJc*wIO;$gWz@;%_;n<;n*Yti-5FK)J%+(3q~_*xPk7E3%NObpBeBg%w|1A&Ts zE(sOCh8Kr6eNCZavrRx6bWp$qDo#s9#X?T7Jg&PELtF);kn7utKBRtRU5at9@vf7o z1O5kuk2OI7H7XpY%Te2piaRdKMqF2Tfk$TRPZ?k zimar>3)YTQR#Hsa2nCD~hlXs9#z@=E5)@G#8x#$j3YLhSnelKw*1v)mH8`0oC_zzn zc?M9#_-wMrCr%AHG8sV8Cg&xr?`$ffq5pWG5ix+v8C zwW_lOAR4DZ>D+R8bJOntq${+@Wiipl1+tLC#=&5(6*>r}n*=lL{&Da5C6vRGUp7Zi znUM)kTax)@bGQ6**r-Fn(?NAT;ps`dzXmYa`|C|`Kv65>1m0h>z1IGEhfD{Oq))K7 zvmf97n)R{w*OR-i(6QKGbJ3^luV0Y)MGkU*9Z>u0+4i$1`TqJ8NG>k3L*$dg&N?Lg z`%#bhcjE4^xxO6x>wOz+j5|s8*ABePN@+VukJKj~%l&l{{=JkuIB69;R{LurVaopc z>GiDZq3o|MIGkn|aI){OKl=V*;o+VUhk}P6%dfQri$((rg#G2dT1@vy8{73}r?I<9m)BKzwEJB;tI7py)K`)dmyzn&=U$n39&a%;`~ zwZ{GR5_~YZzivv|U$3$E(b#6=zJ}v&fBhKJ9i{WjUhl7e?>Q7a{cTlGc-p_e=K1v> zWU`c`{pN{xer@3^&#xPo+xQySCmh@Tbz%1v>LdH>du5W8L)%|pX+L|C@2?-bITQZ% z`uzI$ryLUg-QFYqoizLF6$po;IMvCwzg~l2GtRcBZC}&1ibwza+Q}yi4^+WEw7;%v zWoI77{`wNTfRlZH{qq|R3lINu(4pYrL*MNQ4^N)`_46{J2|3@%x4&+b$w(4y2Ob{# z^J^y_=Jl$AeP@4N*?0u^*XJe*>)&4|>>IkX2TGh@UwUmOJni-V`mzBBg{O;QF9Z8< z|F`3K`XsId#J6D1v4i$Muo`(DS74F~2R1sH{SIGr#0sH>xOcB6Za^%)SOA9Q^W_gO z(KZM{l3>ygzX9cbb!lY8x%6&&n8*F%>XAmoeI`vSD`=0tKwg|fA0t|8t?=%qm3JlL zm`LMEniD;mUyGZ3jWDJx)5M&(g}G<^N3oc)nk@_S2T(C(VP2B3Fo%(j z8PW5zXr=wo$%<*dzk5PVX)gUD z;82MnKn;SC$*}d>6OWe@ug^Z`XJ-CKWoCXkJsRm2iJ3N;#+73&bMrKxz7srkNTQ-`n#=XAR9 z_w>^6Jn1_Yr!=>i@dWQ-2q3p))CA3LS+wN6|OF9*cFB#_K-VaIG6Vu=;BHaucesC=h?m zdLq<>&niJNLnL7?=0(3Y34;}Ca2vjsnmp7Qp=qKljS%Tw7HWh&`zbWOFnuelJg{ds zeKF7MZ@}AP`zm*nk~T zfK9Nb{|WH{lOMtiS+%3Y12YoHhe7*=ZP`3wX%2?XJ`DSvsFc>q7chCgXDg=X!(7Wj*7vClo@o?XC|xFMyxD~O1*p#iI(g0JVI1_rm{-?Aq9X^+GZ*B=ey%OD; z1FO#@_zrZA(jsLLb}Qj16n#XNfLj6IkPXFJc)SC>)j;VmhtC0Q=SY)ytmqlR2wx+; zgA#V}18En3rPD4R*x!R`{8e=MuEj9fAbydWp2VmTb}4vghceWYUfviG~ia{9D)gXb;RX25fJwBL~t&&BJSn2@V^UxgHc z+4xHquva7?9U&gBA;w)~Uw$4Ht!iNZs{`26m zV%>8U>vkIU$5Guf>5uyqDwF;Ms?*&(i0~+?!?6TlGCn20n6wby`q#jw{~PTH|4~V{ z?H89zoBncP+4Pra-WPSTGuG5C+xCR+M+Z1iolI#VSs* zwlP0#`(eTl^L}Z1Aa?a&)?bEp7cwkNEk=^zY9yP#$YJ0whKH)o)qG1J2$tGxUJ8ON z(D|nc;OKfu=V|N@*Lcg=UoJJcOG%}>GW7?UpEm+dtP=_lqCksH0G0pHQ}+alz>9%v zh=x1g!hhe(QBjDW2p_=L~_v`XD7X6;=VNf%ir+44cdpJe>tP0Tg2`LuRk?0 z6JGc0UkKPe>R*TlPW{XB|F%Kl!-nNa%Z>tEvadntNhO8rv! zxdiQFtA9yD@4J!qCB;PMAoMRl@aQ;MLcjjS&R^1N{mTR6Y%H(s3Cp|HzwE^GPAorE z{mW%0i2Y{D7K8I(uZ&zjWvJ zaop-(9{h49`0u^`<$XMF!~dwm)4!On^&kPd;q(5|4EW!#e>tN1m(%~#Ubb`VpkM!TK>f=bg*Ip(n*QZ$7h-}tWzy9T*^)H|F+E{*Q`j=^V-ihUhs()FwrdurULI2Y7R*gVTE`xu{$>9?{rZ<9WdCwr zCiw5Y{-p}f+wgyw`j;ikdXNCAe7=h&@M2I)VI2S4#z+Kk)eWFLXabk#yW6i zc@Nf&GA=8=mf@#tVdm=IcHU3v2iwCEWbhO9bSk3N<7!-#4o7~092l@lMW|xiI9`(( z{F<9)?pmUI5tkjg7i3loUt@AEizbFGhOK%NZPlSNw1O2km)@~!H(yMT0fZnmM12=N z(Hp6dmuV3t%HT#dqY@UwhA1zN&d5h!8;tpt$-nTA zq4&%p6dw?eOEaoSB_ha{z#rvJX@`b%N;(b3VFM=Pcjh6!NLJWh_D*{eQamKcXpVa@ z9aMsh*D%&q6{OE zC_@_7O|}zdxH9`O-OhesiT=o)a3q2~BlG)B7VlZ{<6)t?Av$1QS_d$CzHELdPtEE)^TE()bbYaGQ`dY;sD z8UgW7>F0zX$+q#Nk#KbycgU_z0am{j)#pf6BK~mpiw4LUo?Nb(4PykhE^7zrB3 zKiZC)(Y0D^l}fIGY!aBl5+E>r$7S?$GMs5P7zR0rILo(TO29hxx%^s`XyrE$k3Z6m zZ^`*KE<~OU^jI`@wwfRa1$wrvQ%AN9(Uu$xSti>+_Ssjb{y|RDBAkh+oP6j!4k{;R zP~4Oa$Ah83Mn94gYe+j16ra#&CJvXPEV$-*UQm#hl%fO?u$YJEEQJPZ>`dxk_Yzs(8}NR6OZ(;4#+D+vzc8b>|8LLokgMFJXRY)gMSJ zitHl=@aDS0&diBG>c|V$oN%W$8C0wlvi-#TH7qe9tB#e6Bjo=)_KlUqy-(*YpRa(Mt0j?iV_*pJnDZ+0`s_-Lp zW)ObA!{rp=cjsr(<$yFP<7}@hr|_e|D$43G`FC`1W5+wjtynGD5lz+3;YO*Ws+)pH=pk)!0CIy{tVoV4<#Nj3u zhh6DV;E;j{MUMn32xyKK>5zn#acMG{l8`NrOO;ef2#;O}80pa~C1JUggl5Ez#MhZp zM%`&M0$UQ6$gI-H9T3mgg!64F54YE*b%?zW$Sf6`l3U@Bij(8@x20lkM!=d^QowuX^Fv- zjRb^X$s)&EikRdQl9>b`Cja9{>{;cGdEH@`t6Rl*)*WmXVj6zHSp7gr!i z0Zn_nXGo@rW%VGRn+ke>5A9 zv0Z6|XKi=-I4M6VP=~Qi8S3YdpQs=G2eH+Rk5-BhwcYcQgsA177ay$@A()Ocnd3e*N<=7B&>O3qV`u4Qtb-sI(>mmXsWm(YGJB{vUp z@_+!8+o6P0lk<-1oR zefN~Ko!9gJl!a%Ow>Rdf1z^it!fUVPEwK{)%TPt)Hi}n63}tTbd!!!6mdGiBb|b{{ znFq>1lwCz`ERN`w)D4yJ`iXYF6VWhI75_6JPtT;u6=5&WdL36A3^o+@+uivE`ExA&`) zAyS-5M>hTA*5BIWLHWA+j`aHUG5xJgjBJ_uSy|;n(%;%eQHs7)$(E~P`t`TK>CE!+ zYeUrpIcWKKvgmJL$VLbCUi9^-zx~Aj9ftmP(1^JFJHhq0uM9z#C-$StYVg4O(ZpW# z>D9GyVu{Y|DSF)kE#1b>%4RQ@b2U# z-+m(LZ+|}ky_}Gj$D97v#$&+oIp0>R%b`a@02eB4>!G8984N$3==xiy{LHx}twWsh z)9#HFA$oN6xAu5R`yeY*jbp%UYkUlsZU5Sr^tbX@)81?T;U=f5_3-q!vS3Qn>yipR z68hU7+(ck(9 z#pUsdufHv3haZ3X+cnqQ;^ri>zjeyn)d;rOm-M$K8S2x=^|z64vI`Gee>>h$OuzmX zJC@A*(I4$RMEQ8K=x_JGcTl3QNB!-UKRXQlt$+V%Sw<0jL+bKRaQ&^1U7pyF9!L7y zHCNm4uPQBfp3eOz6@t&k6@n?Jm?wz+ty3O0T$R=#&i&^x*Wc!4sNeCSzrB@-U5=3c z_AEzP{rcM;^|zOAO_rC`1@`N2yR*M-?941Y*=q-@zx~wx-E1Da(cgY*S9kJ~Z$FXr zx5L=W33+)O>u>M7+!hycJIIq;e_J~-twWsh^O);z+k@%#bI4EBudmtPCh2d_LG^i% zNkm9BbFL+Mt1Xe{v$Tsmko|33f4e;3EVN&L%QSe0Y=8U4TgmdaUw?Zj`rEPW#lzR% z-v8rnL~xJ#TkAZv{@qOSSQj&q>T?Ul7f-i?bZ*t)3-<_-Qs=P8e1} zx#L*QrL=CI9NIFlx#^BwNGP@pU&lqqy@}3_xa;vo5|38XT#W!uMEV6NYE0 z_znJ|w{)>A)a9=EWT;`U3ig1ESB)rcOy?lRdl;jS{jJJJ^(o6wM*PqbSwZUIk&G7Z z!HLKUPuNZ}*G#q}D=a{j=vexZC$tnFnV*c8;!ZN45%3cThz{}hguj*LA5)C;)n8AD z#h4zW!#!)$_E^lrGu3+uj$bgvDl5FgrXeutk4W=eJyHUrcN5mU+N^foe+eA=N5ivp zw4I+cEdikx9yce}#tgA#zCBax;*KN+oXFMVPtlN+?L3XY;6WT!}uSG-i<9)5g1m;o?{_pXyQ0H*bKwi#Fjj(2F-&sRm#g{vNms6={)zD%FiV% z{aj*INR;@fbncSz24vwvKYO28Z@A!oJ68YFzUt32M=ZMPhpz#ya6EbjQb}Pa>s?{E z79pm986KW*`dX{9RZ`fgf05G_u0-0iKp-pvB%9R4THQ4TzWi_~<1e4vK4; z8(Z@>5R45M0x$S|TL@;Fr*ysPT80*tB=ALKaYT!ai0L*%Te7O(d3$dJRor<^3iwcJtkRW#;(ELpFg{SUR6l>Q` z5<`+cBi7=Zg2)cD;kC)y{wK@=<$F0}6gwCc*9S`~OTA?)+9*w88& zF@hq{yTS|qyLhs&T&DdU;b;kBRy6y4Z%-8|&aV&8&Mf&2(b%~mN&2VfkF@3gKf9Oz zn-5a{w{sYKl>g9^_fGydQ@p0h|3T<0-7`M!AbU{q|CNK6|J$VeA4K`TCtdzysp(_? zpOXLQ^;-V_5tCIq$!3)QFQSFr%KuH>$^Wle^29Z36TR`JJi(v9z0$mjV$V`Crio|3f}UA`%6FS4J}uFL!8U9@`HjG4~rkP_KNPa-> z9~4~~^#gi-MRJU(?#Y1)n4uVE4`HUB&gX6qoI4{wNDZLjL>?%v)ioD1Nw&V3%GC>ZWyI*cwcL+@r)|23^uk~r86>z+8M&{Q^YxC#*dT%^*c?DURp#Ad-UQNuakHKM-RLqK6+M24K;d7k)!#*8*aCF0|(C1AS5*s zTSKnP3`&GJb=W&b$$H|2R3bQLVw^ez@+%~7V22OQOJfiJYH1U$mfD2J93@KjfTuY_ zlBmPLp!h&dd9VXB;+|)^kgp!VWHE_ehINnuH7L$A2h^zOE}%wGDIK6&(XF)8w$dRb zrp79zbYK{(r&ptkFep?yFs25S4(M#DZ$MlPti{l#uQ`)qPgW|2vb4Y&A1Xev0LAsh zC!p6`7Cm)E4}7A{(l_j5c`UcgiSC?hx6S7rl`i51h`i6{r zV)WF*<`bXVkeN@MaOVwMmuBV@gwXEzL|;B{u>6B~-f+bQ*8cTmK5ww>>3H6touAwv zBo7qO$Mn1*K3?mhzy4x!{aCkqNgMjWc>}k}spkzl3KD98gFSDM<=N*AzjGASf8Nle zKH=1sxcooa&KsU;&Mf~a-qYp(@p9hq>Y~i@U$!bu{`c;@Vf1$oU;eM^UjCm@=M7t% z4qpEE<@1KPJc0cGyd_T@+TVMrK{%Pt8!Y)hj`IIslKX@5AH8vG&l}?71^JH@EmDrA zk5`-p9Q*SI2NQ@Z4gQIQC-wnBY762@gC5TtlK8;Gj^YmHykRx%4AwUP`nD?fQ2w1X zG$+G(Lxc0YVW}0u<3u@c*!EnUADnFG4fnI@C)|0%bALT7evnZ=kbTo(^MemsGxLKJ z?!007vzhq;`B``Rfxdj+V96VvH(WSM${VLX-J!3RJ7cnilk2>};tM=)I33AjAkCcp zlS~mrlmVmHm(Ck9QHRGz9)a@)i#@3GhHp4Z>_2bFKfLpX zUp(CdpE$A48%o*q417Xr=F{vOkC*d?DSyn&CuFPA^bNf`Z&-NkVe^UKzL1$uoN(t2 zk35x`Pn-bf4W}btjNJY8pEnHWc|#U5yEyxU_GkvN&1BfM?wAP4LzPW{NnMr{6E>w8%o*q4D$c@K5v-v`^@tHaLyYRUUB&H z|C#RP{|R;8@W^8aFaM8|^M=!rr$)-Vbp5q0_D+2N21|dy^M)*>k#Y7%vhpCE1bi(1 z4Nm!gYI6Og{Kp@h4^ep_tq%I;dBgte;o#rT=n2uQGQOWbS?{l7nzp0zetKs{ z*T?o}Xg`0l+ke#FFZ=(h#QWiBnW6vdKqih(`(^*H-yd(km&W5jbRd&>E1?vAl6-lo4X(vYu_7Z8g@3*9*y zL0SAwns|WG*fehw;~(S|EkU*N{RnC{o)OauH4z$)pZT7h_{^{=xIEevm%z1J&o9=2 zq6M07*R&}N?FIDf(nN<0?NNuSmj-Y)-bw{3-RwxF@4QdaGu9I@GjqV`GqzA!oX^9vR(q%9b=sP zx)}Med^caLg<50s&DHlB0-k-%<=Tzf4chhEbvNE{{Wl##;pCkUv)ScGcs`sj%RB<} z;ZOJV&xem0AMR(DAL03Mu`Kfl%!l9pq_570SzD4pgrJpHp5^VhO0?N0#)(_XsGAU zfH0ucv1JYX+r3ScE-gJsmqICB#vp#3k}kSKy6j0vmttGGl<9~gI!^O#oA&RNE)a~6 zE;|?tA|9Vfyrzi_kT2&(KfxgqE0g5Qy;^v5tOfF=Sjv}elrK-`N6|r+d_nP)FWcFL zlk&$^r%JGN4R}g*SUY3b8nEs*${9Xw0;`_TM7HgtGN*9Ikp1Nn{GgI=*=j&o8 zghR>H&j|f12wY%^neRw3vod-^WPhx)h$U8t!P;2&Y1LOyh#+Lf6>hqu&oCkr-KOg$ z_HZ7aiLSr{D%NaU%_z#IF1!h`1>>?Qd0iy`k;$D<)nCG@8 zS6mCVSv9W@$Pf{2#;j&eqjVv4K>5@^|E&4<)ICRj{@ozUJaY5z^&cPP{0oZy`FEV) z-<25KBaMIi!z}a2&A%Jw9pwC5fd~3J{>=k$CU4m+nG2bU5L@<^ZL?o)+1^%LHZ2#j zS;^C8fc+Sgn+yiqhWu6gIa{()0#8EdEG1r>4=7%X{l3jgyq4MG75l+XQ-mlx{>oh- z-!wTPZw*`CRzNQn@cZ7Mb~|I&lpvBgwl)>mN{Q|E{z()2#d^rw3!=Z7Yt6S+;0Yn& z4q-p{6Mwi+lN&k%0v9DsT}6Sr(S9*>V*$p&YR3i0(_+fo)vOTZ?ac+ziLy*cM{7S< zD8^ww2cd86=MeE#Zs+b!$bY?PAL2?O046qcXUPp60^_WVzF&{p`4*`S9R>v|U`{pXajKW#$|Oq6HqbkhW#lkJ%&nF6N2FwQ zYKfT3{W*sY;ffGVIikf7tej006LRs1Jzxr~ z{yFU2%PT35ojRTo)RL8Ua`z8bIUF4a8MV~!fy9psCd)h$>+8YU$MyOe6#7`!*JHZeH+0(?ZC7R3x@6jrKg zpjeocKN2*+1VbWMvr?>-BIq&0m_Ce4$i>1GE5%kOm%H)}Em9f-o48H`Z^^}nLc`Ta zdI1GZUB1-NG=YrZG$5g&!Fi=(k<`2M3_uYO>j+?szvx3~Xf)6GRwQFVN#!g_9s;1G z4!nI*^uK?IeoxEFLPdrQxe5vb^N%b(#{&b&lr)eB9yFl9G81)`#|ITAZmC7P*emn# zFCUQ%>Lz4tF|m@e#UejcKLx0NY%v%Wv{d)V+$AVyobGF%h7=f83??20RV@=+{Gux$ zb|myen%FD(>Q|!g-Nh+sCqr0eoJ-z1N4V#N-9Pq+^AM}Q{uOf8x2Hny|A?%s>}7D) zN$3*N)*RHIxf+U5|8W?s5^7o4$6*Z$mu1nP$X8(blU9zg8RSY$v_e}Hr);y)&NzQ% zjX1DOD4~mgnywdRK8d0rP7P4v7w<%+kxxRNOXT8B)ct_QZkIH6k(0)b0f#NG8ObDFwieZSP{5?I3~zLIjD);ZJ46AmY=Q66MpdzMtZy- zmrPND`JkUVWM!dz|6bO*2sEql;Iu>3qeJ#H%0Hpu~Q>O2ex`?3WV`uP&%YtNQWk$n&c? zRh%xVS?~HbzgjyDbw0Xyb-R4Uk;JPNcc9Y!c$J1%SFvACIK28%C0ccK@rw4HInur> z*{G|8$IJ`BtdI{f=-LE(Q(c%i0|4*7BHJ(i#I1!HnUdcH-TEm!t}oO=`v*_^Avl{r*u1Qt@1jvX?aS^Gr!0!YQVmU+Xw9hJU>7WEAuG7D0f3i>)Sz-u6$mt#jla}<8_Tc1BE+h{+jYHj#l z^Mq#LTmq-+sD~le;ndOat`0<|VGB8UY$^UWc^-r@SA*34d+N_Yu^|0<2JLZUOMdPP zMcq|nLeZ?MvqD{2)!z<80{NqZwCq}E!no^quf}4Xqf;)1{*H^EOu2Z&Myje;8^|Gq z^pMyd2gFW|hx-FekG|FjedL~YzFm22&rmPJyOMhvBi3lRUN%Czvpqj;(8Bd>cn9J! zp|ro7p_t1vXBGV=cg1#Nok@lK102jSuA+k(xZiw{+^JP7e!|$q`?Q)}FdAW@O!-Ys}ggiwzi1 z^C`SO+wcxC8oONK34yi=26_!!4_u5~w(r((g`1!CaIrCKcQ+5v7?n4fkuhguni=Bt zTf@d+BQzm9+do!Lzp5eD++%0e;&wR$4c`Z996bMldG(5#S9Q0bUcty+`Rz{q!6M8e z%tlRgih*NYp8AV$liZ8S9Ei=)AAfIu%pM4x>KXN#@Z*X)4ab%bi6>IyC>_6Db_?*nIR z>(9aT?3lS1PDTU?9Mf@aW9ARRLW5QaJI{NhP6l7?CaeZDmsdg}_1PkrW>>TxdJ5xmr!}eIVkubN%8ML`8yWu^BPCh>Fk} z!OF&rj4WWmWm;&@;Ay8>7`YJ`xv_Jw_E&h01Pl)dx^{S1OHGC5ZRIAp#JeZ}ysgk&Yh0~Bv<5u45dRMl8?E*2d2o^8dc6~n zW_0NwKJENb-Dvn;_JsBT(gciMr)7CpXn*7IY2Kx=M$NZ;+Az`RZ4#?Z*P6~jNUZBx z&-2~J*y2!^Yw9p!-at>?ANc@|&46)+jdAB|-nObUG+$fw?L;oa0=P4xz_QOdul)8c zT*+}>DcVFZS{#Qq1JEYhV|et%04_IetkBcMs1mz5oY(BI&Vfak1IyCDj!ky}9*orS z4kl3ZEw|Hy20W!uED?xg){eau3W+-JgqH=8v1Y1YwEDemy0=9G8fs#--`70tbWDc^ zyci3QNmffbVTHS%RV%}JPEYCBgF*7nTX2g~jXH^daUP1?mJfzb% zS;JxhWIIZP4iPyHIiPAIH!u1^Vt-^~DpSEEba2{>X?+Wiyn0kXfU`l%uBgSdX@v>)6Vsd+CuOi+cm#nA0 z1)sW|EK=JSU3KgJm^Ffa@e)T)hiM{5(TG%JfYmdTVKrySKG_01OGqtR0@>g;BEfz9 z)>}X|T(7Ay5#*>$ zJ?r?x%Y-XciWk+40FtM}CrTGrfZy$~ExUuFLxf2ygRYmEkG@zrcm`l-UWUV&GibF1 zfq2PwazW6d!P8FFd`pmOeF^vEa`RnCektY*MKA#sOxa!{PeM^JleuC$u7@9$EC(;oyEHO#w3s7z<~;jE3TwZ2l`?z-ZRE~e zZp%Y=%U$_e?zeH-x4UL2o*tv4+IfE8rkYckVY7r=@CMd$VnHx+8JPTd9I>qlh+B&_ z?*?7ejPb6CAvd0~M_ZVUJN58?kQHl52f=mR~@6nJjjg)n+Afb(KWc8yLnNxhMIE%Ue&YQQ_y`KC!G|6hYh z#aoTYolr$kLBai?Wb|T)Lp`B<%{=wY(Jn>4Lp|ZCYebo(@81D^_tfX(9_TyRhZpne zIr8dhxJuFv<%QgK!jQ2Oq`E`q7f-&vXg97uhcZ*{|NZ;8{wUw2O2>$|Rh=zMe=_~< zFTRV;pP5ob_7+^cCFSDIw{Y=ttI#nl^epZ}ZcMrDt~YR-t!uH{aLwOw(bl!t7fYEB zIId_h#GbgKr3tzQ_q4B&Qel^ZVZzqK9wO7bg8CM2XPqjS@EoaenJDSlM!Bz;$>(9a z0QJ_=fM|1STbfMYJ}6S^*CcCOjM%DlZHv4Wika&5+(bwf9M(+(x)NvDPA$u#Xze$Z ztmca`wRQ!)ADE%WcC4rAw;?fVZgb-gZubwsreJ^>+MiQ%iy?x!W@P+!d0i@7%*a*A zJB$*0hhf`y_F{h#%tdoeu|Ar!cW*3^Rh?_X(uw+(PoomhxA<`i4~2_A(B`)kF1SjC ziyp3ouEForxMX-_Aezp*0+E7Irg$v?MF*ECiED*o$o}l?&>;i>y7*TTdCHMYbd zlIb!c5n)JfxVZ^106f`ZHIl?iWb$=MP$CS4KFWqRGU7g+IJ5~bf`e!~{!vf_Oftnr zK$6`*geL94*tEU@Gt$PUhxx_Erf>3#jZJ6si;Yb?{ze~QZf3<|3y`j`04cODjzD5qeB2trRFRi8y;wp^(DkPM3r#ECe}=u@(SG_FAAikm{?q zEcI0>b{)aUo$XG0VEbNx7Peu2@jjqS>9Iy|k3yRYsmEFrZ7L`9DuF~HlE=MP1L|W$ zX1IgCccCRt1q}7_;p+yZ2(x!>M$+Lv!U%*=QYLLdiAHS;b|~*+jez zVM3v;L0^Znxl(^+H?L#TN7z?lPl~xTrhZA)V0!-gVNU&^+=Jm8R97p}Rrseld`i&! zTDTPZutm^W&2a3%z6qU=?V6p$CzO{HxdaKsED{LV@6#rT65F6oe>a707y2sz$2&~Q z0PJLH@l^(pkQ$|6b^!OwHl$+ zS|~|}OC#drp6W3c-4K_!@jMW+p0Cz%RaM9U_sJDAFp-xlm2t9<0$9 zomAm9R09@Sqk^*~f%{PT|GIFw)P<+%Jg$8!7$zu3$1CVb)WtM-B_&_6GU zC(KUpgxMu><$@s$&rXnq>^xpA0b?+|jUWwji84v_)+|qbsa&GUTafxN_Af_}{Gc75 zZGP~ICo~j;1ML{;0gg|eLr+4|ucWGP>9kXk0ecd=d{TZHm3>f-a7-*^-zgvv(DjAz z2xjg$D*Fm8WuMI$n#mZNJ@qt+N-&0IG6q~d4_7II3#Gx>I{LDY{Vw#nHe+yH-*FSJ z+l;|+{pD}sdNN~ZCSyS9ZD>hK>7SW|ow8&Mjv`)y8=+zhj*E?cTy!voW-^B6>Y9`S zPq`SkNygxKwgtJp6=QH*d=d#v6DrJGI5YQX3sFU$&L|z`6njQ+q~ze*LnjrO7JEph z4(hO`NKyw{JNlLa)HvJol%mnrUDEFCtCN(7@2JCDr3Q1as|Kn}xPIuO&3>2P+pL4I z+v?1wX{S-dS-Q+J>c&>HZsj;Rldq@*$*9TqjMC8(Tb~ISb?7qfp6YrezB8E-=(SZ8rWvP zB!O|B*{zh#Qs?^|K5?;RTx3#*!9}*QjEiiB+uD_3OhFbm+N$56Z!4*YbDnpe!8slj zICPLyy3cu39d{l+^ofN4E#P`_R&2sqaM$mJ2hxSoiadW5G9GLN1p${r?%i*z5H=ezDi>oM9dmfB|`eyC}v?C8wL zkMS>Oct+LYp#id%b`hRY0}S6Ao=~luTkl4i^1!~4n~ak9Ie^Jnd{8&xjOd{T90t$| zvH;eK8f^K_NZ8=DL~ru%k5Su4VvD_{bE{u9mWL;!aClNR$P`VTCDs-hmS8YoTps=B z9~~mgzS#5!hsd%o{^I{)@+AmmH;kql*dlkq(8mbH+|%H%zs!vMu*>ARQd0)2Mdhv6 zfrEvZ3cQCH5U`~&>bF$|ReMeE2B|!Ju(5t+6*i5w_OK;drvqIgC2kX{`>CTM6F!U# zFWKpNe!XkWB@uUtuj%e#rs$HLi|W|zFShNPirN0N(SA=oH`Z)^F}S?d{OD75^Bor# zJ!v=Jaq*W=FidL$&kv?v%&kjtWW@7tV^6eG^E|&K)VK*%YH_VDjSQdVTYC3MGve<; zwM@|wxAP>)pN&|ipz%-V|BiLRE{eNHOm8TH#z@8bzwWL6Ebfb~giR7OOR2Y2Ly4=FLBvnf%?7-|UJPDVk`E5X*gN_IZRm%=IMWmxqHn$l^=;M-FwVqA zP#I^YY|XJ|2FM*g6uh^F%W+gNK07@6z+3rXWZcEnVnZLwjx@y^@m;-ttXhjz+4e$Y zw=CdYn5Y3C!dKE*R?Zuz?PA?GU_2CzRJYHkg@TCxP&E3VGT#o;G;SV?uWl}D1QyUO#AP`{N7j(TF6s54!ya{%iKUb0=*u~wf zaam+!9yQLB4``jKiLrP9mUy$fP_{b9e#Cl@kqzxN3^PsFZe^HRL4!@qc1 z8*Rd*ZiiNxvkB|aTAQvnI!`ep!7dfFO&Vifi6dO9Xkk+BMbCA45#dCRUnYZ0(*<+i zxItzK?J=t_qTXV%G;CavQ90NW%_||pQYQ|aG3+qTEz63tERJ^Gma0*{ma4%;YXSBX zh<0T*+AWP<`htyij*IJ`wb9OTaq^$3i%{=@V6id349znv%*P?Bst>SVVi&+)sdO?4 z0NH^ZO~C&E&~LRIZ@8E{&yyezVE67_#r~t&pHgqb>6}KIQoX&w(REizAKuHm?K+Es zwM5^(xVPd1EyFyQT?=J-x!tD;>;JpipXGLcu8e;4oZX*}i}io8`_pkT=b41`D3%J^ zo}|a86VijdO}T-yZ`pGjWzRh)qv=Sw@g4R6EWN$!y{jQK0BXJ$|37=*0v}a%=btbm zM2t>Qs!>tWnziV#H44_GLp3+d;2oL4pgf|2q?KY?AEc0k*or)ofYZaQwA!M5X}9jy z?%J)pT8oy}JV^ip1eB*#K>K%Me4w`SQs)2t{?5HKcP8N>wOi}rM>6-Gd+)jDp2zR^ zJKx_+z_S7qv(bfFO;8v*44Gmt02GF=7tF?MhQex;_N@j0u}Q##R~7c7eQP_EPeI@2 zIlJ({NG>6A5gY~ygMoFx>JzLZ2-Z=aplQN7rtprVu#Q5Tb#UB|%06JiPAd86jt}BN z2m3fH2<{NnSg;Wp6EZ9`n8hTYWFS0FGLXKW=!cHvU7(v_=XxfCe~^{LaEW|mL}QTP zoKYl`w`zbz2J~bH4UpMxuab~&zh`lb)D*#|g3&v6CTdFJy&NcQ-wI0MU2WU9W}~Yy zT4J;90)eobgV}D^ZYgy<3+M9<0(jQo=;*WmH6QG@5Pp(_1BzA%yYrDG93kI_PNsBv zNOf9F>GGF8(BFX0Ndlbgs#LqyBXz1koCi&a;C5enQncPVk%NoR7k9Ms7aAZ;qSa%(?ud@|(67KOOug z4ezSeM#8WT);1l_0_XvN1S=ocJM{i4qg^m;)5eH7@UXGb?6cG&G5*0$q+FZuGY@+__o#z8~tBlwLlc^X#Z*wTK} zbZQjJ^H}~rD7U~dIF7>FXKifF2H5+))VuuWohWbZU9LJ%{&;Hrm!tk6zP9Q~X?1&A zaPR!yb-YFkt=rOW-mn~nlN_zS0=1rxZEh0MEEGpzY4!wYQ?(Y(QFzIJp-{M_qwt(x z>Q1w_x3G1CP=8P$&5Izahp{??-sgdx^nx@ktKdQrWT)qs63^9m<~SSAe8IvqjfPGq zpt&;k#tb7?kMkCgYq@K%b!_^a(at8-T;qy`wcsLKXFA9o>)Ll$ zZ^hoT5&e|}Yw2%6P^<%`;pjMkwJ!&~F9m543p=cDaM$h5Paw8m;{|)$?MK=lIMxTF z$p4e#PI{HS@t$$){-l6!fl|H@%U?@*Xleq!%?-j7H)z><8!+}ZENgF;CpX{$#|FI5 zNAwOnkQI*RUlmj@h2XJ5@<@EIRIFoYoSU%rzKHXD+;9$+>=+fc$#+)52#b8h+Xc2F ztR%}a2S1#d_bR->HnRk0fmKq0a2KJ^a6M@uQ9J^B+50_AH;cXej>i^zna5*`y^Q9u z#a_A}6y$5F9_k#>Z?|#+y|P9mygYk;pj85G^E?$(IO04BMe~R9OYD!soZ&RVR|OMh+&dj#*We|< zy=Wh>gb;!dK(mJKYQ*@%i2Ec2+6%xF3c^pro3<&pC(wz24N(8JguQTC@*WAYLH5mTljx?YS#* z5ja51xoZs<6p?gBaCPIMQmi`Ib0dcQaBIgiBPkgcC+xs~ zkMmX9>?S+YbCcQA);Lj9M+p@X}FOSugf3?;eSA)|qyH*FU5D-;%Xs3t*XS zk59YvtP6o=2+roMNS&i-}11p?mg~_8fx3-X3lay){MF1p5fsW66mbkR<#d zKeR%y*$;=XOq3qbcocX$4BuKy=aC$Im~+EB&^GCxEIJR#>w~dh+iUDa=fSam=bs!B z=4Yb;QJF(e{X#-#o*h&%J@K@RDf7Y(2I8rwbWb_&R*@vfqScn?lS96|9Hkr+GdVBL z{u0KS9-V3BU6-M}rFZ!=Akp2NUsml7*>ZF5yANJ~yXW>Ue-fI^o{F?r{`4~_yxywU zAy>}p{roGZ+Oxy)DL+NlO+7mtg^_qtt}G&EjcBRAvW);lu0$udx@^JnOcMsa=;*N8 z#W^JUe-SA)VF=cJfapy%Xpl?=WSgRO$WENY2h{t5rOoLQZBD7B%_&c4b1(zCpv|ez zpN|K^zC#X$PB1z-snBT)sRKdZCQ;}VfSwnMp}*z^O9Y?C9M(eSACcHggv_sn&=5lR zWatdxq^$$K5@cX8%Q`^Ea0*7#0+)Q*mNbuQ?|+8Kmz!d(EwH__-WSZg0a~VSX4$3! zX9iXOpf{6d|3<`sq-luZKS~*FLu-2aJFNcuxL=Ez{ln4Wmsmc9B+9~|w3OLDDP&%Z zDGheVVWW^)riDze<=(uWeub1Whr?hywj8zeZTC;@rqk>nj1Ds9(qrRqKe*Sy-)`WE z&EJObMBCqW#$HA`lLUYJADkrlnqdo>2~&Ryx=0xL({->7+>D;gWhpGJ%w}nnP$-eu z14B`h{l>w8)xY?}+T_s5{)85i(=Gmxf)^99!04ZzoP3%vESP;g4p}ugtG55&iBlN= zGv>>Ir1?MQyoBh%oDaG-+HXrTL(js8_zuyA-G`&Y^27vP+?proWP$xv)QB+=T!93A zk;(stmSV-3HnZoPq~-s4P0490IzH9kR*!{0#Dq+hWDh?P*;^9%rHA@4_KH0X*=>vd zpKuB-n@JCK|Lb0UnpR8)y@x<`(B@%`Hv@irxa4Y(P*2FGe-HU|Q@vyTKExAy{Z8SD zy?%%C#FkIrMamF+dMDTMr(8Y_pO^gTk6S+d?6)8(^d+Bu6Xku$r${7pZ1U;kuRttF zmrp-;0}9jS(^JQz@EGOO@0z$bT|S*sj6#7d9rEebg`Wobbo{x0ANlm;T8wjF^65;J z_a&d+it=NYPkqyHcOUYpYcd8hT|Rwl914$3KAk2)?a0?s-B! z)llePEuZE;lVtoSSpAvG+N&!*p-l(97JhxK_gQ0cjFc8LGI+$gLwVt;RnsbD`fL$hoT3aq7 zdpsq3pkvP$z%-wLsi86?j&(p)!f18_z)w~S_YU7KY=wv8-!O3?sS<5?o)yR%{vrru zy*=RFY7nh!kto)%ug`mJ4-X(9 zHUxf_`y)RQH<8cDHGO>MQWIOOCva8A+qS9@Cy^gZkf>(uBqEVBO3@yT)dvx%fKDPC z98Mwyy`4l5U*HTXJGWa-BKb}YajKI@i-ymjC)IFYXRMj-k0PEp3V$-sW)HL?g>ZX{rA{C;V8WG z?j$R|P|O>9Tl}uH{Y5L-6vRMI|5O|4bA0NzL&WlupW4asl|gqDK8EqNP_g8l zb>B{Y>g5_0n|#3G7PFF0G10+G;THqT=Bqg&5S$qUAcz>CO2{maivtH0SsncNxBRGuItfd0uo3onm+<8dZV5-U>#i z<_5iQ&>`l|qz(%z-<%qR*E)q!%UOI_^{U?ny`1*!N3n0_JA1T?%nPx`C+H&MwZoV9 zsRsi#g*MwNRs^ZVaiqX@lIimihl=$|o4jBdQG>>Awlrv>KJym|9jZFnCQe!QU4B@y z+H`>s1?^(YQ>h2 z?=|PgHUNf(IHQSm_f6VXc{pI1VcLOagXKWeh#nTY9B76E4W^#uJ@Y|OwQKL0inRDp zDgKka`Qd^$G$Qv@(qCqm_{;oR`^$VI=`S-b;V&~x^yx?QmqC>9kKiv;nc^=4eIfj1 zTEXM`@|Ssu{xaj7{xY+zkVbv_%XFp%Fc*KBHd_JW@Rva#a9FIbP5R4J+R87OyTtZn z6R6i**tVf}_{$`GI|^Y)l;$r}rp;x7YIW=!Ws^Wh;lC}mNuZ;!puSK0Whf5!9l>Ab zdEpCvSQi=E;mGor(IOD}VPF0-&qI3zf0@oc{AFH%`or!zhrdjpT_-XqyY4rq^vOE= zaJNkLmnrY7QI4#i+l*0-?kz6I>qWOAW!7CG5m^g(;fW& zR8OK8593LMUV2eHiE4wsKiB+|9k1;0{zNbI;ZKC*9k6Z^f1;NX{zMMTrkjG2Fhu*J z9+vf9ZnNH_>YJd?g+I{?u?fGVJ=3&=Jrf*RkmW|l~jkKad0R?cZx&N9uXony%+Pal)mh~2c}Hu6gU+9xete; zm3=!DrRh&j@MCR_0)vDEQ#odSTz=BW!H=(5YLiF@>un&Dw*6lyaguX4f~nYZ-QmCb zkI0Yz$^AFu#|Qq!?oS8nz5F|Ne>w^)!G~;?^9ka|C%gW3{CG#y?i>f}&7}k*lg&|h zJ%m5Ib58K%kIau-e|CZ&A2&Z90LwB+2=MPcW_~>3kxvCbo_PJF$;Jd@qA|&sY^pcR zx;JV=>MO9f-EXSuiiEpW(DjZPsfP6QwJj!$hs{Xf2_VLU)ne^y6^_xwcA!sOtpbnr z3}_ELrVVT#PB>bfnsBt5YVrn?H|Ru&@qj9Thn1lahOxRr5ag+kODYC`WG);>;9oVj zL)@zt+X0ARI*9xWxQ3^ioPe^wXx=aw9|KTcP2Va6Go9Lj#~%k^6Y#ym^XlhOR-vvP z9*U0JgG@t}l6he!%-{WL9&9RKVCIFuaxuyEM;<1|9FC662CM}G+>Mq2u6S1w|5DYD z8FlS&uG($e-(G#>c*>iDa0+@KSz~B_D<{wJ1o|I2xtk}@|H#QzJc0g4PEN;(UrjZk z0}83|ax0Xw_OW8h1>40+r(77OU96aLVOU-eGJAX_BFk?PJEg@|1m#kJV5)Z#%u?Ye z#D3jW6U)WM_V-!%xNt=%dK+>o1Ta#J;}V7e9t@Jj))o+P2;c{#gVyAuZ zA(8A5V=4t6Lnv6&Y!5Uh3}=6f4y4WLbO~nsJD%xS)T3CMC#5ua4MoF^l8O(mN$X;F z{RG}IoxO^$gAZEw)4hs)_oMjXWYw3k>a!W>cwB0=%~5nV0vS4A^;24lAzh`j>^pTR z8*erA3f9J0%ru#8>G^W%t)6>u>xHRhJ+&x1J+*A}Y|$zN;X*Yqq`ro4#Wtn~SrXi{ zFXMpdnM&P>>0R9$^Iyz4+C2u+`;4XNZEV}a4X;*Bz~~8dhbT6?-kfnK2dIn1Iy-y@Z z@V7t0n9u_&wRq_dQ2d)-#dm!d#Xn7sprkW7PpV$t>*fy>y0<8*;gx*WA;T-RKp1Xal9M|5C;oO5_(gt2GO|O z{{iLIspYgkuK5bW=*M7xrTG!EEkLW5)U||tJzCQ;e8y7xvl)f{!IC_-6Ao>`csrhg zmIaJVT-x-#)tgkHA`*C9+ZhL-!<|?PGO#nKu0gQy8*{_zFJbR{NVzcQt5mAEXkIK? zOAuoG6#93ubhPEjcKu=e*x*lbRQ<}0xjh~P>j|ojvGQe9j-wr!BkYtVX9W>tD(LN} zZHr3)`;=I=#VBSN8RjhEJr48YzMj#*PYD7VA}khimfTTpMyBr3Hk~DKV0(@vF2hq# zSQ4z;Al-pJ`|3(`{FacKi2&5|5N15Eo&%-UgJEaUaR$M~L%u!2%E`P_0*iAVf+3N6 ztEu2kyDk4>@b4q}&j>I6;uOp$n}6>|TA2j@UcnQaf6wEI&A+e138vZlqzy+wCqfth=%rSF+ZOWzUS z*OP_qkVz6{!rbkaVyPs}XYGh{B0BthehEJelY^52UlgpvyZ}eEvyRxgr{N3{@BSjb zL4}`Jfeyc#TcPuf#Kl)_>f?b13`3v{LgG5hQO)$eYeb4+3B1yXWTm>Q-85CF$$j4b zFAdL1k)NZt=XaY6-gpcXi%x5j_{PYE@0zLR&Qs#J246KZGB`36(Fx96uI4mNjzD>8Zf9FzzTUsbO z8RGGnN~|SJ;g_(uegW?^SxZ3|=F|o+9Mq=1Cf;db-@8~}DS1XVv1wC(o)nI4dv)7C z^f3Nuvc5KzIo8)hJhA2DDLk>)*HE6=>+9Xgl#eGqtmWfhSn}~j)*3VF4kS_lG0O<# z;{%CR20GqO8QI$cF*#w%&mkUuS z3>OyobV2KY3a-mL@zexkes#ygkiLGK;N*SD&yx17xBUFuq<_&fCt-zH^0T9O7899S^0TA(roAZE^0QQ( zDnC1J{MWZJ805u{vYTTlqx|eByJi>4AU{iODe`l($j^>j@7s!7$;usNV>h6T^0TAt z3V7b5n}WWTB0u8_nDs%hL-*`UIC2s&3`6W)Md2B`pjdh}7mNyO9~^Ahqe) zlOkz5?s{}H?&458%E}RFL5A8<7Fv~*+9+v12O;e@hjkwF+_xRXjGjnh67(uhKJox3 z90rd(z|C(SSuX!?EtkKWHp0I+%m{0_Jbi>Mx%?N&5$=Jnr9Hxq;zti8N7zvueebX% zY{})0o7eZC|0$O{%9gx}GRozSvf3Re>pjAx1&+I#U&LJ;VMp0LYf;9<>?r$2dvb&+ zm;b_uPD&a=^^(i!WOh*Gav9@=KFH-FlUH%1ft~nOcpgxlL}14*sP+QC7Ei$NI?EA| zBijYhb`JEhfw#lH12q>~@h1}T9Ubm~U=rdExM9vN6_^$YJZTB((|X`5J`vO=d~3oR zaGUK7cq;{RNj)xs9&h1k34%;qmxE_+r9U7AD&oF<$DFX*a};@|9V^@Ml}e`qg){p2;_>zgV<{mpA5kaj6J)Q7wFy>z#JCW zzTI@~>#*i9Jo_MC(6JA4d;8fR`~;*Q@3YOm?18kIm51t00E!)B%JoN2Oqb4y*&8N;a8(HZOZBGUVnZ$ zf&qtMh#HwXC+Wer&9lf2F`nPv{hjyu2@_`qz5B7)RQSnAKe+7C^lL#YCGDj3m&ocT z`TR>L?n6Fj zRDffV&v#!0t!tWm{$HO(S(<$Q!?RI#Z1VZgLAW(dKJQ^bh&1_pbB1I+_(aR+u2=sa z^7-%Ko@h&N&n1PrMQ~8Gk#I-x%mNf^B>d>|`MaOTKu~&fRPcwPD5Lb|DEp7IP}W;| zBNFboYorHvrOD?R15n1HcHH*{c9Bjb{F5V}e{T2RMLyqtWpacaQtqR0GPFn7Q5^lk zVMn;Pe4cY5`aexRf9X7wrOD?VjN;LIgwy2n>lnZzO+G&#P(iwUKJdfj2%nJ86EWdF zqI^Dh{{MCP{9V68hWHInZ27#FC$)#YeU}M7WR9 zU$KH8Ej>}3?1_z6p-=~wNETj+LRNV$syX4Wc*0+iKFEOTL-{HG zip4L0{{Pkfir@OOO#&VM5q}zGlR!sdDGEO&{t+i_?2~nV9R7+Iv+IPVI9wsV@3Z^U zQJ8^3o23Z%{ABnmc6X&Q+mF#-@l^JMbdJLnq83PBFaL;Fijtjk!aw38`$s%ldBQ&; zp&|h*)1{jlxXcMP05pyX6>>xq5 z`7El;Fg^ZeNmBgJrrJWkZqFj7e4$fpp}{nfFfFwr3vZr1jR_*ldv1b@Bn<7FO$4w; zgdG?f!M@I{+YdWfObr+STLaP!{{d(;5qTWSe>b{LqA$R3l7?SesKM97X0IXFDRcKs z22vxipmoZO5zW4jGPjKX)Yze7%O$k?AFEiGfAv!(APJBsFy%k2YcADO|LeY89 z@*;_GP$7k}1S+O0drr*_LFHl478L3*#b$JHChd&TGdcJ8GzngrXFY=}xDA&L8Xf1E z(V9Hdw|dqtR^M|PsuCytO|f%tBO$)zS(#`H;6|@=8Pn%`UaqMf$l*U8nG8o4xQ@e{ z+nf=pfIb?&(4!;Ihetg1$)@;<*Zp41hpSE=VGn{m z`DJWO-#ebgNUscG?g3dz;b>L;1kRcvvq5!@Eka25+U69EJ!7~OJoVS1 zU04oMROIqBl;Auud+;X5>~SY&&*iJQ$PZ0G!mx7FmIGq0)D?tcS z_soNoZgfbYkoW)Lh^;k2qB`(P>)fDf4McLF^q5<1G4En+%nNrpWFBh=EoZ=-X3s z60&^s48%+Y4fn2!H!aUX9SpHgsT^+PHdm$L1Wwg7n zn6U`TXt|q3_NZ-dvhrZFZPK$13@XL7EfD7_d0gUhup=3MsZd-BC1KdD7z{Oe2-8ht zA(#3Y4sU|+xPW(U>+ZYut^$Medw;CE9Sjbv&F@2&w#2$lVR7Vdb@Ni#o1{vyc$^-) z4#xu5Yz{rqk6iBGF;Zy8C~~=iggM|x%}`Zf19t0TpQo?RE9h79Mo0Nobk?ymR5{A$ zAhpLaWTB1d6;B?<*@bre4L z4S24DgTuakI%ofTy_vU85730ZARQ`Jn+z}hPo@R9K{M~k7V{2z;gjQJ-r(C2?O*pB z@Tvsi4fwWLgm;~jZMVl(v{-C=JS#RSF<3bUz_^3Hzc>;Mq-2Z+M?uEu7hzGT*SfXB zwPm3l$o%~_JH{Q zNGTY#`2O(3;rr9aBbsXm!2gGzZ@G7vlC;Y9`MHA2<60OJUR?=S3Re}^=^QxwF!2Wn zo{6rSkMTuNJQx*vyS$J|;lc~I9~Aa&QMdya{NMsR@k?3D@e@*!1o?oRG?((H$0@%hb*ZpmT8tom-MWpX~yv%ftncIvj>F z4@>H`0^gc}mURN00vQft|cbn@q^zZH$L7#$^>GMpwB7+&L8 zUW3Bqr*>vE=f75Yoq5JPU56%(u3t%wBe(AvW`oLHtET< zjxb?0UqR1de+Az_Ep8&)8asT^QxI*s7cpXvUc6!NhYXst2d|7|qKxm37?5g?n0?@A z`3JPb^0*bst~;zC%5(%>Z*y0QttP&CDrDyHJ_-l2BW0qj!fT>~bFm3!|5jQXQpuNP zZAe*OYv|yuIP@QNI~q`sKn#c`t3tj5920(}p|)aS(nTH;NgxuXI09Qwk^6g2EYk3>K{%gpQDU3Pxon*-ct-14TO4)hR zLDSm^cYiYHf_NiDZ{5-k+?hT-t1idX#3r;FTfoF#O%r`YPfQa1kZOyy|DIY_WQT&A zd-`s*h`ZIH@GW*ERl;Vo&DyT6fcc(gc8#D?l{%urUV@z` zz9HyEibUaFdV8h!pPT@W?I#?cC6}A=97ZGqE8H|TwkP&Ccs{-o?&F?%M)+s%tF_GV zR)8Rpey=@f*!&`|$)PxhZr-rD z#=1?8!WS>KN5N6}GuUG3QE(Jy4^P6d5*)tlNS@yJAbC*$u+TmUxcr_t4nsBrnR`k$ zIHcDx^s{zYu;7KYl!Os>&+vBCHMvxiZ}sc}rVDTq4ZRyhqCmNctHYd=qt_H|JV70JeX?0S3WY z00KpSktfE4B9pLhL;?MX5ss9{4p9P|PUp?-W32uE805knbtQ=rwsg|D>Saxv$7E#% zii8kV4X`K@*G9;<-?R8Ov;Y$Z}9O!qF-X2+Qe zdf&Dh0G^4oOa929zQfHOC11~D>|_fB7@rjewx@zQzXQ^Vb?{U^(O5D(M7sft%rVhB z_wo{aVF~frf+i4v5M*pA1|ekeQr2r@0OfXAoC#1*f@4)^G@!*((t_F@Fs{0fU_jme z{t?`tsiD>yifB+5)5d%ZHFq75H%8+k0&;a<`s9U+mrw9x)e^gjtsL^hu(>fi; zX5>D-?Vmz4`2qQ&pf5JZ-t@2TW7E&v)cAP5P-J1|B3Juuyi4}~NAicqgzAi42hPTp4CY<5(AOWZ5+hQD> zx8Z41CK50{nS;m?3qjJ#Le~mG#l*1&cDf$`KEHFsh9nfQEsOVIcm>^N+@sea1N&8v z-x~u#D7Vmn9eyvEAhGUfK%fA>Ept?)$sBDdXaFS+EpYfDaL8y`KtKu;Oc6GK=@1yU zg^jhAu%Y(_3;{A3dr>PDWePN|nKrqcPC3}bF;%V1#_LEqXs4otY@t(HuZz7O!FHbL zkAUgP^3&>3{)gV>V-VP;``?qbCpoL6qIA?eq!vRi?AB3u1;VBDz`z{9eezwiZb#un ztGQp|M=*R$RexmPZSJ`$?dHG?+$AmMv-ieU+;7C&!VPgxJzaD$cMR1@iOC;OFZ!_= zE#NFHbBIe7;O!8X;1NrCsTIEvn5>l zA}=KpSZ+=P@RtOZA_wXS{xX}ADesx*nFFDdq?ckvp&Ph>(q_~bxz;e6g~`!;bTMW~ zBJF*$dPQHLEX>Vv|OqaQ7g*#@Vup+H67cf!J^^S^@ z(^Y1squFmV;+D)SM`6~@D3p2SC>)L01Gce(2!e&t!HF!EtLmC|F)~lPotuDyAk(AA zutnqa!xnL2Go}(^Jh^IWL4H6^)_Ru+rGhk_BKKAFoJ8@jjPt0H$!Z_a#Eoeym!e+~ zeBrP{Ao5mfA#gQ>K+G%h2t;}MkbI*Du$fgAkWy|)b$}TNg4-mlKZL=rqU$aJX)xD}D%u#BgxZqs#pep$R((5EA%t`x0hI!8_9XFf`N z8R4g!K7$#j@ukk#Lp;&=QfF)mPi%fVlqWVneRuHD_$eVJxA0RUO77#~r+S{)@RCIo zDGdqA^kYPoA!PzDy=SLTNzo^(^_XtcTT8yV7e1}J`xE<30`ovg*8_s{L!S0~n+1W| zB6!mu9hx*vHP_S6l~glHGA%_~z_&+rvL)#od8?70`a^Jr#h#w`6uIouhM2g>3N^jX zZR^uQh>4$0O?UrFTbEI=(91w_LCcb2!i9pcZ?n@?_B6@eF0QhlABV{eAk>-aG973- z;^bwUK_sS2%1b!Q{#YnLV){y-3+(hOZtk_f(|sDgjB7sV1qoOp09l0U4pU@k#%rcH z>`w|n4Ce-5adfi;cE39Cuit}$=I1W1u+=1#m}Y}B1g z@F^icGeNtd#?TN#bZnHMDYhAE5i7>6r8uO}M#=dMLo6W-U!ws_2wXHppJv661oUGe zPrJFR(W({^iv@Q27Y#eTB-@pq&&^m$#V;Gxpq&DHp)U{M_dz=zNZMt6Zc z2qX&D4h^0eYPAC-!DAUl(SYg#4t05N#!th6B;&v0Kb?3K zVlD!}vh+%+S&FPA-xZndFl=B5(@*~?iou(ylRDnWj4I2Gin=Z z61x5cf>FA+AZ_U}MX$?9pf51nh)z+;Y9+nEfRSWa-M*UL&W(4X$Jf{!Z)d09poOjL z4%6qU!dA;K9l}=9`JfLAO6-2Q3OOp3_NXK!5>cL2CI{q4=i39~DC|GP9uP<2H_uK& zQ(`_@nGQ{Pe&1%N)%M(XE7lkIoKE*p%@azpiLP#u1vyDevsV8mdtLfDZI(+{>nZN+ zYYPJ8SRGEPy-|1c^~coFH$HaE=9rG2uC;sGAym%CCsI_bP4@ObbEb>@=O}#e9J{w2 zg|6IWZ-0r(>DuVE5~f5ln4_mlqJtMkv+wnF-E%Ix8ObALR-;XJ5{WzrfK1vHV>_@l z6@3JZjcTeiK~d`K> zsdWt4LgA6*!Bw+%iGPI7Y5qcN&lvhhTBZ(cQYh0U)FZe6f(DSL^TbZf*$$K7kAa_cPSr{R9J( zfZ;$57>4KZ+B_#vSQzp_ga%N^h?tOp5DPHqf;c_ejX-{QK8F*Ae@e#)5sT*-;$`YsJa(jOD;Cdl2$qRD1Bk^Fepm(WgVSOpu&!qSemN2r zC2o z4gpc5UW4#~P??(*Y+JjqPAP)4L-Nx=PnzHtnAVs4F;axSK!(H#e7kRmk5 zBJk-rf%o@{5l9S2M`#v^3ZW)}2##W@j?iqy*#52NgN(8Lr)t14ofvcIh8)F*Af!2B zkl66y6#!Ty1_{CxvFch$DP`c(dqEpX6$xB}Esf3N4_06PL+^;>@rm zQKBfibQavp$dDtP7BD(icVh$p@H|Ng7 z2@|y5F$b+7am*bny7$A$x${dzGq+=!IEtI^K(Q6w+fjV*RunU)iB)y)n1ha+*M0>9 z%ZL|_vey}8w>-7%!bvDYf2Ykx#x!v}nZY<m(s{;T{HrCvBei0?&QKIfDI{I;;NW zGz_5?7R7#D+YKn=Bym)lIRRz8CkY^B=Uv+w>dFd>V%N6!YLs!3IBFYFlEj0tA7I$R zamoFF4qIq%2+ko9(HNr+DXv2oJ^>xHSOVOkCW0h%dc*fYRbXSm{Y_WkwH`PAwxiK+ z69}Fv@d^hZzIe^WiFk!6#sFcF{v}{xw@K-L4Wxg@Ec~@L0tiUVLezsWZCboTQ0M5k zAd2k>dbcyYxCAPc@Zvgdp*RKTbaE--#gnpru`TP~*b;9Q1|mIfUz#`rj~4fqHl#;=XK0R(ReML_c-Q=iiy+7V-n`_(%kS2cP)5oUZd z2TzO*C$8%|#P~qiRo78};uM;8&schF^3taGhsoH55Ano~jWUHNw!AcyC$_xw?jhon z;6}37gdm?hV}MsrRBa z*zEx3#aY97x@};URI6&c!X(10S*80y_TJPvnBH27;u>Kv#ISFNMs;Nk^Z?aG0K^uC z!yjL0O;;V+oKx^PqMHX@e*}AYE`+_{#C3KUL{2XWa1Is%Cg1K^)Jk9%BFKcl@ON6! z3x#EPW+W4#OcQV}Hzvvbj1FCX0?&mw|BsI6-unIH$8!;_O9NUC=yur$C=`XJqp%+e zA$nR-T>j7Fx$oWYkexqHJolhIAP(rZKMQ3*9EIOJkd!Ds#dz*_zUL4?8O!GI?)Ark z=b{gLPspUm#YV<@os;#I1bP_GCm9U0J3p^x9&i{S*PNPF2c1Ig^O~XC(m2|#hacTiWj2= zP2TlQyRuq$-?q1@X?K>ZS>IB3S9w3bf@4jS@eFUQy40`6!_Kgo=0nX58>&8I;BEr5 z9j(o?_ijKHuC5*wbfG$2h?Eu^suW1!Dm;QGyd6ktQ*|9KweFt17pmpbLOc?0b^(4| zWkibo`X>82tHTv@6mphCicL1t@9mIwj)0aM2gn42E1?#|8jzYAaSyzxO&BbpO(-1| zZ^UgZ#gn*T@~J??49N!~qhwZKL}Q4b2pefU0378&&a7)pwc4!PwWsZ!w^y}wzrDf6 z(^{LV4`nZGZMx&ogoSx#U1N^vYnt_X+na})T6fRw*U`GWx?fl8D|3t1XSQ`8YHV$~ z>mD?JebCo3dvp+C#JwHxxbHU$HV#AbgVCGfO9L+VLc=v-A;O(E_A`Agv)(clF5!N6 zz?HqQByHeLdxoDQ`^3as`B&N z4$Zv${;dNu>vr#H+x7PLwykf!YWD|QbZDk~aodL*I@|toXj9vvd4m@lQ3GDEO*zRc zZywq%SKmDJs@&m+>wRn6zG19<$Dx+K`mSyNJuP%u_pP1%4dlVYj554Ub^H3w3L4&b zqGRG+v3Mh#zM|O%_wjanT6cT*x|hWp{jSD{dl}FC%iM98Wh`_1T?m!X+|R7*&a9Sd zPvzz8W$`B1DQ7Pm9nE&RwyGBPHOwQ6O>kEvV^?G1`=T4Gzqzm4lsiCR1 zj(A@M%LD42$n4Uh*&{s-ou{Jj#A*>*$gDYTf8^VMLPwX?Ezg26Z$D4NTlg_y{hy1G zz(bf3RntT2T(v1Oy8sXr_I?Tbqma73EC{_=Q!LB#bce5NPVQ*W)1iS`$QgCo@>B4B zZ&PdYU3(E^A1LnVNVW^xeRXcIt|@D@a=U_cjqc3R1q%*98<|mqR7+#a%mq!2IdFRV zZ6+L3PmW{N-nDl#pWbZV(rhfJw_{{B*6VucM;FXk8Z9|ws8CbZf+lJ-{c3$vcaFRp z8iiaS7kql^`1F)WZk|CJc}|V zk_RXTi~vZfKsg43;v^|YiO`*ZT8H=MASOrnmQ}{@E(cu*yE-DX3&%yXBTEf+vL+pe zTgGVj=_FUI18qN@sr@oX!@A?;YWSQBy~+W(Oup4guOhQYA?VA388Z^}(ufuxQlaJq zz3MpJd-1`!pjY?ey}6)Q-^m<33eSRIbtE4@+_UJj?>L?V=PXg7)kmjS&WG?a5Uh{> zGCT)@bzIMZU>(>h1R-bHb{sxVUY{tS;;^0=}lU4{KIIY=3!6+n)}# zLi#Lj#69NDwige@Ag=q`<<4F=?QH8jvNt`SsTCz1Hs%>vyU3`+)UJ8znyXWBj5jZR5)Z;N2_oAF-}JYW+TD{nC-9 zZC_5k+|agf(ERxjY;l_&OXt_e%>{I1ZF{GhAD#9q5@{{^#p5HKu%_DOzTGotQ6e%E>o84Lu+ z=J+GmkAzQZ^xpNTDCldNb5hW^YWA1fJ{We=!sjvZFgEPEJn29FVNdF>!S5q@=-C4N zN%E(l%2caqg+1!tx&tF?_Hfm-k1izF8@7E`|#GrtxSzjg}#;k#-v)oUy84->r> z^Sl<*ycV;(_HKJ>%~;C$^pwn}r!b#Z!bRv1<`YVr54U_r^^|jihCmyqJWJYSEYHT@ zSlym@Ji@g-HtX37q?o(0*zG7rSXv)PeiTOJ$xQv#BT1s>#ca)hHIWT>T1jT!EPt08ms#+&wymqf}+w)o?!B{c%DAl zR2czf7Mn2cRVN3c3o@|#k2eK?)m%*cgqVpm1KWOXfPta_r*Xm52caCtF!&+%^ewov zYxz*L!Q0%lGb{C4qA@rC+%T-}Tcw#HwYvHWzNNA1JnJp;628Mml(3H;#)?P*H~;wr^+%cGdOg z>_KJxT9@I6Tdcfa@D+k!h!+Bc2vAtnF!bbk0mO=+|Cr%<8v6g@OzhF?-1qhi5?tts zx=%MUOA12KlXkp_wja=KZ?@ZhGG4aC#gq&XYx`w8q92Mer4}^i0}6^ zpYZBgf0EbwBWFR12hu=93gAg@S_33>X`0s#c?`^`Ipg8Y5>j_n22{8DE*+V|%#_|Z<+pYzkO-Nx$8{NuRE3(qn4h@`a;Gn|Mpz!g)6NK z89z$9@K5%IjNhd`k^S{>#(&>+#ZQ;#q2jRm*ZKJI!fWcf99U(xe)S-IZ5F!GRI$#C zchF;~l0G)Ql8iHkz)0tw+qZvOn^uNNf$OJoVkE!0>(OS$H=NOgI@-sP+r|`7l`gBO-zL)~dZ>Ps!H06=J9k z3#;J^JoVp4UDrh2=bLcFFg!0}UQoOR~TsaCxv%NTzw+|i~d$XGLYzZNdPhriu@F0-@Mc($1Z%a*fAe!&9 zdm|Widttj-RpWU&V|1Z==Ipa=1)&-g8m3>~L6s>4)B71n@ZUiu@sECKI4 z*ZlH)j7`nyC(Vb2#xsqm6=6QFZo-zp@7-;{yJVl=w-w`$jOi_X#jG%+^)mcDKa+R# zJnE$W^vCmC@ht6BITkj`H-*% z(c`zr4pkwr^r$+uRzeDQhSX2yqjF?Bg_E(n&V=g;Y1i-YaE59i5r}t$;8nO3=d`@u zXv9|&o3G`n!y<=|D1vl8l|LWX1HKpWLMw_D!bWlFt?_$TiQB!ei5`*ra2s4sVR>6r zJxslYb-6mwAi>be4Nss6Z)dadfN?=H16B>gnX3^UjFw^Wp-})4pr;wsMbW^?bb2hs z`AD^Z3!g7+!D#^&4`mKah-jJ1k6Bp^t6xvu+jzU77)cnRamD7$f)X$ar*h)(41Q4xktFDAt{G$6L_O@1E+6_(Pcba)zafpEi-%(s2^$*6dG_XQ9) z?9L8Co#v@qh7ad^NHakPVyob#K~GF}w%VlD8fu4k3nU_Z#Daqv8SV_v_nI2Is%}HZ zV0e|d#5v$M--OXX-9Fc>u-)S5SbWY(Y3%P&QAT7SqP7;m-6>My#u7*PDg*riZIWkM zv;UOls=<7aGXO)E87UdwJq=IU&EPh^IGv6elozm3C?-GqB?_qIpIyXzWVByFXUOi=j|7zS$)U^1DJgI01Fs;eQe zxJMWyl%Ew!#YbvE{;<2PF*KbF$m}ibL9Ap3vBSDzt0P5n&*z0UVv&}CEEdG8(1Ch{ zx?xd);3N8^=XCo>7J`10)Mj;Va?I`dm7bv)LjO$Hi<h2C7YUQatKNnR6m`Mx6qKB?JtbR0h<#caismoCcYul@=3BNm_Mf*WD2Z8f1E@qn8YRKLLx@LJXYpOV^tpCw-ZH>k0buzeQhuJN?r`UwUpiL0|qV`jUzd*`{-p zhzJiMMHTQNY>&9P;nu*$hjKi5pL?> z;R@WrjglA#_JJ31Q!@+!mTka@1gE^)A~@T^>K*__R)ert63j^NmEN-VO2B<(dxTw! zhK)i{>=G=Uk2l9!zbfQr1QK2AdJM;jolyw;jwevSoze3_ zgsL*)t7OkQHtHT=T3abXJ>DipaJoC->olP-e-MxGKOR3KM}lLC8Zfz+D&=14dF-Vm z#=3x=ntd@b%63H1r~s1;GeMbE>DQmX|n)h58DLKG{2Xc}CSvlitRaLEL?v>yIH z&_s;&D@5G{f{E-Z32@1RmI|=FLc}!-T=LYI7GHud z&Wn{=Z;|-quwM=OHW9(n8#LA8t(X1*=CTX+s*#{Og7{pm@NmMe61lhBu(U>!tTy0R z{Gd>N$lAa?2LuZ*XWzzKfVTLy2$WUZ{Tu8}5HJ7`mV`>hSP-lepXLVy72_m7_@}s_ zSsd398yr~Hh*b_W%Txa&be!too^#e9Z00=tDm?zu&2Z_wi1B~Q>>dz=8YW-z(FiR9 zU7*}Lei~tVsL=p}!H`yeHbR}EZz>F#dePCYfZ7$w#K#ukOZ~82N5vt}1I-N8-{@J^ zbV^s%sRY1`$e7{XE74@aJZyR$EG00o^@0fl2E$0B6!EW#e@V0`ypRh@@UOe2jj~s@ z5wJ%%F_7SmD@cQ2KbB*(g&S7@S5319hh2y8F@lJ_GFA9M&y^|PZh!W*(NX>FJ8wW2 z0Xvh5(0}E#PT^*cv<=k}QLCsa!)F$z?Sl*LE+T{xZxu{UZ$X`~T16z2f&ASg?3s}Q ztIbQGYOpflItAXs4-{anv?k~T)`~T-R>^xF;XT~^meyQi18bE4)<(vwK$~^r?Vj&` z$O70n40;31BMxh&ekoQ^Wjl({`PgH(^B}|82y;SO8(|^SP^efc86s^Y=Opht`I|!g z6M&loYO`4hpGspT4n2eBBfQ7KM~IN{MS0S2ZOfw$3IBLh_y_q&BcBnh7JTH3mjAk~ zZ=im_<{viTmiJ03|6nVe%%cy^0lRjLZYUoCbJv2{vU_5YDZ)BH>liqWMM$cpqsqY` zeuk(Xfan2mtd|)cREy@LsT=?(8WKpG26;*OcLZI)5thhOi6c6r28Kth0_0JS$wt=m zh*Y5YNzm1vWH>F}7P87x0Oq~nxlSt2LC6H2YqPmYbD(G(vAJfzN@Uc~$&()ygQqld z@zmmEN?^pBc=Cc4wN2Q{e6~KJu|Npe(PS$yLl>xyY^4x2iF%U!1X-grHz{#3FPP>g z8<97Ovx&12B(zNMaI%&xXr%MOR0N)L*F*gpB{%7S69l+PF|6E}T?woNN(ty61)v+z zSah1;bDsKz>>FVr#OO%eh|z7lfh?rh-E%WpNLR@9K>mE($nL zhOb}sr8e=T&vyu3SKOcngrgGT|YfgtG3;9n3~(#7xbuY&YAR~_^qiVC2((Y==#R=Y9WAkYfb?ZP-eLCw zi6q88PwqYyy_}$>R#h++#>z_2(wi`)dTA%nZY~^>RCboP9p6|Inb7TKZ=sh2P#nR& z0y*xBlzJMzi#8?5>7{}ba*BdlQg9QB>aQttqKfu1BCrS+xskx4nL=LuHJ55^Q7=Yf zi>B6J0Eom#NxvruEWbb#Sos!o3fL&yzIwS#f0Mr2fNS}dkA=RTeBBB9`pKuSXI%TYrLWgp^?%yv>-O+Rp|9a_C*;?tC5!*B z$gk=4h?6E;_K4gDgw(985pm$nK%GPCK*&mZy88L z55t^2I3YF=<1Ym3Qrzs@G5bpie-+{bok7)&VE_wMR32Zw%C1h^T$yCvk(yLoRj zAc_jL86broQUv}Lz}u0~p*R)p7QBMfLc`rl^o|mUH(!Xa%!}P(z0sbIf_HDO333Zg zn8L3PIDk!nNDk>jHS4J5k#7c=VaZQseyvyD8hl!4mL^ZeMU{3u}6zL#r=qY#sBv#dP5cuX*9ekvkc zIYzHu2#&WcY3->;51_d{dMU7Um4&06Kl@?}mZq`QFyHO@(`#-Ei7`AnvNTw?QZIT# zeWB+f-dW0vpaGU8mwsX#uR!}C3WriPj6GD>5(kn~P&G_?uX__AYCezTOZX{{6m~y_ zui%}bXjOiw=bT895xKJaVXM%Lq7Qop>bL3VaGBjcmv=m1X$jWG-W)@nhSoZm2$_M2 zTO3qoWmwIhkHKIv0+KMl8iip%xI_)Y`T?3%cotnM9r={dDX1I>cs1f?Sc6?qFJy-4 zK;AZeT^OuwA=h7mQTKdnebsV8==BG?I*d#n=GTbWTLBq9Tzdo+p~!0@EBfj90uxkp zSjeS^yN7BOld6Zxnj4Mi-~l)-gekf<=RLzY(7i{wIdX$-(|hDmp6G}30_kAQSdKRV zty(e3J2Rl>!RG;ZnC=dOZpA%k1k_asYE6HQ#0U!(X7{hBfk7qt;e{LoplWrn)74gV zG3hr^9*`v`j9XLLH$W{Xo@I*ye4-CgfCGmvcZdSK(J2aWB_u=vHi4qRPX0m^D8@yI z0#`8_P14`94|xEz4E8PSV(+X@mj|Q;$0QF}fH9N?FsO`8_KQ3qxeG+usMZD4WLT-f zK9ssVjrjBAd}J+SqwX`Q02svz8c`r} zL2JPGN{Sp%N}ddJ-pNB~uqzq?qLk%gsXK2N40WY(@L2k>5L7HJ*z4AdKp|p4t6#n5 zYD9Avuu%yGvqKXgtUs)tqp-kMzRT>eGBY+(RsRHvgX&rs6o|UK1E*g2SS_)HnQMoj z+A?Zdyz9kZ1D{P<0Bz9R-|7S`=t91x0|>A^LSf1kfEKBESSo1mHOLAp%@ZRYhj? z7q|i&aZ4~dUQ`wATB<56(v%mgu-;_pxuK`nTyrfKdmg^A7vDF?_t{tE`&wzzoAqm1 z(c=EslQ~+?P+?IBFrRe3mRSn_6Ep%7Jp^itdpO0RtOzu`@2RJbVyW+OEwnD2fiszs z!Z1f!rptdxm@Yphgqsu4Cb>{Rh$c7|yDGsXr-5=(+2CZ7;tIh}O=Xf;m`M(4F)*4j zABIVK8kVB%2}XIjWyTEB2&yf-vedI^KD(Y@PO51ljx`1(1O*1>R3pj=R);$WTlVbjWwptN-Knwf@xZ;l+Gj=gV6J+vV=qHVzUVp_2e)^Be zPqjL5U2Ob{kBgt~z5E0}J;6`8XLRt>?_Ku4#ZNn|H+@?9sd?!Me)_TU)2q>;pEQ2z zDmcMUkAa_t5R;(pjS4e*(pM2q%#676aX9%8aEyqIegub)H_PE;ILvI9!zXY!X^k8% z$Kj8<mc11d)8-2{4yOcl%#`%*+7pt>^0 zA02gBYty%L+)$(5UYON(aF9Dcr1JBF>IJju^*j@%&{=AmcWafqr~ioU-Y(bczCX?? ziw?dt*lr9%kbpR&0Sv%8%G+5V|9YhWT zZ&!6=cQeXMpuPx1zETh!e320e4l^R-hZ}$mCk4El0+G9h2V9#y^*_XY@-l@3yXp4J zOf@*4?MCH(U)QY9;6;x2AP`M;YtIy9vP9gw9-zpBFLrIL3e8x`$of~M*A+rt$%ac^ zX^rma$x+C5fKSM&>K`t;A*(tI-I9ZL0ri_syIkpYjDv)nqV5Bs1zU3w-J`{{`p-Uh zpefW(OkwB{1WKd2JI|QR`28U@9)rJMf}bHK+tx6pQ`wUH$OD?5hznwe@Eh{H!r*N)`tnDkNfodBLVw z-sq@1*SCIFt{HFQA;K|dn~||uc;36dy0OQj5VdG@4#M6c`sKUTS!Vla`ErJ_Dy9k+ z>P={JV#P>5%0{V1zqj4@?P0SDeftnfo;uSn80t(se>y_K2Ymi^cg=YV4rHK`*`HBk z3lO>;+S5S9zuAp&a+{4ve|DnusVD%;&~pXGG`&8qhegK(W1?l%QHlAe?#c~Cf4LOB zU_ynuo--7IJzaOfPW&Ac`2G{P0)r1xcECLSY@*Ior2&xK!kd9(?&E!pD5C;zK7Oe< zAmT@xk9+YOdlbQ>!fNg?@dV`ES$H%6PaP|AN>khZw;Q1nfu}~@AGq#a&~=3JtB}m& z?7NW6Z21aV1=EAnK@MY)>R={q2XlgX7-6k<=hrgnr5V)@SU4p*h+vbkrT8Ym z%&_-2)gObZ6DqpckcZ>Qvh}Lzdl?Gr){yHJiGLCDJu2PfseA8abR443O5om7R&+2& zJMKtK-*UbQ9V>l@j;&-zXJC4R=)4qG&wKHnweYJz^TmU1KCW_LhVjGM(LBkEKcJ(l z0E7s8^!(E9JT#SgF50io zLdBQ@FB*|)*_fy1ulU`TY8KPC%!mviNyx;XL02ORIkHzouFhpRa6?U4=|;q=s+!B; zM6z;(hy@(55${9s^8yakHuUIv9AGG(#}C5VJ|(LA?iK)(e?Wg=hFv>s#0HoM`C%jC zKEK`gGYX62DEN zrPcTY!*lw*dyKldi2pe_ItG~aIF$G_z7fT z@gogOz_pSwxeV79r27~=3$BeTanCly3Eg?JYYP$v#%_5Ci+MdN$U#hJaJ8{>n3862 zKSb3;1x?65gEuT_9)Wrd*F@8`(NM@r->6o)4w$!X8G_zMGGo`vk=cm?zyv=`LRt+${C%S)qO9+!YdVCsp-p3>qb>~HwrdC}Zf)3w zRL7zG?5L5+7sd+EI75wu#BeP$%|Q<&N=xsa*dhca#ht~v68QSX+_*P*+xtVJ*#m;E zy}r}tAt04MKex51HpiXM$rQ@Z!6NRDbvQ03GA5Vb6&aHqIj!!VY%U;w^$lv0TeW+~ zF#QZaY)p~AD4R6eUzAg#{6)E9F@jYa<5%hMn5az$lZm~$EFQ^Y%#D%N!kEh((PK#fn}bix|CGixiRIYh2m5;#koYtg8a+ z)?USk`r~c&dmj}#jpdGK@?w9Im}|IE7Q|~9bD0H+B^i!pujI1yEPe&oz=!-%_hnxu zNAc9Xh!TWx9BjJQn!a_Ox;C7{*^R@;)unJ6P(#*YX|Hwrp|GXN0#cd`Ld+%^V=j3l zIO;+8df3C!D9$u|8$1g~<3X;x7QONyPGRx+)&Dd0zLeDW`=i%>7;qs>FW2N}kO(J} zD-z2Kxoa9P!IJAih%7G3>d=Cfhg+0b()OZUX)nq>$Y&H=`+Y7KG>BGKY`1fT{&Kb? zjY_W2M!fDMy+8w|YbBnmb*=XuoO3Sh0x$(ie1nVTPU%5rUPrubc!agcMQe4Hv}0D{ z!{JLm>lOW+5p|D>uPcf8i?Vn)CNibSEw|yWjFQOUB8isu9#$?_b_M&C17y#ecoT;L zmTvIV#XZrnn2$|Eu$l|;crl*v%lh~GTIRslmV_L6OyjJ&52 zobS|Jr3nkA^_Bf+?#V<>p1g*}>O0g*YX!IN+JDcxeJ^7Q*jUQ@@QJd9d4Shupl4%e zKR_!N{W4k7yoitFMf+p%5bVUVdQKsWDhg1N-s_Lv+>f!(Y7MoqAzpQk5giK(*)#-S zI%s4eK623Ag*js){=!`IwhcpIN2(5TWD%hdUwRp8{1(ESm!LO5vWmu`W3t#Wp`x5I zYC=&i<-*pMyUuLFJ4&(+**`=Q2bP~&x0jn|~t z$o|qbqCz-^qt5Cl3{a-UH_Mkoj-0X7nwn@qc8RJg!j5DNevscR|ICK>A#}UecT)}u zfZ#w}hR_nb@!#2f2x!IuqX+@&@FiF9`r2wC05yp4eY8*zGrh&NN|+i(Px_NCb-4ID-ktN@*9Y7$J_>5 zrnAH|FXI+gqSe$58&i!bG?RAhXo^$i^QE}cA)iAir)-Xy&w⋞p~c9}3u-Gh6{ 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
W)P;ITwKW#j zd1A003G{zYh!a?aU}o9>jJD?A5HRs|V_QO2hOzDYoA?1mG=rn$H}M?55moEu$_I05 z2^pkv{V_>(=-*PbswHwVkutveqk_|fehH$apkG2nV=%3we!KuT-G3Pic_MH*(|BiJJgCW9?4 zh1~v8{kWRjMt5AKM;#QY=lffN3&#a~70GRY(8OY&UJuVeBT z9AxrWks2;0e`4-eVQiz#B9k^XkcG^fORRT)Dojm!rNgI|nm13jdL)drz~}E6Q}gDa z^}Le|*d-`r{fcjZbYi;$raSdjyg<`W1T2yd(*YUZ*f7I(3tTQ=)>Zt0q5dSn;rI)OnF{9OXYyqauXa|d zabZpW+J*F9R_;pT18N?2NhnJN)UraEr=Up3YxGRf+`?%$T+dv{iYN^9KUkzuKFK2_ zkkm{WF~5Oa!}XmVEdzx3-@r&SV$Q4qwyj@oNRQjA43YI?KJ|Dce?m*>?HR^Ou46-) zX5UUqW6@v;&yvFG-@5i*`Y5cD=EbB{`x@UCVil+H{KcY5HE*C3Vw8p{$0pA(8)qah zBzEHKw0}`Fb_eUu{7E~>Shwa+1hdF!NCj5qymaZW6U@a?i@$xx0=a?=`%@LDF;}${ zEILCWbCqnZsjEUPXk6agcSz0I%q~??0M5^n-MUmfR2Me>FR7v*JyC@1ryPBaT4np$ z{N!i-tm$l_*sIwF8U=1Cwui*3Q8o&5)j{4Hw)~C81LMl<DWCmPm>OokV4q_5PwMRnNEcC#h@Flr7}5%M=q;A?5_=6rH? zGB3l!iEBq_QnXeGbLesiKNj((G{GqzIRcQz1eeNdnu?b9934DaUUMCyRo;i`VD$Yq z1-uzrc1r)q?y$L58beXRw8H?wD_+NEi@nFjKL{am2u#9-F2`|6k5fo|{7J(j>dt~% zN3#vUqULQ=v2NNnbH2ON-HijRyrtt%9z?+&hUimGz;aX326`$$x`e&8@soZ7uug~* zu!QHV&_n1aW{2EeAvrum2n?$m>H}aj1j&iKuZ8{l#py}Kp!;-;O$L|TLS^H9WYe^M z88CAMvX5?#!{mo&o(-bwAm@_bfzEnEQ2#i<5*JU8Y2~^=Vs??}dfX^&zg60PX287z zwMpH6?^5jz;7EK()7t<+iZC`6+jalZsoSEeKcj7QS;+s^()`V1=xI`sHt2La^-|!- zw8Cto`B7r3)ixn81MzJF(e!kh=7g6-&%qa`hIka~zWt$S76_3svAx>VNBb(XMKaW4 z7JYpvv09HO)yl-7VS?R1ctPv%lLgU`^+R0*bFFi$feHAK39MG=aKDN_x*VWDb5nu{ z>>tLl?#U;PMh09`=U3A0|7bnR;d}e7ywVJw+ zyJW*^`QjOgOZp--VRoQy23ayC5RX{|jBjwN3i`htuqA6kYLfET=G*M$mmIg!e3y8*19U z)V|~g)oSL#i8xPPzBs&KM|EOyM>VRe@nw_~N!*xe7u_Bv&df1SZudmb(=CeYx<*Qi zYD0VVNPD4CwLf*Cyu@hvTX%i^r1tcLIiBkF^tj&-G;oGCzll0;hd0%_oZDK4i%O_Uu%A2P;{sc z1&+QZ{%u|h8lnA~A1&_7cJqZsHkN~J-Pi(xjd-}Bw&QId-pK>Dd7s=L=iil>l4VqG z$GWeh_tcRc!HKUg%RUO?Kpr!Q2jcKI)BL}|{@UT3+=-_4u`RNl;2Ww6e@o(Eb1Iu} zK5ELSu;XOsOvsRq+ViJ-&~Sc8x(@uG7d?xG?~{$I(7NXdkh2{ZN!;a0c_N7=9&{i* zk7viYfzBIn|K9&{-6cUaEe{NErs%C>+Qxo4vrt{KA8y@#wZt=}_>zt(#nBE=@)_#T zhv{S|Z|V;GoBy}EE3f&_D3u+t9YjYGcX-5ka(S)sZ12driE^>uET8q$RW#%)1=#z} z8fQHyA1}kX>9e*x#H(DBYgxaR*Td)y3ZBS{&CvI)3s3Q@UUjWUy<{aM!OJ@BN?rp; zay{yB^n8t0V&lStt#i+h<;GtujQ_DczOyj?r*<0X!T*XO&f{cUAQ);G8R+xGO+__a z_9=J}at4Lqxp}7Jd>$ci4oAFl*;6H=+!8Pw2+h&}ZxK^;|`Np=&TVVmY zJ1~{3^e#P3BcDCi^UHBvPT6&M#ngaRGiBfaltXH5y7hgQ%AEU zsr7x#p>W^ot*3W^;_-7Pt(_@_vM=C*Zm%^0>lc6>B&_4EAdbm3nl6&HmGsXlSvtbT z^tve!e2c-tLhEVAnk1rvn~Dmh5eALGb6*-2J06gFD0X8n?+*Eb1Bf=a$LB zo?VuDwXtnc(XHa@eW8F<1RI?Of~yiS&vYzC(h>8go53XRa&$5cM-l*AO9PJ%mjK{; z*wG4(1N|#-&Qf7JXW>-OEOC8OW)>-W_f z}jM~A_U=E=C9VCQETq$Inoa9fA};EI$juFurrdF)M+&1)0aJYnpeaa zjE4HA#~F~Iy4xEobp|DNS=j$p9iDo{9~=Hhes3LJ2UePan#HT8+j^f5F1r`bCh3;E zmAYDzmpSx<8b$gplE6YDJ!f#P_nhgmp0R^MiKSi%8^{mK36}%*fT^z(9%&GV#@W## zHvHIlHES-#)l2oW=BwYE)8<;Y%g0v=&1v&fXNj}_h0~Ql`7FFI>5quz<%_u)W*6m) z&XJ;O@PaQ3`uEnwQox#gKBPYyUaT=XOcpqmv`C!g)+q1-%f&Q?$U!;dgD{np#OI#Gcil=i?RY8}HF1nO9MzPH)}zCaQ7E zPZ1&utV8|%d&Y5g5b^B{|+?X5MH zd7Oe% z=vJJ5OvjyltN!}p>rcIi#qhAZu2ZX6ZhZSui0V>TMNFk%CWXwc`lUEz zKCNHQiI#h9JGKylKLa}*ljx*bGto}7 z`l9(@eRcgf7>kzJM_ylYcU4-ou{mESYJ2ra$KjXijcrJf$hdrltu} zLc4|7ro9#=rh~ZHEn$H{FKY)3(9n|t4Ie)cyFhE2**+LKQl6r`a_8_!iBEBHu>F!x zySE#g=p2ROjzK30s>(t+_^r94NCsragh=A)2~^JIk;bNv13Pmu5xch_oS4+u*#AAc zYqZ>PF0rehU!0yMDfL-bh09fxg{xK0l%qs;HE}x)^VE%FX^4murT^dRA0T5!PeMA{ryc)8Kvh507{Vny=_TgecFZ|?|34d ztWwmVtZyB(vwnK6&SdSC#^*9P_S8*1E^THptp8JHgaY3iXAoYWE)^yEa zmHP&VNzYDblVq=zdRkAaCj!mgz(~q5RDL<;Ht{1lp23F=Cl3i7T)y;&U`aJNxQAc{ zK{9@_iK@=lRp}O*x#&Aev&^ZUWR4v!rRZ?UC*glC9MWuwm$EiWS^J5@bCy&5qE3Qd zAV`dG%y>H~lN&RiqC1}4konvppAYbz@j&?ti2K}bHiA)=Mf17uhTtlQF zDW8OtQVzdruKpdZMIkfh+ATOPb$l^h#~H%5dgSw!BGMHtP_YXV3#sJ0H+V?^7&unozB^$u$ud|hI6;uwU7bKe8Cu-Y?oXJFh zMhC|{NsP)h;|FB`f1WNR&F`?GvYBj?xtY3&Xk(KSoEA^cjSiRT%I)8m%I@!K?vEWv z-bQ>-p@Xtl%#6;!vM1B#Fj2T~(HKeNY;>ng{Zju%XhFPzB5_E|Ip#xbO)JnoXeC4| z7x=IBuGj+pa>cI(ZD&zVfBbR!q&utht6y)K#;WAm8XlDl(wn?XzuuL8?QuRV`FKG- z);-Rv8YS!G%io1=iGQH`Z>M8TJu&xNsy3kKO`%==o8C;w-hEagjU{l5^vFyiwl%V=Bb zsrA=k`#Os+Msh7ttbbUD78z?$+&+xa#$m^Zk8*8`A8@XCG~iYU)F-(1u68?)cF-4u&(9!ToZT;a7aokS|Q7Sf?ek5sa=)++L z<=rO$yOPl4LuUcxK-~Rnco_tfqDgEMPN)tu7Ah_jh^;iNaz*h%REPUDMB56)GILKu zUG0nu^gD2yn-v!lQ|Z5cO(q(vE}|;x*YJC`{k}@tlE-^yd~)sKse5P8(7a-gMtXn- zMx{uP1n&J39^Bn@JA*MQGZ+j|^kEr`=sIT{^s+i}FxH;=ImQ4@4ex;R^ob+z6d21H zfn-36%WO(_$v$|Jp{d}gET$y3#13hm-rrxCBEDzSVHNx=(YO=0$7!@heG_<)yJkY79o60|Cs<6 z>`;vwl*~v-d3v}_4z?AR4vf`IkM7=L84;#Nr*LdPJy7l*!>LFH7Yx)*A_pHa&V$Xx zGs7)qN`=8VJS{p0 zxHeK_%B~-0tZt)u+|q;nw=T=JstBo_C{Ex16me^Z`nNIKz_GRdt%6&ZaNDP2ZB`3f zO-=h}{nGGrB7PODDi9%DUn1x$BxjPA#bNlxuF z7N4uO)gJf5I_aIX?;~UD1<*~T27=oGdVScx!Q)>i=VK!-u6LOj z`}lauh5Oky{2ehdZz~~QOA;}DIRMa7GgxXifCyyh5wXD`0|!U+*(r-_ttYF!#oc#%RCn=SzmomjUWznN zFT}(tFk2_K$g(l;-mIzl#7~Vf3t@j(6N`|FZ5FU1^QtpZrLX!X(dUp zxN@8xaxj%3815UT5pwQicblD+RmIURvw_?s8H~1lh~qxK>q>`Tq_a7BP&e!lYb8|f zLkmzmjAUm`F(a#vc(%qfNfnNr~_Tba_G~Su3(cre;@Y>I!iVC8>mZ z^K41(JdIb*w7LvTVb64CT+gV{JduV6&8w4-k&I$=#=KUjw)-XD)&8yaTKV{|ny6|O zgqJwwlXHn%>H+cqt=PG`{h(m6t>FfCyQC7DU{2bcoXRKi2lc9ecu(@nQtX)Y5?st# zg<72@_!yX7mLPhE_7e20h2+f9<=N|y&m*Tg{n^249MqpdL?>RTllw@- z*NvxK;g^Dgee88Uz39aI1L+@?^tOrQkmwpax`AlDd2W?zaT@udZg>wLuu+9%lUk}& zFc*$!ey%QAvI<&HyU!|4Z;j4kbWFmXi8z0t0ZgDYGpszhVbe1z>D85w0T8A_<6aLY zJ4@gii(s4nJw=d%Z048K181L^naFDw97AV%=xYzINdz@#8b+6YIhsNov}QCtNR8>; z&}b3@jO=siTn~jl#Ha113||cGj*qfSs{k<>TQw$FT;;*5TV_D*v`BpSFXNPvn+#A@ zK#jtE8A+_?2n;YVs;{^@?Yr%9!tmNM$afprMvzSqr|mDMNBqS|Yh=G2>@votHJpij z#dk7NgE*nI=ZGP*a1zOr27kq#E&@WCNJk&vV4PGr(N zDj|Oy9P(ocd3kWigA&p)IOO{hvXKx-X=f|>A*)yAM*O>CGu67yG_tw9{#>M~G{wyU z?^SGzjOw0-cUClfTw&-E?;yY2eX@^K@ppQUzSevoV9a`TaFPf~9P*J_lVJ_??E zQqUJj#i%+B87&PNBS?Tnpc`_a{+vX>ZisFLlIN}?9V?6n+nKTCC|a?b5Zt!L-|jtn zs2TqBtbLjIUBsuiO?zI|ko->&4<+I(!3}&>TybQr-B_!cw&?Re!I|^_SbWo!5g5J6LQ0Byg*P8T~}(#7yX zmx(DLW+2-LJ00dDGY&a~ey z%1s7&lLNkRha^+8to6$zdepNOybDSkTd(otSP8ws<9G_xe44M{rDOU>W-5n|V*ZWK zqX&Va4|KSGeS_Ed7uu7*(?Riev8W@(i+m0&unG=TYE1k+x2&;msQ6*FX$)>Z;0L2U zwR-C>=?3Pz76BOh6}q>(yS1I-u@h_B=%AAid7NOtO=G~$2jr}l~wPb^#Yl0i4gMh^H14LXZP{Us>t z<{joopO50l@GmW2i9p)Fw2HRMYH98BKP^Pkl5y#?Qqv=(bB-%ekjYBwKY1BN|B>72 zAWmN9{fjm9&Yeg5m{gHxv6qd6!R-)ZX9_gkxZN>y9zz-#7z~|LBbWvCimZ^H{ucxO z|29??L49cqK_eZI|MBpF-BT|IqI43_kE{&bN+<6o4g5SXLgU-*^fY>5JXt|!_%k|w ztRi+^S6raSRRJ~{3px+xfivB;|@AFUW_b{e0 z*~DMjql~6|coVV6P$u_ngr>!Anz!xVZ}Yf~){o=_oaS>I_g|7^HJ-{JU0ic98B-e> z@3Vkcd!TcuFnxB!ri93+I?|D>giOu@5;@d)#o6f{CO^HyjBK!- zva8*(GnM8;lvR#fmi826Zw6|&27YtKBvU&CPA;QlwHyBTdxP#j!&eV{Y~1y*C(Ukz zce2g{QX9lOxj4nST>Q2a65cS$m!)Quh_G^q$DHL4s{N^FPH6V{bhB|P^N4g2BS^d1 zM)L;@mOc}JE2Kg;?RFzx^G9KGjX~aO#DlzZ5brTs+DXe{T+RzJG`bX7yaG(dr)Xd*S~{zyZ(xQTz^p(-b-}-XOT$dYBoAta{umF-p;saduJs% z#S)lr^Pn$c9thh38^`8D1L_MV)lfc9ww;XzY2z>#u9W3SN;OoFPS zKCs0_i$sexFWqQ&)yR$`+da`y>DK0Oxs5ekG;M*Oks;^Cbrfa^9-+n@*iwKVaI zJjI-rmli>o(>#t!$FQB#SX#OMxY+wG9WKfAtG&Hj|GCW;q(39&r{#Hm+ch z$ELn>jr*tZ%}`Yg4Nhp1B{wN5Vi|d-(RwDIsQ8&&1y1>SdF_J?F(gqJRY=;9p!e0_H+#T>B_6zQ9S7NidCou3Qf9 zuB5!8O3}Lnt?@KbHu)E1y3~$n9~^Po6GVtEH#s&ND`kL%`M6m)*htZK!vf^yb{L2O z?w!c69N#6jUo-x|fXC`)f)jVytiQB8_x}(7FD<=UE^TP|_{k;T)=k-@sZ!YS^l!h7pk~o~_5V9--GMjAcb$spd3CbHm)@k$Q88JkUtI zP0@qIeB6yx;R*s9Z-i!Fm(i0tkf^Gb? zVv6Cq>sw0aEz{x4W;JXTb5d7qRw(hs;OZCqllxxdEb`oU2}>l{^pf+(+E0H~@}Oze>M&ZgHMF z`IV>1dDip$zj>Z@o?m~h-1V~?%U#=?r~f9(omcM4zq#Di!E=nK=IiCI2b^cve9Cg3 zJ-3v*KH&-7TJD<7GoNP>&vKr%JU`=khG!?wL7rO{l)K*Ik^WtA8)L(>lIMFo$N#O| zHL|wcbs0|?PbJTHcv^Wj@ce@3X`byTJlB7t+%@=#^Zk_b?BF;3oc2x1|5mxneS5j< zI-Z+(WGwIH_aPo>lRW>)`=UkVt`B%5UYiEsKP~6a!cXxYJFwY zt>~#92*h{bM!vdN%$hL<+p+-&#|%tgDr+w57W3XvwYp3Djb1EYH4*dMtvqW(W(;*d zT<=RLO8?(}TwWFiOP?6dCSo*g;1C%S+6%%=bu?`#4Dt1b$S!|g8Q3KCy9EQaO?cl z1EKw#mI7);scv9UjlvisP<)LoXp+vMo}~L_U9D@ZYH%uCOFok8Y?)DDiUyi^ik+d= z$?)}mnc)p_jcZn|buwH^25IdaoTKr}et6gl^N!zs|I0>8wr=>&3&bjrhTfL&=-Kjj z8ZGZ}+H$`N;9~Xo?4OLfn*-|Wr2#dqB2YX&P&^DZmtksq*gY)e!Dyx;Y)(Ul94wlv ze$Yz$rONFnQUuhjQhd|{`DC3%Rztd3;Xg#?Jz=*YnP-uC78VNPgUmDHadF zz+mc;w6e6<--8lg?{x2M8hH{_3>m=Raxr8?^+=|LP9}>3jX?d?5v*M?8~%eM`nYv%iWxi;_zyVn&v)cZ2mWP+&6gr?Ggi5%Go7FNTL2A4pw_IKYrVm{ z(bk70u~9b(c6UI%xfF+4|JLBpM>0~ICC#>O)!E;P50ZeH*W^EE$)AE4ZcIvDDt5&( zJ^q;sjrdK}gHxl891_|w%vvl`Na%xB>~m7JJb`)QPllMvMB?5Wr;Ur`&6c1iC|N{%B3O=ap~~!{kiahMrTU?;dbzrIH=v7YOq#yk znazT@E^E5-3=f&0U+1n2TFxNQWri(!dyui598qsm8olbpqQ+=5{JXK7J2YjdXKWT~ zg=`70T5E2R#lt?s2N!<42?NTymoRzvRIA_X{L(Hl%azNA!*X-@(}UX{VsVAlfd~Ug z>#^Cc4p{}|_5vgTcMVvXdc@LuVWb!XGkijaiw{<*-#P1}Qss>e6b}z@`&y#HQ>lVu zj|Yka$E)esl&qlpxZDqCRL!%D4D` zz1A|`ZKO6#Rc}CD4MztV5Dlr=K|yS^eZJ9FHMhSb3n&Je&G$!G^(%c^+mRN_ zv@8s%WxYpQY-^b_13>ffpm|BW%DiNye0-Yzu#@~40P)UL=fSn$MRHNZ=g=_^P z+TOuD>rtG;RM;1+{E-jnV%8-gUdO(&Yu zAn$YScQEN*D`LNcC-+(vybH#f+pGZ!INxhsqT^Ym@-g1|sF9CT`2fsI%cN_LfafUz586N2VXL+n9Dxmtv1xQME<-D{w;=Il1;)-{e|Hs<9z(-Y`d;hsYxb8urMoTrdu_rcG zBha4Upw5sPvPUKu6_wT-7DVcmk_?2(B`^tOpY3=#w$&bcT2A$}w0hK5tEjCcf&^49 zqE)O`@lxG!w9?i>pve5czqR+|LVNyw-_PeoCws58*L^+fSL0Jt{{mabviyN`cNTivXEsjnJG+^V$NdwgS%CVbS6m+G)1^PG!bW8%cYXx(326*0>(tc$Px^M{ zM*kDQGInldqySyhz0k5KryqzuAy}GxthKsR{o}9{(Zm`DWV5+%&y4*~;-M%;PKYxm z3(&U=!KxD(U>FMFuI5YULE^qYdg13M?jlLln(;#T>80Na0to^u=E8(^cV?^HkzWdT zEx!l{78CGTIs<2K%SOhkw_@ztd@n*^Fns6Tc>@nw`0g;S;P?DX#ml=O<;{ zhz7^jQeuQSq|s?i6*3+y`!`9GeYd~&vR~4*^5Bgv-)ORo0~@RDkIeqcgEb49u3r45 z=FrN6&GQ$`Nqx@Fto#OGf+vNQMX(NYTev1+F|8~kK*1YV9-Py3<$P<6G^VV!YL)Ty zj$3cOD}AtR@g5iX`*C-C`x(^sS4BFcLicR$E$&lV{i0xoF8?())l?StLP{{3(*LPw z`G56)DjW2vc=_u7Pa_9?DzR?4ni1*$92)ew)VjqU^m*){&v1259`w0<(C4AnEyD+W z9zW=FnRQDR`GfwtD+YZYX5I4qpwE>X8CiK2K@A#Rc3f!KX zX1FxQ7VBQfBh^x$jkQyfMzF9YL* zTLahI-<3lj3`<(dFn;g4v< zxK;D}*N~Y}M#3r`f-_^QN$-8>hQ7qoHa8m)n0|+MI&*J)5Be5C)0^gN8@yy=6hDdf zoV|$s#ccNtyX&12CM18J!@4pf1nqisnYVKtP344zNn$&5$zCR`xO@pmV5RUL=3|3% zR@Nm3cHMKz)x3&>P&%0`#jB z?&Yv$F5Brtxf5r1vD$wPphMTn<&&~`M*+FXOnf(SY$ucMC}q#xdURiE_{7nIApayK!o*J!y7R-{yd@@)`QQ!;GtZ+=6fdo!uL3Uy_3nXC0Bd`v<{YR;$^%N!lN#oX(?c=3l`s|36Jx^qAwAlmS*or%LbU0OLC zG59{48 ztCc*dfqD5Vj9n;~GqMO{{CeZm7T&uU<1yJ{XA(lzexczhp(aFqri9cqD1}!S{W5#8 z4h#QHd0a&1i_DCSQwEF8WQ!JW`@b*vXR^xWZg=WiymgEVrX1g37kNcZyKoO5qQx(H zC&*%$KVXOXz}x^`+Zp-S&5(Pi8F8=6b_QwQFlpki18y4IH$WaScvJo`GR_R48DcZI z-m0HyFzXliBPo$*l^=EYb8~pGsg43($NxsueG@9}6pg`uEzuYd`yg5!JE7YaV4SxY z!za$z4#kIGUAS9C3 zHV^C34+6HmO!`U2$)1i)$#XPb%H<3+%I zI3k}7pzpTYML3yh(GZV=I-rN9pkaKNm;M{Oxv-Q*bM_NDtZ6g3?8n-Jr_J_@G5E({ zUX<|y^PVr`8FJ>U_O>ub3C_CnoWdaAPX>Pe8K3)`)?P$pg=U98fh=u-*9a)69kvs#3K}Aw z4Tne#!7sHl1VbQoFpSb^;H<|&U2hkAn-=zeeTTvl?jpWkUS+fSrVtF)1vw7I-9-4! zrmLdA*3sG6$5F{!ngxP8u#Izh%Dm0PzKwT2@77}%ln@w#(9=sP{oT|&E__j06HJd8 zA-n7CQgCj#WOx(8J{w0;^umX-W%O&dR=P^Qp(z-;)cI;|(zUCkCmgmOWAsNx8c-E( zfR9=|ua6%bbwT#qyst=y2dbislvtRI;=#CUBuN*(xiTZTWlsb`Wu%F7AqWC+0!%SJ z1DFmv5#x{8Tp$9mwvE{+>?;SVO?it&$;zsz>%md!n~}H+CWM1DWMg8_)4FAz;cuGwl0T!7%A`P%NMo$>G?E4|rF$Tsh6h670-NG*uW z_s(wXT=JQTTipZU-#4|u*8X9xn=S3|qP^K0)ih{tyRtuuOm5n~k9-^gg|B{YV%-I~boEdq1FvylqY<=vx?v{3z~JC18LY#9p3P zOIwgf+1u8cI@a#)q-Ma6abyMq=>typ@wRTbNUwBDVR%c%}tYTKEj!FIT{n;#&Z4V__tD4NH(5!^JDO)5K5uN_~VN%QC z_i!+fX+p#BNxJ_fWE^u3CfoxtR13pnE8|xE6t2v7Mct3(a{Oc#XR^B6{cX(s?O=Op zFrNz@-Gg8tiz|Y?aZH+)!)1x<;sm#C{tep5HQt7;B_J8GHdz7@b3J~KX2boee^t&q zHCb)9@DebX_5;6&TS`@?03ph+CEd#r#`%nCK%RbQ-MO*nN*XdFpF>x3DeCIsrx$*Z z{W5qVw?igt%su6_*?vbr2KUO!GH~?DR*4 zsZ4@xtvp~N%?f2lo3QQ93TY&w!dwtluGPMENyt6A`hr8=mU^h6qlV z?LC^0DRPf?jv-40H#k(m?F~yt{b#pq)Vc}SQ=C)+ex1*cGolPf7>_jm%qP-p$3Hu~ zged|!Z&^OxJv#jCQXKboXaBW&Cmh#pC$gAKf!QxE!)1D1FBXYbkf1C3 z8J7f@x$u70pQgy|W;oSfe@Ge59}6ddBGfW>Xn1dvAa3M$hZ`C$vVMzuo z;eHiGY9ONd+wRBU^X38b&$aI5W$w1PJND*=%qchf_raR~lII3be-?}1n3v3L$xr<> zrhHm;$!D4Usns(-TjISJ3#LCdq9p3XF(hW?o)H8@!#xXcPE1}Nvf65Bj;5(5f1o!A zgU!a^j{I@P8*#Ua+S_-6KfsJ61J11bX2NxSLMIwZI#;6VHBMC zC$|3D80zgC(P)Ufr?lCbQ`$)gr+pV5KHM2q;a8DGv!?QWCdNYK3JcYE zZ`PHXf1f$58iG{owF`2#;ndf#g+MOH+l(#H`y)@)T0i2_W$DU_z+|DR}Cb&#>7};RWTREX!n!?cU!a?8*N+^ z#3>Vjj8kASJ2zLhDlsKugX;sUZ4)6bxLRW2x2-nGY??Cz8Sy;uL*;u?Smpa-YqL-?-MIS5l=AWSRfQNT>0OYss$kEa2=e?#n zMN)n7GcguVWel`YWm>?WQ%GCJ#FdO@e^tF~0gKwq?iSL#P9I^TV<}RT#vw&ZDyu3f>ighF_r)W@TvYoEJg_O`y7=E9GbW`V|GR*v%NL^*coGUAvEpz$6oX9$^t@~5| z3QInzurW`Fhb=?*i~;)Wuqq-HYA#)Db4T-aZeK+5&*u`PEEgg`&>6H3vS$e&kg^|jEl`b5A(*eeXZxP+>6A^;7+hL{)2G05Lly_(7>pH!MOY^6um}@)>!7#5XTylC z>6wN|mbC#%Dmg2tb?Pv`OJkh0?uac6mqwhlF1DTNN%fIw@+U1)d(+I+(9Lx-3!UkW zj9pEn78wsX%t%Nv_*UCrN@*h#V72w|=1-}2mc(Pg$d4Wm{o$?_IPgUf5>0mwj~71^ zP4~zU#}RY?V+zHp$t3(kEsy%2I~gjqU%ymK^JKe`GP0%ql6_d8ha{bOp=`C5Pt6nM zl%n&-+&d2E1lFnhgZh%rY%=cjs=o{cVr^KArRC>%)|W%O)@ptkvn>M#@OF#Cy_q&}iy06p7BALMMHhmXIkB$(!Zpdfg22t!sH8T*mUa>d*SKmjn8t zWntt_*s!}sB5l@tn`>l$keY%viIlle_KT31iyVT&uZV7r<_hOI7ajIpAiuN}41pO1 zvayJsorlT!gj2#%xNdgBiESxE6)U73^3Bd%xYz%d7Kg%oZs1xJ&<$g1$p_sO$kepa zGz(t;g}pQjd*qw;MGv7zWNj#N3at%OOB_7Yr=Kq4BV;C`vU`+N!)x8H;kwWORI&eF zruhB0DSl?)EzOh89hG$6p)?5%*A_g_d&rb<76AO&dY3RwSvYZCYkiEBCoq&H%D!MBq0zo zlVy(o0swoa=(zlODdAoW2zSNYIgL0+!Gpw&T3GI3ySP`A38aAw>Spt-$j_e>XCE>1 zMr@61(4*b;ekrv#x?|7q4(!j*pw;ftt3>gNS?js~!OU)bN$R9$4&E3q=TAcwEox*r z)y?9M8BP=m8hvz2L#{q99{xk~3EGuwxh}(vgTUkdwf%*Qm1cUiS^Wz)S0=4hr?Bjq zKdu27679=8XR%%L0IByf7AY`XuK6_M-bpQLuH;*7EWBsYXH{1O;Z^E+_rLn<`2zLe zYq7DwYBSJ^E$+vS1ZuloVzrf;ujkfAdj3Y~K!mbi7y{6F$}m?S#u=W+IL*jf%HBv^ zE4e)212f1j{QJIf7VaT9aIB#|aVn?(AMOJiyb z_n$niOQGMI`)C{(wDS=&YU~qxDPxr3qxqy6w*s}g75L7*+zPDRBx2DV6fV`}03@X^ zied!#jk~_myN3mIBvM2;CyuaU;uCW5iTk)Cnuw>2o;bF?+E!3b%>BM*N&E%i7{0LJ zeqty15%Wt{`c-Djc7J1&1R)@qy>Grgf13(-DOL-vyQ0k9GBq>yyCg;6s-)H~eig5X zcJV8*5uGHNToff3ycY-WT&CIK-^ts>^iT0^aflQnx(FQ3zvRqI_N=;0$*{hPuzdv= z{-`4>2?`rUL5C^B&l)f8ET#_|7k>$AebLA$W-VgjEvfNQymH{$0sD0Litc1z9*#Y} z!-b2jxceur-_+|>ha~u*>lv{fX7M$3FA zCoriMr>3f-=K4bSjY~?|+mPPMjVr7ymB!i*BdG;F5_{Hqv@2Ue6!#A7qnh4d{g~xNW7%hv5ofCFJ zlmkZQZ=?CUAU>fp;nb~N+Rx>p+AJc5SR9R{426B95tBr{l(nA~q}Mg@5r0 zg<0t|^F9zC!cE`f9!|LJLKO|g?;=;cXXSy4=0$UwYgQh({^|wunvYv~V8K-j7g+7G zOvHKML=F^Z&Ru|y+~Wv+UZEKZjU-f|P%WXPyD#7mepe-f$4jP8j=eq7YTrZ6wIP;awgvD~qGc9Yk)g_rJNT{AK)%0i zSE?+%q_-edl*6|U!;+pHyl>TqG80JG7B`P!`!AQcR059G)(M^2qK68NX4=gLYy^Zg zYfC8n2bG=l6^9^@7uQB`2*P>soj&HoAm+dDj~fkjw@U1T9>K0Y@;htlRwL2wZo(+& z1!ADK*v|ZNyu&*SJc!mkNoW4nuk)*r3 z&Ykp%+g6LQSze90y`G_5^StYWX5v~ z{;^%%D;fBTM0F2-ecY1j@Mf5X#ogI*u7tz}*_<6+z1e-i-Qu|upzn*Hq3GMxs$!Uj zP<9^|rnZ{P#QgBVSh|bv45k{djk`)LMoEUlUx1@(1`%LH^ld#5CtgUSN`O9vlP~54 zyOMNZ*of9r1c<5Sic2;|kVRq++04FPqs!x2_}9ev{1d_eu%Y^{BpX4m$KXV6%}$6$ z`Jd1O+$I4N5#+N3(VPls7aI=xNiXyS;tq^68+{Bojy=%YKeQNDbw9v zyvzIY#pYU0@rXbDNVVXQ#8fFMrpzg6n;V^Dby4y5*UXI$g13&Y)38|g`-Si8!^yJ_ z=UO*N6^+$TE`)rA+jn>m0oD07tMdH&z#AEJAH$7p{%YXQ$&902l`&yBo|w1fx~u&$ z;m&HxEvb<)XM;YAV|=2{rnRcW_o0%6+krAYUm(J_d*_2oG{O;Qjn2W6eYtYZjn~nz z+?_DeXv_}uJNv<<0E*jF1doum7T#(9%()uzod!0|B`PS$t3a$TD+7SkEtyJ(2J zm!Xd!d%EfEru{FYTz_YTN@OTPV8u}O>H)26TaP^`#H5^i?XEwdA+_Bu&Uz1nLfKKU z>YH1kG5%t}U!Gnjb3Mz4g`ZtkieIRQa`SBOREsk-vqp4?`?3aR>qVmbjXm#TTQbljivI4MaZcUiec1SjS9&G`@nE_3q`h#8e;e zJwhkW)YQn*z;=rFete<21rhJp(WE*y($Kh$o0&NEH*8?3m?aY|6)=W(6EZSfoYIR2 zCojW+?G^t#i%k~Nzi-l?_RrIo`{_S6>2q3Kbm|T>3$iJ?*IUCoedWC~>IT|-@mHdm zlGgCki~fbw-SHJ=488XhBaw7d4-V+3iy%nPYZNNSTTc8wU%T&o2FjflsXo4Xh`e!? ziOwq?A|aS*5zYln%rp(8_tD!DMVwX}t45eUQaze(J*HB8jXt}0w6e^I*v<^jNHKr zqHesv*RTt;>;4T$c+k7!e@dV#pLlO{)1^v*m{Mo+7b(%8w0(^85jB#A8;iG9XJ6Wn zkw>R}TmC+EU;EJ0`WW8x%P>9Ohq!`y@t`2E!u!ikPE_$7;IOvaKr_riFa=J0zf3PM zW!-&Krs+~+M>QP>oG^jUsot8mU_o8>oKb4qn;qp|h8U8-<1vRwXW7v9*HXjdZkw64 zY%yAN`StWBG`bVFxOO%dVcUeN)R0ZQBv748eT`;c&1z1s*NhiftAEX3W^YGQ*9NIK z`}zC8tCR@Fuf~S&YV^$7yf0Nl{cViqHakP(;a@5L!rzhS#-w|FF1r|FkbB9z;=jM-UBT6HF}$yD@a6d_zQHjBQTKrGm7oaXAvzaitAdU9TStFUBv zH0-Bd_@cjhw|k#7s!@wr-{%bDheU(#|3kqDhNf^A37`@y-0}tGfBNyn3%yvuf zI9TR;0_POO(K-gf>Aq^ax9y|=+daozc0l12Cf&wR1DA!Dx^<}jabOd4Q?*+MbL&OX zC+2KCF$d*Y$?p_hj6`$0z~+?}tndo4#G&M?oVp}VeZ&?Y!26bAXLFbo(-abW+jltU zr8hcL2tq6JP46>G#`K*Xysn{*CFzce(92u0{91B#2DFA-FS4U=~ z3~u=WnQf4;3dvlgd%H<|Hud4O(BBJ=A#HY%KH1) z4*X8sauA4LW4@z0V?{Vst7VaSVJtN|{l}ZRI}aObndz1o!>ic`|ocewLpv#WvvNY^(c!^c$X9twyu|jjkDQZ}x!@OjN#oM@* zc!0iGkABC%h^DjoXus2os6!`oRgY@0s!s&fUy`pLgJz%b9!>8k+J}m`72}++udAr} z6pi<_v(0!L_YWHHoBXi5ha7HchLDqH)Cx==CdAvIQtvfOx*0+tR#_$|kQLk#oPcXL z)zaw|?b}&ds9m2{Wz+fO69TJYz;>56w6d@xErY}Rr&Sb@-FANH(Lpu|X_nc}>b-}+ccR&iEGs4_dw?lv!cE6A4RYfONpRF3WbG5S=6d0~r` zHCOLFxG{-L$yaUX@^ThMmb*K@Q+8%rMaHq0yz?4xVM*)gZ#STI0xt%jFxuy9-$tEQ zmBB-0Y&83MNPOK2qe(Upi6MXTDre$O^~wE(kP+fJ4Qy1u<2W31uK!W2L_;U)R#p4|42}ODJQ!Gd?s!35V}csF@kidTr_+m${nwkAzyy^)cC*uWzjxI_9T9x>MG9y@a7jlN?|Q7M z_WX`i2~=y=(%A<2wDo}zH`;<;SUH?Hrqys_+`#+C@N|v=emG%X{}|ME3LK#m3aE4k z(RX?WksR*%5=9Q==}>1hNA-*+fU_+)h(0(~jGa4)d9shO^I9y=*bxYt61O0l)?bPD zeO0iP9>;V(jNhrV9Z1Q5uz^AYzuu4Ovd@foFgE%6JFWJs{%MvQ$wD{Z_tSsnpQbzLfM@HILH+>3YGIir?eiN62lshaUS}3V0p8aCUC(cb}0G?_Rjw{qKyo^&nkP<@3HthE8medBj)K9=dydO)xXky#2`Fk=1eS}yS;V1 z_p^AuoIaa{@%u%Wao~RNHl^+0`(SQM_ypM}g1dt~gMhmeJ{RWB)28%`eddm;a)-E_&Ic^A zj6co02>yZL=}dJ>PK$>hF|3b;&~d5#?0MN{(Dz)Hp*TB=6iX+#UxJkV$NZdPid2?= z$j?!!ntxUV5Vs7LjvDT>bl`n@-@D#q2JO7!{TuHAOK0d2EFH2R14GAfJ6*UpkHzl} z7&@=JN?DG z-5YzhT6iRX=M4lpMd_vB@0fL;=kFNiO{c^?1OCn<{yWFB9o{U9u*=gD{A z?_4xg{GB_qN3-8%NB8Xr$U_1PoX|v5!TjlDK93;1j^I}qAqv<$j!p&Qn5-9FBjY0@ zyZ9}UL;j;v55olMHZEuUo{F_Gm?vZSLj$Qc zqbZGe$Yc&PD01HJH{sQUyTSC7#!T*S40ozD4?ohTJr(|kpy$M@W!`Wh9JyFrnVG3zESIIhyT|tbJNz-V0<;IIBBItWugs15+gM z62zO!V>7k!iSM#z*R;`aigVKUQtlI+7n1;!Ce6<^N4fAvmTz%iWrMQC z{A`+7Kier}L&o#5R=>6gotw=oTDjaBJNL}zo$=&t0dGctlJ^!R7J%KOY&<&r$8Cx? zB)Rn%!g!oQ&g!4Xt>5&)fb&+!YJc7zlgN>VH~Z3SXuj8*yN>=?Np%xZh`RQ8K(!J(h^9AEs z?k(#{>#o*Hx1C$>q9kXH=;fsIQ_1O*Mbg)VB%e>HlSld~B`;VMBS(lZbM34d?|(1n z(Y>aOzp4V^a&;Ux?Kl8UxqUxEyjhP-oi`J~f8o!gX4QPQwPD6J?geFDONia`g0i%+XXn%*_&eh|Z_eOI z?03z$!J9#3KH1pK#yCY`P-gQP)?*`ZH9sE#32(@UpK=74UgXr3&+G{hekm z`XUF+pBZm|5{=M!pufX(#@uf;n+1O|yYazj*Wn@9;EB42Vw3+%SbNdwoDVWS`Sr4H zBz)t;?#K~FJ}58>m+N*)MueYIhJ`zA_lH`)$PxfxHur|t&hwdz7ZMA2w*rQU0gs2L zsKpxVFg{tSWs6o{d#71_u7KA``|Ir$+x5%6C^Uf_==Ii-sE7W(#I7#VFZ&qAH8K3QY+aA2BPF?|odp7axP9NfL zA^(Bu0`}vW)dA`=>_^zZx0I8{^{X&kH{Y$ZvwAJ{_}1*5)n+NDThxrzohIHa<<(ls zZWl`|eHY(YRI9fTqj0d8R|ktZts&8OEoLJG7pR!pf(q6%dJ6&#Lu+0-=t{ucFIFJ+ z1^~Tkr)vu&tBfS4}M3k+Z09 zFB;E=SfR#VT!wBOD<>E;$#yYPrhNw0`NQ(-OVyqO|DZ`z)g&&^7=Y<&)ifI~Jp|6m z?bPF6ZPzj?FLuW8OhwZ(Ai0pclZJ8QZ0>c>g=<@=%e=nZOs)97fZrZ&@6g}Auut#q z{>li5TdYqQZd?`5e?7P=Zhr`-m+k&8YIuE7Z2CD9;HqtATuV$pj9+JO{x=M5Y-Tw# z?(ij=cmr|>B$)Z$|3|vU_5+lOgF}0VZx})2d(vPqsOli+TICdcbSpi}owWtXcpWxy z+^a470@8B{*D;;vJXC>(Z=it%JyQs}>4+9UT?mXiYRqu$toK*$r9&J&LDDhj+LBo9 zeI+cX<{{}V!rMvr?mc8_V62DYv89YC&MbQ=Fqs(@GrhO~*6p{x`a|PqcUITo=Eb$2#60yjU#$SY*-H6zVw08)Q4GaE|h2i ziOc{F(6<_tev}>Fk@_f#dt5Xa5!Jhv>(Fa!tPSbqW~gVOM0dw3UfH|m$D9i;g*eyI zCAt#jFdkh8LNRChY+UGdnAlD~wwKttx#*^)hOPIQUkrZChrb41thj`dg5 zCJct{??Gp4OV`1oX!W!1(_P*P#XGGHPtS8MxB=6S!{)_}vR>T{WSfpEX6fPSg0P1L zXo1xYE6jAWh;~vY?Y|mifHbrsQanFOoo%-W8(^nOiuf| zFh7}#DwXQAdw!_K5AF3swSK7A5B2(?+W=1Ai=fkf7w?mtspR@<9Y znQ#|JOuK}}W-*W`?#(R*_9pJ)ZT6gR-jIqu#T3%E8Rbza;1_tuy#-;!YHdCm3mRwM zLlhoCdxu)>y0UQ1#;vD=ScZo$^zMvWLX+7(@F_XLMh)M~#$HiBJTj zh?_CE4v~~I76ww^d_d}(<9ffu_oY`HdA~)$R@>j`xa4dq;6IqTXDig5w(RLG6}UYv zRITMXPN%nZh>F7bP)g_Fz5EsJ+=MfW(O*$p?w#9r;k8hm78 z_1!zqj}-#*)9Sky_G1lxFlqJOJ4vxLAxP`qF^hUV%TL=Fw844U#2!FUm^Nqu`Q_@n z_l_TH7KJHS-@R>qtXUi;R^PqHOsrdLN_d5O_1znDfhpII-QoSapS8>+65~l9yrq6@ zs4rIEy?K6Yd0(u)dyRfy(8_ zV_Vqa9UWGwnoXyP4HW4iNF&3Y`a620EZFa*YYy+tr+ZkUC+P|^Gw$)3r3K#1_k98c z>qA>09oPiTykUt++jR}QHk1wo1m|1xf%Q~ocSow2Fm5sX|Cw7%gl@W{5#2s_M`PkO zbVqGr*6wKXXcKBogMPZBGZnJCqq9CYOu<@01)HN&AlH%{%0M+`6VbK>50y>Cv1yk# ze4_uynL2w}86Hcg&PJgDv^2DP>g;jbE*VM)d7uk0c?9s!#`>m4%+UYWaKu2+f`(6Mwa9qrUY*fa zKg7FJHJ_uruHBU8x(P{p(7k+hlrfZKxaK z)X(BE+^I+2Z)B-9Xm$vv9_`Rje`u~-H#S^XzWlSL1+>#_A@$ebZEHaAy4d77wauf` z=axlm=SPBrg!{UN{m zmdR`kMfI&gqyN``Ahq3}sVxoepW@hLLS_%)^>OCDT15T8LyZu&J#pXURMn!ZG<$S| z>AwvtgB4tzpu1Q3WGd{&o-Dxy?Xn@flx0swjpWIZ@o?{Qg+tk6-I-5ffn!JY%qJ20 zk5zYiPaXa=S4>ij+F)uaRkiRTp^!!`@rdw;?Vra7wxfS(n>RJ30t8Ju-vP;GPeW zP`Y`lKsHY+t<)w2t;8-`%M4M&i>Rj6m=vI=l{TLRz6v1 z3)bl)oZ2cqKWH`wfO4-NH29xjuOIAH;RNM-$0wd9zQ&FCcFHXz`Yxhn>}RFgg?5v+ z?}@nq_xG8x$J5wGpRn?27d6$Zql=)fulyfTRK5HQL@z(WJRJ56eKic@VTy_K4_=x-4qhK`&mX+@ zFc=s-!Sc*oQFpiBA&{y2Cs?1tN4DEi9uL=t7M2sSQ)7{qyyVwmtJ+;K}UL7_dGB`E5UoNuO~Rgi+* z%NheZyjSFo5ztImLnTpqzZo@l977LRq6HbNoZk`uz4CGeQ9)4%AGd!}D!j6$N+aO3 zi`pjS!&7?!Lq^C4r}i>G>YT0#`FmwZn9Is)D#I!Ze@oOr53jd_T#)}uZLrZ?0c zBAM;}X9W*5LeFEHXzx^%C}AD;Z(-yL(r*=}x0X2O-5>EYUHs0tPifQkPB8GVVfiP z^w_s4)Qp_dnhx3>tzOg0Ly79ggNPb7c|SHqXkv)+zLPIvW-ylmileyASbki2)9{t1 z1A>8-zfmUz6RG1@{^t4o`%&rNY|?vbSo$|x^wRtlJM&#L9vK5C-WNvDViSYti}%-q z(AVEpcK6)z4qbSc2-;yB2XWJlxGPpebaeHzql3DO0t&AP#R?aXr)zkFMTJ-@^zGEf z>v>E@!&-N>8X0pR5F|5yvuyWkWz9qF^s+q#sVSUCzg0xZ%O|+Kd3#DDq--!x&6!@} zzJkrkuk#+wZHJYMk>)Z|uXs&E?i)|?rYI$6tDxCmCKzL`HD;{T8{7vq`|**s^sTjrco5}VvuvIrrtXA_xohBg#$MRF^V%#>_7$4%}; z#Q*8(PVzZa@$52pOr10HIc&l`iu4k}nYSNO1R9`?B?~t|6&f^T$W*rCi`lxi&`S{9 z=x6)3uG@&gYo6a2)NsBpY$MdeiF|1#W;?OvHyZRHZy;JsQTGHJG|_2NJz}(3h5sKS zoVPF?cW>ls&X;@AIX}WujbYQG`8=6Sm>G9}+mJaIbKq;%ktu+Wgj*ZjDP(Vi=@I-6?XByi63D)jY^>w zmIIIP_ZGk6?MNB{8>Y8H2<9(rFK_h(rQCSX- zRQkZs)Q8>mW1Ht+y|_oiNWvh=8L{DhiXo|wNHM>8?&6-+N|71&Q*>u^#!b*kv3>ab z?WP4cW?>a?WcWS1l?jaJh^jd3Zp7&-_`CBBtsFrRj&eyH93jJXEOltg0g?-TB&o4^Gncx_t{ zN^0#*`VHwBluw(6)Vm{3&mIM00B5HURTl>yezw3B4^7;KK^)ixR}GXm0)J+dJ02cc z-W*?gl+nBDLBBGx zJK_Fb(99-@F=Q?gjip5Fo+nw374F`K>QCXHGD?UhWY(#htjLVGH0kbg>;Pmg@eQW_ z-k3Gixod#{ldY7pb-Ubo^zldK60Yh zd$dp91#QN5K~IDG6Em3okYAaH{O||b?{-rOOC)AZ`^bm=kBJa$3v&$M=l|cq_t0r> za#Gbl1Ms;6%Kv`~-?wrF_IL0t(2fYSPiK(|wADkg5-J3`5oy5hpQ;#tP=q~ONg?RH zkvnssSMvl2;>@F;PvAo@^BI_z2MGqW2sZ1C@IP05R@)3=6!&7V5T*>lcL;6+wT%Kr z%wVl3@m@z97@$o$S65*oe$mmfOkK`^6O(yvjW_IDw7|Vn93^4S2S`n@!Vij-#hZ7R zA8Sr7QYHJTzI&^P3kv9F{f9Xo-w%bZo>VZfL7n1(RY>{^f{x};23Duf|AjQ3Rx8mn3x(>ZsLNiYB$!} zt+snLeH;>|g45e2h7g}zXss44A^X>6uR{MFhxd8$&4jyB9mE`|Q!+drE?oGk_$m~P z@rOceI81#Sw1pT3sO99iyEBGi@SOqv2btnY=6tL;_~kmW;dooj7N*{dhQ~CGqrR0I zLigDmwp~j)h+Oz#zHn1TKdEa#3QS0MZuc?a?xg#ybZLi0-QkmmH;r`s^EpFMh9&p$ zl@nicH$vrOj=pbv;Rbi+*Hps&H`N_=$ClMOV=;YFv~W)}T-a28MEa;R-X(tFU!pGi z^Z3fBQ)tjundp7|x4BO@xI4L;(BT`S+ISrgm4;x#yp@RIgjVAp1AQW%>b!Qm?ENXx-7Uh!vfoS}{IazsT}Bh;pl~y8 z-bmvtZqlK^S)93j5YV1>UStQP)?=l@dSLqQq;P7-RkKM1D%;JP5#><7i;SL?1K*gp;z6H+bbDiPz* zp;U~+*@VGk;xcgcW3`=T!a1xEwN5#sAhjQTV~t9AkUhi`RbrvMqppRgiV9^x|JePR z!?-H>fM?X5Hbu>NgZKUv;vOi4cq;T{e$dv(6%0S1pq0L#00w{;s7dZvPv((w&qQjc zd?~d*vkWaEn&Sk;tmGLqCk;2!eP(k>O+nAK153NyFRhi*+_CF2-}Vczg90KvWf@>Q zW6(kpk^b)354^8X+UAmp1wAK_puhQJf^5Th()==VsE-Frd8VIIki*u83WXogGPKff z5}-3x1pLmRzuie^is(#>-49>qE`DW079}?T&fZKw!9Xx4(9W-DG zL3%J-wSa!c!t!qVDqAn7@HPa33f!vfD4L|?Ryye?ZuApdZBtBm^(?}2uL9D~x9mi| zsAb3Tr1j6jn$^sg=i639yzG@wDUuc)o4SYfT%kn#{6fzQ z5+#&~i!b8Uz%vFVIweR{=_eBUQlfE#5)BO!$s7(P-5(^{OR&EWZxhmp{7#AJLtK5> zmJg^8ol4)=hhGNie{Pb{hq0f4QOy zlx{aqp`G;_CyL%OAgt2YD;Gb1ntslka{bt(qV!+qOTSI&`dTen9Ho<2MwKoNA(ej3 zfUrvcx^nUJOHcBqTrrc1(qGP(K0)dFO0NvkNgi3HKN*xha!{(nq*rPCcq*0L6sQgF z5l(+vWToZhy}xovf-AXf;+cUHW7iDauapj`@*DZnAl;9Y4)q{G;2ncfva@54(@)em5+#&~pI=uvNHkH20Mk>{{x2#CJ@u262T6p~X!f*IX>wst z(V#RcTy=e@N=Q><(nz+bznq;xnk_+^T9Za&hMPdM0ZH*40z6M|^=(8w3%NSN+XI%d z*`_-DRM;=dZ&W?!``;0L+0}fVPr}D&ec$&9{`Ycy$Hk9G{6XK3^1oN;JO1AO?)#s6 zbGiKdG>^a+6RLSLs=zUZA)EU)A^}zwCn9qe8kSA8>w+4 zwRYDYJj~d8lf_#a!d;6m9YDV)pvS8_?XKPu`}=nF(|BoC;zV($i<_;`h{h7QM9s(B z%52qbwbPxr7}=Gu>N=BdXCmCSNZfXK*HLGLYmbaN(@O@>l4@V%0$ql~tPt9U1Ap@` z`_aG)<7;JmY z^N~u=Jbl}WVnVDXY;K+fz0q`UiFNC}yvZfNbKbG1nX8*hvBU+pwrixG>*wph_&W>KbLlB((oC~&Iq5OPZ&YtZ|-}8+g_wlBxWn*&r}rtBAANyPVh#+bKyevcYC2T`dgo>SAk#nu|3UAUES*CCak^N#tl zfq+SZfCfI9_KQ6>$=nljSdUu|?&!Bb0I$b;XCm|)ZJZsOJhyU^)jlqtkIob>uWNAM z6pwm-qU)Wac;-C3`VJ+cQ^4Ajz9INV4UV?BXxHX3;jF+LhHi%KvgUb_@kf6amP3t@N|4mkRy ziQJ|*R#9($R1*)3HOj#8EER_lN86V_mMtqmGm>E2z03shRhqC=O=*}^W-gYWs*#y( zSMQe0#cYNj?y(a)7Fk@>W)fv##&v0r@q;%>fGblTX4U~%&AKeGkZZelI%U&_Nltw^ ztXKnc@W`e^`@thK1c|Wo5jMn(ebbd6`UREFc%Tn^tTja&PMN>~OGj9+m9_}N?M%e% z0BGFjau*m3f(OaYB_q4*d<3GqZgJ=f40zsKDf&lX+G(ELkC-R-B|Hrx`8P87h@@3n z{aKOqSTip^^m-es- z9JlSXMll-cQ;jV)@^>mb`HV4@DT=zMoc?ox~7T3rBb^0Xlu>8`i4F{wr}*t zyw%3JM+I#AjByOmvfJ*BK3zaPl*z7T(Y3Etra8>##E&{IhOt(1o2+%T?^=F2wtzE_ zn1+aHH)#JDqQ(e27IUYEE14~R%NQApo81z$7?=V8PdA^7%BAzXsKkklJ`}zVxakz6 z;tGS^xw~AraFTWN0e}@asTHi+wu5Gu{6#p^LkOm4M>^BXvqPCiAJl@G0@TdR0eYHA zBa)<<1y^bY#gjGg0=&I8&A^)gO15u(e!4cOoo2#Hv-kCZm_QUypZN`{CScJD($Mh$ z$RZOziW-ziA7PnHVm@ei4S+T*0JQAqU{mylR#;NpI89F1nokaIX-)(kP{Z;IVQSDY zDh<3IfrrF5+wNUm)sL?}&>Xo>39eLEp5uxMuQOwrk-%D~L1aGi(!{fi8lg1r^QVdV zyA$iZIv8su3Qqrn@>GzJbx31%mp0IHy=Cywg&v?81-xv`3E@+)W_iMPaZbgo8T^K? zY2l}0M!-zJfl6lkR@E_h!iiK_eRID_O-MSF?AM2+CHGx^E12q@H-Q5^U*RcI!u-qY z`=Da-D)Q8HSDX5lT;qHvy;qHf${V=BP= zOh;wxae>zpa1|KqZMh5Qr+bH3H~(Hkm8?9)eU+`QX#Z=vtlmo8%D+iorTJU#i;qj{ z)tmJQG8_;z?u+xBY4g2=AFMRi3oE=c{9u&{R(jQbu*L+dyzzc;k_py$qX@DuoKnD1 z3ROG?j1wCix8xRf%2OD?3TO3PI>=k4v-&#!t;)G&frcV;i#|E4=kwQ_^TMaOHk_hq zt|gPRy4g=W$pl&mu&m+%>7nhFwenz{ZVzxc%BV(sKWN&a%lceqr9W(xS8y_OiEaKD2Ob9?;W)LpA&)Y_uM=GSQvs-r?3NiPg0pxWsCEMnj#cACm}g zYMKx%s?502CzaBG9l3E0o6OC9d9-`Y9$<(HHPgP2HWf)$E66(9lr%1jm4B1Q-$wkZNf+NF?E7*;em-UNf%O- zqzO%h^@S{;?1=_Z0?R?XyVIn{$KAPG0(<5rMQw8O7p(LP3_-%ZvzNhOd(r-Vjxfcx zFKLapRko^N7Cx#?njB}n5_%5~_)45UAs(qksY3&@;ch4Su-1RSX`paPP*%*{7WgLK z?yU2aA(Qtf3yRToRE2XNpjqHOY3c~>z?_w;moh|W3)>u{Dub+)*|#&5@!gc7PP7az zLd_gd#7mTDJlvbcBFp0b*2qBTt9XR(IJj*8X!%Ld?|Baqr4x@S#a?y3i+2b;$@}Qi zH~c|mM+XS3^cBRTQ&o_VcZjvLYHi~2!mkz-d_G+OaQC7=B zZEY!#|gqC85t%xe29Z`Pwj z(_RhBU||I&=28`=A(8Y=j zPgw+)%T9~oRTd#jY%m27VTKD_%yH%tAZ8D#>^Z-+-IAS~ONQu36SP%yruxEAvFX?L z;L;s%JeU>T#Vi(NKgan$4^!Q(TFU$nB^Ji*eH~<>A>cT-%XnSwpmi1Ce;@z&4tIsa z1N0*ifA<=O@L3692^8{ZsMrqIg_^$FT6;3gv*X?-~|JG^D#C3f`|yXye;^(;TvPCwb9 zp>TUx)G97DMY~SR6IHyU7v~*^z&cm}zPge0>kougzP-+M?xX+k{5|lT_q#YsLkwFZHF|yLy{-f&+mdlJ=V-*+X#{Kpw zVL+?>uS`>Lo?-C(Ap{C<-AOGmtev|z(d}wQ_RuH%r^>QR(GuCW1{+yJ!dn{7%V^*>!#B%G`htuepbDM4z$|EVjI}uR6fjX zj>z|;=?i^*7;!>rL2ld_(}xuHoBNtxoAh-8u{zg027A*DIMD?0JcxvB94poS=vnPz zh3nX~z-=w3Dh8rMYX#q)t0ZS`=1n$Fws}{bq)GGgvn3NqlCqO?rEOjdY;FO)z%si2 zgOCbEKVn<1vBH!t*EMrGR73TjWXlzoiYz=$TJ8>Q%(jal$2KgQ68xk}#3KDF4wyBKFzh-PB$R6BX@BG ziDugIuXgxP{_TxFDytxoTEnNY326#4bwzf#%Sz8BmUcgcx#Og}g4MpG`Y+6Z5CHxW zIiJP%n4S$yuzu4Pb+C*2`#?}BmgVWyeO?%1uj@n8XU*3Oce2Zh z;<>0n7$UyT#}39e*LH&);t$cK06D~}Q6d66Jf=kgk{IptM;TJBi}Rnax3fQk85;3Z^FwnNQzR2)Fd;F^*qI#~lx*f{Ac(HI5|d^|9(XocV$OqFFR|LI z?zP%vhepH8mH&&QN53gL`h3oq0^lMh7|kuMX>PqIR7InEJ+3R|Dn_`~(dw%f4>BK$_&7t2{%Vn$n~o zQeSaSX8eCM7X{O>?lB`X=?{887vr4$Iqy`?%!3-uCzuXuYN(=u1~*=zOeC)9PkfCM z>wdv~36(eihowA>h75qU`XiIz>N`==;6{*Lzc4@QCkBbIOr0+#fs4pUXh1=SX^iU1 zr%^d0NmH(Jgo|_#?Rm{Kxo`B;XSAZ@p1c38QFLQ-{KL_H6Z<=%0r_X+xso(}MDyVh zrA*7fC6$^R6?$dh;-0?rLsSY~L5&Xsi3S{MSey^&H`hv;huG5 z_ih>wilNekQ&OplOG$-^i5jYlW5UYcY9aV3)=VU zI6j`JCq|KgcoKLqeG2bgTry#6w&)jyHsauG=H132a!N&WXv(nWk(dN2nKFvsa5NDh z{=%Owe5>b5#)3C1Jxhb)KCJqa88el!>ix0ehu0F(`sA?S5NfUQ8nB#^g{qx9g~x^P;%9owVb0Hu|LEkP85_9!l`XlwhXV->r| z;xgaw|GYCvK-=?O*LQtf7n%3j_xrh@du7#|-HPgjd%r>v_x`o~Y)=bmMoDB2q-%fU zyPu4O{uePK;)f_dtreN@y%5z}%QE3jBCe$~HhE^TPZ?@0&!-3d^tS7qbu&x;McQnh z-v1)$(>yH`8ULXrWOqs2V5XTncc+{kGSy93u&6EIwxdmd+>};tFD)+09&fX8h931E ziE2?OY~CN(8L10EIzbs zuH5m1k8-bC_~L^WtF<48orTSB@LUuT^3=^|a^)8N-6(()-XH=OHk{V-!@WCY0{5=_ zJuLydg!l*fB0`51Qx)G6K*BhcR>ga5yvVQE`!GFhu*p+PoUXTt4{y*uq^<)MmS*Pl zjm+nCF=Bf;@AgjNbPiSEboJO`Xsh`wK`<|8{VQSf4{!cIq_&2790z_s{FBs~8+@p? zeSZ32@nW=$toe}L-e1uuuo=Z`Mz#>-^kaj_5vDgw$Yk@#u`SDC3vNs3Cv?+t$?U|3=$cq;`^P{yMV1 z-^$w^_1iIKtr`tH8gnmZM?gAok#43T#EVC^HR3{wnXPbiW0@ZTRK?5PFX(1%9AN3; zA-#y0Ch?Bs!ZEx-NS;?JGHzem2S^HsF=!{8@&uuRxmBD_z~8@EdY1l=4Jl!}<<0WC8Zr5-ywy_dA9 zhO)eF5nyX=rq;V1QI6rHr%0mozC!7}Dt+G(rG?hFe{UjvL2GQyKAIH;w8Bg)-Mabu z1H0++$v9bDvll+u3ZOTxmJ{F-@;I$mMYUq)s7a0l|*QE^&b?0nOj+Git ze=F=$wfGt)nq&1=8XBS$<`jV;MVtLsU~Oj+mZR-l+G3?BFk&0`&Sy$sl*AG1E1V06Bu>Af$yRBsvlyZ3sfOerSUq zsw3q7N_EBDU)ea5wrE=Y!j{zg>VMTk_fq5fY@b;$)g!1xJ?bH$em~UWhip+dJ=cb! zI!=}T=R!VXe7d$q9xJ4!7DkvTns&OD@>gmLxWpn;#JuBXRM5OrpDJ^13X>|{mZ!Qh z6DH&DK#X4PiG;x@_^Uocb4b3)M9Z7aIi>81gOr><%{^xl-$i7PyA`F@0`@k#9Wme0 zR6>P8dCIv-juVh0Q7@0IFD{>{6;Oh<<1fCsX8U`~r=Muu9q+thkFi~+pPfZu-fv`O z_DlUBrq#xnUGt~AWrZ$r|CaLL%3Ih%|B<)qp2&gjuI)cGDgq*X-wS z$3}q;vA!0K8wMjC8?|X{EOx>yNa2awAo$iI&9J@HA|V&a3JBjBjUN1dY|Z(uj1>bz z!YWqT$hDf`e6|)F(?a!yY(;$A$OlJ6YC|hBxO?>;(m)WSPy&`4L?$_aLRc<%cZ^35{2?OIF#*VG~8A(BG!M;aylh=xa-;y^4 z0j>ds+CyEl$lCEcL+o%gBJ7sWJ3o70!hkl-QcgKEYY9s9S+X2plfzEI3i@9Kr_%>V zYZga+0@b$Il&vv%M^*#dTmu&IV%+SN%@LXV>rzt*952&XlmNQK8H|~QEzKrXi84UP zYFkg2n1V64W357H$YU-FH9w4r&j{wqnf%iR8#TYiQkE_-We4Lf!|2kH#qsopFkZRZ zmw&b>SsszBiil*#Lvbk2ep!A;nGeSHG>_O?bl59wMWC9UzNeDh>^fU0AC{hvEx?Fk z>=3G{H2qWWOF^@2Dz{17+Yd6PqVV?8YQ*2vo*E;UL>cZR#Y#c1)`!8~`;u}VW-ADp znRVW%-|@_t*&yC$XLS*9w6C+eRN$0GBYvVBpm9E=Bc z#6w7UP1DL|E`=HOtg}jzt?<+0#m>6oFttR+_eYqWX_+!1{NO%2@qg{C5?REGhv_*P z1GQQp<|9bpq=(DN2A<_R;kW|FL3$s#O|=oE5f(UI`$v|<^M&k{K=)~LSrmOJAh6|`=zRKjCaXj-nJgH{#%u?c^Z6#oH>h4 z`KvWN1jKXJzwO=a$?))g`a73ie$dh;0=q0};yAwykZ}^W#FWEX4>m>>cLdoNV>28tkhofmig1K{Vk|I3!^l9$BV{g3J|0 z&YX28ST8)E-m~a^rWZ}=_GKrtIgn`zZN6c@-iRi$`mLetxIx#c1c*)SdW$O)$QOvz z>?kM$DnI(uC6St5)TT{ENliti_laK#fXoaAN>9{c)ecpLOj&ViG@9^k$rip#Qt#tC z5H52|Ot>r%4!YAy6(2}_)PyGn!WDrdQUi*sBoE`WiGDD+#e^pZ!qqm}FLDlb2EtQS z?bLu0Ck4WFHZFK%C8ScK)}~S@U!e(CQQB5XL5k-yxYNppL~HCTMKe>bErlry5L3&p zm7!PvzQRNy7KMOV&4GOhw?u%=A#n-FuVrP| zwx54hDvrd*=y+&r^0c<|APtPN>=C%^yN1{!ANJWJeQl?NH;kefDAetvMsao!Cwb?; zEL*elDRx`?`B&Q7#tqlzGh6;;ZDak~E-KXaV7|6)TibLzpJ$qm^=rF?z8&-KzMWs_ z+b6>tMB<@u#}{h*f~_qz(WE80^rK>|SN4~O3kx!tkQ0Vg90`w$Ojh>M%C`LH-TsG9=Y zv{<3_7t={sD`t7|4TJx|!D>GQ6Y71+ooV7WK{`XXLtdW27iRDo-wx5HCS3DsCW;(n zg|o_XXC)@HMWZ+8{^qop&w>3zkhpiZBZd{XZI zKxig>9~CW81vc3lQyXn1*0}iNSUK}fVaHoBi{uZcem8Xv#e*b5(MlpmKqD;Zx4Hh|60LqqHRV?7(}S--7-pSjL_E z7!&dWd5K7LKxG`YMfm0G(v}Weipax~sMVZp8Ks+gFZV)=NCIDHiFiUBq>hAZz4G!? zuH|&UF$wpBs$47c2`yznB|glTFafAlkni&ntaVI>l@n4Ec# z7J6>9E%c)ig`^Vmu9k#$47KzFzfhf4HQ&;YZ6RwkDZGJr?omrHiDgz=)YeU}wS8GB zTj-?K@`GKI)|u#m<3kl65Kl;D#J%QJdo(lTDy8ElF zJq@UqTz!ARd_=6{uX{ zTe2_a`7umD-hTtz@>#1OZWZ1wLcAk^CJe-&F_HR{nw`j#VY9F-{m%H*Nt`cURhZ|t z2LsS0%kuVZ6^2EZ?s-RKXzKwH%RS%Uy)_rRBW!MLzx?ANEOPYcUW|A2?$w@POE$J z^J&4AkHf;FFkyCP-!HZlUyo+X3VlsOU@l|1SR@<^SLKe+<*{7QY3Oq`m43P@*a?Assy% z{fGS+&;d?XSOWzXfZ3I_8d#xgF*6RP=rmnhip|SUElS!^(I$J$in`W+u5=L+#zmpu zwT=q!Ih37*PFitMxTfMB=X<{oJJTxeK`eb@$6>`T#m3qWujHp9CHLpHgg#f=ik}2) zcH4?NN9xNSl&$iz2gB=&5&HX7D*$y!OX7_eZ0AnyIj|Smb!|4=#ryy}4$(kS+p#>^ zGRJ&Ok^$>W!&`=xoQ}eGhEbh@kjpi}SmxV3Of$$%%>8Bq%ZN#*W^<^a`{(rpunP*Y zpJNuO|56gG*R;mh5?@hf$`j!YONe3Nyz@R^;>)Mg z3U-K2iwks}PyD;+<&bbUEmWIQD#ZMI665WU+@W`8t}i<}yy^3lLGO0G z&dS4XJG`7T#9s&`db&dG|4Oyp0Smkv;HOw2b)Z)LFKu0pr5ft8nWu{8hB2Mat1K`l z>D{Df{C?dQ?KEoUEYZ8|#{+(3>RL$84I&i)CT7=puQMXj&3>;BS?I1eQZw66e+PdS zOb;S`{1=?0&_B%Fe_6xCvm5` zh)f7I#QL)L(Hwo-p2*x)-A)CV_eKom%MBw*0T!lR*Q zTB}LMFj-H4-Mmx0FwAgc2FB84JKc@EZFc?e#^;bLuZDPkk&>AFfD!M6~b^#LPvNakC?e8X;!A zysw;TG4fm0(xff6#z|Ws8YwiQy2q?Pbg|M+M0~&2KeI`a;lFoLy!C5&8k?%-oU-CqIU((v#BS3{-k;>UGnaJn|GkwILY|k|)lM~UgaZ;cB&lVRAW+@mq(O@_;GiNHgxp8aNNM`at=(fpxIqCB` z{3;Q}T+`TyTRmn_^yqwfB9VC`JmrnJc?Ibf;7r8pVvoi}R=r z>Mu|FNoK&5Io`q_>d|}QBv9tEIBv__QY`BI6^jg#KhXVK2eElAJrg;Yvive}zA_L7 z*4}nj?1#CUpDN)34Twtoh&DU7T=W%u82KMYmIUldGzS8NXy58?zQ_gLPRPCWPBZW?Ak8*9H(bZ6|# ztX)my5&KgHGtFv22C$iq&5v0qa8cz@9;}~NQf8Z{I=DczVO$ zQhu>w_dR~t=5<@*rhQ+za;G!L;O%-dGqHHLAcr zl?8pAXJlL6SeGyoy73~2l8A!WSS7h`Zq))k6YWjYuD<0v5X;RgA928?-Fb9+<;Zlf z8IE#+zA*B>6}kl}{LDo|q;O5G79=xa+dpMb?GSgc?wTq*TBr*=YW6Y*0?d(aHi@9? z%bEsh_B^i->zK#s9I)Rw=ZWJ4$Ly0$M)PCMERP{ukxELuM#xvy!@;16KJIOTNei`7 zl*%fn>j$LAGdJyn7-3nPUQ44YzyvM#B-z8cifRE3fWqRidE`MVL20b%NPZF;t#NbX z_6=%5y=xLHLqPC9!QE*P*#1o@7+}G5=>C0s+;$}=-Wk0xPd(E@IVNgd+gLdmpl&qGq;lq{e>V* z44$}uvp~xt(vN#zKpJc4z0xr9sWM`_`u>-WysB7hP7BZGv2TQfCCLv0QU(AM+Byq! ztF_g%o1{R}*J#&DVn#ToeQ}eOBv|MpJi;B7keM*}H^ysRe?vc1*wAfV`3+sJjCxv+ zu_ff|%J&$;1muuH+-JAFRfsj{1N;@BS_STGE}ob_DpsjYgjyNA6cmh@P1PWcS_)Vo z?Zm_k9IIK?LGyr}I_|P>(|zsSh-sS$RmOOFO?LKa-=!%U=^&+;061d2$qx>X^~3ibHP-hNkqt2MNao~c z-Je(%!cxo=oCK85Wd>6Br9!;ml~8@J(N5zJ$3 zQTL(-0md(HE=+mH{`Z>l@!bA)2T2;kPPwJQSf6U_IYr8%>KCh*3~x3IV>RzPwAt8c zI^_$5HZ>&7kNu5&VV$TiwXi&@7%$JH-wf?JX`|;iT-f~7-*L&sI?M~j_JNN$wC7Np z-Zs4FMy|p4?mlV_{*#Ep8WdWM0lMZ5twDZ5p`6_<<_%!Sa&YLiC>I(5I7+QpI^yKS zP)i*7O&&jTBzW-YFP29kri6tI7JG=9hwVuQtbIsVYi2^pYo*|i9d@>*tdH9k(8Pb? zwq>Xd0m5K}YXy4zQ9`WNbMeBMS+Sb=wE*e$?a=|jF>3K(vG)=(UzEL!AO#Y}^V(G=GvTYmApY#Bny>o(cRFu7 zqK?s}qf`g)B@qa{+o=k+ksAeO?DBrR8@Lz!t;{DnT~|^LpV;&8H4E3T#lm7_Ke!)q z7YCJLH-qWew4c8-XU&?K9B1Xi2Pac3y%clqH=f6iWJS4mAO7O!uUa5>!0l^klv@{_ znrMrh*qW!iqXRUZueUr4Y6IJ9H-zq?jyww_%hz-E^y!U5_2e_8Dwx3H?W@ECF7Au& zJ(29$SyOLvy8dgpVAZ<{YSuN18^}~Bb&5D>yS(r2V#C@wkPSVWA^kYMSP6TBXQID- zxPj*YYBKx0C>{>YY_yN0@zNz5dN5&^4nQ`Fn5&qzr>@8cBywo4--Ay=b90KlWZ?z4~C{<{Tx55vVDKx#*Yg5pj zPSBW1ROWqw2xBJOdXbw_)J&q>w4(4?cP2kpk-<+S<}70TB0l8zrtpHN2_{xZ7 zjONKZhoEuypATDnD@=H)%9L}%70@{*ZOihY8QYFm4 z<9&dTEXXU!oF8k0GfQo-wAy1ZAZZ(_d{MLUsUxQnx4H~aA3O^(9@Bd0mn zlO2sf*eJ%{gcslRCp8OA@<)yRk5X#aB&o+Rla$Lb6b4_`i;MKmel zddU;f-Qa>B5Inxydd6(3%;FS))bw&GAODqE-~avZo=}ES(R{?>PenVQNS+2pwK} zs(mmOptCH?S(V;v)|J7*C?!imxzCYN`Tj;1+^9pmN;r{01`kjMOGVZy1NwV1T zZG2dtn@*?UlRj9Vo8?FP+|0J-{cUFDZ}U&#qx@|?4_P%e6CwQzN6h~RkPgm2Kd@jk zvyx@;J~ErDVyanlBP*#seMEg?-O!aCTDO;R2yK^zDAti%_V_=89_&)Il+5;05HF)K zcX3tw#)Ay5$caSvj%^A~>8Ve@MHqDyvqtW0!p^N*z3sI+LH$nDQII zX0V8Bd^iE(Hj{1RxsYO4E=F$Z4a~gbo~4!^H015gnd6XApH_w^8iXvyAR2URakg~6 z=!B=kpG)@!L)&k7RyCbEqUz(hTLR}|UrNn|d%Y$kqy>;OTn&=QAE01An9hc;NPugd!P*@@E zu!4k^X!itiEo^L~`&-#h^*(hfUuKPs;Lfi^$Vl?(r0X9y%Rc*5RV@?;`P!LVy;>=K z>2e^j{uM|{VS{`v48I+z(HlNQJi;y{ukgh(cUP0q0JF7TH(dV@~qYt(?V4jRoZ zx88NGV;x3255MTNjeTQPCH*Wm|ui-C+Xw-SpAy{f(>_3@@mDa4{(-f6f_u)?u5b~Z9cr_O~=;R zm~d`;9M@-&&_COb&3=2M)-F40qn2AOx7%NOCV^RB2aDa&P|y$@dI}A#Z&1%oh=_S6 zauqaQ?Y*$Pn|UJ4JQHsJdUZ)E0cFMxD>GsClY0Bcg5E@s3W+9WCLHciRKNF^yeG{Q z&>?wpng#ZXkQjMxCeZytw&KA;uazo_bb@9y{eZXMNd{4(wdAOy_qTk`07K zAMEJ89>gRZ`eqN%x$PM8_VW=lrTtP8*n-cc&tR|3;#<7p2SjrF;h#9V4E}N*yCLRz zTC#2S{Wm;bi`@JCeGaI903k-X{_6d$eL2I9N&uMwe*Oud!sNEXc*o_(dzi*(-|74w z<3jZt1E2(SMcPNw&fLJDE=eo#JK+jml3u?`Ko6nQty7+>|6J9gFNYt|V4;_=A2k)w zwC9>f=Z8a2E&5<)g(e`h%8uWGN@rFL%>a)NCSbOmfK%Buu^Q0bb;ZuQisDGkW|@5N zg_!+{z<0Gc!BwsI=xu)F#JpRoV0e!l2-|C910yJMZtr3K3cDmfU#jkJyr*mHI`pE)@i*Y7W_#U<;l~G08Q#*=HC5w<)3r9d_4h6CKtW0_Tf5mc_03RCP=a}wajJL zkBKw4TRJh&@yw5?o&Yex-2O*)f_I{gu=3UBb|Eg_7(b@m<`LTG{d1BENz{Q-y5_w< z_%T&xm9BqSP|mtlLJYbaC&R!kvRGr|S$vlIpS8HrRJYYBjNS(@ct4uwz=fEQKW>Js z-8a@^>V7&Kjv*d7{NdS@{Ym+bw62LQVQ0!4OlX5leF}(thE1R?*%C9qsngq)iR(H; zkv=QI$}-rS%L}}uIXXyp8Z<}a$TZ*ml*!DayZ#Y!I$vbs^2eykKSrU9e~OT68`?um z%JwW0zFq!#Wbg^4-8`Ib$R?DKRsb*U(NctqdGP zcHBG+IwUVc>FPxA;)jZ=_12^^=aKPfCr%x^c#^Yz3|qXX?Hp%)|9rTf^8@|!13Tus zj`K)hKDH9(2YTnbW3uDh4^=HLmmQ%tG&{D$LeHii&ITB*<~kO0?NmW~YH-#&W;+&p zj~y0|mBU9KcWgu7_oF@kmc9hB8Ti3rx5qw-?8`&Cd5R#54}rO_?b2WXbDy}jaO_WC zs;GW1pgqbUnLP{U*ldu-b+EMMW4V2-UGjaL)d$&B!wEiAva~O`6F!pOMIFz8e%$fA znmCM^iR4uTpHYzSOMOc3vyY2)WBnP#)wOSfKKT&%!5jRpEzs7WYsf;{uCcbTt&i+o z0Sfr%Q~lmxL6!}V*sytci9WgZWo2RS-YHNSH-`{wkyBy#2(4z#7q#`QY*cEDg#y{n z>DD_%Iy?5jTM5FQ-hvM?BPeGn&K)hshxk=b7uo&ZlbT@GETAIorStuaN{PFp=`vGV zX3SSeb{%;E_2<>6J;Dz4m-z^kjI~r(x0l$Na5^@qllFoMY%jqr#}SzscY$#LUiPt$ zhYFcNrYKglC3I0$+dnZe%;Ykut{}CTloc0+-SRxYG0zVzaPes0B5%2QKG$wI9J8}L z9Bw%(Jol(@)luO|M}=#T3fCPKZa6Buz=ntTxnG!fRQkfB!b^?}uWe^SEdSRNzLxX5 zCw{OWo|kVQ5K-{IZMi&|V_f#LSDm$cGzFvTxg>_D&;Vx2Ckc;ul;mw+_O~#Wg4qe| zUT(d@*^1}p$shMn_=qJ;nCE@zYGCX_xSx|R9WrP*H(>_3%3<4pR-)%qmB@U)HlCSY z8?TQ}a#q~09qnFLKIOT%`{l~tXuac@MR>pUIYSY7T=A8 zN^icQ3|av}kZk88%Pk zqyO;*KYDz)k8yx*AW@Hufk@pGt(3 zo&h5}N!UVr_V^8&rJCN*mQ3mR<)dtfalxRCP#umSpG%_ZKz)-()<^X9C;1hIsWBL- z!FlqQ>_orL3Hdrn3LjZ3QhUr?bxa=L{Az2DtoDiFYB#IeJz=x?-PLZU+HoT~8wPTN{mKj8(ONiM8b`t8S)=a+HJiZ6_b3MbA z_NY=cCwkspX%CeK3zZ&tn_a;K%wqhFw#KQ$H6qGVSftG?(jG>B^dfB@G42CzBa`b+ z#F_->nfG5*hd2tqq%_LeDT}y`G56wxY?EYhTJ8qe^s2SGTyaD-Yo^?NB zBaHNNcL!lHh2}{rY_80iT#iQy!1hAlf{DEytETkC`${dg5C*Zt0(hjlOt=FGT&%A# zA|xVv*M|Sn&-&r}DbF;zuF78O*Vn}|)2m|j;YqFY!Na{@QXjYW2Yvut$y^e2n`Y^P zxyO$k>I?t-0@5qILzmpKr8 z82>@wYX{CRUU0gTcz4<`~geX-_V--g6g_V`gck}X%7lLr*KO3hN zdSlxhF^Z$-=BPgX+xe-qor-9FX3;M@4J$kC4Da-&`7u~-?as&4663DCkx-#C|JUk> zzw0C8m)eU6j500pP+?Cs?HeRhP?Q|MVXYdV<1&DFQI*$!I_;z-qfI+Dx*#oAkm|8l zrGH;?bYL|i@RG;+uc@>80U-OERjaw%Zw~<*`xdgKqRd7~*0-N;2@J4re<2W@{J7~- zoApiQsWT$=iz`x9@Dq}Bd5(45Y|KJ(S>dgZm002-7E^4T7#X*!D6b!H=hHc9nj!vu z$s|1((|-wi2TsF?-}Kr=r{>q~261gILl>~G7qk^R|12I#d;B-8m!j|6n~ICGu;R#* zFE^BNc>G7qZ)*IAiLz6IN})EtaB4?HxNh_Km%v}44*(VG2Cm}?pBGl`mOp>DKrGyXLg?|nPq-eT!A z(a_tA-sc~l^wxROI7H}_#b(*&>cNZA3sBUi%sK55({Uq}8@F3c1a=`0=&ZDKaq|l+ z;hOPn*~ZNM?c`|6l<{ul#umFyO1*{wShQe`DS}7c6YY5jkdXw5$z2svGou6HkcTyQ;(xH zuQg^$CnKdI$P9zZ3Paw))+q1?*iBVr`3TDU^VDjlY#TWNy^`V$>|qBXy;$m91;sMG zQS*$d@j++h1LXM))vyjTt0LwMsJE#3i6vc!OHI9_lPZj&)8r$7WDGP?N6k;E*}vMJ?5-f0g)%aV8&k`A-zpi zEI~i+3D~}DMA4zylscU{lf!$pa7F}AD|Hp(``|g;49Yh9p{TQdXM}_XFsVrWrIpSq zas9OyEj#Bw8Fl(_m9s*U)Do^n);XMhai4_Nw++7bgcwML{bBmIZcd$77R$uS(>+yN zH-GiKidZ<*+xq9NFMajA7q|XlY5j}E+YYro6WsdJb>|K6^=#?Zm##UlUvVXh+soJU zq+a@-sXbd?y8gVKTYIlxwj;EqZE^zL(Ie&kK!SO1;X5m|XMWh3z9$EJb^W6VX8(zJ zjL<_4@g-kj&@kdEODtjU$RHwA8SfR?yD*B%LB61yq|T9l&H0LGw7+7X71}67Yr(4wW!%Fsr7Y1 z&~QKsXdybT&PwsP!i-kY!GSrXIdl@wA_DA+t^`XbJBoFi7C2G+m$cG16cy}7>m?!=N!0%z*@8Be{WlFv$x z?w<_O4Wk|AQ))5Zk(>#W$mv>5Li+7F&ZB|(pgiHiNXH4L74*_MuuL&bK^^fN_s@e>QaDoRvnrPUdJqLJ zI7s^wXhxYsPNxh`AOWw*V>z9bDW;pttV~)zMSOb~9^$c(xw(w*p}0>G2iR<<5YLss z|GINZy;c8hH^&0-6&)eDtd0+jrHmEG0a$b1YEU}Gw7ZqxPBF{xjLmyE?!x?G|8R&{l zA4__!C)5;N6u{32?kn&y`%K%}k($3_hM}6*-YMsbgxYqZ8JO?h)ueflB7{s6l*QQQ zbINjCDABqnoZA}4M^WfyXT_H}FdfUSRFRdwTa@baWsI_4$wZ4~ANDcY@;dK2V#=0N zbu+V6C%x#RP`35#JbdJW#*IZoF&+AMy$Jnok!tq7iV&fl?Kj4>JDne))}e(sn^S6& zhNfp6$zk(?6nSzq>+=H(>lP?vch>pq@;q6FDjS7rg}W+4mVz_iPX&fzIF9r7X{5WE$GU^Qh&v^bZJ>$jRNNi z$9&@1(n9~*+sOwf06{_5|2(dtop5|LoPijB%EN2r##%FIR2E!2NcJj z^6);z@uxh#Uvc|E&WlrbXP03;WMtzTIMs#wIF|YUy?yuEQg*-H>rXYCaINfn-+I8p z4F80sW+Ahj-yhC;ln?tLmK+-nHCHYMj6}=P;y^M4z*08fwU(pYIl*ihm(WI?YJNkI zp-OzskJd*}yvsi)fG)#^-$n}M7Lc7I?%R=^sq4xu5x}zXP&1@Eyt=N(Ld6=rEn@X& zCP#Vi)1%+4(fd~KqVM&;os&)4=(CR5kg@7s9{akvuz=xfnVF-6_O);R;|X9Xzg)1cR{g5uKJ$n7QRi3Dl|g-}x|Sp)a&i@^`J6 zrdXo{T@x#)F@{qM1>O65m?HQ7emi+$y{*}&{(;=&$1qE|%^Fe2iJ^ef-TNgl=G7@J zW28q$f}aHe%=-tFcwr5(nKk?DPTS&g^RFzJCK> z?)|^E;Wc8?dH=iJHt+LZ@b`1SjoswO%KU{!?cT3+@5g?u&ks|q(!Di)?7&c7rF%q_&iinCuzG zG7BEUmZ60UlLB2Rs%A|?fetkTQr zQi#sPf)tn67RDd#%q6FYDeiRrgkbyfGe+SBRa2CiJyU~T`d?rO%`=_#J#Nz^*`3Oe zn4MBcK934XRzlL2ujVHGf?pH1L+A1}wbWVF!mqP#4hY7saNvKv4S@ckZk$D$y76VJ zfSb8jCrm?o>$rf9N|naA9@|7_&LpDU+vPpjT~)_lZ(w9S@&*hpv6>x>X6SCQ=OGgw zgK)x7Q+voVXw{xFGkH$w^{PCB<3{AUmpn)%N$PY$eN&axwUA~4Nj;sMU)e@Y>+S?2HPIQk<#+BhvKT&@0yE%Vk4m3p(R=asGLri2=**%%L z-R@?p^s-|{^j6-0&8k{*);BdctDYm+zH~9>>|S%NctP@XUQx(h&4IGC%n8kDXdNfl z*F}R{RIsVRZJL1Zti{f0~Kc0oQxQs&{y!sz>zlQYwpO?rouEmJlmu?15i`wGS;!oy~Bw;F{Jh zKdTpw9Z|;wvUF@3;@_3idTPA8N>FW3z8E9s=37*M=4OGRsBq+`yn6vQLybI1E^~XQ z-wAc$<0HH9D^k@q%l1IN{XNt@RQguiM)RhyuQ2bdx>!hrX$FOl&Mdr8AGV@S1?7qe z#8#^C;#-Cei8Nr%>`jpLKfuxo^zt;1yTZVNu~8}==k=EQ>y+onGMh1OC~6>&6Wu?A zADA0oupm1#`vJQyS_7>Mp2X$DGC%)ar;X_Qk63Y9n5GGvFXF0cu;t)WD}+YHc&J|JrC8L{-z zr_Jg z=4LzlzRG*zHBcxYxTd}|TtVt=vnruE&fMHX0})FBx?MHsw6J>qfw}K*!=)#i*>kvL zy%uH_=!z=CgN!0O!Jp;vI^oHnH6-Rw*b9;pTTA8AGuC3u$mN6f_dct4EUl^@!eZg< z*Dn){T*J~a!xKD46TBO6&II#+r+4KhCYY_=v9+HPmmzi0JN!M2utAvu73&xvPeL|0 zVl6_6(D}2pgeskks)$Bv6&vGNqYiR0Nh0JeEqhv8SWuZA~j2JLRw5vm6Du zl$@H$&bmt~Bv5zy6qw7MRHe!yWi9ZQdtVNY-^S&R68kIAeY4{u=AWu@J$Vp_{Bj}x z5w+*~rab3;eW?BqseW!MS~#hYf2jUH1jp}H?XRL2`hn20^44EvF-m{VL*h{!lj}1R zA0nYNbh!2JVKW>OZi@7c0MnEeJ2>nvT#X4_sG zVnZ*RL@H&mS}*-wvUv0F)IkGDqg8Ff&r*a>%OFv}M%f(+{up!TRwmpSTdU^{r!y~iqvss@aRW38g4hjrH5qF~2{6$?X(7%a#5Z7?(mz6s!ma7-$DW85| zK3ip8GZXL6?F>EJR%)KjjtPBsqSN%*iLzGo*VMQRV9aCA|F!HVVUr~Sz0HBG%>+Zw zCO;(I@&M4ItS?d1>utu@PTZ8fmH<-JZKt(d>1$#zu%+1Ui*EBl2ar?{HD-Kgh6%S$ z!z*oeuVUW(u_Ni190P5o){TNZJ(2t*PMVX)Ti;kay@?}6uEZ0Yk$D0faG~w=at{Gx z{dvj;>jy2nDkpcK+!fNvpW1|Pw4~N3pfmRuYL@G0Y@f0!MVT0O@^EqeO}?FV{Tw>yfj!+#6)0u7pDPb+uGtfy z8@vp7-)utti>+##SAKwBlLf7G9tiV-x9leELx_l}S|x$LaGi5sn1NyV2i+%L+-t#~ z$ThF(_F9k~XMZ3?rOpBFjRVJ95Tu3d8JUYY$-CS+6C3bhI6jeSn&jQ_O`y>z@8d(g zNs3=qC1Uk48<-->@?xV;7LJG~3DBFTLob@^Nb5L{VV~pq*$C?cv>IZ%VGc!1yqwnO z(KyHFD*wC==)9({uR@xsZJ*QiGlCL*if0;w&bmu0IKqfNRdRwQ?PSSbQFAEnHV#13 zgTeYH{(5!G7kR&1Z{gWImSZshr>V;6s--eBrwlplz?`7>)-865=P6yQEc1odK=9+< zaotBI9iT$cxjL9WRTx-G1p3q2VqX}QkL1$yo5jgUT)wxkhy?+xoxdzGZj>8JG1ya# zF`w~!Fxpen`;z|=;3JmqDIJfAo|d;L*}7+N8D;otyZ+yor&wUP*t6LSR3?gi_K5b# zQ)1gJ)c%L;>B@G>NPZdi%~7;MJW#z<7hYvzyh|85%bK5+*m0}}G5ZWMAKK=aM)!(SuTZAfmKjT#(#;=%F-S%UlS#_iRKml;oYQE;X zjZ63xqnppKGk`nz>~6e)20jics-5QiHtr(+i1mB#@!V;PFQqutJoD|L;yPHCVL1dJ z-n+cal6E&PGpow^aIM6HStT;G+gPeq2iumm0{AS5Wx~7@k7pY2hPQdq*m!8bNn14s_ycq$R*XD%@Q(4l=pP;WKgrs2N1>sOd+X z1q)|UlNGX18gZ}S<+vqk{vI`NM$I3>=I@lB5TcwA&uxy&bs*+1S%||W%;}e$nk{B;`tY&#I+{nGqHIt4@Yu!G;f{m!vh0RYvU~Sa6h>tC zDtRArAnkCHBAL=@+1t~H$ED`YU;Uo#^-$HnZf{)MBpFoFT}T7Fv%k(axAYh3cg8OL zAGMO(ZX5Y-`fyotRQmAv)aA5u+=y|pZw|LzUTEVB-#DD_LS7GHMnwg%adoRz0u)~?62h()*>HqU@!i~=P{g! z&}wV^u%J0bbxtI(zcDlM9ILHykYP{DOg$r=8|B=5m*$}3pcU~w(K@n1Jl4D7Q*Y;L zUO+Y#ZM7?kvfu7{ZrN2LF%;qIGO@+<*X-`vvFzfSy=a-9_8`*xSN2BClTqh^(hkY> z=BumRa5WZ(!UsHPYT@34B``&Ly;CEB9v(|(FUlSuykTd?v*F%9l+()K#~Dw}3nUdH zs)$Hj`819E<^id)_T1TM65o2|z#$(1oZM(;eQUqE`#+!LI^XgZ{Z&1Kl1M>Jw%@zW z#=n`5-$Ok9k<)K7>`i>9-+a@#@z;FNz~wZ61aD>RN*>TVeEHCRwRoUD@OMCL`kiq& z{{9!^*-*{QWE}~XW=gyG#;(h<4`WX}XlwAh>)d?NP`}>!gz&SygXgR9ntq1N+?^Qi zcvDm2+qxP@?4*%7a(Za7kT69EjR@4*NsmfI@wuqE1gdtIu+MQj}`xH@FKzjwhEP6#}plh-cY+MKSc^P4t|W^xS2i){hWBs zCA5Dy5Dr~J`_;Dn%JiYK)bWL;bu+2yhX;e<@iWdr{C(i3rA75KOOrTN>8nbgUzGaW z-~jdGh_Vjj2AIzZ?8j!TPc2-rhqiM4>4T%3Ro_+fG9KHpq+7;gcVIl$Os`59y%}_^ zoyerdGqPdqUm*^k94MAYKP{WZ_9lO5suO3X})4V9uBD ze;4+~2)$1spQWg{jT1mm`{6E>fvqR!=ufkYtp=7~=VQs%T>AWA629e(s<=C2Qhqj8 z;Aa>CupY6{nLaDttWDqxW947vl3~7V%Y66P?1SCMW`7bfSHr*mt!bLrY?f6a?DEo- zzfMQC*vj1Lktjr=*_@D{gcFXOgeMsZcTe_grr@-HH3fx>2aC7)3AmggV`IH6;GrQJ zlxWYf`cvwjC06%Y*+4`0Sv+ORVuAhP^j4^t-vBlYzRl>E94zSQ7;sF5s+TLpBgIb6 z;LChj0?FV3e=Y!zwf>N~hkm#+R5WT;sOWh9>s$W~-w9v;2CB7b7pG5>3ch+;N*8oq zJMH9xl4rMlm;Q;&`FCkQV8j~c)4LS%&pco4W$03E!28$mJ(~GRb&v^wcXp817U~}# z{cv9WqiY|uo&+{Ak->_ZK?FtR8WWLr@axy{N)zE=tUSn;kDEs<+0X47(6P6!e8JSg zkzksv5@`0*ldl2Hi@~pcofoOrPm`A$#r*@Pf#)$H7;rQuk|9p zf@>2xXT@dgdmUP7B(%J$4Lc4GzdWw3G@O1s(6>^^w1nRKR!Zci%hAZ+kI{;eO^aVZ<2cnbIW!N0y+<%Hdqn&XnC9v<&^+$^En~@h{e*U7L^<6L7 z(5 z#A)pBn?A2CdCeExo76EP_PDpne1)Fq4J@Z7Lo~XC9YWOfSqH7dD%}n4^p>!RIp+9e*Wj6`(B`brpoCG)B zw6cXSes7w=Z%w~@ESl=rq{u1hJX%xIRDSbG2q%*C@XN5wtWb-`Qmf=!$SR* zu{GEKK;&qrvyVWbr>>n}X;M|r#|D0JD|Q>caZ+*HID4TEe#2G;1!-4qwZy=+gxwTR zh_WD&vY5GSq8%j8VzdqHJZb%_!e$9?@jfQHs_Bx8!?|0k8>m2K8i>wMF8O|rn@o0y zpX{tpQ00>jTKWy{j23tLEHCvL5p3agxRn7XX=mhxDA#c;q|}wT_FJ-gxMV)@QOG3fJ^UT-$cJmG!Ws;w8*MG6eyy$IMcXs;CfDk zgqs#S&cu{u7NR~4lJMx-&#cGHcPyvQTo#MDcWWIYp&c^niuTVQbCUpq_x4O7Jdx^I zP>x&7O#%%*DDeJ3iVq9~&5E<9Q1>d?DjKf-UKwG^SDjz`319gWTNf}`M>n^15`GR^HdxZ+)}+mrC{%Ry1S7gz@~&NM7(_jUV8)a#8qjY(>5?~X#Mph}oOx{tJ9 z-(=HkyHl|xANhPEBm^ukXQ9u_0m)yY0xG;v`*$uME!hvn%}s(Z{&w~GIhJJaoyVvs zB$(Gi=M!q_TeO5Sw1xhe+3ms)GnpbHag1tvl@Dqe5|)CGkxW&9Gp@7VJ42-Vi`BF2 zvP8Onpt;GH$PcK%nL1si=ZdgtJHJp3Q1KE5X~)+R%zm&il=}Y?A1noJ)n|iIXs&lY z*5o91+v0TXWW4$66ZP|2lE`cRK$FJ;@8u`UP;M@#2Hjy;m+CWR9q1~n&KOqT1O0Yz z?oBG=vKGuc|IcU z_kYWe#)R=)bE`_2gPKBPGrG|pV>7yxn7u(d@NcnsuzoRngMUY&3gZzIGdJz0YwUD; zfPgG?yT!c({rls>;P01KZ4Z|f4}JrbK;Ye)|A=Y?DyvIk2)xGtUkIXo5&c2aXFnQ- zjen5Q*#wkyXK-WG0nxH$e)}}Y6@me3^&-+eudHyJ%ow^&A|smf?;-6%HOGEvC@!=X z`+2c#HIcua)STdD0>fR|bI*Rl-Yng-svCxG7f3=!-Y(gSqc0WZuj$vOTHww|xHD$u z4>fyWgH{yG<=FY@B_~x{10|SA+ZRqhR@(6!0V5$C`FyEUI(~!w9vhWn>0oSsLkpvx>R7;!U&Vmmi9MpxTYtf9WuSv^wxA~kJHnJ zB6s>Z?u@C)j~MpnjM$wuoA(@y*qjk_n>y{yv5jb6mIo8v#x4l6--Llz8PukD0rpM;9a*6FW>zWon1_3sud0+Bl=MBXw-J9jd zE*Xkdx_6#p-TVDm+hw1tZb_XMr`NFFO&`mArTP#^{c5|=v#*u+XOlu~4FkmRoUZ!e z!}CaaNIGNT%!(o$&NiFDgn2~x{Eu_US!is|Ej^t*-O+1dF)VhXdjL-E>?Xu%tZN2S zN46i%}s9epNV-vwDw?`aePcr_BH1(WbNt`;%^`i2v0&^d-#CkNZjf zD_TFlJb4O2B#BJ(a*Sa85a{Hc{sLFyK^`%enCS8>X!|9&CwSbO3^J)`Z0E9bi3M>~ zfycckt}Ud<>jow$(UY0|LkSCv#<*G{@KQ6Z=}hx_@A_9&b2z=MyeNqseAwM7SoOzd z1Jr`(&JVpMUx!`KRF+W>zEtzQg`HuojD9BXjD1RG=YqsHueVl?#(J+K6e0spx}ABZ zb!^obho6;KSW@><{97xx;2ZHk765-nIzaW;RVHyn_(r7ux{5{c3@@&PM`fVFP2EO~ z%tpltUZ-uWu`;(k;hr-l)K(!+7&fDK4M_>ug^BvMV3LhOJyRA<&hyvE1j6^Yc_$X2 zv$GBdy-)i!1yxh>U@$bL^|^c|?^K&KWUvV`ON@#spJ#~R_DJ%vxYvp0jrF>7MXigu z3-?K^X5L=QbY3u!FkeEJ;j04@jpdN`TOoxu;BjN7g6fbTTLM^*)@dJqj%ceTrud%@ z$2SqLs4p#KnlrQO+$eism-n4TZ|CZ-sKXx@>GIy5EbEI(AhBprGKb2kY)R~5K?JZl z-)21v@t0E^jkSG%k*zjypG}O`$<8h)kQJK%*|hMzO6Th92(KV50yOEj1s>4uKw@B0 zUO&Qbuax%OG3ljsMabNe!+Me`4Tqj@{hh%)lmuy?_O4w#H0o%YuOlu=QQuy{t}t7vD+NynYJf9ggo%75P26ug&f~9<`1dOY!!P)=hcty|-O} zF2T?bvgcCghjXLrPhIq3*(b}_bqjSl>j%)144R#8MYpZ+1VlzpZG9dtQdEBT!py*w z=iDne5KGB9n+4wOg>DB5iph_aD~W6&xAjF4Qj?;@-Bm3ZCcG4#f89doqMJr;NR3#C zfazV}hc;iimj~<7EKwFe4cG0CKjv~!O}|Et_a+=Gq13+kMZG)U^j?su5TT*y0F0PX z4}Af;XsmZysIw$^PD9bM_jm2E3{fdCV%pG|X&J9ura2GXSh8;lR|tk%Mle>N6(~mu z>AB=I^C;3qe#OsF@jP4cqc~=r7P_%0U-uLLqV8LYR5#)~%i(B^V9|CQeix7SrE-Mf z)CDjoi$7fw_q{g)4dYVTf5v)ol-Ie{@mvq~X-j0EHq_(XBsPWagz~Ue^on1J!`?S< zI2+3$iOhw7ou?Cl9kCi1kx#~Io{R;aT0IT>vE#yZV^hb5VNt+%%;~!{&ajp@g&V_QTs4|r0k^j!K(H{=Uaf;gRZnDqr~r)hcL>+$Tsz2iFN| z6CH7!L71_;>hZS2mueAxj#|<~o?d*CwOyb5c+~7vH7l`Yd7e-UWTalP5-Mx>NP$H34{xHNXnfW?mj-_nMHETH#FICq?t48;>u@y-1KU!_YJ+}_JRj~UgPE|(V%yRhGu?l`4*2x0j`bx zJazg?7%%M)raoHeS!Tl6LYKq(y-y|58`b}!6jE@;4k$C>e{RZ; zv!??8s~FLo*}}d zf5Kn1@!dw8Ee4N~jrxdtS)JP$bT2H8)O|_m0Hz@!7=^oveRoK;7^BhNczB z)4~NGsekA}A{WinzHi{ZH7~?^|4ojM_7TtbyADBV7l6o?Zvd^TlydrxABuJrTFV z0(NIzpQ!Z^!oqL#1t7XRxAayQ`{a6XMV|zpz%&rVdg%1v>UB`#VeBQOZV=HnjK~V! z)^P59f@?Pe*C>~8e^M=GC8T(pwYu0m*&Y3j_fMdwjX*(A+4V+n)~(d^Tk5Om#^&y# zJiB47_zbj-`pZS+5(|OP7VYV|xz7a6$_>Qe3>ui{+HXeq=W%W4n&vxV<`G@oUh+S< zcAD4HdkAXYd_rnR72Bu=C{&owaz9tKy$K5Mb{3D^-gzTRHF&jzZ0;7G?5cHp1GewY zN=u)pS(%`aO@=60AdO=7{D$h2D%-|&+@wBgZ90CVR`n@D=uZmY5JK(uWA4 zmU)7VEObH@^6qJ36!ueu(1i#CnOjvuo)G#uBJzY#TQb6iMDpoKGU#JoEH;7++UJu& zTZ)q3fVg-O^BiqIk_L((f6&rFdx}z@-MlhaqM%JrouH{H*U<{<#hyk_Tvcz&rQxs>0s}U%F>5=kw!Z z^5>JiZ&qkIegDm&jt5y*CoOO5LTHft;3xd+CY0N`Hx{c3185zb3h>p7*~dyQ}`lmv_Zk0)uoJUkqdWqLmtc_9P*TIvJ}3 zbP1ee1FsO!6Rq9;GH*h3x!n?6fUM1bu4Qe~I1I(&Zeca@?-7xwD-qMk%UxMdfuNTO z^K;={yg<#PfQFXbXYkbkbm^8UjSZ)EWiJXJm>=x@%c#)boSA=%)!(a?aJsHn`z#r9 zDyT97$^eTGTin;jC?EI6AW)AMoU+$bZ|VYfy_OuL6f6_U$Tj^od*Ei}=nF4oJMohw zz>lnu6!mrdlE2nTdfi8gxmy*>_tlI# zxf9;PE9-++dV3h3g;Y?CPnX`8g5w9m>7E?=9p-NJ1GYS`Vm0{Xl=PD3%xCff#OW=$)L*6H69~H}$PjWMicwc653>u`gTLKUQkh-KzXT;6|_3<$u5qzxf1ls%!Bn z?dUo5z2H##)1*Vc@7~QX+<~hfj;TKSy9sxM>7`e*(ab^1(ntDm>EcggzVIJ>M?<}f&r%1@U;JUt5G`|4hXxj(WDS4N zN^3VuDoYB#6N(zWIydbPb8(@UMAWI04hh^w<5WqEWSYoa|wAUFGmCVI6liAmG~ zOQMLM&yBng8ZL%>Kbws>R~gKx8*^idV^h#s?5q~(ikly=rGwT|b7!@tjXkQ3`Zykz z1?;Q5|E4|d!g>-D?tRrQ%4Bz<`^)N>A~V&e3XyKG3D9DqXLB3;vbvjanA043-bp`8 zBM_%PX)!#ks~>K?j5fSwI#A6)v%jVv**WrHc&bo6R?1+J_bS`fWK$PzBM0GFhDN+; zD%)>+606xYqVfPrNnfZZKG6M_{-9bU4RY_~wqOmm!*2F=boy@=tOdu_ySZ^GyDXrGhkO8cKfgzCH?O0md zYOAN^oId9qPkWx~sizRJmQ1)LfZV*Iw%#v0ju+HZE{e?i{jEKd1l#kx@8@~_NM`S~ z)?WAZU;q2RxBo)cvuiE6zGHNMyh)rLYJz0xZRQ5cZZj{!MeLftIH$zjJIu`M3g3N? zL9etl_BGd`%j)0X$CxTW2JP|5pjxg?R&e_#g%#|m0$~yvL`;Lrs7j{(}>1?aU zlkh5!TAN&>DiC)%BJ3s-U!uQS);g(4@GSHRw(#6$Y$C0dzaa&a%W7jqo1n|sYikc^ z?w_K9n7hhc4Z_^QhtQcLP54N}eSz&FSTY81JYb(ESp1${gAU7X7@I=+yhqywP(XL; zF(Xc$Y`Z^Gg<`t}pvZ_&>h1WC0NoB&Yhfd%58T=aomg^xV|83kqy0L2(j4W7c)5NZ zyY0X)?UfNC>Y9Q*ex!LIbsecO_f9jy7sNV~ zOH(f7(}vzR8Xwn_%nvoZ{Y;74EDZkw;!pYGevbx{cK0sq8(GLGoK&bUNd!ue4@1MR3o?aWiHMFpp@TWmqY!#aaA&k6punwA|C@Ljx zMq4F-JJD|M_Sw)&h4p`t{D}tu_}P~ciQKt|SNDmD&%33z)6ph!0Y8=r=MU{X@*}Sm z38!PRGQRbJu&_j6oz4EkJMs!zPZXI)qI=?ylA&Cy|zSwAR?7)Cxq6BfM68oz9UyI zqQ({2OPXa*ql4RQHZaN<$UgFyBgQf*`p)U-)U@dXd>U3#4?(2V3$)I@kif~7$)Y4` zMb)KbZ*4c=Uxf=Lb!z^dp_!w#R%6t*PA^8abfxYb+ij}zj!aWT!KR2Xesf5BJEC+- z|9LO@c~O%WC)L|U3fg>_xtmoo#{=xo6i8A)E%>@_Rj#Q`9$JxDxgGl4e~GvqD(b&P zbEA^((cCa|zRV`U^w}GM%8JHltxHx{cXo=Oz?3t|8G#%@u5mvBa)~w(Oj^EKpy|_+ zaGxeA;H%)50!~$fs^f6HW7vIUzVr)tuT6pd32aFwzLs=a(MGwR`ThXJQ}Qp-9A{{4 z+~X6OW$z}!Nb>FX;#R|JYy; zo@p#ggtuDhbM=zn6s_4oJb--q&{%8rX(T1xVUNRYZE~LiqqkO$B#9g2Gc9Xk7geUN zju!(KM))=xtE&#B4uS*_WF!?ao{FR4?F&z(jnZU|Z0O2M>O!e6{$rNS(zFp{i{-`)PuTQ) zv33`OQv2>LrLXVPJw*za_|V3nX!+as&@-;XM-B`iG;>K|8%e#E+wd*BtD9z|TMgy= zzPAjYNfMuev~py8)pTrFb~ZV`TSGbTgPEV?H;m^=r(81impN=)X`?m*2uk`-F~_S3 z7%{H-9*nxWR5U+s(g{J@+(|jhl=E`vmi50a*a2&Ajrv$Xg@ik`^Db0rF~44xl4~T` z&pTdC_Aj2oCZZJS*stiZloS|ZwEB!Lp z#vy*fM_d1ZKg@F#pkhTo{dBho07Cp^*~!nKz*=Ynm(@!5M*T~mWMc^h)tf7$fj9k2 zt-l(q$@H>jUo>;us2l<0;VhV!5wXA#fLj%+1~pK#nt?B0UL5H6sj4Zn%Ft29rN|Qk zg@&}ej;w^cPFa9)=(E7qnDZwg`iS=de@1OF;b5iee8uiHM}SVig1bCId47QYU-qAh z2~F-TY>hLTGB*jt zfeF62n19GpzVG1V*!JV@U*m3$9?<&2J0!NBkjVVZAK^}~?=tNRZoZw~aoo^m7FIrl z(LoNf6B3be`qgooxG4qJYvVOY%?}MrU9h}>@Ynt`~hroJE?(m%{;T<##!9c4lE|_``*lMctLgk&~Ud zHkf|(h>ex0??sm>2U7TM#no#m?ih6u12(;r7J`BO(e#SBeaY&WL#2hz6EBSx1?2;G zchd#$tXW`TepT9eU!thF1*`||7Ruq(PdO(4IDrIrc3qPqls}ERgbJbi0*E?M@li)1 zxb&^Rg?_#VpDB^f1{3n70UY1yoedA&mp#V9`&&=Pe#p)=v){^B+V$l>@vRH(JXRfB z7rts(Aqn^0M)$P;0<_vStJPy>Vf7Mz?V8g-0r*pP0JM0>l;vrJfI%VS z`Ue#E1aBPBV@QD)C}5kLI2Qh(^~+fQ7V&j`W@j4mFk;v?CL?f6?0N0?6NKmA-$y{Kd^nn{`OtLEt2p5SF(HknO@6d zZgk;Ahu2h@NN?0pC~3QW;ydmqcKrj|`wOq8f98k);sYGI%k~i#3U5I1=d6T#x9ZXIxtBeM{By8K9<2H1eIYx%QFXWe%V1G&ok}?m_+RRzu?yxH4?MfP zUy#QD1$emk=Yd9Y>tAb#Vew1hPljZ>V}hdk?%g9&xXx_Y#}^YHHgcm9tBhIe_tN%%RBkmF9pLb{@KYW4CVCYhw>zSA+>e)e@_Dq9x{3=zhqs0I)po z(GS2&OIf%9b_wo@Jol9l$Drck`fDu)h|^fBB}W&F&+j_K4{YEy#D)e+d~Jg75C+%I z4f|Rg`vbS(&$8FF|J!ZYXC4j}Q;sC$Gp5g30Fl^ui)P_~ndM;WL~H#cVs7MO8`w%E z{o=Q|t`?K_w0cksXJexm9Ln#IpTMtG!0c)2bq}Sp@GFYdwm7%VXFraF7T^a!%>{|l zMr+s4`R^dSsH+ibeN^W50Oltv9JQG=Ug{K*y2Y8**5!0|b{>2=o;i-7!zJ0b@Om?A z;l#(ieIFjlr_FMgxO>`0r>BP^91S{1N3X7)Z*kkLzVqA1^p53*dHExMz2Eo+HQ|0i^9df4m6`D~Lj##A=KR(ylJi?} za=dT*Me0-pcgH5bL@xmD(+iT9iv*5rQ}7vd=u()dNM?ZxWEC_+iI@*{rqE-l^~RdQ znj_~XW=zwTmMWcbZB?7-rE`!w+uh~r3L!f1yNJUSd7%lA5Jk5!{Sjr*gEIqT@xi5k z;dfG;sUE+I8tOsV53;TcH)$DEiy7j=**v%sxSO*{Y`L^-ay00p@kBN%2 z2Z@xm&OSPN4}bH#u$&_QdX239(HPp%ASYa1I!1$t~J2p@TucM7vA9HJSTkBtEW&Vm}z zqONhtPiyU~Hv!uGhe2FlPm<4q-wTP3yL*ifX*Yy;^vIYMhe!hyuc%~=;?9Z*=H~}h z{7B5v82BV_>Kr1RReiz-w17tbSw+?Q!01l?sKh+MOxWSYzO6prt*T{qftYH&$#vF; zNOIPTBk5I{LVzi9{Z6c}P!-O4)fwqrZ@MIeRcFCxMELv%ku6;L!!CKFz4u&669mHr%C?v|z%4O(RpM+u44cclO%Y^m^OR z6qnOld01U>sleLs>hYMCi#+dt&Ghd-3_7S;m=DJmhHO00sbgpNPBm7m4t_lFvvPUGCD`=EyGJyj~M!|s^#Z+gWbkRCI+PbV@z)G~R) zj@Na>2mbMzPN70IAUwc}w(7`%$J<{)qE}&8Zq6j>1AmBgwVhY=~cT4c017zA@E|(HzWK@f@$1AJ76lE{J4=IVzjn#vd!+( z2D$zOQNc4K>VSX6mEv2-nVQV$Zv<(-GZPiRsY%{0YjVCBUHN$1wfNC=7gi-B=3-4Wcwvnh8=@;be@G0Yg z$D2UQh!ECTKQ@aFIGEY?)>lz5kOh3n5c*sgie2T{m4!6i8OnA9tTpOBzL!WK+u9OI z_sXh)`jOn=9CYjsc!zfQ@wRj2CnBnU;JNPhn(YCa0=-51eF3Ua5`6CU>;U9rwiTFx z*Ww|K51w!0Ica-yO@l7k*yNvz?BQFL=)mJg7iV4e-gmjy;cpoZ0m90y1$jU9E|`IS zI4&a@bd(Xt!cVlFy|?t1*pP1JHcBH#ezP{^{ui;XobkDHqJ(-I zFD!Q)x}WT2jo2;kGw83CJB~XHn7P&WZL5u3At(tH5^NNx#EMFg(ErcCFQZkBmt??} zcQ3}$c=n@p%)UI_+nPIq^-9yJ z#7{Tx>v-2J(Tcz?Sbmvvi4i|&#+Wu5RnN<$1jF_pyaPZM&svH8%4JZEno<038c&*p z5LWcyW917I@$zpEi@|TgA9d2`U*N9JTK#Lywzcjb2*tYz!YcyBw(fg@#>_cY;qNY4 z7(>lpo;l@zGrc8%nZ70>{W@;Cc9Pb&VFIt-i8l&jN<8G4e3`s;#8k06b+Pl^B{=+z zAr?))Qfj;J+UZxzV*F$pLYxyT+LwMkh*Li+nzhrfhceAPffIDw={MlHm$w(1OlE?8 z_?fe!J+}40=6C=XRlU~gH)!2hD?P~rG_03ez$Wbw zz~TQS8qhBEL4`R~vQK~xVP;Bd@P29vi;8brL#22ZUN7tbl56T*Kyxhz z9ughBo~OO0JB^TF?$#htuE;VMlfNAe3czmERW&4~aIT9#>W>LM%BOT-zqFmUbL%!I z>f>{)jvhJ&0aa?al{!=Lq&B3O)z-SO`(F0FVET0{@JVLurHR0vgj84z0SR%1`rU3r zNE#{rA(&n&_?#F|IENG%b_*rHhh}9;XPmV^djeRWV z=ssuKk#ui9^^#u=>?a+>xCT2%c-^&|1m@l_E0TNBB(sDjqd0Q^*T6T8&MZn*0n*hP zfADXyG!aJ1f?%G-GnB}ND&D=5q|-w1MAC%4*K>@JhT*|-i?w>Ze^^iSU5Z6JzoyLz z;yS&wg+13Yy068VhUdlU0l8u8oHmlP{4Bi4c+Kj4YAQh3g$C$@h6-W-ZKG`C4p3(_YLz?|cn>;s*nJK% zp6wcUafvD3b;0HerAhDbwLYY)i~DyR&}0#R5QwGHjZr%}d;XRqNzz;)ZTcQPwT3ACWrQwS)CjgDI;e zzXS5O#rgX66ko#BH!N2 z+1%GJAs-L1ToZC>fCM@oAWFcC*6P!F75nDJ+%VHv)J>ru5j(9hGwBjLyno@;^wvQ7 zjU(x!gsFMo96tkbU~eG2*idQqWQ?6cMBOMn#c_o_(HsYRH&@?!K5|kR>&2?3XUZ2& zJfPc4jLVh(NX|h22-*I;|D5x&78hb>Hw@k(}O6Us!cuF{<6Pcl~`+3Re5YxKR>3bXEm7U z=x1Y2GqK+1lrxA3o~bi&2EKdId>mO9Xm@Dx@A z1P~oH;6`Pyq>2|8eaTPG=eL>+Ze!vwcUR_Pcu72Ht!PCg&v9$cjXL(Soud=RR+fP< z0N(J~ir8Tx9<=CNLLC_C9VI^yP3!K$)*oEQ^KPy48SZzp3~_{7?F^f2@M(eAj%qL=uACwtG8fMQ|OOh$!v-4)0~EYM;0A9O`)9 z>bR7$5P6j~n9_U$Uqsy5QTJ7A<(Z_5!i^*|lWtFB-v|`wgC-L%c}v3DxD+YJ)3ng& zM$a2N)lHsfRNcJKfQG;=zlW|yeZPzk@tAP0gTu0M_Nj@$3pLLy4{PJ4E?Rz@*@3uQ zX4l6v!9yL7FC(%?WQctp;nPaFXd@wadU0+m%T4h=n5+*ja^G@KbS#@_j~hR?o5@W$d?j5BYC5G2C2A)A0v+C7Xmer-dY(Af1|qAT5*bm+j5<$ z(L+oESeQ!*k-5(c%aK+nWAsGbO}Rhw?=Q@Q_gPb;CijahkU;aN3Jbyto*ko~Sa1yC z4mgwk&uDp)yGdFNf}3nblGw~!J?^|(~; zq=G6czPGzweb+6~nQ)paxCy^)ALt%Iq>*ClGyK-!W-)|rVh09T0o`M5EsH( zgZIHy+F}~EnCwgA0W8jGdL6IkJ}9hFyf?N-Yo+Sq?lpVx;^Em_W3@Q%=i^RFCo>mV zXJV`4dj6NQ%gALO{k!kex18I*Kmo)goED^%ENda_uI&--;_*j;y`9d8>k z25z{zYT!;4-iF&|P2FoYqc6S3tWh_D;q*&^w&@5)+N#l0A{q!Sl;y4+n7jLRS^i0L z7ijWwQPRtJHba+l50Dyvjlh*zqdw_MX^%29x0q~w8Qx)~=klg;y5*e?U{x(=y)rc} zsZ87F)p$swZwThD8K~pzA+5iiYZ%xbC;Yvp&m8#dLuSHXaGQAMX|V=1XKH&|kUKdw z(MAa!EA3)mdnmy<8R1VAT~-vRbPw#*m;5>f-0e%*D{g8+YP9`uh}`}&)V+-}PPH~pxjvr_^vRlH7z>j73@66O z+J*T2#~VkWUHWvu-qH4Rr_2Lmn{j>IIjxVE`CEgfr7ig>*Z1!xSM^Kl<>UiEI5uag zN>cx+#rnsQFqec%KcU=O^$mbwu`!&SdXop+TdH101uO^p9`gI1yRq1Dq6!Y_`N`@z z8p{AeNWQK+oU-Wm;+mA0g(Tpx%! zO{isTOMwWQ-L$A$@TLD3Tyh%adAJ`#ePDvu_v#Uxa&#YiQ8(?Es!itGqF3*$?pCMd zv;(PF(S7=w@BAfPati-G%fIP`XT7KRm*(FUEMDlv!GGW3S^s=Yx`0mu@7W;7^5ZTu zSgd;F9m>)<4UK^!4aNxiG%`0g;=m)v|7}tv{X0 zzwe_I(^HoF9JO)IsqL$NUYWZO>j3Ldv>43hgNVQ)-S3t~taS&_fP6X7wnTX4Z2g%e z4Aqta3!WVjiqtqc?d4(xaN&Yo_x+`1BV>D$P8!!|^2SEX1 zx{`gjECDiMI&zEpaGCy`uZ~>LZ~{%?Cwz8-<^nIQvrDqC$jpj2Nwh{w#+Cgjl)FG< zr|_cd2(DSYolGgNr%HuBV7eAHFij^wQ1Ow1BjKJZiO|D2t(tD2WL2;Cc+?qb*m_ao znTVzB;4cK8nR8x~bJ7q7PnB@a3BoyRg{;(>ZG5$`&H}w!w0D!{hmg%3hyid%;T?xP zr3ezi4~2*n2cF7yc;5g&Bpy8ouF3m3dExh4$N5T*kZ6%235i);X6!nB^4TGE`RwNNE7E=-nj*Mxtb3l$apdtVyt+bMkGyRmSQ3lw`S(J9hbA;5$+ zX*kXhcF(a>wCWQNu>J;f=gnsz@RmIsa%Qq&8iIJz^*Ii_3^V15+2y2+AbWW6Yo8HO z%!aOLfMGIiWHEcRc~A$6MaHs2r@<82%Vv5d*ftitC4`{$r&$CC2eN@w0Js=)pM|Yi z(I#Pn=&v%ajX+;Q7F8!}vm1dujLBIrLiByx34=sjsVJ!Jxe@MOBesYKvIJ=I3AsS( zbI>i2Um6@T&7&s9klCLQe%hbT71iQse!;J|O7hDhaY((n5Ie&_e20)uNHIlLeMR(> z>Dm$wk75KF{y6&CWN`TV7JU;ujBc<3i>{X4#+%}f#52tbpt5M1STsxtccRYhwx~06 z0+YxQn)V4Pqx*RA*`vl7St8!BWv9l6DSLiRLXRZ?m@QE zgYagV1+0;7Ei1eYXU%})4Ihr6lC%|xy5q&%Am;1yw=Tg^2LNA^qQ~358)am*e`1#p z*lW@e7-@Y?fn5w?q?)pL_^Pqb+{?8(uqWtTln8ReaQTuOzVK@j-ypg11vfnd@}wSn zK%Ugo`fG^~BSirSoTTC-ebXFQ3d%6szD&k%|H3v&#u=-YF*i(}L|7ZDadhEC&(k$D z_B_o5$SPGH7!fo*PM&ANUTt?mxnDUIxqFLi7UgWiT7y1DQ5_9e_-l|}*Vo1~%e$!> zwe+O(*|@XZu=j`-<{&gCI)v=)o-Oz=^6Jh4M69fCr@Y|WTF4+jjN;7Gj>%X}1{hzR zv4KYnv5ya$CbJX)z$ zdMY21dYn?LX=cvxipNtMb*`I$D%8qZbX2^hmDAK?cT@T$Y2i*veNJMIgt%HFpj2By zg@JR}2zt&TWGh;@`jCR4&oKj4m!Y|}u0|ZQciOImoLTd2Gz5)d2f4Wj$?DyPa@krRYC8^?RDtvsQV0;ciK|2a?EaD3`rfM)Vkc~sB&JD zyE!xK2sl%j_mh6ZMro%<+QVCb0W~?4mqE7^C{LTYT|gq$o#FhdlVX{2n3cN>;rn$m z;u-%005A*>Qm8izSTdkBjN1=y7oIv$1a2pt-M(5p5gbMGHTOd;U+}TD?)WAXux<+S zr>$Uv=C06bHpOk{vJzD02%Nu9z7}MOngahS;e3;O=UQsDakb7oV&i&CcD=M9)W@HR-wzhd)_;8a8I;-OYPMjNShK-+emmY#i=!>eY2d+5H>ls%pWjJhv z-GQUloN%vzjB%3SaWgs5i@*JUeiOB_wV~*yqoEDsnlKilG}@rwpk3K zb6^mqPIqS$%VH{eKC#GN?^}JcUH}I}{20zIoc@URZU0yGZ9xsSP!q&pi{WV`r&)Lx=mgz69>VY zax?1AFA-K|QXy0fdRl(MWEfeBjz(^}8~rW>sZ(n0gG50)9I*EuYF|1B3&2QkA!f|w z^P44bJVvP z+%%xfLJcnEJ?h?aGhoD8De?<{Q`IbQ%zZuSE?ev_oDaJB@?OtLHQ!&F8iOvBfaMK+ z$-v=*FOVn!RSV_Q@4=S1pXSqf0LAO1#NDR-fIk@uzG!!~lNEKJaeIyG#TN2y_Y?Gw zP<%NN2EhW*{4sX=0~v>d_`W0THxPrm-|I=NJ~rBk^3x|&N369ZELiu&-0>3CTVyB| zWeC&6#P0ldFo$2F3bHw$`e$uXtO(S&wem6=rTE0>`=#BAiO+tY&JmNPTammDKB9uM zR3Tht2lo78!NrI>4nG(?s_oQ7_=yG8&?5$_cVh=s;Na$ln~%B~%rh!jHu~eeIXk_T zj>m6kYNiUNE7ExhO-#hx9If2rc*AlrztuE3aa&#-ykDZtLa*1T*ULZlJN+wqq_WTV z|B|O9ou=_v&2ur$oDObF9Y-=tm+v-}+ba2AreBBESlei2 zKc72JN&F6b9cPE`2ZrM=TP-=gn zj%3EwGH_TB4Ro8TmT@2WQ+Ttw;F<#Hu(#8e_oF^3shK2uqt*=j5qnO-c*LIPySlW$ z&F{CZ_4dvD-pubU{NlsXp3m=mep~r%#n@yxHSj2(mLdOfAzHQz%IhCOlt>(nsB;?( zm)-+*d0D~arTl;$s%i^j{!nFH2#Dtn2b}9Q_8{V!2RTT+u|LYPV&dbyu`XFv*na}7 zGmaUR-d#QZ(1aj$U;Jy5aZ!V$reg(3BnY%xU|$bX(gw0YNa&LC*V+O<^(rU>&yg}82zDR^!W$j`KQ{Wx&4o*tEM@$7ET!X|G%}z z2K-^e4oCgB)9?4JNPKx#$cOi(CutH$I0hBwh-Yo)t+z2kj-)%7EA=M1E}kNA{E`Zx^Dlhq%_WBVmkTK_kqL zITbMs26pNX^u5d_ey9i4FwfL5PkHL8$KKXSSWy`f*ou`!D*5yDKyj zY~c07n+7C{cz)a!`}oUO=Ev=3AO$A0Q4$e#%Xa&e>W?|3@q+8Zp)2nkqO$&mjYrVP zF8X^17L1ELA>kx`%D=hA?CR8L;}qQA$#IvtZmi=nE`k!jeqY`wc~8{+xo{Wm4HW)G zEfdVS5usqx{gFVWkAE~Fug1m7_&C0FYkFnhUeO>2Dm8mkBXFMrCio7h_^HUW5o(2E z;T=nM(j7ZNFomz$@9z>t*0HO6Ano1D5{A1}B5!?;F z0Z``-Kpu}pzokq4*9ir`rMLL6MZcwjj}$KYEp6u2_${U0(n05?R)8b_t8+Wf-CQR%A1yvSpn@n$M` zZ~T*fFkP$9Ezbf+1}rso{;T4&A38Q3JAMuSb1n54RkClhIQZy!F8?(qF&xM5NqQwW z5Gp>IhCS&+qpTH@B)5Nbm9_F;ctCtU236q&XWI%}DLnh~FA0s^ogeqp#{!UODU=0Q z3*(`Il79KO;uEXz$?^Ut;o>LPANz@Tj{V2^pPW$mq~L9+viQll$9_WLlK$sttGBW8 zpY^USDISmysq=Ljn1ZVS`^RD!F;0z;jeZ0oiLb+N9HEkb(<}StKYOu|c!$nPEsC z@)BPz7Fx{G%}1(iSZ>a8N#f&~JF461vQ~_Hc9)aBpEnav#rvwMlTQHjYNWs{6W?er zuhQjTTx3NW76?rk19$VeI&2N8LA@GM!w;z;;SR?HT27i58v)7Fc%$)nH3 z{L8*L=&!+7;2`+Nrtv`}uKF%N8#>hvA6W8gVG3QeCbwAWN{x@3V?)s`AuP(t-$h32uu3jBNUs(#E^okB# zD+jb!M#D?07cc!_0bY1G54zw^jEDca;8rz}T2ONkX@qSC8_mop)qt^!XWL)N zGFK5DCUJu#6>&GXXKQeH361q1LZ3%nMe$Z$GhwIMt*k*w?o9N%%r@$6*O}pemOq>$ zR6-@Eys>b~@AEC&(?dKp$?v2&-^U(p?)HCLtG$@{%{(egy5FygXMWRd9$PDfmv0B3 znJ2%6bBl*QV4Q7b%-q8J)}dc;f$1w3wCJb$1(m5=@mcd700c&=@tWQ7d*a!{D86Q` zJ6G_Xp%yUd%uYV?P!@4`nH%wjDdXxk5;n+oQ)0)u$>`DAot7VNJMqsen#g z1&h$KBC*ShLb6 z!YOC6td0|Su-2U$Y5(Nhwo&|@V0DOXpr<%ScR%6!MpHY`Yu4*8(h|$F6`!ox&6ZT5 zXy#TdCt`;S1C62En7?ZdHRuTc-e{GjYk8gK1}E5^lSZ^(`sLK6Ad^Z1L`-wX5_b!Q z+ChEBVf~*mVJ$+i+AfNY$`gqreK?eQL(xR%;f-&ujtSGG)>An5)l$Y?#C|-m5wz-7 zdLk{?d_t$@(N5CcLYJeaYY!H>cCz2KPF~TjRqqn%EujcKjD~-$Wn7Af6g5+*am5mS zkU1_%=K%Anwy+JNjwx@{0<4uA@Ya&dJfuY@EEh)u;1N7e0P3P>ZJzU(J{n5B-G48| zn%o%^5ML^S)ku!CCTzJ$Zkk|ZA&7db{M;tDq)-4mntbwxCDro`3|9@)GLs+WI3QP; zQZ+3z=@UJhugdG2++c0ty9vdLb$1mip5m5UGu+_tLXlyr8g(>S&UdrsM!liyNB(oIp#WwHhPz)CM71*z!piFsWwb9kFPxp0ku%tcDt zj&J{?@eBk@7!=FzKqS3XmraX#r^7W{6;}A?@tU6a-a~O?w7v2ilW8Oue*3Z+n*=?i zd%xM-(3;IEv$?zlbT=tydWbcK^!G!$pTuj4h!jQEW#ovh@yND)tM3Y{lp|PG+T@&% zlfpS_ff;0IXs}EwS~y3!#WhvAWw56Fi*vzE1B2>VNE2pOQPCS>}yGb{AylfH{Gvb{kR`0F%B-HZ8J&^8-CZ%YP#CS~{qTp@9U?NIM`#n7$+Fqtk$#VQ zPHnp3Dd?wZ!21THp@1-UltjDyPBSvztnBe#=X-Z&O<(v~>xa+sjHVV2+tV*$+t5=H z*w+-^zGQ>HqY521JB#3DuG#x^-ox8J( zJ}}Fb8JiHT|HE2MjS(%FS;ECd-0jeUfu2=R3WeWC4Dv|w{eH4Pjt&t(6q-XJKr0+5 z<4#H}dmiJYI*;nob$+_m6r4?o**NO@5ozvr<7S*PQTHR~r|nAmsDAd_)}2WnZ8dC28jt^t$dP}qwc*C z^EHyR=dC-l>Wur4Dm>P{2d+WV9lJH*Zf$aVnrgQGeg4BK@E^o`*z0E0Yr0rX7ZFw6 zT<8ZWCzuo*O-*si2fH-Zcw-tu-+(R%^8sA|^-(~tP%7uwnj7!`+TlFp01lfl8w?*_ zG7`MTG0j2nMFiQ+CecQU@efF1Pzi3c$@Tkd)yJly(u|77BYgQuaJo2{sEKlZ? zaFA2;*WJ%wR;`Mgy$w~Frak#RthM+_N*RgASZxQB*j`9fv09T-tB(uCUNXhnmu@ae zfl|$87otb(t*qwyaZ zR)-KQI0~m2JV6`W?mEsSje8U-)G#8-5!C3={aEP*oYY4jC&t~QiSU613yi$8{nDH8 zn46i3-s#o__!Q-|QuVlNXv@^I88>#!2JlCCZM6O-aP)7Pr5Hp;TQ|g=iT%2BM1o)| ztfB?pJdg8*MxethB9d~aP_F$_{2U9fr)4zjz;+Irb{F|1=fr`gj*{%w)V!OC`M!_; z%zLtaqLqHal)w1msQPK*HJ*!Pux@y20tiCf507c|*)U$JJEtslFd6O^6B;{;8D>Om z<=)yv_{fs({?%&ait_YFquJmlGJXCELittZu6AdJX*{A!J1$q=wS)yn zq1@or0c-(p7L@e8uL&E|Ud%KcG`vJK)pv0C@m73SyFMPCzf0LZ$$TdElLJ$$4LLZi z)(VRgLq8QnBDi~M?{zpMS`+gsx*-SyyVHlhC{>j)V5dBoLm z=aDt^goW-+ujN7i#e38D_)jHU)Bj6PUS%E)7dUb5o&xLn1XgZ?VM?J^bM^uB*O$b~Nx z;$a9)b1^5h7me#oyzO3L#4M4dyTPA@kBoKN`)KQ!`6ZH`ZN>4#=6Po$6E2(_xD+97 zzs_^Pgk)Yj-*{-hxq7kvsQNs)EH%G)xHfc=Ag!+HXQ(TE=s9ZAz&&-g1o>WKTSc97 z(VC4qpLM5%oaOhEe{JnnPX{*GKsVXq~3}QN~CUL6c?t0bVg0J?u z*2`SCXu+cspC1wb+>${ z^&b$`-&{Qzz-P`GFeYBMTL0z*nOo17rL~xYxTr+z@hOE+gMSo6w}%Dz z5tjd4JK0--u$H`#;nl?Urfx(JOAyVELg zIOBc|r^CKV(=Swcll%2r0LjT%e{|K~`D$G{TYa!U`%$pq$<%g7rhBTg9}TC>1rV$l z{20v;10w`=3^1|QPoE2D+iP1fz*l$MDW*Sup6xc4vlX+4hKKj0`Xs>J?)|6tw*#8q zT!W{e;j*9k`va1HJxvc_4IB(B75FtWjWAyGQpb0lsr4{SXS|__k%P_UgJy`r+;cjp z;RsRcU*<^{0G_-s>p*vG%C}=2v7r5k{OIER4Nm&a)pLAnVWEO^jrQ!r5~JGg~(tO_A?7%xR+AYqDvtOg=EBJ(TeGxoBmX{K%ffnR&B{rtpH) z5VY2Pdzi27zpf!*9&$=UogC{fSpnGLTS8Xac(bzo1nK-74I=9zFovD+(RnVKb5j@FS@vl^3 zg2*qrIlXm+`dkj zMV!P53ZaTwk{3Hg+#+2*i-oWQ@S^^CcCVP1;FJcQh-1uilH{|Bs?=E;zhUZpjEP8X zeH$%3=^A3@y?Q?l^hQEVr=*h2x`^lMO2&p}z#jz*Z-~wu9!NW0<)1jP%s?Ya0e8@#}@;{ccH(gJOu*n zYWg}@pf;(PcrEpmv^p*(!&*OkxsZgH|J$HYc*fHwD@=8Be$aZL4R`VFu4i*?lO@qYZ~(B=c=t5f&A zg%veu2hVo;lZu5W8~bXF!22iQ2l!xB|1%Il-U13TC)}lNE%wGxJH3#8sOp&G*Rj6^ z%D3%&d7r@{Lng>f#7h+@euwv!fsa#2Mt68qsM>ded>eHu<-hSr7jOW!9MO$RqKRQJoY9Z?8 z`(Fo0Zfs`pTQG>}c!sy)F1ptzFA80pOh3@-dw?d{lXs&%>Rt5q(2gPwA#~saR>#k& zqf306mipL3ekg{nmuQ>U^;XAi${p?JJ`9G(D|7rw)cJBtH2j@ESn02;3*#ed4B@02 zyIzg$WZ4F1<#!ZvW4r5Pj}Yo0-`f&i`iItC{yN{Ktl1*{yl3AZ`px&rpi-tnm3~Q; zE<}|S;sWApSs+pdr^3Fj4np(8EeD)Y|p)%(vJQ>pl;^!`1+ z((kI$4ea&7DY=&d^j@mx^!{UxYrpz!u1EU4rqJJp%-CM9d;icc#rdP^ANo~KQq|WT zQ?EvA=gkGn3R|_4Yf*RC&B#<%@om*?OuhKc>oe3~*_B$M0>9EpS-9 z9Y->=to0w9->qK7F_r%(h3N0U`IWC! zre}0c&FOPvC;GHd;oZB3lErSP7UhSte($iIS-%{hvNzDDn4~K{fEl5cZL#xPw6yM0 zH_*rWZZWylCKp(wt?Pe0+W)vkw~8r4$b`H*oV$92IU~8&X!y{Q5k^rd*8)O(y}7G? z=|c!VkRYo0c)7i6Eprx6UsTctt#8bgyh+?0kk~@)MXqnD5O)4V(lH7zN_mJB0l%d4 zJ5^Y4=q{?eX}mmHZ2F>TgZq#jQN!}hx<7|-#|Mb)0{>3>VPd5ekY_^{o6s@xBA)nE z51qAC=Kc7cAwAsXo$2=w9)S9+|HO|UOt8kmNDP~`fu8oW|}bX-QIE<(9J58 zA&J>0X+V^k3)wVZ0M;sNIavk^eYnJ&%j||c9JLm^Cfm}{lWM_jI6%T6p4?@98-$AB z{j+{bsC60%+ftU$u2m~Zc2?cN-vd+PrKxjWv=nxGWv2Pm7u?H3$;_&?*t3J}yWfLn z^1Sfutm2X*d(}7)E}TjqQc9k+slcnNjUj2im}$y`X(NKu@@yc zTvk(4sX3cK;Sn+yuLYc+k$nZrx$Nk@&TJ+R_M&ztDvnz+7_9pH(ensQpkF@Tm!g**-_V(>OJo#RhgvQE4>~5JM&MG+pD}s z%=_IF{2EBA_3rnRj1a(7q)hL}CRMZM$5W>Pm5}aRRlNR(YnhJJiQYMX(J5YCrRtp3 zN)$CX$aO88&*COCt74;0CBGs4-i(vPL2COZ@Z4(vLdG-39w6>Jp{#hhtYq?twhJl2 zL>j-8P2&Pess>1c7ZKp*x29#62&0CtDVTA1oT*g2V(%S5sySc%8k54dsQj{%TM%2A z0*|QxxNk}S2o1q?HAZxxw2hw9XxvB4RLL%F3-9u$nYjN&tE0=j*rn&p(wi*45gC`A zGgEIq#IXY|u@T4Z`buz!|2gEHMqXsZMR<`rJUsO_uBTkAosatuN-DnsOR$TgWAdpn z@$^T-Qg63kdR}UHq;3&TY^d+Yl!Aow?zm8V`V`^{wbDtdIali>g!L71Dycr0dI!$a z1R107dycGAa>KNZCvdv8I8_EAHhidxNr1-O54E6X2bvS(>mCoRs9DbfsE6TjSd%{_n>o{<0b0 zr-7{RugP4OXHUcc_I())z@i+r@l5tn|ChKBqTyIYYr$?zzCx4kqif0YRT79zgbT%B zGVq5784i9Brwr%Mj8LG@nLdvvy0taZDdu~1W zm|gQ&TSR}bF)C|2jos2V%8>H?|3Rrt!=>1$ejb15<8xJ+hVgnqNFfnI)wv@i~s$qA*RNw<*_yRh7==R6YUFj9(>(wAoMeJjwN zer5LPJ?{4OD-(^k(TUkt%0_Q@v)wNT@y|9YYj;NSO*N0Ddfkj>+Rg6uCT8yswq1=| zC>&C4?)l!q&FMpBZD$cQJvBA%PG8K?$1PlIIG%m0jCf57R~)qZ9Q#P3=E>B4v_Few z%34p3?|sW!uM+r8=nD~e=%@<44Iuo~i3Lc{5hu`~Y{qeuHY5M}_5eiX^t2r$$gOS1 zg+|*+z8NH8dJ)w$5)njSU$v=MnmELIs2Gw~WbnxRZscScZab zT|LauPPCDlL29+1I%P1mZuwE}q>|JZ$erZpP8iHRmDH%8D(|DYQSb^I$HFUYoHW!% zrdbO$u;B->5AAo!+T`|!GQ-YjA2bJvx+~1$ypwc)prym}1IzXZ2tS@*#Ht>P?}asK zJk6W{7A(IN;qKP`?xy~qYQ^?Tt_loJ1l|Y8gnJg2KcY1wd!bfskH$V1l1}dyC2+A*Cd}wW1+2 zXEBa=7m9bYpyJ?HNUCBiDt{~@Cyrf z=gu?wN*Yov(DeVyCu~`Uow_8B+#cIvao`AbLpMfv7t<;Od_y}kP$+j&ev4emr#}g{ zK8`L*we1+tYBUXvvkxiDXnv)sVoY5|5F8lz)l7&M34Cy<`?z3@{`;HrtEi{`8Llnt zh^63A{^>645A6;G;>S{_E)GB@@1T(wXABbt?vit$9t;k3uw^8 z*81mK0^3`h84zfFG53|4?XjAdQIR5S556DhGUQvecf#JmuJ#%3$dq8QyU`l_Ypma0 z({h2m(%zcb3$xQ;?m;fMo2=+*nG7s4Uu~fjB4ex%yN00XbS{_Lb zBQcEGm}Z8@&~2t?S&$i9Hhj@n*$>wGGg`vemMyxd;J=O0($f)M@CmcAFXm^1x`z^M zOSq>6p;b$M6JZOFhYT#!mkW2oK~89(?xHO$KX z*(bq2aDOcDYgk(S2I|@hymY5PF}$vm6^so&ft{`kww<2uPT=edwgB)~=gU7;ibgJ< z*@xU1u=vejJa8B_C17#kU_Bu)ywiJ@Go*th2s_uDF2Pt%=T3RwkvM*ym*U(2PNVg_ z;Oc}vxQCX%sTplMXL;USP|O+!ldp_d?9twjvB6{U`*IV!FFsdzJpGt5BfMLn9sp-2 zo7($K?QN&KFmdQf!HDcrgTeRCab3Ut&2N5VAAB?WRvoaF+qp?=zd&Na@+b?C+>^r*^+l!ScTJ2{#8KdJ+m_6&h%~Da12#D(e5F zq6@z_$Ug^fKs7?s_+vJmKugrQsoZ>j94YeWP$`{*^zJG^hW&Y&(gZsN(his_=VVg6 z=LE-Nh?ogv%lCNBfoa!gyPGLz*Ysw_c6(RoR`QGdnIh!L1^1~NkVSE6@2=V7T`*W; z10@R60Rc9`I~zoa*?58T8nnkd6n@LIG6ci4X=LI&?i_d9s8h&5{(;BoFOB0=~; z_MV0;G{ckuMT`o{`2e+^f->9Py9fIBA-mk}44%P!Y3_=0brW%eN(Uy;`}IeDl_p&H zqkP3o#V4|#*REw^jbu_pZ(;s!k7rKnjNee+2_?|kNxF?y*Xr9%fxXZjx5x2(rQXv< zA~R{TH&*-58Lm!S9R&Bl2%s_8IVIG78xZ}5#!%Zi7~3`2cnieTbdSDN4SelAN5^zY z`JbN2r?~*Hn1SJEe#OnK5F3Yv;dqh9vmCkf)7$_(1_f9Q_2%P7MPE9@UT77RT{(u!r1POM8^N5$V+x-X8eW?vy!VcW(^i3((?Zfq!Z5c`;Y@eE;2 zouw}+DjU#KnUT85$CF7&AE)W1cwjHt9-8vSYd&>Hsg2Vl*;v3=+p3LbPBas>kq!B{rfgWj40f{ptU&eSS5_8@@mM*Q`#YR+!nY2vO%kc|u=+M`YEbo^fSNDrzPI71#yF`Na8RTB zqJVE0E@c7VAP$OQIUn{U0OuN;BY1THVh>)g&-&e4gc@?8G001a9@&cn`TX$9gYsBAu*FRL}M(XB=+Rlo*%@sl;=jaZ< zS$hIi?Rw~MtK(nzFjpS=Luvonx|HxxgHI?LGQ|y^f+{ed^)^l*wZ!`!`V}&+b{cE_ z3jF9whJS3Wf7dnaT465D_M_rJ7!(fIbY*Ve!Dp>FD!V%oL!t7L8`EM3_JEFk&|)8a zp(Sd?KVSgQpzRMLa-jxs*E{|oF62ZPSs3r&^H_=P8%jbWxR3vln@AC6#)XZg!Vd5G zxBY(CsG1&eXK??#W!cEyspZ}I@g=zv345;DKtOCId|f^w4vi}>e12cy^QysN>vIkI zues4J___!%L~H%~eB+(rulKydH{*}}W|-~1GxU>w@E_?`a`mUqaHj^HspaU|;@@iH zQ@(C2LW-vQG#=6qpaDYW@x*M};`Uh^pZ3lti$>El>d3py4sU;sp=QQ8emB?`-U~_r zcEsCnhez3<>AcvmD_PPZoA6Dx5k?eq09$EoENPctF}O$jw96c0!VI3t$!{CxqlTY8 z?Vy}u)mL3!wAh|YPl(L!Ou63!|?A%B!sN28uE$Ilb?5fh&WOr5hvev&ie z-Z<6o?ioY6`yq9zaJsi5zX{s@DSVx(GD7VU5s2ZMC=o>1dETy3ke&2LrENE&uQCTe z;C*p|9>>tw3G7brlnf9j$}X?B%NL#uVLftlc5y{1bag2YV@8?_-u)`f0lQp`hX17D znjQ*UtN&GfV3u6s(AqUU;#}=(z0cjt*Nkl}U z3Pa!|U2xTQj|{iDjtIiM>{ltrt}<-&0{ye3x-@X$Sd=&opdoIR@F1Vm^6q2axS zyI4uqdh8w8I~Z`F-y!_~LVv*!M?YZV^HKK%;m@~LF|&I;js{#pUuHsodXt&cPykSX z=fCOCu`!5;_9yB-5yi^NLd}^#!RXgq-5Z2EA~qVB7p=#flLS_){vYn%JwB@HT>PG7 zCS(!g0 zp0=m<;;F4IA}A!>5>aki1#7El?QxIeg=&R>%Dmra?U_k}^w{6~d;fa#`Aqh0-Pg08 z^{nR#J4iKD+I)j2`KohNRR5LWb|WL`$S7%jrIJ!A8x34o$w*6g{Pt+X#E8<>XoGxy ztkh8++Rt}L0zlb(Qa;(1^ZtP3Q*R}O9aV2d@Gc4EqkW6>%BNl}EVZw4o~fQB3w`z! zry$h;^{UdoNWGFKnom0KGm0TuiHT!>3K{NrDxPOpdDq>RA;J%)d6ZZ#VIGJXzZpdz z`XJIoyK{#eY5E++#a}_vZ995bo(9tgf4O@?)=Lm{2WZ*0qsxN_?8D=si6n8&<58sI zyKOnhIb!oxvI?rZjjI#(>4(x%oV*}IKO{2r-FBCxRx>9#`Z#v>+B4@ex1c!TuwPl!DkHz92e~#8`FBM!cji=?=ko0BKcJ zwRofF$}vEa;rYcip|0jj3rldX0WBv#aiGzP{fO5iWbUo1vKy(acN~>novv&>5B4{{ zs50ugih5p%oW=;jQrT(W$0S*^F-vG*yVh1T(@|)5b0KrT+x|gGdgNq`f_$>-@HPHJ0fJ|zy%oJWDMc8F4a$ORoTQ#MVZB4w{6x7BfRsU60Jh=gSiD0%O%{g! zf{|HKjC+SUZGu%-S-p9A{^XqYRH|)6PyZR`h?K^?89HjNyKcfyL!pA#=IGX%ss=&3-_XV`k8Ba+=lcmUSPe>u96`Wq4Yl?x- zq+FS#`LQKUuE@XAz$wzeucjOLWocj^PVr9Iz+7bVObtE~h#nhn7fNb!XF;KB;i+sv zihw%&3T9J%4pC+Ac>vDAS?g5ePPOVvfSwVmso;MkUCDfrI3r@_D56*qrl*kR6)K?p zEkLW9IF}~=dMr&uNkakcfAV0T^94;rmY|xLoxz3UsH|HNYDf>#l-l$n9Qf2LI!?w! zR~4ctbk20C@RD?ex>Wc(B!HhElOmBvR5}z*KzD1Fa!^~JXT$K74LCq96OR~#ZBz}QW*T!K=rgqEl;R*cM-Vfmza-> zS+Ihc|KP#?8{)vvPvInm=niG`S%dQ}lYCE|Fkcoyq6@zY!h(gNb;h`fE%V|rd$HWz zEq8Zu7p_`RtaW}}k~!!NM<((*jpBah3|iVoP{!$QmGl~DXa@^8 zf{m3v)Y~!&B8_nrqGXqp$FxS&vpkAhsQB1TqeLAlD{mxCz>5irqp@_dQiw{zgis1g z!9R(U_~+-~jx9d+dh&+ihTEPs zS}9IdvH43XEYPOOCx;(_`cG4@fCK;%W{6 z_OJgH;M`3~Wpp8F~X+7EIf z6XoAIu@7=_V3YDhE4Ih(q2}DVy|H$#uAJn_&Kpm%*tu~h^PQU<+7d4F^*Z`kQgL6- zwjmQZJU^R1@X4cX+G9Q-OlwiUnnghMVK@jDtu8TN3*a2onstYxnKf&k zN-`-sa90)bLR$VSYyglmILD^!xG7K@fVVXKJ|%;WDv|-bi+<%#c#JJ?f^8<&ZVI9O z8#nEj@uo}OSl2ERv(-n@4j76^8=4ixn5GYIwx;5iASY5I|4s)Gqm8|8*k3O8WVl^U z^U_9?X$7YfeE_>rB~<6}c@&^#wV(!Tn*d*qy_=!*p$<^Oar#iKe-lD9QN~$Q2Bem- z&DV&1rEn-Y<2PfDK3~bNklvxnj?dtE>z$UEG6sQoV@}ZB$MLh7Cyp`*bnI(ohu{!y z*3aYo+6<6hDsVniTs=Td!l--MT84Qa2xGT>v`7^D`5F)68)`C8R6k#G$q7rqyi&hO z90#WV()Q~31*VY(PC=cCK+FD0=7N>8J8hUNtqEDSJsi+waRzrocP-;XzN|JjphVynTw?fs8MR2 z9x}AI3IFvd)1EPpHY`{gyX^HcSSKuwVwHJ0pi~WtT78f#YW4{0kz;>{E+~6V z^@-`2FJ=6Y)Mn0c?g4a=nMKvYOjWw$^*KJaJkyj^WFXJ*M{HMyJ>>h~&k;(I% zlV@C}o{_2^ud1gq`OR#9w{W6U4f~#x;o3|ur>hJ`IvzoE#2^FzU59{Jf8MA&_? zH}XZB_eCgJ*q;e^=YuEjnTI>Tt0q79{PRU^^&xFz0p1g|wGW;=llSqWcGOUF;-0C* zX_d?&w5FW`Iv*^RoYC!uHNH%ah(xPFN(d74Zc#CTPVk=g%IAUp>=@|JrgVQqi`A?t zLn@+rbzG<5wheS@^49;#cIwR`ovLy=rEho+2$;JXg|97bR}A#6O8SNtjPwoltK7Nn z9_im)l&a_--JI**yj7Lh`Ji9*@)_I$sUxUWQzrXR@xx>nF$=w(o9T9@d#Zn7OOCi& z=XdBA^D!zYlO{-kxH?q!LhQ|anE;ujI>bS7q|oE#=U z{Kz9Gx7N~u9ZU|c$p_EQC}(zd$keJfTRWuSDe0+=VjMTVEITb=xAarCwGMn`+Ph|O zd&SQ2gzcUBkJ@{KzV6|Z8FTbbTc;l1U}wlj4Gg(7no-XV_i;^sD%)749hZF?)O5Au ztAUolIZ>DqrHHic&FF=w z<1c$bJxRi5D~N2?JlPw*!n00rMYDCD9DEmCkv$KJG$q3WoUoHIbH$dHdviF7Syz`s zMnk`V2xXU`@^Z|ls#}{{kipGrmT#}|O}E|`_5fu!Q?`Er@=7xAwl}MM*Z8;(n_sb? z;4y42@EP$1m8osjxBFZ6IXP#NE4-jGtG}l*uNazn!Eu?xE&FH!BeUDSL8Y9`fXx?7hXfE-gVzAq6!_q3464efrJw(l8A7Xs1Q%?0&%bLRRxlLN< z(>&DrCu_MJ(K~<5gJE5>C>&p~h~x5Mw&O!^YUPCR4!ws$8pQ9dZ&v%Zo3UxM-Va%S zV%uv(e@HkQvSB%VjOSI6iV3WB3W|gEfcD4k389*EwUxrJGoI4+TttNzNd zk1AiUs@6IWa!+>yl%#e3g@=$e8**dB#B?{^PB*pAhxnGIgQctE`x5s$1>uyr?QOlv zANdg_z2kym^l*q37a#E&_cB%+5j6h8u~Osn4QM}Sd~Ox`P>w4?d|$(Zux6%+Ia-JZ z83&lJU-s-piNcJ&p75*WuL~pag4hyP7=UmCnO`NU;aWEeFXK>n8B=p-L_^i(1BuKP zCGnxiH<1E-pjXwDMQ*3jv!&6upfD#hZ17-Mqov__U(j$Yj$lqnsF3Dsb%Tlm}{x9@tkoh&9C;BvRBq*q3t6+oy*NnAtHivty zGweq=3K)Dv4!vi=LW2`!E&7gold&y%x_iIg(Jw$2EnZhk64}XXK|2@SN;wluXtWz7%KcfLkh zbIeB&HgkH`ngf;_uB0xQI!qXO`#CoU%q!7Sz0w;w%dl`j450CU9tF#VeMBxmgj{?| zD4$@@3;N-b9^ghTtv%cX{G+wbUU|bFI8U}e*>}pC1P_X!1_i+sEF5}~-Y=j}a)YcM zzeMwE@2`lCpopl~30RgCcemY+OIWBQok)84+|f27sr_X)K6p^X+C-Q-v z{hAgN1n8V)1p#VnhhwxfL0gM*bUV+y=w{=G#pKpD20T8|qa*a;G~yoO!ng~#+N)jBe5GKFr~(9~dUcPe2O$)&`r;*iTGw)N zwslKTN>r`Ga$XWpIevPFh0O_lG)cXZlV7i=Pr6U+OWE+6WG`%1LUtkiXVOjOwp76U z=>I4d>U{min{L>mxHicHWJ^np1*&1YX6%z?hB1PdHGohR`1eUIA(5#jWJd>(ee0Wf z)oA_AKDbM%o%jI${o0Bvfs(nswMD7rpu)d?;#P{0U`+AKT_#&eeC+aK07(mSx-}?% zCpsV|XJT^+?HyGIaka#-?||ZyMIp2ECiOsAl`EQT9S^a^K5xWJ5IZsbgLtm1jQQDp zexTCLDv#amcP%W8-5qvm_nN$e)mMkc<)&$+l0doqgp{^V+ zVnuVSjG~AKPkJa@syCx~Q>@;wRMeXi-i$_v$23Nh0~}pfE;PGop!+?mL~0@g_cXE4 zCrJ5|dZDTZl`Kpft}L|NkK%M&IE#<^q#rIqD(5}LReCBtv{!sAo7XIs>2CXEh81>B zxg->PTT2QfO;*nG+edePnv&%w{-4yS)fwbuE$_Bp=aZ%21?S*E@Im*DR)IR6o`DTs8{BklfO%P7&3kI^ zno?S_%Z z_Mz57)L^Q~daj-3^-$*s>J$)rj!zsd8uDsvBn$u%@_0W#C1`fNsHMlv_mi1CZh$5_O{NebBBLEXz ziduc0G$l3mOiFUpx<^be*qVx+eatYuiJRE+Wze(LeyH{$7(G9_Rn`0@soB_+nP=wr zEQYwZb$rL!R}g_1HU_1;5+_m4K&nIT+DJ)kiBDWhD=-jh^CJdJUsphCrsaW5HJ7Ps zv=veCkW6WTOzAw?x~N5q-Nc>KM{R|Y7qVtVG2xdeiWu=FFt)ObhEhjd;DYP%Jo9be z$2Ol<-oKlQ4L|^#JOfKM=r#moISWM>QQDrY*Oi5poU=3b17Ry)kB2yv?L|aN9F;xr zAp1}pM5fd7msB6Rfl|3R`R!MP>vL40iq<;2Rc-mmc}1RPi64OQYJ>7%2UsP2IKyXm z;?z_-M4s4HM2PFFa`=jg2m9aqI+4ur?pobY)H*`n?x{p!shfwE-$SmQa*V00K8ROB zK7edE(@d4YCAJS^LtqU6(SGDv(7dvds4LZ0T+DazJRwFgefDD?=K_4SiRL_+5GqW{TIW^97 zYWxjD5UV#lR(&|lDJT`?Luv(OMGT&K(ySfi}rsQ^>E6g{&3wWK9Q{CHI671X? z(eT~~{S?9uXFE&s*WB<}-P`ih?vNDw|lxPblw(&1J*n-w#}(B=oPV&cSqziKVt3(};G@fi0AiwT*G#Yv64Kc@z(a^c zPo#`+Ng zkC&GHYqhUAakFiZ;XDSpumh+NV>xq~zVjfqH(ho1i8#ys)aKx0OmIz$3AJY<||%xL?q!=G!+ z$x`&E2QrO$09cNF-Sq)v!(kRDX9Ju)NaRO-9h$_l?>A8exH&cU*Vic&Cj!0tv7k5+ z==HYj$&!Xze>&m4PC|o()AQSp_!gdOtj{TPB!cAG(K_6J6FYW&eqN!XSwiM)8-c}#~Iq%Zhr-fBAH+Xbyj}ZDivs(23-h91qcSQumH5`?C-n;T^S{!Qk_DPFSs*tsWNY@rp&Bs5VRqci173fLQaCHW z)_+L^>(5!9WR&@5Wf08Acc!h(~AzF)O)e3>tu(f<9z?NjyI)|gw*z>4ez>Gbc z&30p*IuZ$l4m3$xp{WSkf`%%4#S5HkeV^*iLaYpT+l62{mggbj43JITWw@5cwx4Va=#{LVgneqon z)WKOTe^4!2Urt5Rj?sc~Ee6Qc7iHS>k~$*IP>rxci|qH;4zB)5^|b+(#Ef#xUQFF5 zv({T%F6RO%BJmwkY!GlsSlsFBH~|YHdlLMV8k@M9eRX5zyei`;@F3%;$&Rr_+NJ%N z*fhe)Ih4;F#?|>{Hzn*m-Ib$wUNii5=p6_w#?~2=vz#Uinc}rie^Z!!eF~UNqseM$ z>alYJ<_r(V!v%;Q8_Lc3O&iGJO1wkaj)NDOr!03s7(D`=zQN#7n|Uw=*k zF|C*d`zR+`QH4o-msiM4npgGw*I*=l9sgu*$B31$bh9ws%_v)#bkie~I*$jZ zn>TS6jxPjh?-qR=_&?)S_w2jv!Cjk0u_9f$l0%Ll?~owxLfu>d_HOVe8yxICps(9# z4f{MlK=KMh;7vJTHTZ?_L*T?62GIl&V87Qb11wI^Kkh@8%X$q{qp(#ucQp?~_yL3Q zcV!lTD-M8OT|0okE5YA}gTKeVFZlalg#CO<*Q82%qjfH%9>|??2jZ;JcIQ*F`oMYd zC7>Mq45`IQ>`lY0v=^$6vNUrX$itMkwZMA>_9g!?NH2m!McmNIeA39&mRkR$Q$!PNi$Sb% z(3cj2rNjQfMiwq>whO5j*^9KdnQ1)xRN0Irq}Ol$N5Jc9!bw7GMX!SY8P=lH5Fs{c z8@;ifXJSV#SXg5aPc5GJU!7=&a2&)bSPkR7s{LSF4L(l$Qg7(J^*$f%NRF1fV!89m zombk%IL#EsZJr%mhs7iav<#?8aN^(F_EEEsr z=d$wDAz(kLl$(aJH=i=F@?QPxVDS8%l;kWOul@L+o%LkuP_5~O_xh>O zEko3?Rp^w#K3L{2sd3%Suan;@elBCSKrG6ng;wjmROrtolL9nCwld^W6MgLDud-~II#v}}=L_YT0 zxBOlyFUl86!{^9y@)+i?%2xBjQR#(7m&Goj?FdmL&O;&+(}`;5lo@zN+Ri`_ih`vt zvc`E5RFmH%eUmJ6M_vrdy+}wv*~CNflCK~Nz!|eW8`CG2HpH4eEk5BwrJ6%A0m_64y{|*m{ps(xu^w z4>%(tYqb}?o;x&GqxG=>LhZy=vJVIMSAWh~#fK23~^F(i=UA~Hg_yZ+#3%S+{Ffam(KVzMH?MjibF|({VG+!U6K7qEN6y# zBNKi5SqSXJ;U5Q|X9pCbJQrpTKIet4#f&4NC(qolhC)yci54pMVqy_+7^W(TWxAhF zEKxmncWG{$SK=$Z5s*&q2oj&tp3Ob-0ggw}(YiIIG}iCd;v2zi_1$=LyH9 zMn#W=h8AZ4D}KN$(E^W;{W7jeQe*!mvtM)p|$#S4E<6Mnmtz2IRs{oGae z*0`)y_sru$;AZxG1?RoNUYZ3-IlEWX>SxtT)|}|*!@=FqF_?3FmH!(!)6mOneR4Re zeO&xQUR%k1qj{GvXx>$BPv9NyCC$4kdGrUnKxR(=3<9c2e?{v@#+v;=X{}TciZ7$J zBEGoh5K=VLptn7eFh2WjY0%~?oCbAhYl9!?UHOTp{H7-R~@C+`+iN&g1K!d#5a-{{eP78=vM+&Ei zlEk!slzMa~wcscxb!p-(}&+UPq=_ z|0p7Y_LoHeo50zLYk&yd`b@VzKCb-7C^NHW&OAZ+ZQ1f$2g+}f^1I)S^9_q#;TfCDF>XqTDxLzQ66ye7}pjx+!KCw3mzBz3@RNQ@09h2%A;^V z1JM2-Dg|F8eF0p1ya#_y68jLkDm^Xx>Bm5)NEvaASc_eRWZ~$QJ$|bNCmBTjVzraD zoL#yWAS*Ll$HV6SVB=%28D@oH-cCDi_hOfpw}~U2`0({7A;f2?yk)-v50H-}KBc__ z1tjVkP+yJ}Sy}~5`UC$;spzmF|1E^s)UDD7PEuXaORnl~j@RPPa3c%`N-qw%cM0`m zIJ(QIBEZ1!H!7+ZV768mZuaxxf<6nV&5OG&^qgKmyx?m@hG&)>G{k*zU3tKq^f<_4lL$@NBJ zi^+8fHZ?iH-8Le9%{;d(hW4^0g*MKn$j>4Ht%K$E@tiujOyL3 z7mI(~wWHdPIuenWn6IO1zH$cUtA~U#U+T(yjg%u;t>nHA6=8u6BV>-ODc3s3(f67g zB9WRUk*nIPE>au2vipGG)B^i;^QL0^zroaKHU_Gel}0@w91=_KjK->E-e`WKd3n%W z22O&FHVDrsm-#ny{M-i{quAMUX@MPM&B^fq%$9t@K&K@8SHyGPO5F8N|@2i>R-QE-@E;ubV);UmBb+CmY_X(N>CYm85z)The?E+N_uG+Lk1 zuCUp-Cv48%k7|7%9SiwT{KyJ$QgPos9>@xmW(yo+YDZ z01`}ZtQTZ5^0+CLNx$bjKnb}n=EMMn1yDfi3jheMFHqE2@u{JlAma!5OQFLbh^%W3 z?+sk@iLrQ(eFZzSIW8=KbWJf>s#)AMauSg9-5`}r&UgvVcxr;IJfAOf#>*FHkmhWZ z8E5Ycn2iqwtvB$=`Li%ezGmYO?QzVy)%dnBoag3Av!bu#N7-5e7e2bLH+Vk)1YkaZ z9mSJ+ER`Rf9J1P2Y4s?L-H3o;_6H#|2w96K*LnmE!D4$m^BHSPxkF|fcC|MaM{BIc z`-z%KImzL%Bkt%$y7j!-c)vug?EFZGkJNT`$O@%)r7L1C3ZX(@<)amRK#yOW3a!iF zS#$PEh7+e-BR;!RiLrkcuS;z(KBOy`Ye^2K!st;Q$fkU?TzE&_ z2E-*h|MnV8 zz8nLE1-s}Jx_~q)_(R=#t>QJqTI6F~wb;A7wSsTMGLGh_o@11g$QyHUK`cX%+8*0- zOj!vye5QbdKb;gxBauT0u(~VlN5S6doxe;oWvQEYj_s zY9Oo4m6$KBnMm)bx|=dk2?$>D7Q0WL{<|BK`H(eZ^xw4!urfnx43x74>oozDi=d~5 ze;!uc1F*6MqXdB!bp=+CA{y35yllND;6FRk$a?U!%?{nl(rWuaW;ZjS@tT$PT@0q0 zH52ONHLX*SKhExhoo_`-rTQ@gAf5PEnUHvEjufb^dYvU_HGW{<_zjK;jUVa2kbR}P zKg_+y4yyZ4xcAys+;dZuaQxi_e^?(c`l$>j&2csarUorXOPykb0?ud`W8s6mca2!* z^n)xnrAPZ;sC?q9gK+Q}wOM&CzN|C3iEO8O3!4xKYK#}Hv|mFTnfdA}pai{ot9Fkt zZq*3jkNnrtWh|Yui*x5cvpA!_hAFF-=qH|*4iH9UffaqIE?$F;!Pi;$?>Ab92m9Bt zQ2rcWW|!T8WY}%>R&3X;qI>PJ@>u8LexqHW?!9q1!SddYv02*$wm~Y0oziam_Wxi;X0IHWIWQXtDn;l(5E{r!uxK3!l|Zcz zC1!I&#@?W%Hd69eNdBOOQLyu-F<-d;!QU$`Pam^3!0iXWuWtUg8rNt1Ugh^OzxHoC zzq|)(T*VL8xSV(|!rz0BFDuN-JO7k4+V3oz&l?V)xolcfeHi~wd@pDnX%y=YbQ=Dq z40-%aX8^dw{%%ybtSQ!CD13~3Wf%~UCJMj0QeWreR=oYs7n7Q`IPQhAL`Pt8;ky6i zOJWWG@P({GzmQ97xY-w5UWBI0xk4&+@hWWHS&Ys|Lm4c5FTNS9VO`^q%n_LY;&9r) zc@(DxS3{wj!$j6)HF)J%DI_NpV+QidDAm|ueSb8Z)=g>RdO-f@v1sPRN=CdTF_7DSW+xrRtvk|^rX}9&2aaq zjs)dwlph&uR5uj27I0w1Es5YvHZe0F#7mEc_DvD}j4RY)vp0T%jt$oYNC zKXra5sweYFu%yKOXJz>ksxto7&UOrB(t?4-#R2P`uvO3q3ktQOEcYPHiRmj+KYj#8 z>1u|<+K*poIfeUkqT?CL>=_ZGOHxaedUf3;(z62IXtDR0B}pj~GhgtMLu%7oo7wc% zwuPY4!!R%jp&fggw6c3aaWnHFWEHdkeS*yXC)#&ebUb+fL(--8Ke?*?4};<7cxb&f z;GY<|UJOY`>ecVHU2WXD4Nv|JL|cp#?IXPvE)qMPd1uP%50@?K=|_)tSg87y$f>Dq z!OlaGGo%%#3=B&`jC!Bpmr8oV@o6jx8Y^d5Bsui4(JU&%#SbD8)~rNBxp9k%@5Yv# zBLOyLB|%*86;{o3hyRsbO`qe}Fy6iY)O^c=L6V3VM*>3utY)r=KR$en5v3_ZSa5wbcCO5-d_ zm{!W69)VLGq=DYdwcMUrDKwWDGRSuz<@V-UKdb^wq8*QbC}WiKh19oK@&ifVUMn3~ z==7#;zI5$A=fRSLO`5aG{0P&9DHN00Av`vjG(^p!j<3rw$q=bFGZu!Afw*tokbxkn z4^Ah(H}zYPy6dO7HwWC^fok2mKvBAXDi?oT1EV&;zj0Wo?ThEgnn@7!7j4pmM3W|v zB!{eex-7IEn3;ycCc$i7;_K|N|9I=CDF9dJoa?rCIuDQ%c%K)*tkfRtKGxmE0gH@t zQ}q-jd?fm-x+)=hhx|z`zDxuzdh!a5kp7@$NOwZFNSDO9q6FCvc^7&nzLy*$bR2Y) z%TApK?I7D;Q~Q!ROe6M#0D)n|TXG{9&uxOgB1Vqa7aMMzSYQ`w#A|TbMm)WNKIGd4 z=|13gokq{x?#`K;8pg768a_wa2`a9Tc*Sz!C&G|KQSsI2aAzA~4sX~ZBN-h&H{}NR zsuy9pfmTGQSyUrRQ$23n)rX4cLU*zR8xZGwXFY3I(F^*3HP|L`$i7S>cGWR%dtn!s z5)7&jTg||g$0*q;cgXlT_*KBZJhr&W9klvU0cYDJH1&H5HL$BG#2^FRB<=3io7m*V zvNAeWW~?dGhfGRAs34bG|7~-kdDNP0`UgG96V~Lo!CkrYTnVEj41_c2jT_6NWn;7_ zXVIBHc;KaTQ$z*3+K{e@C%t7TlBf~7MMmh9^ayzuoRpbh_7wY6id1tPZeK2Qj7}D< zYgTi7@$qx4ruTXK(yyjLbhkZWifyjvQzO*3;b zC)lA&-f1Dcl!tD`0f7i-;^TX!Sb@EqIBLqK#%uOUvMP763dLd6B}WJDi7q7N1K0+8193Br}9Ngts=b#pYhD`-yf9P1_m5Gz?0A-RWOEN9BHTMYt9SX4yE>-S@tr=teV@dlf^wR9RDUJ0ua92^`@L! zf1Ar$>0kTDE4_ECN9@GpRRX4-O#1q5a`n9aFWhz z+R5^icBIK0wp`lpESq$HIOHkR0;$3FepL311MEU9AA13D7NLrft=4v;dAkh=;SjRj z{!p02@s*XL6;JREm3n2^JSj%WuE$SP<@FwUu@?~pZXF}UkvBV zBIk?jhhU&~=V^`e)a5)q>OA?JR)Bh_x10wvwqM=PSLHpdQVG2Tvj`O>Vuh<8gfhH^el=~t=J-NCY7 z@=JHDl_J76V>7vD5a-FojQP1}YgbCdp{`gh|E-l}Dp`7@{7wPwlG<8X>pXR-C+XX9 zq^epp3Ll2ymI7+wGOwEC5ZsLT!`-UWNA-1k;HD5X`=_kiM~g=g08w85}rlE8Yf}7k_VkIabZ_oE{V?} z@zDRVS?=z4d*8Kh=FaEBS&N;0cqz8Mo1mDLb2W6C|tlMRc^ z*dAVKPd40b#{M98Ya5n!#rAVY4Q15uCvH^@54FqZ6E>)=D<(qdbPh4@b8-l;_QW}s zb;ZP>PvY>z!g8}x4hlekx`z)bFvGnt!fSyA$KXeCxx1vn)|GQ&M^n)M^4(nB$D}zt zb8EGHj@>=S6}gD`vXK)QEdVA({$vX188|Sc1tC zfEBR6wN|e{Uv&>oZ1xC$=Hj5$v$_s`OsTcE=N&Ip+QdEXp4<8!xR?-5o0?p%x~`H^ z(p2uAXO*qqT6GG}{3<~NGD;)viSEp|4m4IYSw+0ezax4?*gNV0}fy#XNr zUa|IKCyqyh)Z}A~skTyB9>&99)y`q%|E*N>?=9kr&P(cz4JYxDBf7BHHFn=fp^icp zPJft=5K^>?UgHAQyq^ACwK)ry+L$aXYAycnB!VJpjJJ3amE3PArLg30MDN*^{6!f3 z;n*Tcf(|f^tI3aOHAUD*Ny-vQvT_5>b|u?G@fjYYdZ)H>s*}1Qhb-fI-t-RN!%ahO z_Rh^6o>7MHiQnU5%b)Bzich@jXuGyTldQkXNlb(fq9dKq?)i*1a(B2Dg81K}!XCMZ zR!FN>zA2yJ;y^I<9PpCplh(rc>N^SukFhsdu>L`ct=J1IPYQk;^vp=~yjeVCFcOF5 z{jID1qkTawv(lrjx>rW#@GFh+N%t{^x%gL;S`g`Io##4tCCKgQFz-%^RPY~95lwsv z5uNhh8Qg@eWwsG}pUwDAHs>b=Iue2ta6&IT4W|Z9-2iQ|eSJG*vz#_c$!2-QpTJ1& zs_&PrON)zHr2z|AW>28anB2}AE&dLLh0V*2*mmkzsdlzoIYAcfF_hYav%4u)vu8Cd z#N>I_O4+-J7sua2ROe`j&>B%Pp9 zIu2@EMu^yD7;%g}0^#P90=P^`>#T{-CeBC6p|?Rsgyk_T2OA%&-jmZ%!^LYh)QSO+ z*%07lT#-)2?m3W<6cWd_A&@Lu_allxSg=N#0&zD}$h; zD@1LpV!{1=3r1a#T$NDC4j(Ret2#ugb0g{rW=zOO*|TQSN}(RPooB`lrr%2273Ik5 z`P}#O9+y*a_g0$eZt_PzT;J<)PA8xRdM!&1zGjQ{5@Q8`YBzG$mbHY zN@!qeO6|b|sG^5qVSRKDBhwp`NBPTg7LOy+@Gmb6_~X^x$EJqm7!$W5O)=T-yTMEsp6l&1?zN4Cr-j3j~uywH^7Tnl(J<204 z0=_!|6PMMXZ3CMc*3Uj6UV3p!SmimP^wbG|P zblJsHkkv(b5^IAKy!k-4RAfG|M_pnEe{`kZX8K zm1Y~}hJ((yQ~eTjs@cNjDaD+S(4G_PgpvSeU{rDKcjjOBLRA zf?+Y9kUf8Nu=CYO{^H@m&iA4O`po4u(eG+S`X}8nV;&OoCSb6CtyEzw`TPmnZh||!6cyS5A@3n8&;C$fxGZkr~4NU>_3KqTUlK<{G(Q#;!nOGj%=>vj^pJg!XF8Cbo`I{ItjucF<6ik9I-e5fJ0G+ue`E(}GSx|0whP*@QXQ0Kzu;bu$>tB`P@cuX zYzFKIBHe)zqIQI=+#`K{$nZmu@_3b;n|)!O40mkP<6hbkj^BTPwnlCM3o7&%zkgk^ zthha?nZ?MJtM8X&M5&Q!6gsHV;V&rck3+*|UhWNBt9A?WMn=r&GD(go3tlrAv~Hem znQK6)rqxd&;5a!KfB_U2!BQ(DwoZ*vR74ipaauQcoYoB*r_E+eu$2&QrcV_-kAis+ zqhHgygNLwbRg&cR24|^}=bxY04TlOY6|=1S_>~Sidr7j4{N zi)N-~`2s|S=7bow_F&IKyjbgo%BhwId#moq1>np=zc+eLBUXwP-5LD~^a*flRm7Pf zibut6wCvs!DxAY&u==@{%^6vauwNNl;*kvHmk(Mm)+rMYNziMQ77~sjc54KG!&b0# z;vt&Xl$uTRZXDD+XrDG|9_Coxkqgt!JJ)Gm)*t$b+lOyE)xI8)V*Cv=mJ3r`oH|>+ zrS}5YKt5U`3M@_pi@JGw@-;Q;SP6s?iZVmiJ+(4VjJ|b`!JSM3f&-ZhA6J=>(!r8M zXVU)Z{4CiM|T4t@eZ5RctnO>~h-sxtH1p*UE$p0SxRDOL0%!QW9|M zAUrcMRdnV{LZ_-gvBE|VSl5lm1t1YnQ354cYIo563PBB8kwskTTaE0k zWD1c8q9>)gdE4@VGI9foH_LE(x8N}?bL)&>>|H;7ptUlFjn>102gBA(FC2(8RSe+x zw+M?2v+5B=Ag7?!Ec=Xf@Dy1{7ng0eZik-4UspewQ#~Jio>d3!+ka*XG ztx-UJ?Ink5FM-PXqZlw&zo5nbLUZ(Z?Xg(@S=!2%X55_@C$6ikh)I=dI0OHjY+?zS^nUdy$p=d#Vq3xYV`Lcp7J z*FKr!G^S;}5Y#?l+*j6irW(zYf?Du-iSAL(3?AOk&aA`qkty+uvJ#q*+<|%IJ~MRA z{IFh26>D;^t5%pbgfWIsW94vG4PJu8Gf=juOX*b{wLVfx;9*f4I)izlL#~<&BIv9f ztf`1r)?CmSpP!>W2=fNjj|N0B5Qvm%BP*1d7do95#hkKwQncgJ%1@~#E;*ddb|I^=sbKp$y2jZk^ywie9G-w zO%2L5&{XVc7UqePO0A4=b$WygY6=!!)FJx)MQvwv98=eE@uIcyNh0s{u6S>mC$%$~ z7q8jmPC4bbJSN?t2dx3==!D>-uSYLKMNjq3X}3Sq?#AkaTBlHmlVz(~hDK>la^z&F zpHy3({`;I{uG>~SWY~16+F<9u1{f(`%Vu@+p0+~xq_o3u>?1lpkv3}aAM-Xo{@>lN zI*nd>dMt(FaGbYJRQ3<7qdh4^I}(?@pAJk~>pqm)x#GR$8y8PkeA=`>3@3Hc`eV;0 zxz-j*y+1u1`Kr^&F;0s2tq*&S|)-i&JZ-_Sf1!qcU1WI$5(HEim! ze!_YE65t4km5lgQ@A`o}nT>ws3fP)fTrvFc8#s>CtM_X6bnq=W@hu5pjm0aP>R7y85yDYg_joU?Zsg(9`!F6St~5kAr{a#a3EF|rMHyYyV(iZ zT%&}Comz^Ty%rx%cD!@6?c%l8`5D!SSt;5H6~xrqVIL#2)gL$BjUBmETPd(>-1;o^ z!K(8kJ;GgmF#a{JA@@tEH+AvU)LR^=j{3E@u-9??40rqLvYBZcV;BoiaJ=5dU^UBa z$o)FE^JUx!cGS*AZtau#Z|%WCeCd2fu1OGtIh?zB<}^<%bxyP>VBYFA>xvSi>9kqr zjit_t7Fka4tk_XcgdJ(Cd=|qVtI@Bc+Fjif$uoogWUerc8#(BVcx&!4LR0EOL}FNe z({ML*T9%Er%9&|S3p-6L6XV}6TSKytb%Q@--Cj%hM>M7WGQe6(b=SCVYC$wZbjksyy&CR9!2&0A8)zqglE zx0ScCdEUs;OhK-IDdRa)027{#KrTBVX8*4V)%=U~=V>ci7!F3L z31xHPr`1W6xJ5v18ejob?u1B!9g)}t$m0C2I#?cYo56C-D*R*@xXApet$P;yE20ky z210Uz`6&$cyk(fffOHN0<{O}{z9u|Jut~S}ts_8y&?oa8zbeSPVQdO_v$pY88y`5Y zRAVE4a+Td#Nqh-6!bi*l%?#! zO3l_C!>E-2lZBC!+mD-R;@i1imlPKou8h)fmb_F$~PI&x{vDbbhGMLI-{IKgrv z*HnjY%@0)^Gg7-5^o4hb_ou$?Y41;&Ha(ZAd~?Vuh+j*<9iYW-#+fT#rRHOp(%_9= z5Vmj>@v?yR!tdn*T@Bvto_tqwEN*Kq2kASsMi@$@zb*$VX<+T zkJbGPmvTsk!Kvi_5Ln{B!O|<03awaXLv;D<60Ck$tF>Uxy2|KOBsH9xTFZ^9CB6k; zQd)DeO~vTuuwK_a(q>|VUD7Qr2QNnuqQt~8&*Mzi&^O2Dl@_Wrk~y0%+eOEI$MJW} zDb29HcaRKW>z#>*L?AU2*n}4@Jjlzxn+ru2^si_4al>}Bta4`8GCN6P|MlP}DO|L` zmsBsix_H_1MzINpKJ#i-=2c19dO%WzaSqU|$JQ4E8X~3s#b#;-%I@pt%JcVnoag`C z!c}cB+6vj1MV0*e5Rt;Q6@8M@x@Rkwo&&{`VbG_v_!G`c`8M$KKb)6x7;;|DcWd7= zotJwCyk_f`*K4qdJQhK;cDGlQAyw8 zMZp}`e78BH(mp)q)0E25+u*x|L@MLy-lc2PcLj(!2Ygkhn@$v&I^8U!RH-2S(%qdCP&LWB z+OEj`^V8ogUMJx(7kzts;QskJ777P(k7)%~evNmg8MuF5ssTNs?%YO1`S(<_IMUk% z(=AbOky~{xp?_*UQ)Zp@;5{O!5w(DH|LSmmBOZvXG-99Sw%n~-_lbkT6Xd&@d^eCUc@3I+q*$-eOZ7{w^|FAQ)6-+E`feHd zsWcGx=oF(@bT1x;s->!Zvr~J}bgS4-PVFeXwDe3o#GsCsub^|CWGW8V8DRn<_m3>jAXO%89w4HLq#h9X#hZDkw2_Xxt~25%1J+>6LjD)yT< zmlBCgSS~JI@Q*Y)hZO50BzHi$}S?d+3ns_eWiB+oWE{3 zZ{WT64t*lF1nWh+SnMGJ*0nfdotleko1F2VFg7fG4nb{Czze8FvFn-^3#_yH(WsKiwXZ&_Cet%gg z;};zxz`&W?y4GvYd_la7N1%qM$&f}xrSQ1nl=!mHQ`d1Wdd@E10}-~puF0h+AEyP% zKSoBgu{mV*z(=-@2CY78ujL$@1116)=SYL}z}pF5VFc@>zW3If)=l7R3<0#+>oY5+kH zGj{Kb;0v&Gi?hiI_Sli1rnG1J5FF!4QG2Er+~w|JKP!v%U%1p`?MN2m5(J*sdnoCE zLx?ggM`K~8vinr`wH5aKPqDQt@dk|(r;K=3I-vKwRjgM(-!_HdVPvj&mQg5&c)u_4 z3DhtRqP&Ve(JTAcK*cdU;o8kbm|ai~%rh+KZy}v~e?krs);3kk()#KhZA-x!6Rdp| zANTyV*xG5=NNE)ZVY=O_SNu6(ZMR;Oc8;YeT~g5MofI}!6_#vNjk7+M*U#$}2kp=7 zPjDSRQ)mdLuWZnR4zAt1hInZd{y1&tE?KAKVDaULa?qTqY zq@ke{i_1o9ez{SB2aSHWC~ASR#vxHqEQmq0-NaXu6;}8|_R*3Lty3f{dXcpq&$ZEU z3}AA!;;UBd@7UtW$(Y9$`ErOcckj2TQE|^R_*5bfN!{Y+kV>oV7U+JD1bQ4o zO`_{?KD8yRaKdAamKqDCzOleDpt~6^ZN(nka!GwhaXvTFE@OtnET?uVbnlnGq_(Ac z_3A~wmQ~0-Ro5G>KUlk@|4su`ud5F(I9VEi4?<~!PkMc-L(wM3nB#Ylw756W=b>2q zsm|~UmoI@usZ*l1;xP`N0uQyJ__Yk^*F*trsRIV{1Jv6^KAI(bktEjMdvW|khi8-q zD*6O~fSjICMFTUEKEF0AT119MT%MB@Ex_)`Y0|9HUe}K(2B=zu$pXW7z-?48uZ8MO z8bJ=CmmQmT$zkPv`PD4rterO&px^;IyTU4=bURLKHPxy!qRbhQ*g2j#ZdCGi{ZWLCP zW{wNu5hm_A1J!Wd%w>&ZGSx_@tgCx4Z1wcS-pPrajA@i^F*H5VGUlBmanCqXC(C%N zV1Q49z(BsHdL)6H55zeN#Ws7wxT;-sEhGfJh!zGR4#0wuB&KRy{NFDVO&45l^FP4K zov&LA?QA5Di}Un~7vYy;<4u6E%|g871uHfup;x-;&fxB$nN;tUS*oFX{xs}V(iy10 z9xL4A5%3+MTPF(ym&%HP<5vKt1&I6NkGOnl(Lk_h--26#`GSMtn|L zGbnzkzEQ|6tIh+g2CQi;@VdWSvko#hm6n_TumNOv3m~V+2WaeTFIE<+{ovBbszC#kL@N*L)x$ovv zdSyA6LFetPs3i6-%jI878&Sv3_$@-y_GyQS9-j)jfrS4sj18Bp{>BPB)bp8})wNS^ ze*@nDcN17d8A65P(~Cp#Yf3Rbi$sX&n0b!=OK`<|QE-7X+`|J^<(Xv!o;(*{_$b^K ze*uyVS@+1v*|56Q3AjU)Fr)%@V)tgLRX1TZt2FKFYK3^zR@}(4;Gla%7xnJRJP3g@ zKYmxv0Dn7#@m2_@U*NIyK2qJ^a%QHfV+3!FbY>%y652HRW%li(EcBwII$Z3C2LG1u zf;rLCbefYK$1NKn>myLnt#@?G3c)aMq*1X$cONte$^_X{R-KToBRwR8H>>XC`BwNH zK_l;g(6Yl)B1LOrVQ@x8Po7$J6iHAx_d$v)-_FWWaV1ezq@z`{e9;nsW_GbWK@2`X zh#Jf5R%rwfzYGOj@ z>;~IiIZ5|+iB}?oAAr*?6~(sJW>=yTTpQNbSt6;z*>o;e5h0kNoEX7olfGslBM%7dOe2o+urn;#WhX_AW8l)NvK!m#4f3`ydpndmyzk^>!2w3D{ieH9xPDZz|M z;psxn*n_GiY2l=)^v+PS@mfnzV(n_@BM~u95qh&f;x+5$P_EUlt*t9A%jt^A=7*yd zqq?pnTBv}jx^8@=2G3>1!?0khD}jq%MiDM@WnWIfr&;mzVr=iH)%4cQl!H3S0&+EH z5%jj$>WLl5^~dB`85yxR!6NUnKg$!&jN(sBpae%VNa8t<(L0XG)GaO4tzJc^n#02J4Wbd6yjWYS z`jUQD$BlFWUFQP5vlc`E5}90}B>n-Y3?XTYHv{BD3zr%L+cDWIEB9R5npY z)%7!@w;R?|0`o@I4@K=TqU-3#Qr<#;TGNkcRHEu#jL&T1RiTS^M%Y>@NgaI&KF`&w zJVxX+{r}x-(Tc(s;> z8Nf;)I2qvF?I^vi)!y2Qx9wkhuf5vaifC2x01`kk-~&)=@p0QTj#ktb0;u!B9eU9}37EBBNgz6XLYa#B^DCA7F zRSFi%ePNWJ6-y16PZyyM0V{#6=9q9PyBr9jU>mI>I?{(< z?31XCYqT`yV^*muB;2B$1@mVy>sm4mxKkS?taMYf!GE28cHs#_j^AtIBYcEo2`YRQBs`M+Py-}OsgFB*Mnayos?8(I{#I?SYL( zv^}^~rx|QtMj;(xH8LD5t8&ZPAmwa1pd3Ta6d_|VgN&M6QnwjsJG7*YCe*rTu%(uk z(gg6BI(AEMpeHZ{Z_v>Wgr18LAf5-cw88XD_G&yAprm$0+EI~-8b1S@xLS;vvZDL; z;ywc&J^w-mK~rPIGr-;xNVftTg^Pd%#C#V~XgIK4bAwoxVbHZgCL|1lv1dCCz&sy` zZx}10Jv+F^d~HL`R(rI4Z0!$T0{o2DFKA5GP-?dCXX-zZ>G!pN?87+jH3S3Ch66jS z;u%CvSnxeIf(6Gnq}e*U7yH!@is*XUJJh1Lr$1hUwjqlgy=~8SPg}5i(NOzXdvvCQ zb&s;nm4M)9-LidF_1K$ z`U6rw%-*6h3Q0;bPh0j%w~jqKJR1lYvG`=SHTbsFts(W|t^Fx1OB>vXyQN zB5n(6ep_5vzKU550cp|j`*RE z9+6wMRGNiA356XG(kM^6+48htsUlt?Uq72{QYTNS9nK)DFkk%Q7zpmx9UgRxlsFf>9gNCX(+Q{KP_Vuw*NmFFP862y?k*53rkx7 zi2V9Rek@BDkt((z+M0wN3QLmrmEA_cgeM1!JJ0n3=*US#ih9Rd-aAj_-{9%cv&*^f zXlcqw^%9Oaqn5LhkMg)pZCBBl^LbxbYSyi7)Knucl_ zy@-Sl@{4#nmJWxhlpe(>7I`#rgy48{kzp_5(Epiqrinu@~V@zi>r0Hdn z2S*ngAwh~5miTEd@Zsl{EnEY0%!R?o!7z9~G=`SgSoYHbftI~WMwfY;A%N&^A^q?t zBqCCxUUAI!zB7TK?k$Ue=AQ}KV*gAEu%8w}#)WFP*To#eQ%hx*Wpc$M{MEi}b)kh< z7g`78_Z@2IT+$XAc&uO3+;_5{voYxOl5XI@DmoPgF>X)kJXkRrafJ}*VY z46Nmr@#LlLOU6qlg>c3OR6Ep%7ns3tYjw;3TFgN^Ev8@-aOwahxJeeSMjhfd^m@!! z<!G*Z&=U>V^LRtqMIdG?Ec`TQH&!Z9?3K;8$l1Z8$<~4()U(#C zn^d{Ti-BONTEAyITJi;^vc}><-TPp1;-;9I>kGVukY~KmxPByi716p&2Z+LiI9UFQ z7KNP)J<}%&iy9A4^+!EZtDXOB!k8~N*`FOJ6&nXsym+Xtw8MzKBeq1v9Jj&c18ebN+XVk}s zpxZZ#LzU6ohA5hp#J>aT(_9(|{OCGhy;K68y^dGpUMc}c9^IbD?O~7sK~`RAR2fj^ zGA+D*1IkD&Z`m%K0a zN3Pm~_`m@Gah3jx+0tB!)rjm6M(Q42`^A6`;sDjLXM1wzkhPO;+0%ia!$@-9%z2}u zFqxuVxjCxALC4 z!gqpB7x0O71gg7JhUEs*$I{DW%j7MU-RWE^uc$F1Rm+gM#(A8t-$iNWBP|w^x9Uc< zKL$Y-(iU0oAjZMRh1H5JxCC+_a$;Cb#(3bWJNeyb*;oBnV-QY6gyt3|6pZLV^F8bx zSi-R?!Xt6E1SD5#qIH5y;XG|D2(rpK?rQ8l8NY-x?aUDXc=3 zeVvU-XAfLc2X>YSN~%NM;th1UT`k3-xv5^sj&XZB#PxAA{P(5wkq(xqed>8ClP;n^ zfap;z($94Ld8TJC-RrWO*U-bqIB`0#hnM@3n|$P>ft}eCIdxbz;2Dizj{=F9g zP*i5i!WEcbr^{Ew&kgNfKPdh$YSK(IfMjI-;%m;wN=~e~@1-O&?H$H>{KZpDltDbR zL}Y7GQ*JT?&t^X0c6aBn_^FuN%!He#gkaa=>m{O0t(2l#m*_$~9bm~j*sy4CJBq$A zUYTzbNB)pJz^{k^X9$X%CP*|Sc#=N7q5+?2O}>r=#oi%C>SYQ5<})wqg6Memw`O3o z8C)LGElmpwTv(wd-L&L&v4Dia&E*Iy(uic|*=*E(DYxgeJg)l^A4EU0r8?noX&WQgY!LwMEScTtEc0s1FGdvqX$T1=p|~X{cbc zhoz;jYSf{Z+WVN^XB5wobmG0xV=YnjipDg9cqJR2J}(h!J;!KmV;&G}h1I2~VV{?k zD623Uyz=j$o996{(*@m3M`$voRL5P-ks?4tNsIn*;8O>A<5 zkF43_ar&RXB`)Vyq?j@Y+pzl4h0q~Uda>Taoe>6&I@uz^|K)b=*nUiE=?z;OLgN&n zzh`s`MA}Z*3O)1U0Q7kJkw-3%Gnky=DD+BjjPBK)hxAJK=#mGh{yuti_u+eVXLd}X zM|Wm1j4AYJ5Iq84%9g{V3usC|6n;mOP8wc@(snH}K zauc&I?h)Pk`8ROd>&x26^XY+^=4Ss1WisH!Y2fNhx)siEIz#1LG zWFG?WA8VQEt{3bSr%`QpX$EJ+6Imk@wUKG~5=ydregV7GerE$oC;aEyEyl5T(?mt2ybFIw6NI1AM+#}2gAzHsb2 zq&0CI`1jK+*nT;O+WG)3Yq@0%o7zvgQ)U%SGKpwBh5&nLqG+5IwCZXX4$ZaY*c;oM z-UhdhRXq`SI!rifBc5$mu%sE2>9_sKwp`)^`@AajTH^={kDR;tSan&Y6=(;UIO(_0 zrJPqUt-=xz$f-s)*h3j55%@nT&k9(cXoy%$Gn78?KdOnY;_}i|~U{xnu_4ck#WK??w6V zrM&m?tKjG7H=7?#xn#k*eT!2qltKELf*N;Shj-F8`dTqYc(COuA6It_=+RL;;Ojo0 zL=IX=l3K2PNzUfM`A?n1PW=v%h2DJMe-BIF)Gi(=+D{TYHD-$BrqJWLabt<_NU^*pjTK>~I{?g9za!IG84xXy@%SR=Jv*p@CVLeo5 zr^@vxk=D&Wibrx3=`qWf?3VJVRL-YT89^nbG}0uUP5nr0642cVHBFN3(!;*mck-kr zpK7OCXpNdY!A`YGvsAdpPQN2ykF8Q^mmitR|2OpG!O0e3qM#PWen^+6r0R&;Q9bTCo(iL7=O^1ob#97wxBgng- z7|*lw;e?N1w%b_TZNx3J>c061aY#^PJQ?C^<{?W)x^blr>Km~k#R-Z#2U#5@Fc2&& z3(2MNRXO3@;M2K}%gf;Zm4flCq03RbGS^ZP1rhYi#uiG)XuoQwIF}fnugWAr4Nh9E zs+)At=Ht3wU=}~^<8o8}ZbV7;s|PVxb92DsO}mpZO@jn zp1VhJN5AM^3vK7Sk=ouM3&c0XQomlneAaAbwG^p+AeZaKcx1Yme1>8O{Uhe%e@jY; zUt0F~NL>)2<%12rrlV6i^U2}7Ark8AVo85fc0%D;VFTX%SGg}+_70B^YS}w7aTG^! zM#!14w=5(4hR&c1D~)@$>e%!wN>3*;WqOEht)a zGzo^z!+WV!^q2FS^hvq!I(pdI4nJ+mKy~%m&Ik;p2*qW^xWYHJ2 zn26QBQJgskRWh)Z7-`jpXB(+YPL=t{4#84Aggyc!FkV(LG7iFNJ}B$XlJ(@LVA%$O zFKTMN_U;gP#7He;>|_RYT`~=smtioa_@mt7cL$_+O5K%xP^yqSRg}F~jK0ZOFoec{ zbKY6Nk5!cT3SuKQR4llMCHINV{_A41@0vSvTFMXAuy>>i-|lIT&_Ejt*fr7?(dJqZ z!#C+cmsLMEr^$T#+HtH0teL64+>jeGoJ`;ohL z>Le9A(<}WNNxvqkvNIE7q+{iBdvMS23KcIyI+GtVLgAeT8*?O`3-#b@1*zFvA z;s1lqO-`2&aqEML`={3z*phDW5a`%*Ub@PIQ~G{PFhG(5SDg(EJmOHsic!NjpT&AP zs_$$=A080#ZdhyJtNZZ4^>U=JOV*4Z+gx^xkSviWU+%*QgUw_Y(wSchag|4)rmX9t zG=W2d>x`v-Hl_k%5Gg1YiU7Z?fSW)GctFS3x<;pNC~FQrwf%zyFqI=!NIuk->;x77 zMw4w`;;6RC-ZFx{#Z;rfbsPx;*Nr;(R2YzNArY8v;!wu&ydCAJlt!sS2_6Qo9yFS# znkv@jMN-}-2pnW(VD74IPsM514Z#0 zES35zclk+DckSX~ed;d$7R&5>f+n`*DPbCl;$MoX^mguIY0WA|(sv1`!lsI4tBd%Y zKfadB6?l%Wl&*r(boK%55}dC0;>>eM_L4cDapwhJqYc+}iIbaPxVz~nA$^DRhb|r$E;rS{(5%lQi_E8^`Is%ovIjmwC7UkOFegsXyv= z1h49DI^m$nds$1OJTiIASY{^{_Owx?Q+@BA(Kh`qk2H4#Y*2-EchpdkMP-fO_I_33 zB@B1?%vaz*I`P!A_=AodvzY8X-dOe>A*FO=ilPbOiOk9EEtOoO!im6@ST}fFb3RS0 z#$12}l!Z*wHe7cJ+L38Lu1heIrdos;(G*gCuhx_ui!3u%8k`=KoBe4EUAJCPmrLI0 zqVomITF8?TQts35>vA9a)a8Dga{p0dZ*~i9$`{HZA=d2Q8-a>XQRo;79mwFNPWJ;r zE&IP@B&+1kST((>3=iRcm;W5Yr%_^DCPN_1rzY&4!>yi7WwQ5+gccb`HfC*lVb)r= z8m-%Tc@QUnAoLKnN8<_5@rLZFkn5Jq9Sj%l;5bv0bm&O*aj$OE-J>ve9w~l%F)#s@ z8{fTG?J|@@GQ>7zLFT=vwYe^K`A;9!%FB zQfSFsJp{NNkabsO)%g>lLTDZil}h9UhZ!*r>o3js}?ah5me#IBtDj2#_mI2;TN^ zXhPUZWI^LaSjYL+m=SKv)XTyUdO3KhFM($9&|O4x7%ybMfJU&Q|!eIuWHK!#wB7C#;!s`log&mJ1Cs&l#Y|Y$&+r)oLR}a^gxqWR> zYdIP6L!?nW#FW2x-c(7}swXgsfuI3t1&Sy_*WODAZ{ENS7^5#7!i+@eYr^1wxf<(N5kAg*Qg=}oFABk&Fp zGET(Yi2AfS!4$FyKuzL$CiWf6g~-%jcIqXeq3uO(#bm168UAy0-G|hYIJR%XzU-6o zAPqAjMAmm$E7+{)S4mTWvm=dzGJpQFfSRsoKBd!fS|RWx2j5#rD&D`kn@0&qw7x6x zt4a_REzTPH#jCuKd6xs;9GToo>3t=q`%6B)(1mX2D5>O9Dq$TQG(sT?)`iL5VdpCaRE z*)!eQ$%COxhaL`@3dTJ#o>bbF@hg)3%NiE7o@HSmUSnL)?Fh6?+*+~oopZMk*M9J^APy8J;9iO8#g%1{!63L)NfA8gIZo_ zAMIKuqX7IAWtJBz@bp)3Cl&OKRQ6;6>HB1)kN}(ZGWRYgUUZjz^N^g%+=j=J(?-C>s^ z%S?Hbp+sa{@cAQa7_1<0HXw24M3ObCWim1dJ+{k5kN=$jW}|HMOSzE_{;w=cRVt3x z=khABg<-nw21%vv?9t;2p5HZ0Mq!1F0zwy~btlhkZ#c+p-&w)}UgA7Gsf0KAhOoh9 z{^JcjQaP;BV z6G_njI#b@)hI1U zX@%Q1=LBy1Mqa21AqO_nEq3K_@MX)GiXY|TOocoOB7Wrr-IDRr5*-5;_H!q~r^niB zx}mXhaP;a(vz#ose72nGz!2+qR zi$>%&$|yoFF5{)h#utQBZ!!O0)Xg_@nuLvBw^p|U$0*va3aHZ52V0)r<1x8~H>O*f z$?vCOYA92-IiYQYzN{8-JeV}l+~!bH3b$FzHIHL=#N06KJ(d>yBa!mCtbE0PTf!7T$+zO#J*jdlV!?3 zO>a!vTKjiPVV?6a}8L6Q>9XP0O z7u0|sXiKjr}OhC2BCS9Ud!aPeqHuO3|fmaAAq}c!|b!= zL*{Wr2zdZ~#;V&yKlyi9IqR16YQ^jDz)oPuiI%js3F2(*0=hF2S@3_%1G$#eDA-Y>jz8& zh@R0A3za5Dl$aiRi5=oYUyRo-hWv%>kU&pvBlphPi0u3J;r=G}_c&Wbj~5rJ6 zCQj7kxon{@D{pQSi$HgU(XKzkIHtdHnPcUN0oaAsqXQ_Nt zWy8as&BQTVh^NR+*-}i+Z}EgZxY3#Hi(a<{BON$>Z%iiW86P36;&77NAE3 zwsn(G2(HdtM(rYtOTcC3MQ8uQZGProI9}hvhK1nfv5LJ8B5(~aQQzR+!?f=f&QrvW zDN&qB8?;L2qnFqgTY4cUkJp9ecj6=MO9vpNPa{hM!jSDpZ1kb$A@72H|9m%lQ5?7; zM$y=cXt92D-}p>nCzhUSJ0MsvAz8J4PYp;nCUL~N6kHFsrO>|Dm27~wV*R^RPRLF z|Cdv|PR#yxODeZ`dmqc_>WdqYiEH4{7PW=RI~UtMz4QVu4=F}>!&;iLflOVX_sPZw zMUR5juQuR7k%DXeg8iTD6X*O|X5TfpGg2kTK+m>(bhMHBJ?k){u#ER$JujzjAsoXq zHU4|w-8qbu!;Nl|$XAZi8S*go;0rV>J!y!xrRPWs;JZNhdVL(%XnmNBNK4?Ibb(sE zuJX#{vVQB@EPhm7U2^^~mFSYs+_3!iV_Kv#)>-h91x-ZI=r=+WVL*V&S+7{rPoX#3 zrG-;7fnyMIe3sek>z1uk5GYyXG0RhRB*z>c^LK6{t_6AolXv$i66GZ(?>xoqUy3a$ zmzD12L4A321s4qs*xEnBy&gAhu6&D3bsX~u8Kvxv?$F$|Qqt(rNl6K_y7bv+_sH^j z;_m=;-nlCf`9pCx_~ssAWVG>L-^l2CWn}J>BAW>Pj1>>6V`-Z}f-n(&4t$|j)4g{- zZr2dhXT~QZnAs}t4zlJf`JAjdf5sT}p@7d5%V2XO8j6YFq-K%812_h z7^y!qvYBrF95P~`oBb<#g}xCxy#4D|6t$-p$iz>Bl|d$+!*(c9c?j0~I#x9Kb>6pY ztj806Oo`C*tyo|lik6R};)Xo=$zWrt*vM)znzpAuXjrgq?4OWBOjik$RNm*6_aE3; z3Era4rg^n>KEfSWU8l_a8Da zgP$15h3vnik_M+Q`@}`tu0>?eksC~8(DE&4v4!{h6az9jU5T7rD##VgEkD1)-4)hn z$N6_=QcMr`s@UF7+w5?pL^U!Yn z7MV9;k;w}`OO%T?$2{#f1rQWdOikP5O)=BweWIc9c371G*4lkErRJYB9rVdF0jFr}X9=oOzC*=!Xb=(i+gPWbgy~N{p_}ZK>`8~(s^&Tc%5`z1 z$|A4(gUrCd1+~5D5Im`yA$an%fffIQB_(vfU>Vt22EhH{4TIdGKP}k1MTgU;YQWFK z4jvW=>Tr-!TUsvo9k&hdV*&sEr&&~P>66pmQ3F~ohUG^p{ZvZdOX;6#$qH|=P8G{HH4bU_1tQ+I!uVM6@JyY?U#UQW*I2*??B>WJ`aFIy}x`O z;OO;zDsc3UIubZ~M-2o=jurni!4Y$FjpGaW=E##Op#E9mu}tI2e-1o`)0MEgdL@Y> zIaDzA{#<~Pr8HDZtrlb_^lcmKMqc<`$Hq>{L!TBFAJo#Ff*$QKM?YkD*Qm3zOHk(` zQ0F30r#|U2PIVbS>`dF;>0^tV8zi%YEZ{9@z_2f<1! zvBo}zfMTiseH8ZD<`s;IeNG<^`<(GiVf*fbnj?dxV6jh)XN2WtpL20=`vL9Wc|=Sm zHM|Zcd;QblNx@~ZnNrbBfi86GiNrxuVo6MzBOql#n;9z0e45IrYN*B&)Hj{23mvhU zTX*Iw8JTc#-aMWA_qh+N?Vt1fAGn2m&eK0RU3MUFeQwh)GhZOz`he^6ocf_M75!5` z=bt$BrG=>v^-VoTKm_!DTdbkn#aO(kW+UazbZ-0TJrUNJ4+sL|gY2ZD5RrXUHc-x; zi%icM(Z5fAiClCR6^08%)fvdCE6~Qe)hqY6BceL+asN@5JSiO+(}}jV;luJV&b)Zi4PpIBTO5^ zYYyL{|Mu{Ac#nJj=2ZMjHWw95EZT?B!O~McL8aZeymf=Is$Dy3GOTuERX65(nUV78 zP!s6ZlIQzoyw9!+J@a?k1Y!xDW6sg)k=2)1Bn&5ezSw((++1Mw^q&S zYVekn(A`ptkh9Je?Wn$RB7g&JyJ5T&<52^?em>Q-pK2qYIBJ>^wY4t|90kst^X>0k zXX2Yr1bd=`pPBg)LP{X4!Z}}2KwA44aV>3+yH7_A%#AwL6(OwDZ;!CbIAkSe zQ5>{J-4oufWsVWGI1*7~S6u zD36%X5KhZ`XdPY_bsz=6n`2ye$yXgpVH(a{8t-urT#t;Z%R^Chi>_9kOKwhS>mJ}z zRBaPkycx11#EshE#D3P_o1ZeI(sb#KZob#Hk zUJ(T^2-xMp5>*1Q*Njmr(??M9m`e0Cs?9DO{`N81U9>G9$+e|lASD+pw@c03-OH&o zU!%B$f6h6I7QK^E;M3sGZ&>{0IM<8A$|a3^EBsv{jt%B;?v)5p5c67o@oV6g!wOLeKtAG zIt_8*;RkrUSwE(WuA`osXPi3+iyq?Msu|bwykxDoXwnXcuQJ6ceP{416N|Q$Oe~V? zS)PeSm-8F%omez`ko&uS@Wi5D596%d@QFnqm2p;X#KfZVQzjM}U!GVrws>OECVqu7 zw(w4VC!a<+r@Q4z{wb7wY|X@?`@cG|sB)rP)EtiR^jbX(4L$PQ_Zyfr@ z$&td~WUo~lonfSYBXx_IAfhfGzuugIhu~Kd$7zE<*UK7|N3Hn254k?t$aQ(*s9CsS z!~N}x_?32!!>lv=JngP9jWttd@@GMrmOVZ4358=CkO1H1Ygm0bvap-k=&GRj(`lSPa^3m32=#VHgKcwZ?8N^a(Cvh*Lh&8;!)N#EdoTEwpRC;b#65i$b(T{fIT>m02C)cv?%EX1t zR(t`RM6!K*a&K&YW#l@D_1lN9IDaA`I@EG55zq6vH{czzXV+{s#!2IfWd0k-)RL)g z**j$ZBYYJXh+CWfls%?p-+1PVc%8#r_MMWz9Ry0Ma)F6|ji}11sLk0&jA7Q6cIvaI z2fSHv0@a<&j|uzC|J*F{w~*Prmmn3Pi``gjF;!fHu?DUR0dF0b;(a-6lyn`r-BcBc za^?l7nHG7f05#^*kT`M@x~TpnqxCuN>&F|dqEfG~kAJQH*7&LQ&29h&Y;}y(Mm|L0 zvsjxE)~3)VIGrA>(ZHFTdxa~nma!Coj2J(EwrPw2WTmb$50P%- zrg!q!9?AJd5|pORp8BElMyAa*^@HXONt^f851KzBpXxukW+%4nJtw|9tTtzB1cCw1 zkh2*IQ(QxX54y9JKujd~{9JK6R#aF41M8Eal3}6Bq1rFzF6ie}E^LH1XO01aW6;(h zp(MU5>7a{&fJH&yj6<+v?sub46b7?k?;_kN_C<8K(fD~s(^&3LN*u2TVMKgH%U-<* zC392OEu`sLDd}XLFCFP=**kRJQFuC7)3SGv_(O}_$Ibjv`Ly?QjoQU*Ta5hCDy_;id$qMEuwDFeu$sFG5Wre4{SK?Ui{A4z7 zrl_(_;`iZn2CbyFIPs-MmR+Eo#nsB}!uhTmHOW}zEe`Y~hD36BBTl>vraW3Zx8Bs$ zzFJnkjF<$`)k9YpxI6+Ej8k!$@pPT|x!w_K$t8?b7v;9xQhakHePMCpUs`S{xgl{q zPRa25Vm=}JoiQ%N&#fO1aHS@&ff;5~88>T^y@TggB-@51dwp|#?XP>y+(u6~vy83# zV&X+?O^lK0$KhFN{ppDj#uJ%wvaf*luIW^p%+(ly9Z){=Fzg?c-|gwf8i!L0i??EG zU9xyMBSrZS)}J0<*{Gh!6B7}7DK=!R>RQ3eG8!K5I;~;mmR^Z2#_=Ua{uE=YdRAfOrE9`USaJd&?3 zW*a-kOoxh1qp^n{&ZN789Sb|Mxa5C%?r8)3&xVbshevSpO3k$u&6DXZ?vW_K;w;)& z5;wh8Te0w{+8M>oBaBruN{m$zPy3st!*`f1XR}XA#5dNzFX1(w$d1E9tviqmfE>t3 z?p)l8;idNOn(J`!F~hW|(^xg7m^24BnmXgR>o^A;CE1r;04c<;apS!bqTzi)G`RLA zgXUZ_AVfoWJ}y=71Ar}i3Krvp-w8ipieuOC;;;m3xMUf=s3e+BHDB&#Y>59#SPzL) zfI=BRh6LgXD+%%NFveM29@D-cxxsmTV;4WzOz4G1JcK8mL2nBAfPf>sEMm{_gJP;N zj!n&xttwVEL7eL5m@zoayJP9oE*R_Ow)wtT`lNS`^A@R>@Dy$4wnYd$Dkil;leKV! zwl$A18`X<_>nnO4k$AeIp0%++n}+*UKGs_qCzNEpwLv$@dNWvW65ZQO?j6?jOm;Mm z&eIR$T53|4m3~+#f=PBfO?}Tfw`0eudVa;KTpSNTwxmaVnHB{{#Ycd`lEmg_9lf6| z?Xpr2)0ZOqXnQUb*vXz7en5zNZnn|-T#s}!w?6p3aocGWW~py;s_vU>EY6q%X7>L1Kzp?yxHaX zwKS%X_9LD4&t0Akw6X8)$NFuy%kyM^xyj}({r0^s&zSyllg*p-+Yh@uEBnh$Hb1A| z?&xn`4t63?DPB_`m2@#@F1TaQBK|X z(&bS?5*_o@0zAd?-M)qe=z9A;a}RNMm#mew(a%&L;_w@O&Ceo%-LN1MIX*WP&)Fy< zHDA`q&hvHUGlS2^CmTgw^^z^=n z%7Cxq*GGsj)VCf~`TAJ8a=l5on@MgHw+X_85k@PRLZ>M7FG z7G{U-WM3O?*+%wjbGKL^$1H(*8&DY-+41S*}*4AIn1c@7Kye9WeRor{p4@mvYGfVa^ zBXyHU7-Y%u%!K|Np~K`L$qmPPi!#E$2!^zDXmG~Pcw*N$2EcgY{c*wegpU&;^GE1n z^%mSYZ?I;|I>#~x1OMgcgZO`%U#!`!LxKH9Fj2(*%}%+f%PYVP(;%vxzlil>`ht+$ zzo9J|FN0a!7n|zKW|E-&Rwj{qylCxE?0_M-=H`AW) z=K?58cp#y#`Wh*`HFQ8l-p<&RI5TEQ{>;SAc!^tM31_e0lv4=y60!8;>8r=T+ze*sGFc6*1Oh~5JjSZ>;!(|*2$3u9Nyon*+GfsA=4SI*)1^@ITy$&$PV4C1^9!S4eAWx zslF?${$#4x!ol8o7n$h`hKO{xI{A99$N>N_Q6j1h5;W)k(5H~L@{Kp z+3IZ60!|%^c!8g?;@GgQ%{)q7h0YX4`lVo?X`Ge*W^tqV@#FmUCdUNYRF9AmLfTq3 zJIb@k{~aR36!Dy2y0+t@J?lz~p;35yAiJOO?Pv- zCLd5h(@#30EEF2dc`ec56i!tg^??MARqsLY-7?nn?9%85`Z#Mo#r9mJ-Xo$QuA3b- zRQ-{#YNc)%b=ARcF{Z9MF{o~~H(mxgoNOy2h{U^DFMk&j_W=WvTZ(0}FVjE~Nw-$D zP@bOXaQa&q-HXG<D|75`LCtWNbrxWE% z>G|oh#bNs#JHGs{_D#!sF{xSp5urDHWJD^&{6^JQ3BT%$U?_RX9)+1q7QmRmFv%gJ zc^`AXEBJ+`<6~61obuB*7RzjHb}kps0=?uq-9CMF3tzyN?QeUa13Z^PyAN6WM$?|| z2)P7CONR;7Rbp3&xWWh2 zl86gC9o7ZDqu0B7!lvPF>O^x4Te+a51Dc~iv-xxj`5Qe1BjZmy6HH%Ucjm zt-W^q2W{|3ZRW6!aO)VfsPbS~-R744%ZEqPCg8a#Y*??Q@S=WxanuO6n_Ko_z7hQhzmnh?MQaz5)UiFv`8dRTFVxO>O}Szfnj%#A-QWi=0ST^T`Z>zpK*#>BmoEEbInJue*Jsp|Gg*MzR#;R zwr9q9ws>CFEzv?DA-dR-eVi1+Q)SLfPyU4SDF~6|0L|d_;gX{4F#Z-pm6s5rCHaXr z?md%8;E%|g;^kq4!GDgig6|3wI{XE<=O3OxU$xLBO0gQerlh^^(mi|{u2Wa8g$h`> zb^#>V_<{U;OtNq&H!7&W(Le zvc&*UfrwYNOX%4)lp4F&N5l#bbP^(E;a60t86YV5j)h|f z)VWmZY#yp2y2>e)k)-2R`8Zt;F-AtptC=s6{-(plksG=No@D=;ZK?WV4)w+7>2NoU zX{DCGMbtHAi2UQ1s3FD^JBQ94#4etNlHNH?Zp*S0)CJ{%;i(PM({0Xci}1bhMT@=8 zWLSJ=0GfE4)6H8CX-n0`WsX9~?`bHt&#O!teyRy!m6J={(>HfxD>d}G6M4rM+}6#k z$*FCGfJA8@@zpJ?3eCGfYuVTMrTNMB+J1T;7oQ!Csdp2D8*Fb!c2I+j6Y<^VTfVr# z{<=Cudc*2!DD@(cZx7`TYpf%koJLk`~3gJqm6_B;vywh&p&c$(-xv$&Y z*WJ#1_xT?8xsCV?LSC{*HTO7IxZhgbZ}-^ED|o%qvGi+kG^vYjacc4}z+BWtP=pBl z;GBFh%boK4XKOO-)iBeJ zcSCxeKUSIAP{UE{@h*UHs;9%J+led%>;XetUSIB~Cran)D zKO4NVOzw!K>qF7@KYL>yq8GIpcZm65#CBt5M?kPG6d?Q80_nmW(UZ&+QUN3!m+*R{ z!Zq)jgg4BSyl1HAVvr1>RPL7JlDRCwwp{`Rsc*K1K*(7FeM!9Y3t&+>Z0UzSIbPEz z3l5}DN`piKleUM|d6nrKiV03zv)c?h^Ul?Ts3t{RYBc@LAyQDDM$ts5Xv_YmhxtQ1 z6@~Q|O7{aP%l=lSq>ZH~e49riJgooNw7*jk^ZadUdcq@;Y!k0zBUej^}RA~wKZGu>T{eH zo~P#)yV&_Yu$<&hjJCf{ zCH7iO?KM)Oi4h8KwkDw?>Xaawo9nBlu@t0ta|G6BN_S?&(gZ*Cyd~XBe6Qve*?LSh z6}_8i*skN~*My}`@F)AxtBzE??Kz)wIu96zMbj5lAl{)I|CDsu>(Fa>K6k$OSFxx` zoaF`sz%$mu|FJ-!wUS!nRY@xltI1F2-|)af@*&xwy1xWiqpvhdri{sxhBA%JB~2Gp z91?`oOdNU!V}TH4dg?+KUm{$D^gl}A8@0no>8Vb(gCIm*CH;(~zgsPT7tV!^u8~GHT?`=k+aq9&KD%vc+^C6QTRWS2vPn!{Wb1khFm(k z(DZ2nhBIkn?Ny?>pnaOpsdihK;UGPYOf(TutpX^@H1rp~;wX_#1 zKB!wDYzlQdLAP1s^h;V#(}jaAw5#&Kb}^7L2)c2}wbka;x>0@DRNBYzRX3_0`W=ye zi_g|%#}HFa+NvG!872k>xUXc>6~q)te-D;PtH{mL=al#`Ae9DLdh+>UYz$4P1gXNVP z0Q_trV0fe_fI0RR@598LAn`md=J{DCz7exYdoFBkjfH_gBz;ANup>J$l+xd)^Ia;f zmJWc27FI=K_B@iGB{M9;>enkm;O!D^J5Y;8_uZI!8=R1ykqd4&l0ACkgO7V!bPY14 z>~_Mj13%Sye#%N;ho^>Ttl*nQaxUo`)n%oKF=5!EYT-tXF;#BV6l#GU)|y<-p_YYA z<=tonw@20VjishB38&YkO~C7nUuE{tLfLoQd7L*$p$*&->@g#x$yRt~0tZP;1H&{_4kMVgeabD}5fYGqqH}oUJ83w$L9@Go>#o zF2&k13im>A!go1{PQD_uYqC#Y)sR4E(kYIgFM+HFOVxnQv+_v?^c)3}SlfQ9Z!&f| zH15)hb^CcW)7k#lVx)3D`Fj6?QQn$$`?;UF_WoN(Sv9!9FrZmS>4}k;FTs8 zCdi~(acG~pl8M&nZ~?Pj3*cSFV&+@_1M9jE{xoLs=VO&?fPnKvUgs#=S1QZ=gZ9@w zOZGhxEh||#diC>-*ZTHk@PMMDKzMqr;0FX@yK#LpzL)Q9GnX&(lLzmL_an5^*6PiHFuJX+OhDA@uAW5vNA?B zdki;Xlawvv#tZ$H^+XXn)ke}YyiDZ9D-f4ag_EKJb$*#=9S?RxrIV27;rYi3XO{l# z%|H8`OL?{%%83onLL$VZKe@BbZrCL&>c4aA;ZNN#%F*vX zqHqc^!+Jw;JZg?N^=|xzSt}Y;eLeC$Z`AWD?K@|M8m>kMwgg5(T17WXOJDh}3`J<+ zaBzxWD*QvXLN!#{lPfV{;^Y8rvT<yF!+>U(Y^jr0D`fI|PbgHXoOsBk(~g zVXl$h60&V?Ed5&P-fYfl>IdrVVe2x;T5VX%BHu06R$VTiK-k2mc;= z``n~cID`2XR>XHbSJ+xS0bhzkt`1FKh{#}sn&c0Z)J^g(^4OESYM4Ex%rnJnPk|@v zfX-#nZD(-55=~!*nx+dOpkyftO!AYZxsat)XDRE?f`HBIQif9L*H8Iw8JjGc!j4>g zav!|1sSui^4OfL$U_BvUxAX?rPfC}Au^M~Om6zHVp337$%V_MdY^?Hxw2j(bm3;944$Gm~IFJk2mdcrd?l!jzUIH?`9#rkpj#EU|Gl% zZA&5y=@tgwUh)ECV=oZ_jlD!H46{e~wd@pMXK@sG!^ZSd(b`1qFBp$aU0`w?02#Bf>e7Xg z^c^jH(8RT{jqJ!!IKbZV{qf_CHL{bGxNZ;2MEvuvv1;-{V6}`LG5w=|rvTGlD*ZAZ zoBTby7>FwaDke9}wp6~tSR?yU3GdUCeb7+cl5^ZJVFjhT3Umc zunQoGpR_{O4sleB$EHs$n-!QoxolSO`B}!)=V@Ar@z~3#5u09>JVQ0<%5X@w)BDFG zpWiedE04`G1Lf8c@)N)u(ihVI@cE_wda1wu2>FNW{LIM_^EVceKU{Q}{KlH+AD1%& z&U@$W&(%%7slY!PvB@_vSC0TSYVsWJey8u^+=)=Iz=}rgr$ws9MWnPbyE+e7V1*fo zkue2}*;=3EkT%d<7YsuagssP==MKttc=HhOZ zAIZ+8CE?XVg0Msd%OwYDTHQA1>5YOu7=0iMD)@bApGZON9&Y00wtm6+R9nArMhiMf zC+}r^1Zf6;D?29}s8j*}th9W8? zr{NMG=D+;j%pt_R0wP3=mc?CoaO~XgN~_vmA1tant!3T9zC-BJ_E7wb5{oz39*hb)O! z7BSTF7Nb*Gl>?9^QyNigVF*#Or)8DkK!XZJ?zIlChE0w-qA+=;V`m_2(t!ESqC z%wqO}?$~u52=3PjjU4r~K{KRJMMrFj&~FZ^&f2_lSZik#6N)@Y!?ulo+)obS+UBV8 z5~tPLp9^*>$G9L1?pa_;?4_j(NnxtfQ|}tBE4f9XhQe3M8}(dW>YRq698Po&*g#|v3#oZnib^5>&}f1(h`o+vEMz&`>62RHSaq= zGlJ=#2=PJ7gtf|_RqkB=q$oeFs#5TlWRv}{3968MMxiL3mojvmE-lZY3}+lUF=>*_ zz5$uPN@mRdFTm$DrA7tpEcK#kmsRoB5R?YIA?+}c=t5NeL9F4HQL)S~az?E4Hd@A- zvWQsvsCG0UQD!*idBw6P!2lm88)X|8$7>MeQc`oDpMn;MrIWj zAKW9zcLtPy>v^oHX!@!O;pfkHEVVAC&fgUcJZlFU1JBY0ADn3W-oa6RyS*jF34G5S z4MD6HiOR|hP>;E1 zhoxSk%uN(+^%reYHUX|TweKC5eElONu-Va6S}1*(+N?hm=i2S_%VfkkOV$m&=gE%4 zmE&0K3d=3xNDHI>63by72MFa0#IEGojXXhWZNU^6HO1t6cB%I1cz0v8)$V{eWyCCzD4@)R9k^>O@N)03~$Bp zcmE7$AY^p9oo_KZlvbT;qcyeh-^23Cf~w{Gg+2>BV84o~54FY|`HhuPbF0;@6U@N8 zYBR8Cf{3)B3I2cxj-xOr&`butjG{&44hE*=->8i>7!Ed9_VGVv@`4I)qgq_r82lvh zfqp`=hyd^tOZ^2kt>D@P>`H}M!^lBqBiEtlEI*{CtPbP0N3{I?-l|7ry3otAAw%$K zW+#?Dzc!X`fN{RK!nucyMDQWFkEM=a-^D74v82)~AAN<$$}f&cDGQw0q?e**g8Jr& zoWs1bPi)C~g}khA$vZ+@AP4_(O5ass7ud?sc%$7uImt+_x3*x92LN7kw{keA=FYC4Gxm_36h6ChC~3R7H#b{QYl@?Lsep}6;qp$lt`6vjvd!%#x_W)TQt2?m)HuCaqGFod-+eC#$Ku1jEYVpy1TM8v0Q8?v7BR^g*xDDxNHH#$r!) zYT5)A?&R50Bm3Y7f~m`@n^L`aaIP)5u4xyG{5!dBk%?D!Nz2od;1%%bQ`SXv8Jdi) zn$T7Wha1y~^#or`_(&qDt-$%!5_h$hRYs}XU^)|n)Wx;g2^NHxx~MiB?2eBQTwH63 z7I}jeXmc*O2KBNpqQ|mm9H%?ZGC`q8 zuou2ptdXB_20tnrl{=GyaN6jls29HQjMjGwU}=8z%D!_O1qwan8kQ&DnQ0-=73gw_ zbfIW0V55bs>Y);$e=YU95*I`eeoCG~F7O4w0Ej6EE#l5B5jLcaY7~j)N7mYvU?H}BeJi8kxo>AMMbzJ^m zkdc158wDWvD7b#{NJ}lQ#Xd~kSR2@tH7s>2PrKE3YEgp*cAJ6s%qQiTS!(y9GQBta z_-tvwPR{wWLAm2W%gn%LtOzjteKC7XaPz{E0gP>5bkbL2EwC<&4DbbK3HPR_%RY}m zSqzfipXe3>%TMd1y{QIf++tE&80UPs!jj3bGZlKgHL=&`D@;^jRwUq8>ff}ul_3{` zEhP8{s!c0TWNMOYX9`4Ig+;GhB$F`rLH7ILALBlCz6|W^S4sQU+YPm_UX1^1O>bmw zrA-CU(O2NaZ^2^-O8{3P-09U&EaO=tC)aG9wZfj3-`$X0hS=RAy>poRp-;Id?FNqc7$@A)_9#mETiZR>jZ33O+-8$yGDqY3SaLx3x zNNCG)?l&w6>{UZG|=hOA+tM-J)Ep{dFKwbHfM=243+G*>yZjD@ej(rex(~eXEJ8oayEE6Dp=D8u+3% zz|?y+3(1nuy~Y@bEp}cKX9L&kbCscihvCX-%ThJ{T!4NuDIt{dyX2R5%sG1^p0Ji|s^$K!fdESBAv7 zy8m!sLjRB*h!pgH03r`uSK@BG8W3@vp8lbleStx>$Ryb5&uR*`QXf6*h6YbX%h5U})iZvuJT-Jd>)R?`oVimLb{a=G6RBh@;Q)R# z^H}{qbg5(E8ccS(YPLCjhhDIvbZ9f_-b2q@(caL`h&4yPF}g>#3j2+TSX#{}vqL@0 zscacl{D~^wDNLN7`+KY~F~xTF_8&%5JkdVbQ_oG_`?Ig#0--EYHzlP!X4$0iD5k$Q#>%3OV3#$!&v( z@e0sZ`TA7l2R-%W03I@$`f4NJWCLD`Rsr`s&L_4FT0LvSg|;zW#f#1E7@`-bJ!64> z;P>HR@}yL6kQ-M+Q(DU;p21sado+zZMgI`AO?3=udvc?_(SSM5Mb0&F{0EkVqnW!( zn%BpXoM-B@a^Ltg5wdxn#LdZNupy;(-T39lJ3F(z*`1B)Q{w4KyC~K2dv3nL>|5WHDK#4Z*XwJv=@!bIJ}h6IT1xWas!1D4)F;D%HTlb*~tE zXrBnCvMfF+J6m2K_&f#eRlVh)2X3k^gWDQVypxB=B4S*9uo#*fxFJ@|1|zB(Y~ zf~tfi&s8alAo^QxwRe+B9WArPP3*OyCHS|;hQzBi%_Y7j{`PPCJI?R#;H7?N2kmf2 zccQ`jXqq8t|3CWYSMloL1iy2PRsD;mxVk(!8RICif521R31Yh{Ys=;1>_9X~;_h*t zhxO}&!FalXPqx%!QpoI^1D&-I*jG#LQmOT>7*^JEGGfo$n4Vo}EYgQ<5H5^maOr20 z2)$v-i)ba5Zs=ksV4M)noOf|!df`TFLL>nZy)O;^C%ME9!v_gIgsUYrc~A?N@t%D{ ziE4dP&3hx1*LQDn<(x5?82;|25#Qzbib&>?LL+U-fA~v26be>rR8TF@?fA4lCDIoL z)I<(Mdtz?XC5O{|F44Xh;=i=8GM-*Yn3*d}U>~Q9<~JOv8_JBjq1u@aYyFZl9nRX7 zJovSIYaIuz_EJF4nLv;pLnkbQU0+OSgQ;RI4w&(IMpt2nA>*sN45sXLgim5B{+aij z@@g61;pA~R<$lI~yp7x#?in4gC2o&{9~uKVJ+$6vdr0DHkc94KmT@W4m5Nx;^a?%@ zf=QfXJ1rbI7X}Wkk2!@-dFao}#|D~$q32eVfkDvMp;7$fU@(@Rj`}qi3bY;vSBE+l zoY0%aR<-{Fu~FNr?a<+M8g*P^`7+i;9m&xd}O^xfmQf~#Enz~!z zpENYgRW!$x$-*&!^oaR(J@Iih*H_BhD zBy`w=c006dMX82lB!h#&MsGw;sp6!K8k19+-L4^p-fwBk!HCgHdgdzd(;P{l|GWW< z&tVUo)<2439Vq42hY=Lyl&&6Ilw5(-adt)8u1?!i(>CI?`Dq(DDU3C(TYOlf=eniA?+6Tt}tM;`C?rEfh zZ0svMg)26qE*~H%`0ClCBn4RGS2Q{UvGlF`BF+#-`F)7A+1b5Q4oW7nv7E0EL?aUX zQ`nlhf69vp#HykTamBd%q8vW61Bo9L(BnzoXwu;a>%HI@%ioyN1-^3P?e(9Hw}$~E zWDPyb-xUR7r|w4eAmIVF9?3c8Xfvj&(ahxfXn;-fdZNzbw;G)Z=n5;s&P<5jvH|Dh zVY$LDi9^llT9)0V^9;L-X9n3JGfLD#q~=4@eQ`G5nra~SAFKMzEd07^pZWc_s{Q8o zLE~94k_)c*jp2edX@(2FE^poR)KgaHs=tySb_lTX?IBgry*~)Q5DoRUp3Hc|b;l=* zQ(p&ZTau=d-SXDPdnmU>5mDZkb7!$L9cr%-$|C0U4%DPP$3!2-@Za_&+Rj@NYO`vO zot5*haHG!EVDkaC9U_qCaQf!0U}m@CE-+|jUROHux&m#*Rw7-C>~kVrLWsW;EMy|s zCGCx7PJI9OfdY5gauqOdHT6#8zEy|kTz>hSL=^?`EO;)OY24?2G6j%%rM^Qct245d zl7q*Qc!|(7TsTf{vz_kHe1N67S+CailbSICL{%#|`TSKmQBU z?DDEb9{gxRrY@yjXKy;vOE9#W+{06DWiHuAJhT&dz-qaK%WxvU4ZXK?q0?Qnr)GPo zf5}O!vda>;FG`e{-zCXdYX66np%Yta`?c0HW6pOqCL<4J5|FLdP1}iaTehn?w58?k zm}7>F?Ng-J>U<`ODM5A%&X~czW6}LHT$+&z{DXK z5A?}7`2;RPDwaAXd5Q>JvRd9Y0PNwTlvJP?HYNrG^Wm+cWrIjZRz0M;oM?&84Z;m} zB~EclIC>E@l*o2Lh|GLwJPRF_#!26K#yz%7a;W@k_P}s|@n|Lh$)=lbxOoxcOh}LH zw;y8I?D&)7nUtta9AE(H3ts}H|LM+;R^;!ezrn{?Kcv4;Jqm8(9Nx6}hT9kBD?Zz~ z-@MAKT~7%i;zrOK!x`VRRxkA5$D`%^2{Eew(aZyj=_gGwf=!E;-Ee!psT(nlqw~+c zi2E`i`UVrh$l_CWtO`k36iv@A=HCSVoz$G3ea7;0z4HI*m;X<%{OQf9yC&7Q78BEQ zQhmW=A7IzmTsOOXNsw$=C5GCQk@teA(^4DHe6#8yGqUa|8|Yz@iWc-| z*q#A1OTE#|#(kRa^p(|{Zod77JF@Gw623@JNG5=^0OLPN?3-s)h52D$K_WgP8VS6CL18#EEhB|$Bycnm`fy2kk0*2bHdzDf__R57 zG18D)`hiOiqWf~^r?;&4ykI8E{XJ9X4+BaeKp@4yZY+oG(B78uR%bxI`dgO- zn(%6g~)TCB(Gyl8a`|m340mTxE**la6&j1Kd3<;nt-W zYN?aelpA`ippBKsz~7w~&R)TSxQ`36UAaipByt9dWQ6bC1HnRyl z>cJm0;%@rI_+ z^JmVBaxj#4UTo5Nk)-{P9g%-tC}0HyMupJ`c=qcYbL;7hv0;Az!vd;1jEM)4?p{pr zPBIhY4wIQoIJlQv&-CaI1U(?)J??#Yj$q$j&YmDX7m-8= zyr6^{27aV!GCXNLV6!pYh#1!ooj8@IWvR7(^!GY>4utEl5>DQN9qVuSPVKwze;9Bvb9yF%fR#a6Zzf+6f?X6(ZzwT9gv<8( z^zaGw(0z%)if&shEU*l(T=nB$9$?q2x8g62iSlUqqR$$7^v%tSZu}T{9j0%teg=5m z#_{s8@Tz+NDx=E@%_A1p?&-&QGcI!+WB4s4WGdPkG-2YvCcHv>rT`c>6E_ULsuV~F9y!@zL=Q* z;$;7eS6E-ZP*J`(V7?&OWUea*I&eLo(&cXSis^kk(}>ocfIyL`4#G=*=n1AiE%Bf8 z_(L=qaSm~_r{D-~B6)N79SWg* zUzeOWbF66}>@WZV3%@J-JrVKgNRzVv!(^v)3ecf0yZcx<1k$FK8wyhLtkiI$^{&lgu}49aVNjW&Kt@z?Fb4>c81P;?1kx8=^g| z__g=l<`HkV@Yd?=^Ik~Xv}#4KFgkVpk%&&%;C8;rE=q2+I_~GKNjBpyKgsHl?UVP6 zrOAqo$1cu2h7K&fBb+Hyd=RcU!b~9;>PsBQZ?P$kQ`?-4*}MJHrXkZvXlUsdSl1rw zk?u^{22&KdHbIUuW$QwXT}wZaaw-6bLi1)2tNr)G>Dv)+zA+e}Tm~nb6$t~B>#uUzl*iQiYE3zq|c+8@`ZW(gWsMijA4YL((GD56idh$LJ{2LVb4jcl`5O#sBP!(VTcwIel z#eQvdHg249kmzE>gXr9foB3a@N0jVQj|1-k;5V2TFw=x0n~&Kbm&{Bv0~yw@Dy}=I zmXWEWml$j}4=xh&qmiyQxhHg^+U_FesnxkHyFDB@V2A$N0=wq*Av2>eotjLS)o$oO zG6>6yhJIe3CdFNOpODVHedeKs2N0n)M)RGweOY_RY=E344vkFp-=8~UMnnER`IUZt z<;eUgPlL-!n8qV`bU*DhZdDiRBKz-Vn=Tt`d@cu1*K6eyRTn#LB%wm%x z(}waG!6WxXom8K|C$+4pKzGnMLp(8@l=ykv1+ZL$rSFb~dRtFkb)ja|mrKPYmx>{m z8o*{kucxe4wb^XueiQ#6uRxDkJO{p^Kbz3s+y1gdCs_Oe@UY)wZDLd{{r`v`Y- zP(dO$>_Ab2nNm8^6KT&TKaHGaoyHD85Sa{k-Ic`2S6wdPfhkDJ~0?zF}#;{ zc3y2d@+1aMLa|ezGs1Pry@_J}?jlC~xnQr<@$B`-4ha9G+;UhCYwZ}y<-d>SQ}y}O zf_!Q|!&E;zPNfzdeWp(|J2lsA@=GJKzq^sndvBcHY4;?t@-QoGKPK1nFmV;J0>YHq z$XB?xx*%S+xIA$@Nb6B4)a0R?PErOl6074T{6Ple)9%5OgVd_W4^YL;$(97hc&r>j zjQpyNc@tIp^;+#U6!+`4+Rxx2S3hU`#|+@?5!oXKz=V(6o?1`03I|Kni{HY{=RfE0 zNsMdmNr|7)ZP*=M^iIoGX;$EP{{AUZ#^2{y4J{iKueY3(-S3w@F_)LC_PZ``C@`N^ zRayR{e1SH7np=cr`P5=GsTE8-UI|Z#>|)&${GiGr6r7IZ*2?BO)7iwe%^i2+dm zr2X~e8J<2$Hqg7=EdWMtU9FDS@yf9gBlCIP7px8pfH)kUl~jbH-yc=33eM1 zFD(Nk#XL_O45W4xrgl_daz!5ip_pYG*xV9-<*D-0$ox-BVR)g?Fa$##DVye}7ub`sY?)Ys2 zl{v-@sU1ZJH&;^MVC})pXt1`UN%pf-Dr#Px2&7G>S&F|}7}$YrqIy4WHdX+;+$sN3 zPynvN3OZcZI`!^r8=c?BGZ*ddgOkskKdV0=k|3=4Y^X<6+~@=Y2*ac7nsLdAoM`nE zP}@Tt-JUv++^NgEKv2nr;f{qRiR-|`(e!oCu{zK7 zL|zN96}YK8^2)+n?np*6$Nl6f*pM@h*J^<<35Wg@A_9+vR%A3j?ioA-i!M7|UviPY zNsPVd#@p{~O|Gx+EF5&S#$o3tZA>WI9jpDzn(ofWg<#{(;{pY%^U?9t6;H2tF1=!J zI@!~Vc6P$ZiRLs<-`>MN#J-UyF(~#JLEj2r3V}+A`>)F6K&qkEz|)mf`_V7x2Tl23 zeEFN+7jefmA4rL8J4QcCh|71Gkwdm~49r0k71kyixCbyvIt0aOJH7n_f$j(FLqlRJA<7Qn<&vILVs*|t-2I2*^p$0lJdELf zdS(#9uMF{gNkcmE8$2_%X9?W-S8KKImx540FT=+1m|slIw+=JE?ms!+2xOa$M?q>G z<4esh!9cyW8Vihv1DxQ!h3STppBAz)toE>`|H)JpKlbCoa_NToJb#+!bi=izs!eJE zsdG%~CjT^SPB$!KkoO9A!$?1qSbER^bX(#MtJAqex#`(op>UH)Hrz(p%ap9?YYy}` zr{_{EHJvJ{XmQ))+I0m9=IY-6ZSv-};OU?cVt|9Qj32bL4{!uEERm~fb4@R`CkECS za7j(`s`-kj9#Q2gM|)1a(!^eB4yZT{_M@*#u9ciIxk{Zzcg2k6`YV((ljr6-N1e7h zE;KLiy%=|=P?nF#vV`?EzF8KYadbxwq8*d z>UnLi|1<`GG#NVL^%|1|ld&s%|B$krwF{UJz441?9(`E55Y}MolFCG7yzT-(1{*?C z_;>ECW=X0PT44$Lnpc6rJC3Isx%>!Kx<6lMUV827rAws{DEs+w zzinQ6?NFH+-lHli62s`Z_TH?|(Rh<#6fx;Xr&6ttow;qoxwlJWadx|5uccn^k(Ttr z{T#WZl^b4XP&%J@Qk&iGMDL{@)uO~VnpznZXRlnu!NgE^yMt@hhq;xcIr%Hx7rp0N z@43?5WuEWV2J^CN-Hl$>kSf$ykLsm%p8G@ZO=Yg|qblRB^Ky0GdFA!qZSiuKF2wc3$Q2_UWZ?<$eH ztGpn&g6?9uB*|yY=@dyLhCwF)I$u${Pnk2o{pSvV7J?Nc$_1E<5ob;^;=UX6LeEpE zNU@Y)8|Rk0hcG~;5=6HN7>T*4JDzg?(ypy@YdKrv))EOX2Pfe@uf6eHEM06eiXm+p z)1Q+ZlI?Pv7m;I`5pw1uF&Ow6$sdE|nBI8imx~R!|CtJqC&$x2UBn$j$pITHB45!0*#r(fD&>pP~1e{4sMV8 zjm!DKv~iJN#r!LUQubJ#``kt^$!ZL_Kfc0bqa3||o}}L&6t<3koKFZ=&0jk+GyB+4 zPUhy0ZepX*vsFhWKeM0}$;2)vkQ}>e4u=rFUd&u3`0qN9LfuP>Gq((Nzg?uxADeHQ z$TSVPTjVKXy7kX|pP6JzBS)fG`hKm2djq}jO0-iV{fHJtajO;#?4@F?Y8H6K-KqJ4 z*HAF#-~d6XaC)t(u{PL+IKbn4e`(O}ezhcA+S|=Fo*V2U|A}N^I60=YkBnl9n8a8T zu(_put6mjv=qrQplkDuiNRZ&^g#rZ$t_@@168?leLkCwOwbb-%CT+Y0gQ>0(EMAvP zz+r!A&{S~bL+E%w?9*FB;plQ=A!NuSa+c*f%b z%f`CTC5T}G@4Lr+6z>nZt0|W7OPV@A zbV^g8@AG)yCr_Tja2XUcaC4P!m1MMF!=`LQQ73JVKJcF%x}v%jXD4UUD(4<;5bgb1 zkfPOo1#n>!vP1)!C;pdFUThR}>wvFU+t+UieNX-1))VRaN91QF2?bK0^j3lIdE@x` zLu7Fi2#__a1i&ioDan6v=WRAq#&x`@q6^% zSu60zA={~1XSD}-9d|k(;*E2^ph`-ntFFo6(bvh3J8QL24Vki=9D`>uSm4a;TEtyD zYOQHx)AJpJ8pyuMF=&X?B5nYLB5SW|qqdCw1;Za0#-N$~wm`n{%R-x%j5io#Kzv&) zz}B$GfrVkmx#%Wb+C_5waI(}-hWYk3UQMKEtb7-X_!&UQ}2{{#Y<}7p1HZ}}Qy|Yf7QYuzb7|%Rt4BQD*=3G-r zxc2H89(^(V_hNq7_G{66O0}8~(C6t^^Mo+kX2KZ~pAXc0b1$NczIfeZ`&sVf2^)pL z0b`>?^;kgR#|0<=r*e*pZkxa9viO_^Uy~kzLqj9PSAwC4@Qeh-O{pUjtko}(jTE9! zuQoM;TD;QIMxtry<5hH%7)}v#Kl{3N(@?l>Mbzr}2_>uzCs-RA3U!-yb7^05`s8L2 zEo&E=R}EZ7FuSN3?Acrjw>*a%i@4&$+OUv&S|d{p@a!k6*zSHEI8t(~pNxd|Td7l3 zNhdK0wn8HZb`bU0T3hT@Ecm;XgMW6J-TemNx@v^)fkX315;)8ykMo)*{6PfAS6GEE z_Nvv1h`+1*)grrQn`-_y@=WJDjK^4N=#$oJ@rhK$E!ndt_=iCQ_gIDs}n(lZ&*E~U~@Mj|P!X4E-73EU_lL}`}zbq1XF@o>;+RyWC`bsS3=Ty?# z@w9eAm<3{jbPhF4%C&f+*J5a=MdWV?)E$XMc4oS1{vDpf1oW%vj|U=ZP}fauD9<%o zpKrcC*Zeed3`U3#u=baHjQO3+-2!+}?TQ7ss%~a&G_*5nP47oXiRTDDXo3E4dS!Jy zy|NZ#y?Q!!GCe&h*SU&Zf>VKhhZ?6^DT&MJC0=k*dS$}TVF3jPzA{QRO`It!=kxDc z9w6~nF5;J{i7S^KTvGv@bJqV}n|VXSsVw(hr^TJ`?PsQ(Mh|p`;^}$&czL?r{U<6IVlAKL3(&FVMkL>l+$`a@l*q9rC{p4r=b;2nGy?S>ikljFa}CLeTe$w&M(EeWAu@@*idQF%oTL!0rf1`r7LJ_FI^%iSDVU$ zTQ4@<(d}FAZ?R1D&uBwZiJBT=Hk9j*XOHzaosw0`1L_j@c*eofV88>qu;@J*IxTE; zt}bcR86vMoE<{aVCN{kR4(3)Igu4>cNBH|9POaIAKy@dvIoO{C@xaT_KBa7=hQi!Y z724Z6hO6)f$1FLU{RWrcvg6z?b)J&|b0HC$)#|+Q{n(;UgZ!C2hCg$QsI4K;%)SO8 zCB(YeFeaUlK*TT`p9y{=l+r>k{W;e`#RJ!rH>R%!D2i+%^R@ncJakQY%YBY15e=j? zjq%XFR>G(>6ybaW_KTv#-4HNX!%j~i_8iQ8ly|duR}Kowde|U+GO>Q_x?(FOr*5ty zgbz$uR_7YI4YAYwlytdl9Dng+?UI zi({!x>Rv&j8CLSb!j|hJ&h!dR_7ySb>y?s=HO5kP1<9FmJ?l!;=j>JG$jPNsfz8HB z_w;e`z$?rcCaPuvK`Y@>MKEOnnzR6Cn)?;{T6(<&DAC-rbJR0Zm1gqC>RSj*FcPT- zkG5B8oXJaUwH*^EJk-1Nu~=ZWy6yBw1JB9j;$hH1G<}kFU)Q=BCBG;f{QJL=KdgF7 zA4HuoEeFOFMyG5Q&9#jEpc&B`@(3g!=6Z0e{g0GvbS{~Smxk5;JP)>Wk5(HWnZVE6 zNFad!Ag+_hDD>Lu2>Tc(Y)QwztE^5Ce3Qm7ANGeng{916Bhpzvz424A?^GRn)dS`3 z0Zd(cTW+;)?HwBh!Ein?)@$*-*3@4<+WvzBiz_{X(EZ0^glM%kEGF_i-0s0saLM^5v`=5lW9N36;DbaPk?8s}-|$4&y&B@Gt!*03 z2*xtzyu!c9U2`5Q_>QIr@-a{L4Cv8x?Hje@Y#6jzsvJO&gDjT}` znP^Ra%y}`IdNYXqiM9GWys@2FH3S|CNh1JRjMu) zSf#3jltGPWaz6_=GzJRS>A)X`Wn?QQLRWe)_!Lx%DX@efh`@bRy3e?$JP$6l+8ZFD z8l7*bW`jAV@N6WyQk@Z*3D?YW-6edQ9@((vjYPj_3{9`MR+o@f(}$oLwmwr90nukO z!S7@yMGlfOViDBOkBz5h$UcgpQTDMRSRxka1_xSexA2;Ji9xiu*xzeB))yjqd$lNS zk&Yr3*idgam``UbQ%JksY$z|YxDA zSrebn0p74jX5J|_=0D!dNT$V7^|7e$yC1`A3|G*SEfQ=cKL@ z?adt&+jjVOY*)Ldpo|Bu1gg%3rtV%gQISaum>5pm#QsE;;Y3eQbyq5@iYR6x7@eld zsIx{JDYdz>`$#dI;^c$%?6Wh)obs;M{rL$Habzp@UbUp8RU|6Yvn$Y4o*qumu1e3X z_UquwqQobi`tt7mIF^wl{%0gofLq1P4@EY#DxVKa04qVR1BYEE?dd&+Xw*>!KEH2!G}Il!%rVR*x(M&;(vy zJfXB{k&J58^|>}sxMTNqfUbno|7s>Ez3{eFw4|`7VL@x+mK#@r;bEz6vfG|~n86ez zJ_#mxOKo* zW=%Hi9Go0E_w93^j-1%j8}i4t!C`|Op z$!$6M71vpvPYcMUXIfi&*`?X%_jv~Rz9F|Tu4$)XU$F>mKKHgV+xfMaxw z$@!b&c2fhkJ9+ofbfjKL=Sq-{GY{cfnYB7h8VTBbg)zPELJ8MQk@E~*N^(g|q~1iV zkZn=pmqk6Xd6V^4$MKY~HcTLhG{Q9r(6Dbo*(~AO0f3t*&_(gg6@<#3F?{lxz)Iu< zdCSpj*v#g%v)GiMF_w9mQQWM9x0#a`;mb^&+|!|RE-9hEBILy+O+S`TWlahj6;+W5 zMs%P-Y^=S5M@gZY`DJHz)%3GL^kNq%ml|FMypT-lT;&j`2}{uaM0ne74lCq!yCrYZzMR#al{Mdg*ejp`Jx?rj08OB z`~FyB5@U0T67%VP-XS0KMU6J{L6d~Zv)Ua7#;UF2 zbjt&#ZNf<2eABg2Jv&D|^Wz!*kNPJYk--4Fz?j+@8{g0$tdz91>ZVrSuK8`Qp9s)D zb`DKH-Pv?9KYx{8Csl!&zu*4-Iab{h_Q<%QwNCEkzozuj-&SquJCpI=^xcrXk8q0V&&9zuK{#VD~*Uq5Zc9t zu!~U1l*4C7IUhTy1Pa?OxdiGP-lX;Ka`>N1S_teETsIzi`RKY?fO_=Ux>QMMXJnHyD5(Vx_-di+g^Z$R~`(sz&?MwX;t%2W%NZW`8PEgi&8M-wD5 z(lQ>Iq6aiZfv01EOOZiwAaN~?jUXy4vA8!;r-pjD5nIDUSF&C+&#W2gv_ETquUY$S zGyCU%IA2=~cY}Tfdn5EK#v0DEf|CNhiE9e9hv(BGo!^XvW>e+NE9OplG4FV2kaQ6M z2@M1yudr6Xt+LQ=^O3E(_nv1+OjGJ5|3&?#N>Y++cH96|Lr?R7AC9Csy18vWs5NSY z@}9Cp_?)czAasFYp`yO!!VX{5sF!1M>D1xzEw@ukQ>yFF1oK>a1AZORz~yv@P{iO9 zZCxMZqcUkuHxy-p^)SdnS$1GYh*2*^Pp4%Rf3`z(Gutw4;Cw z6Xb)OT4B)le9;Gr-R{|pkU9*kMWa1y^|AiTed|Ms;RkZ?<~8tf@K)|l$yL4A?ZuSj zzlOJ$=FZDqt;;IfC5@Tcy^{W_ZD#;`fvB@l4aJ>}0&HZX6~va>$ZrY1zu*_3U5fVZ zO5~yq4-@^R$Zf7iW|MOpw>q?*#KjH}R~mJpU4zT_uS^&yiRS)8FB4U0c|r%Qwf|_E zm^LAGtk_z!nTNKE&$K!oQ(|SINPDunNX8bg%mk5zX@BNL2Z`%lOpnEs^yS zQ?N!&B7d&OS3K%;h-Al86;i#3fx%>l4EG#?Pi<@C9o%qz1p!4G%D7W0TFre+vrl*G zYtsz~o+37y(}ISn>4q?7venU^hFZ9@0)D6I*YVxf(?8JC z4J`1)%x1qD(X!_i?Hoar4|SzTTPJNio05VIcoG>L0;aeWgKy+d5gKYa$;9OOn*tKA z)S|Q4$4-!6>iCUg)#57tOxcmWqEhx}sl~j!Nc}>!s$Cx%YP|t{g?T%8C2w#VAA6B} z$dj?Q$LE8g3X)jC?Q+M@l$}`eJV>Og$>qDx!UioM$sHWaOkKp%0f|3K_9C+J_wPHv z9SgDa1W}}>Zyy=bFp4$%M*}GLH<8&ry65cq=DJ_1!2}+v-&S)%)tT$qI_XFC*o@zf ze(D~*)-QFh*ZN-f%U&rxQcADu*FCBsdAp7-O*PvXlONr8W-iw85a*)a|vV<&aXq)zT1<8YrXbqwmLM9qGQ|6v3C|SUHf`<9) zAiwdb0859UR&~Tc#d3qhxtZXTfiB3cU=+VWMR)BJ+7s|BkU#Yz&At?0fRP^snB#vAi~k5|gl< zHC+rIhq&9g9Lecw1X6Cqk4`r!d~YLfvL}9qE6f0;c@@27G=jGA1edcq&gGMVqp(4$ z31A23dv(3-=K=Jf0aFn*C_X%fG6Q>gI}DCbfpN*Lx1MR3DFwV- zfi^Dn7ILQ-%t_1XI_2P|J6dkO)p-YTPtN?(>Ufz3y|XpgYIz}mQd_HS6Tw1jJHL@Q zIRY0izS9D?@_)$*VZR^?v4yM>n;M<_Rm4tz>-+o|VvaNO>qT5tH=e|-Knw~>fN_{W zr%T2@SxIjP$2;6`Znc}B%*^H@?^3JSZ)C#9f9E*AANEge%uFwC3~jg8$`pqhrw3H6 zn5HI=M*>UpP@gUBOC6qIt78*jZ)P7Y}B%4#b7}vD%dkIi5bR z$_vqJG;M|8lSU2xm=TDg ziV18dGG#2(6}4t?d-#89h+g1aA(&`p7QVk+X6XD*G(VaL$bLAUdhkuCPiwX%dI<66 z<``=h4{XM`miAg(pnJoKDef?%-sMmw!z(~zK~MJIM{>*{c(^O^BhlkF@Z{OJ2>O6tV`%G{ znAoAGF{Mg%7aL%DX5dzE5T%A|f?x0RJ4jdS4{j?-u)0SE;uH)AjtqqP9R?m!Bk9Ri z4}r$81dFtHdBMCm6cfj9BB0k2dFCcBl(4s8uv|HdOiuO2se+BbKEgzN=l*<{n;sAg z<;PFKK@CDBJsWD_fZc8>QoEuyEfE8wN+wwN&vMfuU zCz5jGR2Cm~%cf}pf^c8D>_Tx3kJNmSCHJx4lDnzTyxN%#)_L~0^vSo3@aS_7>8@id zZmOEv%n5u&*m+e3HqygoCT+}2Cx+Cvr8K|W-E^*D zj21K2S}7_PEAzz98-8dphUMw8SSsi8kJb+77bnI~>Eb=|sq|RknOb2HNIh>LAO)*k zAYpvHn&D!K2bnBOX^UDP(QQ!6+F69kFkog!Zv$E6vSCf-XX zxGvN5p-N|_qaWY4bhSGAAsr=;-di2IJu2VRxg&atTjFKBVWA3ugLX?_UPd$}7QoJ<5wGQ#jn8GtRL&MzH zw)oYHqDF837fBNk`TlrCQ!k;5N8 zJzvWS!yTapKHb8<08&B`$IH;P5^a@OZU@V74*{^dJZ~y=nYrc8)%S7s%c-|24Y4LW zDEkRO4IF2!dzn5?dC?ASZ{-TV1LU;tBFFx^GbW%-`5#l>3mu-ywbkbb5KP3ywZFe zrheNxo`~Y6i9wtO*LWPuuRVUr>50{Fd>}(An_APK9LvQsaE0%%NRy#axU^&S7tP)h z@@BHQoY2$tiXib%GVYSz;%pgwd3gR(ZyF9GLDucU(#N%~oA<9J6A)BA<%H+61c1b}SImf%NU&7+1aZKR{ z?f5lt(dPbY8;59+668|U#G~KAJYd=yRCUfjXz1KnDh3Xb!Cy1k6Hk&MhHQ+{|t_m2p z<^QUMtB1t6vjj?g-5Nn?YABmH7kA47c6mH=+@qI6Loe(?w_XV`R#xAb2@>?fbNYX7 zihA42L?r8|J8|CdXUq94y09nz89ccL70(2Fb6-F3dGBk$CK{9O!Wo_=QAklknKETs zgwgytlfr3B2vGEWT8Yewm*Z>fb{;U1glC(5&MB13|B;tJ1xaCTVe&KlR2C-LUg+ea zY5Z)l{feg92IgjBk5jF`-oqpx&CCHrG;>_tw*mzN37iDH{#}ZL$1uF8zn&-|?ilNk zD8^nUYRqAf|B~Z;H?v)C02zTOOlVJ0oJOq8WXYfeyoV{vD0drf2zuR>! z_$pOSCSetp<4qv>MyjXSguW2H$gNH*3qz?&O0*p3#ll32avz@=)1cpL>6ttvA|3}Y z0@*PjkDby*26hE}3c|7?Zo3~I9~8IQ1(y<;q9EIKk)gUjONS{O4fNCgcyPw?=C*Y6 zvgK{Ayi1pC;Rac!o8!tn7+4oIf?{0#4PZ{a&^l!|RL zrCzwt5%P*Dyel#)vW9Hw0cWkZ6h+HVs6V)UY$CT%d)-e`P4_#2(EHZRcXXvwa;x7y z)ZW`Aj5i(_jECGjNbGeF;MN(=+*~*^zNk#suwui$TB`NdVlz2j>w(e((#ui8(EB*v z%RYOIOzAvR?JT-H5q1AcW5fNd#3@f8Rk~3>lCqBI!tHcH7TR}7x0c$B(ZVya(6cSa zWy&sy2Dr3~Nu%^QDwH(rVoK*KE?hn{aL~Klsr8~^{$5sunlCH}H_Xmrl6yLehdQF0 zg}yZkLif6V#!*w@P$R{Txg>P!hMhnz4i3nM$MGjV4pF}RDf$zi0=!`dWgHQdj38WC2nkmbFYO{w z^bo9NocmE<6nXMH-qr_WnI`;_H%Rn=s{JG}R_YmC&k+~NL97w5rC;vSJTUaO{*gz1;%}?)*t>19zP44(yoDoYe6r zUYDB_u3@0A!K%QH8PEd$yBJ-Im+pwAUS(2t$3wfVb^(x4OC16r7~8m5=1xVxvSr75 z6`cRcW>UIs%=vg73xrFbXV#SjWMwS+ytQFYwv@jINEDX#GZ}%5CsxNd)L2h3e*r=Ugd>}e(-^i88;D_A6`)d%@ET-=Ax913$^&7mVMjE( z*Gp~xlxPxS$W70b&5B^~Oc>>$)x4g*H5GC{qa;uz!W#XFvP>Dy5uL~so=#qXg?F}# z@-4r^BU}*%y`BcMU4!FIm18t1-ioaLHr)TfrD_MhME4zq)5oi~Ue^o~^zk1n^0sjNW9?P@sidIa<-8b+Jfz32=9yaUTHPx!SyM6^T)>}*8U3rWOuRFKMr%i5 zg7h6BL*&XRG=8DE)Io(KS`LHlau?v>%rq>~T+9dIGhrb)dIXUW>?`jU2&r-+A^VoTpyNmbg z&sadLIp@|iT+s>k!L5aPEWFEoP{sS-0_nU_&LC-ZxT!YzL7SsgJ7#`rsAzdoRSQAf zEhxQ1n|w)`C-{CtIWtO2T_!@Q<3Rq~OM4z3+1lr*vHx8=^x@JoGr^1P(AJid``-y1 zA_z=!!bWDhVCx?)J=DcTe#4#k03Qv|PnB&LE+ovc%#!k0;DE$!QyVi^Oo$`RtBz)- z!R!ZTN~c~sJlZcXuA2d}toCp@f5PSd9ws(D*DIf#CpYe+83}@>8pdnN)7*q9{v+(X zi8#ne^-dSIs3Atp44mO;5`UVk=!r#z?CQdq)`rA*XydLTEUFSEg&4{gsWZ`7Ug}Ff&E{7Dt}$_<_p4!yl}d?a*i>6p~cBH~ExEM$xVY#o6TMs5;E zi@8Vp9x|Qn*zgV4c~&$8jo5Mtk)CR{VaTif$ZSOzZP9gq8+i~~at_wKulb$>xxEtHIo2En z!{?b%_LZk8dq=!&NX&&kzYwBq=`>E|%0t>+80g5J8n?a#AL5WoUhjYALD6Bo%q z2uQ)>Pg!DX^+8Mvbqdcn$ZNr{Y1gn|#9*_ho|5QUp>Y;FFL>v2i{}lz_?j&T?MmFu z-eo1C&P46(1#-@;mM)6GkXgsL0!Hvv2&`Vu{70QjiDBaDJ*^Eb1_7@6qwrt%AIJ8) zm>;!YrMlRA#WA2(IW)#&o7tagHLZ2@Rc zD`6J~#~G9%nZ8Vn?9dBK@AB<`@bH7@iPdc5WR<}nJI5F*K}EdBw$VQEcmcLy$Zh%b zDh;?Gc}6(&T=Epjgu~(vXc7m)Xy}_&ZPdT?9M}X?>`S>==TTNy!_nGSX19gju~y3y z2`9rRG;BzVGdR+aU`Zd%Av#~8z$OU=qY>u=E%hRusSAvtn)TtxVg=RyR*WPw!TF5+ zbe~$%=?>+S_z%#SsZ}-*)#1?m@|GX5oP&QaOQFntMlzwhZXR zYVb9Z$iq-rnOVopfo{Xz7ec2H(=pL@nEBAjTW$DT4{%~Nn*oh7NcjR*xU@Ue z$HjgPo9)mRYwb~5Vd=-s&YV78cZ#<0OwDugZ`dtD3Fvs0_p!oo>8o%9hN|lK^cl`m zHg_b=^^JdLheIzXXXvuA6A`IE!50|{{<$URdd}E(rVMQd4!@xpg1X31@l1fcTGka z{RyX`8uJ9NCchGe!=BVciJ{T?f>@tk6T|vn@~b5RAGBe<(+PBsFA4bCc=RY3(L_h_ zT!-W0QzLpr zk*o8}p-1qqvpHX`Vd({hDa`ne?j`lx6;<_p%!n_^;q_;^0|qxoPWisPAj z_?LR`&;nHJvmUqODRE(TCS`)h1OJl>_!BND6luMAlw`rHQQM38Lw>6*Um+fc>({_G zO(n6+vhmKT;0R$`1d=q1dG;3GMWF-5eeDo85iadth2o-6%D~X`*l<}5&%hQ&YPx4; z%DA9yM}%8)!tuafvwx_?hTe~f#+CVNX?OBd9^AK1;aWb?`kPw_yncqJqeSyiE}*MG zW%_Zsrj#ZvUoJOM{;v-|;$A)$e(H0fi8({j&-j3|s=N}Ugy0LejuBF%J??L2dDO6c zU#|#iQZf0%1Ua8lK%UY*B)uLXzCF|@iHEAogUudyDYZnMdsL(`vqmqer2Z&u6O+3L zUr6KSuRI)w@@YJWOxh34BM-I(CZfcfd5Uh2dpcG7b;=XxPv-tSSte+q7i*&!0-!Qy z528jOIGYH5vY~?3m&wU#Q3*#(={|X$>wOXJnhYHtiub{tZxpne$End~dT%!k%RZMv?wyIn3hMN$_+fn}5ADUgL$7A_a)}*X8JDI%E{v9gE{+$S@NKz*_p0RL6mR|o?_?l^zOhmH2zj$^iv?f9GY`(-@lfWK|R$OkL;;1GZ}+cL@P zLWLHImEtCBq$4PJpm_EbXgeB=^?7SUBa(o5ny85EBCh_BKgXM?GGZLw8*0~|Qy$Iq zMl)XtGR4df9)^f>W`QWoG?L8CC}nwxpsSIWvQAc#mnO*pXNS71hF&@R?^=369v?t= z^k#8M?_c`Kh_f?N(;E)-CMPhW)-w%JvE=2!apBM<mSW~u-ALxsq{iL*RWJN_jO)Bkvs4GMe~gL z4Dya=zJ}eNPW||(Q$G+fr~a52r@kgzcy39~?c5yu5pbAM3-A^cW|9<|an!I0GmcS6 zJ{UQ{jFD~EY=a-6y=X5=Stbt}A%G}W852F)p*&w!0O(0kPso)$ z33>t^Dqb)Nf+AjUqE7*^)WeO_3!k1a_=b(t1)gXsk7edh65O#a>XYtoolle-Z{L$K zVMH3kARmxtd(b<37J>e`J$mWEaGIgo-ASm+IeTo%juIx;EFs!A;iIWe0UYg!h;Pq1IwduzJa@=B> zgRkj~*ax-g4A>;M+toN4+GvSJPH6qyD={qdOb|gMK8W7}QG`VC@JM~eF1K>JQE`od zDw73%@%`og64^%%1{$_j+$Wo3^hS1MzUX}8HsU#Qks#Nbm;v&v9ZfNiWdk+ z^6_@)P@dS><^GA>oJgl|`6nHt%yV|v>|yX@F>Vd*&l4KE+)WhD_Jp0IcIcS3T7gA8 z<3Oh}os9_rd{DK&=w|;ID=e|+pt0w5nE2XcFC}*vDo+ZBe)18CWGw}_|JpewK%8O#kueDx zKLUu?4O>+G4g5L(Z}9ij{{#G$)3gtN$Nk^KpLg~X5BfT_f8u;@(;=d_213t`z|+|f+^Z2tia+{i1a$~p*ax*a zxvzFcHJzFXioQ}oqPPcY!%A*S*zo1CG?>TClHMBGkc=sE8+2yS>)M!nCyPyrnH7HK zCx@O%=CHFJI@&r0wgv<%notfXSE-kwgCqJqlbq~!I=W2#e!`S9mK(TiI)`L7Z7vHP zR;=%GC-I4BH#AEh`n`aH)9jHudh)h+yG5gxXdh0^Y{#p@P8R*Zj6!R}7tu{2FIr+u z?^T0WRp4F47@jD*k6h;;7p8yK{<+ zOcI^o$Z^E^8d%_@y!$8yJrWrJjx~GCI6g9qp5{cI>Yu2i?*r`th%w{K(@gLd z6HG==5ePAB{3ZWZKKQkYsPiVGDj5@JE-7{onv<|g=AlXGQC3{k-uxg_O;8x4Oh*cm zqlrC99tG;hASB_Zm?BRfBo0Py__xbb97)~?_Rll2gk1B>z z#ZXMaCI)+G-)UWk_GNoNTFyLsws;Ir`VCLEIm~}UM<{ent#eB?L6V}*Rjko_VF#R> z+A_W;T!nxb@hclC!UnkjyggMRbf7U&esG}*g1%b+V#}S%t8}|RV{EZ?wcL!_VjS%$AfM#>27qNhLocDm`q7?E<5h&gw~ zFn#F>$~Xe7h24z6cmd-=41)*;2j>AXWg4Hk|IDM2G`eW!DkP1!R1kGn!;7W1jc34& zaDnQ|tYAaDhcsl#jNBL(m@&d`N1edvA^!f;W{3+IVjyvX2SkfaA8<2~$7}lT$x$by z3x*$|ZqYo8Sa(D5NTDwZ{L&At4W}?XfjOw$=Lv|!a0?)m3qx?!I6)jUQz1IXBvjK; z1NV_*xg8M6dOP6h#PQrXC=kD-!o45+MU)dK0W7CDyK=c_ooC>RDBfSdpf1Su!&b-j zJ{7YF;e2h+SWO6n*8GkdmS)!bZxsBIHSbJ+|7 zx-*GOTh6Sl&g>pjG2)oy$-ET0N zk{Zzavpp8)RUQr3WVBVYDJjP1RYmIjrfG98ojfk)JnKH8cK^f~LbO3U@SJ;(Ss1J1 zX|iO?7SG7@dT!9%bVY9(gK_8j+9{kst)5_8Tt5YiW0~v585j^qHL3H&zkMGk9wmM4 zfC8hh&jioK;C9J$46Sq8c1zrn#A~nY%PLCbP#xj#qs!bl2RLJJ{j3dcAN{ywx=~?W5w=ns_ zfTC+)=}zaZwJS+a*^#-MDLp(V6Lf@8a`H4YUTiUiR5V^bXuT|4^G1AOkL|o<_>bv@ zxcp#_)<~=BILxJ)N0Ccr7@C}HV93aixukcTCUBCOz}_YAnma5XlVZ6^K3WU+f|S&` z{GpOZOkzo8$2US+1b#}rH8t)O#+)|U#WyvcMH9iw#{4iJtPCyl zEoBfzXkXMO1hk#nMqqVz6<0#Mf=&avEbJU|&&nQ=YfGif!_NYMxzsz<7_>~pro6nt zH(l0+>JzWwMy`Jw8vdx8jyso>;G8fu)NieQkVnNFn^v=vzqMhmhL~`XT%YihmK#*^ z?&j>4i*CaCD)Fg{ZsHo^#2FXOyd*Z4=hp2bPZ^PTrV!@m_Fhh5G3IZ+I%i$c*L5iK;JEvMzFEv+YV-Ye}Z!4aLCv%SQt z#ZiYf3p>v>13?pfKYg5^?CY=JVr`gLh;6$980uUU?@@_i12LEqpVb}?f7S%F`fLEy zQ=lE!Pee{@bp_2j&j{ZT#pVTA9H);5+k3nA2z?S7s@A@nL68!=e*i&X4CGxD4{T%i zl=IKTsaP!K!h9WdzBQ^|U=rT>XA(^qh8Po7WeWS3zNeIly<<`)_>M`9GkT2Zc%609 zV&Gn>R3!BK)?%*L%?@%$*-ixzog5*sF8&YJnuY$!R{dl-{nd$90rSPS1qA%rF$VG= zBF;nQr%&+~Oht)o^m#qu{m4L@(-TL0#A`oJz{tvS=VR(EPQo$&^!NGwRf1tIr_m|f zi?DFR@snChO#Hj^0gBYtiY<4RfM2&4{jWpM6MWn1e7<|AoR~jVB>QBUaFZdJa`hpHH}74vfG0G1)i6Jt(SzIVSm&+nZ%@UeXP2jcD7+Y3I&SA>5Y!<=HG z+q@nJRj2m>?luZ2NEqh4cK6}(n$31wcdgSGS*M|i9?wi_!#O4JGz)dRR}C+S%VSMI7^ib+{z;5UW=Dhd)x$_OS)- zY402XH}icgbWF;fMH02pa17!mMc@HH4(@fty&(|xZg9JPG48noW8Ea z-Js0$bsC7i9sS{`8PcGP7lH}Y%|!zHL2e?c9BzYu4})&2{Q=fK^+7gC^p1Gd0)hZz z@5R=4e=xJKK$ozJHdoK^l_F>+_^Mvxk7^JLWXsfKiwL`NnWRN$Idc|;o@Z69>3H6G z!C1Lx0rs?PV%Q0?^bj>+dAwX1CCs;-#UC_X44Ww#MC$Fr)7hSctWssY)epS^*e+-qp$6bF4vH}A-9EmuHo?)lYbnhZ_ zN>>cvF~)Qf5`YvvleydsjF@A=53%9c5u{6^f$3I?9z7>Z`TX@)HMy$sGwgfc>x8aQtZ2+PVi#DXU{S z-`LJ?wF`edU?x`tmL~p2-o%_Mr#6RPX=Ma_q~Ksg)8P~w>CZ78CRFj&W?|P+Z)_J8 zeKxe435gz4U?gkCHmlP$d?_^9UiVHGabqF1Tb)OnYlfObE=4}zc2KMRH?$q8`70NA z>y~gc+Kd;rhMO?#%oT;1Nt@lzR%pi_$Pb~LkF3tU5jJ>caxX1J;Ur!cO7T9`V18iA z{2$`p1w5+iT=-8i0~sK)2SkmC8YNbA&_-iha8R?8nPd-4xD>f~s}yXCmsW%s2uip( ziDbGQrKhcz^R?BU)1ITJ7wqK->Jc&_Bmo2xs2ao~Vp}JU7ZghZqVxZ~YtKv)#GZ5d zeb4jfdBUu{_qwllz3W}?6@|s4p(|>FBBf*+)n1!pd>64wmkCxiv3GN}hYt_&2ntv+{BAhgoMlX4H>-gh>lT{b;;08Fe@& z4!e_I(QB3NT9U)g9w&YcB-qC_XUW*Erx*_fq>q_5?6K`!-{O;PQ4Jmf zSL{su*GJHT+;#y=@$i2g8EU+n#DvvYd!;0hZMi3g4}nT#0A@s-Z((aSq)WB#s1%F9PXb ztyXQa!WsI3*hfQ92g`+e6!3PmuQ{ecw`vDb2Q`S-cwb!%cYkN%XKx=*)kHUmp=~g_ zNsMfhX9vV#+)Ig?GgwKx3&}w`u#eycE;bBL4ym%%2V{D3xgbSaEb|+JCT%34@q?TP zpx+f~|NnR!z%j1kAnAIXqb735fKTXXHr3&HFYeXbxt2Mr7sP`O)HZ_)+Ku|B8D{|J zWf1MCfVwdL4)pA^&(qt>d(U~~|BPh|yW{O6Zf}o1I{cTnm%l4NX6cUjw$mIt;_YrC zGsMo>IcB!cvG4ZwzfAu9gxkvx%a7zR9J}M~1{tdUefu!^{sZ;a&u%aOSbj=($G44G z6TfHA-`if=pJbnL(x(OKSKUFrBx(1Yy(05>^md*n?cwM`tn ztbL8XbFcFqjEnJlwDy8)F<$RX9fB}JW#FJDolk=pE)}MTRZ!Y~dt6$kx!ap`OCmx> zUE^S(d`E%9ZRZqqA3NoeGBO&5aeI^QwpJO-PnUtEk}e~+ZM%$9%E%-!Ikz|IsnDEO zN4gBm*mRlPOc~vb^hoBpNy_?4yUfy${H3p%rN_9{3I9&=9*Vw{%12;o&rSkSrPmy4}9gb~2wY@KyNt zGDCtU$c*Ka6Rk!d?Ta(BGBj$IZs&sYj=QwOvE6ilEw>T-0wwSvX0+1DFZTGAF1#Z1 zQy_<65q~|IAwe)Ljkd zD|&jhdM$GN0wYq-Te081jZY(es%o5sI9>Z)J8!v&=Ozn$+3c7s+rM024%=k~P@!6T z9og|%7%Pa$knvIu^;K1Z=?+qE?%puT&4~ z>DK*ycr~>IC9uL@$w(K{-4Ia(p3JAXx;uF9QycX0?bsmM1F^~zIO#Xm{ytrVfaPoz z7p13srh8wJ_Iq3ZeO4(8a z{jI~~ZNB~X>-xck-*`+@Bgb_RS)=}K{V+7_vqyI^6`p!vr|~7ol=&K`2!0V4R8w-b ztVIS`*!=+_oLKqCdbYj~6F64>kxu^rHQreH;Ye@3v39kbzv(*c_BK%J)b0I*FVapm zab@}pq$;qGqBimQKcx`Q0n4rpdaIa`yH8yYKs3v)hu}2WW%X5rvn+`m5G#K_I%Uk$ z5|bb_7%(VG-e6aFUjGVDSdR1xQ=!PJ=vXG=2T7E10UW8%O%3wmv$WBxuvW{^wwB|^ z9V`Dp+~GfcjK++HZ*y?lP5qwb%Fe-nrXJ^uG{xT{J=YpqIfL8u6YHM&2X+Vyq|E`Ra#uzy1@XLxsNd z#m$#X;DB5yd{(&1E({THa^ZhY7p}Dn$3``fhiYEWomrSWb4;c$cBhKl9PC-HmEBXw z9xG1(H^u|^1BiD#c(GH62&A#Lmp-<&Q=@$?oVRbk62jryPSmD{ibA70JI{g3d3 z=Vl`kBZ1Gvl~O>zb|YiiNf6%HIv>Lb~9M&*zIID##?%0K>V^X#Cx5M9R8UK zPd%d5>85CINp@o}gR&iD1euL-Zupun+!(VzumSKYY2{QvtwH$wzq2hyrEB;I9D2$c zl>ZdlqRlbJhQ=2uHgE}_mWnb<$T9fvYCRV$;lq59xjhv&{A&gq<}Mw=JdPolX>yK@ zTITkzun#7{V%ORgYP5)*xei{WXD*G##>hjz4>rC8hrJDod)i*9U+Ufo`aSIG*YN@E zyuuf%$}u;|HYR1+hX$$7N#`TS&+!}n4a+ zAH8QU;1X#(vw#B5kf^ql?}&xI1aPR+BZAYE>2*X35Sij;b$VpQm?Wa3{|`E)^f3oR&&2#On#e- zl=%L;_8i_FJ&gaaCEwu~`g`*-bFMaCKMp;G2qpSG|5XDiG zBt@Biof1Rk>4Mv;g-qLJ+<$}?o^Q9>>)27Vq z88n5(AFwGjQs&75TTV@REsDH>tm3)Jy~U>TOk43>K%ZQqLLJDeP@7p5YSUJs#<`y4 z5*j8jLenqum{p!OMR__9i5DU`)MvRV1{Z;}S}r+lvRTU5)LC@O_{j0ojE3*aG=Jh!447|*Q$(*K-WF;4jt`XGKcw_<#ogX2p8UfAr(#3mqS@3(|-}W^(|A=16}SFCY40kcvT^IV_mQRweTBq%%i< zxJm**Y4)()r$-=1vV9t`cUJI4`eZ&Q6w5!bcV>0l6HqEmr1uW9XYZZyOlg)pDq&`` z4_CE0zzH&`CqQW@P3k>qO6d*xq$l-dQrQ7~+<#Jq=OF{Y=03Hm9}0%V)hOhDF|)b^ zS1M~eej{aS2luNlKV9Ed@}NuR$%SdfDB#|iTBa|_~5*EvbA%D*yfdr&$32Q^?- z{wl0~y($8{|G=tje%oG^pHR^$S4E>XSrMJM3UJqn3CjPjPE2ZZNYkv(&2rrs2=twJ zyAq(kPCn`N`HHlY0r~;!a}Hl*DE+4LA6=UN$Ey;Za`J-Q4TYT@#efBw#h3r91-Tr5 z0y1R<(!{B@$^T$MWQVdKJF)<@nbfKK`wPC%U#@Fgocw0P3E;ln#WR*A04gps(!rdk z3>8mrx64`*m>{!`{bpd<914IWV`|HV06_SnM!l)rUn2 z`_frjPB>TOXlQMJULKD;16C!b&f4^;PkN}?DR80(J-;HuPU#KW0U|`jR74!V71^29 zwgnuKBJOq(Gifx8R;#~-uM!H)$&d8j(2vr97lJx zuBBdMgR3TT%n>F;ws^<$@OrK@v1(fO#=Xl3#=XkZYbG%yl_(|9yuJ{lD;2qEJ zjj#A6!RVr*4hwHP`mt{C0clXWW2)WKq+2`WqsdA1HHQ$ay^ipicB7Z}HG014q)k5N zhDS*c^TMaekKJfLhkV;s{1Qw2JM~ zd#UqN+AF0Ow4JIXCdVS{NHo5wOXHY@Nf!5g23mu|G8*+?r^=p6?Um7J@ay`k5!P<% zppz&PT$Dmt3ZLg7 zM!VOcd>q^l(v$K~y5mA2B3@|}A!05~e4u_R{iTZxv&neiO&MmSZB#}cLkk^hTJJ=7 zd(ZHx)p0A)a~M^1hZ>St|0gcho93X8*|qw3QRv)Qd3t2!>5-M|kqv4*U52%3THfko zlIzstAJjOET*|;Znq(_7Hg$eseUj7IWc>HlSrLDS(?n?@(pKd2GQj&ifK;mk_??*> z@Eo8XEAq)I<00V;5ELsIt4^33&)9iWz69<500eEXC+|NtwXSV2c5dS&JZs0wiu58^ zJ6g-zd?goLe);9V6tZ2!S7p6~3yK9!L=G|cIelchVmpanik>2yn~cSoY{#whN|wBBW3xBT)K};F`#am5Kv3X0_r}L z7vAbq)#xVxNH5muX z``~H^5`uyeW8+!R6KQ!{#(q~v*35*zK`VNBN$Go5^gp`v<~tt!kApg~FY&G2C<~x3 zw-9ut4ksSjdptD}pE-mgVs~6qSvhT4cs5GtSdR>QRSQ@bid6bv`N;i9Uf*^pm<&65 zdHtY%{lt^H?j4CC1M9vzU3ciI?pvkuoSfX8koTIJ1))&rs%xfQfBm%3W!HQwyf_s4 z(lu8sS{@3Wf6Z<4@BBrm@S4z)yM7TGK>9pncU7xXaYmeBo2{!_&JPT&u#9i;@AO*!2{{fHv`LamX2 z7GPRK9QFp9d5Ql*-_eS$O_0l;FeQ~ddQeKK9YkqQ4BeJ#H@tM>dik)@V=2Nqt|lp& z661D=rpCikhuFZRwnlx!Pk43K6>ms}{O!k6$*+jA(!#d2va@8)bU)hG9@GzlM0Y24 zqk__}GvT~w3DRiRRCIvQf)p|8%4+<&FAt1ztpNNCZ%JcBRM$2B_NiH-ky{4cnOdLO;T5!{P!A&}a$ zer%p?6K5{qd>EOvY_2}NFL{PG%=)afo+0kS85yTt4^#C2AQ5M4se0kiZjJH^-qa6@L^JE zK1R?)G$tG-O{f?bGE_y0nlj#u78ECk za}CL))7C32p_ssms+A~#-K-_-C+&Alw2DoK+UHX@;HF3|pWwr9S7aZpSQtfE>WTsS zg%z<;Hvy$6)kD9_)RxQCeti`GO+Gs_Q7jve%&#y#n32iMZzjq7;`d-O^P6^oFq!$y zBnz2B?Z#&EXrwCXf&02c|{mtC&uUtZe&5wb>^Mak#lYoh z5I!g%e1bqlj;jIOIRe7d1ca*ugr|KG2urjV*%i|PVZVBN%d;2c}aqU`pl@GR0Fzl0_#@*9q@&4Exl9B=IkH ziaATZc=249JfECEZ)FC0r)Hpcstvs|JJbF3e-6#E)ag=gkm-FVR7pz1=zXw)D&H^N z7QOQ-Z}~t#H9rri)j55DN;(awb7dI>&1AI|``j$0;T7wDpPGTa&^9&WDl|m_R$TV& zH6lOLa4L&&wuT2n*M6NDLeaR5`7ay6f7TcKQIITW;9J8qDz^JDKO^%f*~RVh;mmAG z+_(;t*vojDBa1MG%k24*M|;8~WzSe>khj9U_#D~GdyV@gB#9}$1kwN}ehm7O{^$($ zuUTS7XI#~{KZSpY_AE=Di<>2T!JBxQVIz{%TtxVXOJ`%gl-~zG>`!;+J4oDq#KhzT z9Xse(KoPVC1;#?iuzE z&##_Vtm(4wXyZS9i0hfq7o^yYPUG3DgDA+njc#?e zvDf&A>?eJVXzpsKm1#?RhOOiG>2s0U%0)+rP+NGkHq`-$vm(c6)hMngEk~ocqO4Zm zraYRuWVx$&Fq_#|oNun-rkBFh?k{*Y_2HweeyLpIW8=Rg^93f1-IC{5F9$h{O9twr z`f-C}b|%DuIqa+90Y?j1NeqV3`rDErA=pspSb)Pn#2|!2utR9LeM_gAVs_`;q%3oV|3POWryX(H|)|O zcI-F_9dfj)D9@P5Tt{;#Y^$J}TkhLG37fax;!c`IP042u_;di!Bx(%U?~; z5M30v#xfz@-ajq71&f>F5(sBK*-!^ETf$dyH0wD#<%npE_x%S2^T~D`Xd1qDB)aq^ zye5evxpV+Ua_OB>}!y0m)P^uA|Ao}?qyYE_{byQ>(xCo%R>Co=a3z{#f$*%Q@9AJQ|i zRj(WfuK&y}_FIm&RI~b<-lx>_xtYRp5GWWhP4*o54c|e(YB7l|5EIHX8wo2tQK{{I zZ);fS>pv7re>tbS=OCHydx2Aa7zkB`mFabpE}JN(GofrX423>7eS5N_`8(@6u(!$6 z(raqe?>m9nCLmfRw;9_JYBSp=G|cjH>KSXB`L3s@Rs+^CqyFD{6Ho>UlJKQ_z02Lk z{XgVYX{tNM53kP=U4Pkm4UCYSI?KH}3z1ny0I8FiFj@cU&6X)ov@v=>mgsdgrG|ic6mAF5}5rCb?RMW;q zUE~m&G=ffY+HOW$aM)LYEWZD|{{k#8j;R?F)N9Hdr+#B&yWa@5!>G2|sOaiDk5Foy zq^6abq8#`G`VmxfEC~a3t=i&ghHS%Q?{;DfEV~yQEWvc(#~B&_oVglvhlZl)i0v2F ze9I&(QPdu#!I=Nz$o;T0F zq?6h%v1@x#%^{x6Zfsl1=pTj8#wf!3nqnNp{p*(d6Z0FLGd?-ItxEgfZ>t(lPEFu) zW)Ae2kfz@={3U(gG-skHIMg|?P>IpKVGezRrPa&{8mv0dD(J5u}fj`tp<&N(6 z?pj=8@5nG7o14R9v6q=0P{XiN7dEs5kB@6)IfIThvYZ5VT=wN_G}69SNJdeFO(OIjF`q6so8M8gw zNOzvtCQH039F=l#GW8JkQjvu^v;MWK%hi)KT_B!a!3k?kEHvs{S)2a$7WNkfN(l

RuSIWeLr<*C!}~%c#;9)JsyMO>x-?#t|P)3q_Y-><%UKv zQ;Ei!1RThjxElAZ+&<2b9CNY%c~aW5Qq$*B{{+?W2lDaxVqFys_eR|v;UX?d{AJ;B zqPvBMQD6chiAFJzlkV|1F4a!?agq{dZUHonu({HP#xV`4aJ?hP>2&PJ#j^e|z6)V` z7s2#CS)kfSPiOBNMPTIE<4-{lYTfe_BOIbDiNhGeLHE+xkW}>4Sk!NVc z#vg00E~@mEhX+UQEyxKEXH&b$u(-SXA#!NN^#&5^UR1<)s;|4Y_AX1@*d#+W8t&pl zB;_*hUqFILgSI8ji9cWuBw_6ug8DUAn*uK?9Un(L zK7~02%34Q!(TXtvoJ9nqOWc*QF>;{hMDHsMI$ra`*1$qw@z>2*?Pr}Iq_nk9-+3fA zH8avgg!svM7LacZYqw&~D361yV+E$XB1=9Km-$p38&z(J@1z!SOLLY~a8lvw*qDkb z98yr=0dK2VM3gLZwN@16s@5bH7kkBc=;xb`r(`)xo3^GGR09kPAh#}H4A!WiQSDH( z-v#-U=Sh~c4DxFPPPl^jOaH9)V7?%Si7Hqpz`Br7H!+zQU$iLTcz6*RxoBe@dAl7z zn}?y=u^fqEI^p+LxsA0WS!jT%UW!6DJp4KZz1>FSJG}Soj5%KvJuKAX?!TEArh2rC z?=Wh)RK`X?T{*FIDkx?U&Elj zUcKE&VnzD*k2H17w-$wO3*Tf$PB`m)lId3aBV=0Q5A;`j9(z~0jR$(z<2vBFtQE^7 zVF83qC`{D;3}@=t%)KZlv6Rx#Rvp(AeS6Uz$Z3kc{oO^O;n&x17hWt0x?EP%< z!8DJ7$y05}GX*y`_2&tFuD{Fe{@#NDx9)G}2fDjr00@xeNPg+9FE%YVG3|i#xP2mv zbjlv5LKCWSLlK*uGM|@TOMFfderx;Ip_)Ppotf=+GxVYM3gCTXahG0i%=d&vLcd+~ zo9K!Id08^)x<8^7BeEZq46yCyYI4to+NIPCH_o4`*`dY;@&2=+$Xalt%Wtgz5C=(( z@5^qAIWO^+JB_t(@*uuIBrLSixR)m`08Ve7v9?XJsaDfi-x6uckM}yP#{!P#fFR0W z@k!r^f1ne8HtN4eLe77dHD``N3FKu4t`AK5?!1Dwgj7x{lzZXJ2g04%@%(P#UCJDMew)OJURH z#?^v0N`Adz|H>PD-u-nGPU>Z*#NKzF%b`mxhZgi~yRg&lyUXp_LGPuuB&xV})dMrq zgwL}-MQE%~VM9FJqTQl1r?OQv4aB@_gkg)LZrOs}-+*VmzX!a@zz;koVZjE~H(lZ< z4$0#&?P_2+*aa9VB&vn6Hdk0MGq~ZsWI8$$KiFs^*u$U@K@ii`Ua?G_^lSU|KB0Yq zgt9c&`diRL0x$*qZ+dBJbs=0I`}0>OC|nWJ|gMzMQ04f z7JkO?)~cf16S^};cpOS6j7{azg97%n^uTUq z&amkD`8lD@N`Xp z&u6UPZmjQ&H0R^qlAv2lPM3&Kt%$_KL#)_kNol2s#7FpyOrC`of&eGl+RJz?mGR+m z)@}8w3v!Hx{q$`0sv`C?emdv4!$WmnyTt%GphPRqC2dD1JAKiiV3Dc|O`Jc47U=({ z@PA(DEBx;ajfLVV3=I_}+??(${MTAOIzN5**R+)v=Hw=?1~UXb$;18TuJ zqHQr`I|jD)dC0%P|JU;*_`gKs z|4N>~|4_!c#@dNI#PFh>fcjqFY(1v$09%c6L2}iKNG7`>s1{$01q%6M&YetBj?dGs<%uA6PHL0$P2>c)8hoEMUwK+fb7{}6 z3x}F6mwd%fgyR5}uKKNw>$EG3LRlD&;=78+5r&Z#-?G&EcBB2`UvO?$qe9aoJ-A{( z4?KtUJyExhps%HQK~IxO;5nSEgM@Wo4mBKI$rR?bG*9W-HMX4#2EEB-WbPupu9c@r z?({p8cuI8jPtw%~bU;Rpa=R_zGDvTw`?|kbdZ{e!8_afr!m7pY#m_@GSi`U0OmYFT*T_obK}`%TH<#&R`8!> z1-0%Dh=s{uK3hbp68%W90kqZK0wz|5kt~i9%J4ZS0py+}Pd|F=EUp*gF_(^20a2T# zA^ce-@hkj}-NQNv%sei~kCcGgiV~YBO1x=qw)l*}^+jAZmL+Zq%Fxzg1??Vyqi+Xi z`wNXt_CRZ*#8;K)XYJAQ3|VG>mm%{!)P82XJaD~~%)#O-c!1~VXVt`um%or_=2M<^ z1vOEZ9Uv3eDdHNA4J}BF?VWv*T^gN8(}y}<1|#Y(j44w$jAxN7#|;zwDuHVl>6tjG zS2N0ja@Dw@B=YHP#@hK%of6EGm=k59MlEJNKnh?Z)+^kWPv?aW5R^9T@pdjf4>KB< zNw|sdu7>wCLH^ts)Nc6W-Gx*qHOM_UFo;^TG~GPe?uTJ|w#ZVy#Q=S38=`8AC|v<> z^Riz{am?XvfEIjqxrCX!M^{Fl{_5&;!Dtfe=CEYNzhTBtrpb|%N$2Xe#jOIz+H3*w z*tzfhG)}}s^{d`HB|Pgtt^l=9V)X;hhP%bAA$nveu=Y_fsJBd#@Y_vPy;5Kv75x=X;=^{g4%Q) zX)96rZW~Yqur*!#lXMX$&NpObDh81-;bCsV5QG#nv#BCqQX)&k280wUu@w&8;H{K4 zHaQrkydO%|TuHDWEAlwBC9TN<$M$YfJSQJkh)%~IoUuBZ^lY3<4O+30|E?b`J+QO@ zwWHf$o&bXau@74-5fb@ke#&ayfD3I=wCa)qDT^3d=zzq;k0JbQ zexRtmmf32rck;WWzuN1qTh9OHwK)y^T|WQXoLl+3e8IIj^XL8V|D;?7OP1jZJ|mw- z-q#5;T?COZ(=VKovCB9M@4tjU_P;HL8PQp9paJ^gNK}lY-+2{{ZyYVXO(YFpwC)8w zoFzW_1?rjp4ICMBl|QLfT|)s|8?{``BKGZUSD5(T{v$Qq`AbxL%()u#G7*pvcCASH zdvI36rt!8fIsGX|*qB(C3STy{&Ji9ou`WM!S(N+PyY)YUDG1{&5EOL*+S-! z&b)VG-7qO;gwcZhaq(fYF^CP%3p>h++HylNPUzk#tfj*f>oyn-uY#O)CW}n+agzSn zi!Q-t-^6c`<3Gs(9aeor3{OOgyDgLtcyuPh$IO)YI&f;|hR+vLLCc|uJ?+eb&$BI_ zC~O=|64xq?mAN|MYOLgZ_a_@G9eO^v_BK{Jd2^((62)r$$X%&PCph-(Hz@M^H#AN~ z|9hvev2qB|>ua1kO!r9m;C8gML|D2V_3yU(oSW&hl-0Q?rde%5CltvzeR`Z-lxefe zY~|RIVa7&9Q8gFE+wcD*y|PBbulZPmzWR|Rb(Vw!y=6D9(_Dgz$Qz8^*_-(J6UPy5 z?!xU=PU0~;9j!Q#h^3Q`L?rXlnW!a+cC4xVIbQz@#sl8~(*~nohMgAmzkp^uw;KNu z8Ym>N$%>x_)pyuCb(?9mO_boT{^@aidCoe5ElKK^Y{WE(>`0yQ)NO=4X9%Wx1Mg6T zKoLz@r-^G*IJo#t5TIlE>Z);Uo8ezpE4T%g6O`R>1cc{TmP`3R;IhU+EXdLmmt>bD zl~n+^%HuX3CF}~mSj2SO=f&RjKS}tb(?{W6(-Ap%BDDo4OU#k|t?(%AxbHlM2Q@q>RF zgyffB334k-p5}Z39p*-XeimFy4-!+grnFd)0NML>?%D#qutsE_JlZQesy{!x;sa(K zPm3`)ozGUh-&pmbs(4pmwCW?C-)*cq!cVHP>SKOBYpnX4syLy)9_9H&V-?Dp6^_O# zRG=#I8mo>ehyDnX=H(~6{G_o82j3OP8>>E56|ncI7v_6KZ(~(T%{-iV{ok`dC~D4X z=Enj9NB=qdHecRW^r|TzSF5QL)ahKa(U&T?QX*%o&cyhm+!$v`nY=*?&l4MJL)2*@_vPg*Md_5a~oThZ%q zJmm-tm;Hd94MJ`(*-=?=ZRsI!+-p4eI|v6Gj$dKLd&Df+(0f7@t8RJ2isF+eHt1KK z0F%Tz)CDBk`=AN&Fp3OG5VxI_+MJ z^O(#@V*d)gjX*Br|6fgnm7{Kel;0J9I}h{zx8MVAi64hd?R6z?J&Vcw=_FQ6E>`F+ zMK?|0L9Xo+AnC>9zVNTn5u<`;(W!3-5kYz9C5lhig(4?&uq8h%VtmHp@maXiFPt_Y zqy0Tzt=jvtSnj?ooPX`Q3xh87rO&_mViA`G)nukJPdjg_=h>%jbel)FicP_%8`eLcEC4QefP_*@v5nQl%q~*L2f{JpgLZY0Y2WqmJz9M z()|m{YJk_A8WorqRMxye>YIhO{f9D(kgZKDpBEZt%YgvqoABi-Y~I-Oa%pG6L&Fe< z$VPi=H5*N0Z1_|KfWBLuo@hYnLUVC&7$e{`94>LR8llrKt+r9F5 zs!!9`E+OzvA5k^s$ZuOM2S-w_deLNAHJCNfDt%CJ3d-^G$V)NxCgf`UWf#exI^0K zE4mmD>q*mmO)yDG^43TSt-kl6HzLr~5B)_a1{tx}Nf5b6u+Y&mS8fP-`D}M$cnf$f zy3|d08u=2L=OS9Y{|Ot3&4A;Lk>l(a=JQD^hlTMlIPy^Bf)}I} z{Z;A`6eY268t$TXc=!#s@vF9UhxqZU;hN=sF=bF1Sf3xRxQw{GqK&%8De8VglY_488dT@B; z#@VxG&Fbk^&GE$fjt<91$vnr0Fif5RFW}Y7QRGSFaux~K9%6iv&FdO^_v zwaR6oB{vKNUqu9xNo`4oj^8#Fe=d1zj*0Q`Qo?AgD4vi7y6&MA6!Gf>fs$%fDRaA- zS^u59*VF8OB1+s-HC*O8J*ifkzlXWai8*8P!;E8#JvbQkKangz5pF#U8qjO?6VX}! z4gv`f=1533A03BBlNZh91eIUTQTS2;%(C7NDE~s4bea5Ahw4h}L#zD9BZnMlw)W-` zny<>)_f$pMHp-?J@7E*J+q10y+UeK!OeHVQdeSY`jJij1^s$P{Fc>?ZxUhjk6Z?9nUupVrfe8KruuQGLOS_BPcFM?@b z1b`n=ebt_7b+&~IR8JR-W?ulsC-XT`Q(I>mo6AnXTR~(u{j->}Or)b*hy)Ni)1E(g z3$8{sMVX_)Y%xJsCag!Xc7+7f_BTZPuPZcQ3UNVnE9pf z7hwNPhnKU1TL@~e8+Mym$<~T(@w2ckh9P#CjNRxwgs6ms?S^%4^V6^Gj zuCIZYwl@}x#^Hf$@ou|A`@{bx$A!C}WucA#)BI_XF0XmFkqNTYAj_M^(^?zs9>|)H zsu#>-ySK`Am#qs4)f*H!3z{N=uVv++Dv>GNW=6|gIN#^7U9Vrsgcpour*%EM; z+*F}v7X&<<=hNJ5^m4jVY%S=rP;;d|C}cNv(w73Cr_$w_Jt|Rgipt#5ol(?fU2-dD zgx#!A%V(0=Mx=MU(wJ1`N9W)pvrKJ`8lvd6NC52sT1Nny%%d%&6%KUfXx6{NPtl?E zHa=6vkZyU40-l3R`re6Ia`H*OsOJip)L`tlG(j*y58Ct zZ?gYcJ#PkLW$d}_rF)R+3`QT?>cQa#cwOpcJw&%vcqE5)O+PR0<=5x^z=-{p4qDIu z@;~f<@XORzD~1A--;to~Rpfy!Vgxa{E!LI@K6PF&R^#-mQN`#fo1WJ=0gotOeUM z_jSPEiNn+tJ+X2}b_Y_Os9VI}93&E}Bi1kbdMxrp)F?g)dfV#GKpz0L>VO(NIqF0W zp^29(-sh&_i~dN~gKOib+)yA%e1ZYapz$)8ge9pwIL4UyGY=o%p{;T(F={UgotgMK`N&oTbvt1TD5gjn%D(7p z5Bx=#wKeYwCFE11;V^Q^ahl3)EqGckj>Pr>{k&`~`0WIqR8$s9E{LYSW4^`jn+PZJ zxK*tfB`maF7r=t>ze%U+icIy8EH&TjF3)_g160%BN1M?{q+);c0cnltk&cK%Zm9Vm z7q?5Nx0{|FR@4@9ONb@4-*dq8sb>dvG=5JfF-bhH_H+@O+_2(kv-ojTWqRZ6k$9xH zY!zXyb|vP(pX(k*{XzvV(iFt2>GK%<##A#ImmM`XUO;Qs0_ zc%0MDwubKG7j514$DWog%g;RQXnAY-nIGZyZC6X&{9|uo0lQk{V+XeOj-xaDFCD8L zM<0ZaSR@cC(`%(;EcTyz7AhG1dGTsKx6D7*^QL~jtGKqM{8$g_FHJ3nj`fJwZ2845 zrpa>blO#0NmX_vYJ=^uHSnnzZP;{zP!iv#|6Z;>1> z@#E-2zK+^XLLBUvVg=U~L=IdlyGlCIJsH$&!z}*y<)m#AU{Qk(lxC6sGraK&CnSa( z*)P0|ZZ6nz`30VRszCr(NHq4X%2PiQXhTwgiY)s6pTM`YAsJv!xyVzZ8U!p!K~%G@ zK9-SH2^Np%?<(F*!T@>2`8GtOAiH9ehJ8s5<$&vTk*d2uH3;l`d+RPG>WqsUcijd2 z@-v#<aG-BJFNQz5}`P)-Ma)qO6`VvK@rD#W&SByb)pSmlYEjxEdc zJ+d{DgFRSu6`a22m`s)NFbuRDwPcJ>&2*}Y0?ctnV%SgyZ`RY{LoLP=7fS}KW6g2N zzUm%T;U>>H;8@9~GsXR6!WcQ5DX1z&VJC%g7#1Sr>GXTH!*kbpI@1-6Q>XidDFnZt zdIfh9$fL`s{{>I8? zEKh=AhE6k8i}iS*r#FcD5?96jlno6H*e{QZZ52cq@@}fA#^DXAfZA?xgAUSv{{B+E zU>jU)@j_F^YfLXegcvr^5a$tBZXw`GuuZmK1cjIrKvz2ho^3E4S5{dK@2x6Nj|UEL z&;z~+LZHUqDGGSrLFb^Axs!dOM{G|V0bE~{aWi>lYL|}CfgjC)r&B^lHtbnBo0?b6 zkgA{v2u;+tB0#U-BBV6?t?Bg+@)=?cUXMSZLD1DR`2Yw1z8I6+Ypj5K#L0R_8% zCb?tIOW|VFUQZjVrUkJjfs@5;Kvy4h+{W!BU2nB&k$TyXy8C9VLAq-xUA>71j9vcH z_o$nQ7*vm1OwtF3NZN*NCN-5DUT5G5>Px%+s4tnB)sZ9cOOzm$IALjzmH3+m2}xO89?1kKV*Mhp1iY z^R97|yDsegzEgg`1H-9=MD>EEsj*Q_YK_cXsvS|*RG=$QxxCv~xkKJy3+}9hP?!;uGf9Y< z={Uf;ctsozC;oZhb_p>vPjFF@`63s7X8Jb^r6SehQxC{sJmOJoPuxp9-In*KGB~4N7z|?FT*t4E^TgY+GOXI-y+h1~Hr3Iy$M9iU`0~npl&UfE zeYtu;yWazR?Idbj{<4XI1%zaIFw)W>5lck3Mu(aEZ~sq@tX|M86I2IP$KWR42jyG= zJ7_8*N;Jt7cu>OuYaA05mk@HXa&>fKyn$4?hnvhUyD*uov|+4^g9p5X6s{(it;jK8(~t>N!J{uG@H@%LT+ z7Vgb(a=8Jry{wDQXo%_*u_x)%s&!W9px-AW4ht)366j!Lm?$<=eiksud0Fm9Q zQ$VEC^!~kurAcX;4&3!WYP3I$+Cy&`0*o^3YvP~LY>#?Hnti2zvurHJT4rp}W`{Dw z#_NN{v>UvTX^^o8q3-b>@WsPTZS}6VVeU>1bG9;|(D$K>9wPo z-!&})D*}?-nfrs&OB*Mc+rMsC>#Pg-HsL^bsO5k#&XTy~r^+fDZGcrCH~T%te&huOU23pCC$S z5J42$@=mU+BYNKG*$)*WrW?BxGrpDKirad{0z#KH>Dd$#!{+H|rCDMwV)7Wu*OKcb z8UcNBv~w~oZ+VKAqu=1v&$cSz8^wmWgvuUr%CVU^RD|Eb}2G2&6Ey3|i)+DvtA&wkG)k$1)48XSLnFw|;ju;Z2- zN1Zc0A~d%CUC7B0j|_uHY;w|?>N zi!60diCE95xz1|U4Jo%sJGq^-RqCuzzI-Qspo|AE$(4hEKz6WljEB$RNzLIFzsKx( z&BOv{Y|`|0o5r+mZ@kW__9ZWi-I%ILZFh8;V_#D{Y8pDi=d50JXHEz%+WXGdsynIK znGYK`(&}{F>Ri3*jvT_#=eHcXw+F-Jszq26w^rSe<4qb5K0`NDzS`-5BO_lIY{MHa z*zY0BJ8j%zJPu5d)xh6$lpl$iH@#XN)K@TDz95bH)pSO&cja{z>iT@=wAfYoKF=PX zcaD1ny!3W6^)j-rpF49_y8OwWsZIv*)+|pj^?p()6<-EnPaz$_BI)tD6)lxz*mT#lw`RyM|4OAMqj4@6Nrl$roM9lG;lqh*=h0aMwK?P{IXV zEzfIO1UfY1wcqZw^*dZb>vQW6qt%QLO%xf5L|rwKxGET3UTZ~7t`i^emfgJ%l3@8A zFM@&4T3tQ~7b%By@&()GTy`h9k1_jctbc<(=tDj*x13<7hU= zHhG%86)xi^T-bLcRwGJ~9*ETjeU^qq3xGJInE!2#$e2=i8g9)K^|Ol^y|LlGg_fFG zTccG0l+KUZ!u=$e9oazK@fPDUJ(ar@8O`J|C=_v;jcQCfsujAwXC5stgsF35kstH_ z@-ZQ<))+x{CC~DCnz&`8+I`V-ge~nzV)Crq$!?USrJuce6NE>b+Eeq6M8bZ?BIL{( z$EV>3lP+Mx2uAO#Ws1hhL>ND45)@Jq9NP$)FZ4(f%oB5IJ{5oC=Rw4PMofJ${CYZ)2m?o{#eG_4aFc%RF zbHJzW1K+f%`vlMI@^Rgt*2WR>pg45mv&p7JJ~nL!U-*$v51(y+(ntqZ-$0~uz%-sX zHPSh-N+X>uf^@bB(%AufJA-tZ(@2MCC%Y00huLr;s%Rh`ZlN0Ke1D|<`m55SMmk?U zvk&PUSY;y}#;w&LrJ~)vAf224r$~qW|Gbn|6=MWFjY+Jd_34yqa^T-KQ-!b%knq?(rs<~hH!7mlj%Wo_Om7nuw{)rI%7Yco7mcbcb)mxJrT zUaGmX*U>3#Seuw^VC>zN2Rg; zt|sT?*rX;_lOe+3bQT-y&%!!9SnTw9x;=4ECp>T*U~rqqWZU;Q{&1P-dj~wp#`;k^ z_4C*+#w&SKV^`%p4O!Ym#?lv13whco@A= zL}`83l{^#v|0R!mm`|Td#GF^?q&kcb43{(&NbT}PzcV))zB%AMVMJPhwgL7kn<}x{ zBlLC~7opv>YSh0)&mu>p5!OD^`WlNsF=e00lWlD|2Z-&uG{!P)p$ONE_^WKVgen zF;fx>%ve8!L&{h`=VM$b@jLB=vA(Jo<8pX0I92wvb3bHGe5%WD`1Ua=ugNU%*D3we z=90+j*3WSo>kTljSfz6aGl_A-*Gw)pKWE5JIgv%+plRC&(8BE&m%#K$3L8@1Q|TkAV>fpHTJlyG@R1(o(@B=h@1lh6StmW~ph&!Cou0Ec$$g8A6|X3p zX6LFM%ou7q#`;^Om!4bFCGjxnJHntM$8$rIP(W+=4+@$w=V;nZFHk#=C8X&(hqVv7 z{NAHF#z{j1d3|axS~kh=`P2@Uj-3Sl*qNBCbA-PweYt-Ma1R2m)!H~O%jf5iSaaf=9FxpTJ+aJdJgt%j95p$%0yMZS z{C;2o(mz^!6##hXN@@xS8yZ~?eF|fyFfk`=pzs6$3yeHuki~of;ziTTcKt^Euk7~r z_%4~jQ5bL;4G-`Jg|UM~zLy?cWZx$&Z#;w!>U0KNM*B_S_mjhPGMXo274k)mfI}Jc z&$D3SjPRbhg84zWP%S0-Mktd+m2g`!fDa`y!jpv@dg@SN^2c#wS3m9Q3oHvnEdmx#{`pE7jK*(zmt{i+OaWoi@Y-6o7J`nA>G7tGUl zEF<=1`j-Z?(ky=X{}0|;)9^OkeY6aCAIctTi>KjzN6G@;(Z{!dcY9w7ybHW(=?NDQ z7T66cPeYzj@8ALarQ!cp)VGx9fNMIY)e#KPWk*m(Fe&L~wkmj(Y|6@i&NpVr_HY{MJ3~`O&ERXVFVbTumGTXCU?uqSy6LLJ>2MkvKAQ| z%)+N!p}{qgc6ZXr|3%ob7V-shar&Y_)LLZ4Oq?Q?m9&{KN(Gsh@rl<_lk=pE-|}%l zYS}^_#swypl`Ph6&9~b!Tg&du84%B0z`x&pS+;~kp3o|bKDC^1?X_%TIC*cQaVrjV zQ8`nukL@wX;wlW+L>pcUqKTne%@&nLs=LO=VT$SUZgHHg>( z^dMd-w0odPcW!8Sq}vhtruOD0EErL)oNi5=JT82GOl@viv!r+Sdfcq3qzM`w$?j`hObNFkSHq6WGbhQOQnvB zGIdB1fDZxM^;n8Whm^>VV+(tKghR+pxP#>uT0l2eSLkb{+F7`d8(rq>hgZdOG| z6ImcfyJk%YO2&RB?3I@3{We$>yr5+*ZT)Mx(1?D8}+H^*d?s8cw zfQnN9G3kOPWc^oEdJFEabEVn?c&=Ig5pT|if8g^Le9wxF`rgXGI$o=xxVOOv*9nZN zmwyn5l#e?RQ03zS-tv-V0DpO!1G*)!VDh9GjvAunlhD${0k-U($wl6#ZC7 zu>Q+n{h}nGqQd1-?}#~9{*bOfeEX2A ze~#p3)adN z{&uF_)NcvA#;BOarRt^-J*S*p z3$i7%SAdi7S)XVo@@|n2=JO)I`p{JG`aB<*o`f&}_u;ARp}S>PS8!MHzHK}>Umk3M z9{a_3SVF>aX8F(%zDT_a$3~RSVDSBRBJ!2f9f#9-;qtW1zoX}aBw=Qp>U0>uW1Cva z@906%=gpODpgVewB@Ng?IA7T92Z1!-(Q~4qX(i6gKfs_#=6@yqM{?xq`|gC+o^q!M2;d2}=7ObC#t)lT-*-n&V{V8Eu2|%YE-Y%TxC8uIQNl?D zXKw)}It7iEcZvuCDl&oqxz~v@8^}~UKwo)AVlAz4?_9#mcH4n^@*EWS7xjP5wtoQ{ z3r6Ds)ay#%l0V+_Dfesja?fj!UE|aGsc=X}n$ePgSX9Icu1M`Jk6m@P>hQb_#%)fBs{KJiJJ>>i=>tGOL;>H>Cumk^$|hvY%WHGcRtb;N{94VMHEZ$odKIT0h|q*5 zXqGTWGd)HQV~NBeJlrwGrTe3Ei{v3X7k;H2#gx&frF@_3;#qznF`o^T=?66iVX;-H zw#!~9W-o*cle*J)QK{Px6kaHKYa&*mJ9$5>maGEcbLcy2YbofAfmVsd(~ktZ|y zeZeMIHq}t+9XeX3jS4jk+xCJ!740Gq(5aPObns*0>u783v6>aou;;lVvcMD&d!!uL z?HkXtpW(A@1Y~V*0}#}j4L`*hKQ>sn?^6mmC!sJ}E6VbcX9_bckyq?&tSFP?Gd$?C zCX#3xJxK)^AqkdLKM;IwMI#68caQUqCryIK2K|!Oc{*%=`wo{!o_cvQHbg{lR}-x$ z$KNZrsgf;98!!InM8ibdk!Tf$;TYliKLg zy?2N*kM0a5croOdcG{8d((iD`IOt0~B27dKJJT<}T}b*RoZ_3hWib)yN;(T`vH*fV zwEWNJ6F(yb)Sxf9vV7tvc_Y}s*z^$$1ZW^rLH-`g-oK}zAovPwoam|vDB&6FcSft` zi6^+|wA(;xV#S@9tHb(+&QVnpv^u}{Poa|N&3`Cz{HgO3{Jo{NB%cdTTvaREdUwL} zfo6xCiDWRh_Ket_SPA~2DEZjN`Sc@+Mb-q-5)?6sbWC`SlmA7!Y#U@FCXo@ywn|Ib zu$^|R8KZn^h|dv#fngT;9MJZvDLSLrF{1z;kcr+d993utz7&W`DkWg%L8aR4PlPl2=@Fns$IXU&Y}ED3nFHmjF(T6dOIMtPRx7_=h) zJ9>96^zIvkqc{X(NOWMaH4`G>s9(J@_K1IMC&SCqyC&{v9wIy;6Ar=4yq$G2!Fw?u zGX!rvOOYjbZ`SmK==k&zyyt0xx6med-y=8rTw6^M=sfs_tgg_z=lLeiFA7T@h}~@i z@`wV*scBsZU6hwKt=o#8scNo{O)1Y3x;P+o*o3aJA=lf!LNf45)4Fe%V-E;7Y%dxn zPO!!^zyn+p!u zrvkt+E7pl99$ULY|Jc`9#MOuLS0B#{(U~|R5>J!2V$`YvJduWo@&&imzt`^icA1tP zqHf$M$ELBNq8x4bItj3XByXD$=tN0gHT#VqvIYl)b32ow-IEF_z)9Zp{3^;pKy%}8 z$UJVhgg3vr!*Wzi_jH;^2|VTkHC|v2-JaUsD9Hi~N!j++oD^EFANyQ{MA5{u|HAFQ zq1$}e9_mM#3;Aa)uqWe^^c1AwJL7L50N*_}=*zqFfU?&_kD+wWKz->-%m_!~0JZY! zpgR@z2GC3lCo!jqP5vx$?7U@XMCa5BdO_Z9UpPRRxAr+r?Eex2pWVBpogIlQeyL zdA56%E24z8JvpnMfM1fi{{)<8PXI!Vx>J>*`i6A%yMLP*edWqiW|f|$r$FwBdf7C* z#7_GrF4nsL{7<&Sf;JPaFgXfq+RPO={xnx=HwhZHbpFhFm|>}}c{hC~j?5i!Cc=0Q z#{NY%Cf=cJ6{n-s>X-(*Zm9PXQEs~SIb@6?J_K;|(Jb0cM*Y8m1#LZ}or#<3MJ;H6 z$v(Teq`O`aX{2{hDE~Q8^h!Q|3N59biE}?+x>~i_WW_gYwTjZv=j7<@UM94x8Z3+m zah7RLTuR8`$)r?Wtq>z(r`lSH&r`FlvM`l{kdQMh*MVgpz41qfi!R%^jN=?LO77@v zS7Ima!@nreX8f?E&!Cm`P$Q@{UGl;@+RlAJNE!8eNsEfp0grwmX8dmtu7+WmZ#uqa zI#yw$uhqJ=j?*hJof0drqk4a>R&m1Ec^-=AQVBkyRy5WZORXg9NQw#{$(1CvE;4Wf42R-x6UgqzhzYP|8d zoL)aJ&SBd6ks29Sj8a2Vf^_uzm!+>V@Pw1GeHch}&?gA37e906TBR*k)PEMcvCY4h z*ARWx52JkLR|oN?xe$ngxtl1R#uQe40 zQ%h?#o`;PLw4m%&6ZQW);)=Cs$b419hNH99|8$07cZEllT|u z7yZR%Unbe7A!X`3>UfxU8^ji0Rn|uR`JjUpjs9VR6&n2omhD+Vui@;4svQ>!NeA^v z9bysOuiGK!a1LC--HE}t50SRos@&4{))Q|3!@k_#3&8j;(Qs%*>Ym8i`iZ-GJ&K+A zXk<<+3c341E;E?SQ*rHFrCNJiJM^f`(T{D#&NVHvfZ6L?Mw<)${h2K8LB3(Le3&2k zCpba$1a+Ez*B8r;Le}gY5|Mk|Xt-?rres{xa*!YKl#*7sMU$&tKB#*M-S8`IM4}}U zT@JxJm$IZr{Y#_?!zyJoy$^(cX=9Ntl__o47DUfuqrA^Fqsph_6gkp+p0RcD)&>8f_=MaF-aSROXXtIW!ZCEPQ-NaTng7c5ltMzgCC?Zc1q^a?mw zg(*dW1!3B_9?QxTBgEXY*IiLYk`OU0#uP%^{a4x^WVc_{p&*ONY{ZtvUh-`DObCA}vm#3`$Y0 zUU_Fgy`H|$!*w{J%{+Z#rN33Zns`U+riI|9Y}Frdrb3=XG1Cn#uCtfQoDbks({Hgr(tkU20TGZ-sTyo%Cd5sM3w83|$_aT3V% zI7(OTPVeo#+7(;x1zcLPkqMw|S^=%HxNyR#pjHw%J*{c6oN?U7>A16Rx{nw3r_568 z+c*i(9-Bc**!(O&6GC_gTld59K=S*dJq2i{W;zuzk7vd&?p>5cFwUsuxByZP!#@g| zX`AC6x!)WNSF*s{z9b)|r!MoAo?Z1zi(o~&aNLi@^btn zQrpw~$_)vJ^!CvZMfw(%m^n^z_-7)l60M?J#G8k`i@SrQDXs7BiP@*zX;oN7@JX?) z>IbXH4bmXa0}Awn8$~d5KVQp{f=9;NuAWM0(;6c6v!@UsUBh`R{BwK094vu;h5seb z$3|e-M1}xHd4&q{ll9DinDb*WGX-%;B~9Mp5@aaOpkPD#0s{%-{)zptUxvSM(}1pu z=nZNSz6oa50@=*7$Db3u00LzE%>@#Dh-9-}L0(aLqoLc|Pa0RbjO)t9xpCb9Y$^P0 zn~bY?SgZVg#`tr2T>QO#$42CLyQNYPeMqb!qAs&Nmtdtt->Trc|kZRL^_ zewX!dqr%IAgiV($2-@u*u?{wcr9i!)V{?cabI`1Hndf-7VfBd`?f5ALkx|~^TGKD+ z74Q0ZoM1M|DfXTnb(zx&#$R6$xmzYcv?gcS3o8>KHc^-3xC1Y5qEj9T&AAY+i zw+=I;3m0X&Fus2mPFaV`SqH#$W*wC82zHrt;dIMkwswCTWIu2L`gJY0=hS-OGC^7T zy2s+G=cAwrhY}?iP6(%ttC}tS6%l~4D*3hag1zVqnu}b_b0Bws0?(_B)&(I=|3$mx z4jG`Y#h&9C@|&Gw$uQsmjbnhIgnw^BMV6S2E3EhE@+O@iQTkx^5(W?Ve21 zobgL=p)f%`U8_AdR&tGBQWANSe_fFs{fLIM_!Kg)L?lglx0D|wnSp6nUx`ntrYA`X zCDdL<b`mChZXSuYNZC1P`g z;NrsVl6HI;7$!v%=$}F^l%k=z4!&mVK4)eotnR3s*+Yt+3eWEGk5{87<|#x2Jj1`* z)ojUTf1d0iV&G)6{gX`8F=!!!f0{;)v3B(i$&jZ}!uFG^e>?5o(S9 z#;Ao?I9ss^_wZ&;Mm_NM(Ku2tm%v%QX{0&L<=NsPpuwtE)&W;gS?M;8k354&6)Cr* ziT5sCzqP=hJWpGd?3c91aPCP}Q<18C@<{y0VrV259$k2JbjDgIdd?OQ>})}L0N1{M zQNMF<>O6B=k&``uizR8W|7R4s%47pIU8*i6a@YKk?Ehe5!g7eJCFdu_Gb^#%9MP}f zV<2_8SVx!3*VNg`!2$_U${MA=D49~lq_4Bf`{Q4cd1QfR!T!UH-~n(kVFk6->g?e3 z4A(*7mS*Eeq4*W?>J|Rxdw)15KJ&-cK96FVdRfm)PV1mu?fp@(n83(kxq#0uj3eP^#*M+inOaYq=x&yj(+Xx zjasF=Z&Lx2+RMV;&WF1UJ11Y;w92mLqA&O>{wRPhQh0b9Z-I2XiiyYY{#|-0Gdnk6 zChB?S#JWSyy_jl1V%lG2Jh(4rC*`Jt$*X%>m?g;8c8H+lVw}(VnP%V*XY5QD=dCFn z)skuG|0gl;y17F&PN+|u1CMa*$1j3MP_ z-36{RUPj$vS^|zdTsoINXpR4>K+S(il?w1PEO|y>*Sy0OL}eNE(x+uvSYT0tW%U|= z#Ku}-PPNbbadOLf_p9^%D^(p3Qe^CLV=G&AD{@_gDoI{NZHu=O9{2F;;@6Vv-^wpB zNI~P+a1@73f+euv;zxT!*d%7aK{q0mAl?kb2S<2o7`auv8V3w1H+}>6Aa5b++M+Y? zzoL6K=$@_=PN%y78542g;`hkYxqKfk?hu^Ybr1i)l5&Zg1t7Y^yHQs%M=i85cEq)0 zWKJKBm_UZJg|vmAs?kW-8H{vyM5!D|t!WMOkXn>MdKsXr2o3T|zFX!in$FCf$Ym4| zx}$52O?T{(-_J%kz=}b)osD~dRDGMBldHCT<+`o1$Yx_&h02rpMIT?*qv-)|G2&`y z?nzxKVMa4u*?j*=T{*@#LCW{4uFwc~hzI2P*a)O%s>f&>OINV?Wz+1Jwt*M`u1qJ` z8EgpRYZt5Cq;^?o{Jl>{CS+K~=Zkjj=>`2OgW(#9}{>Enxnz@(9m+Br-cjG z$;B>c{yna!k?v=}%!>3hd%H`?4~odFo3?6DVx&*J!=H7ZOx0EeA#+$TLct*L6MTb) z(q#7Ymt?@q_?`GDiyMbHA#P@?aRM3T>fJb&2SufofItK01s(sHpJ!fu#cD!Iari0# zb8?!Ts3YX7canFxkp+wP- zwZ>nPT{lOF|Fn&ZD7Mi9EOBd(H;^uNT}}oXE6_Lc zAPnB&l8p(JswzaCiKW8;O);qigP>2lI?ee}4&UU+`*ib70wf&LR_!!Zd@QKlTS3bH zM_u7W!J{Z+l^XGi)EHHbI^{xTaIt{s$Q<@|>SfgrAr#cTJFqvwdD8VeQ1RYX|5w52 zsGzW_Sh(&$B4+*Jqa$f^tMI&DN8hLQsLk^_x^&6eN)npVgy%K%xq8as*!=o!iSNqe zTKVVFHf=Ss;udXns}|fksd=PFh=dOb@;gN#{(INjLub?|MafOh@V>7-I#kh@%tBw! zQ)j9H*r;EmMIw~U$Kzo3HWhs!2vQHrtpNZSna!L>#%rQ49yD)vh0PNz1P;zI;ZWgs z!M4EL*1L1?7J_55^=IBG7=1~3&fjePn)g&m22{Rm&mJ%{)ufWlq}*0rj38ns>AI=ofgyzVG_;j7B&w#qy0C5~tOZ6f(0UY<@cr(;u-0FBW61t!&3C1mc~_ z9tbrJmN95fQS|lP*a2=OyO>KcCK|d{#3tQxNnu+)h8Rd;!7o3P&k5e{H+N%pw$o3X zRKvN|fCZ|p+7U88MT0Qd`d$G-dAYwiU)OO~;MqQQL(>OK0%3gY$o$iMoAPH~>p|b{ z%ZT1hxLl!@^7w^1I$bbrA?4*f8s$D zjtWW*b05216!8H;0h1Q;} z!T7wAz-%;o+VE854mdXi!HzjEjon1B8&dqv#|&lcj0)=9*JClEDU9waD4Gj zooL{#`&}H-d(JF+e#mzmf(1wmqu`H^DR}g?s?PP;(1GV{=>7=nx;N%akf)feWh}@ zRY9uZ`KS4^;rWyge&=DkPo6{81yaD-DJ%dX%}T9*R4U%4TP^~iL8NQqaLOkjBp{PM zUzphIm^2PqsZgrIKQ)h-hkABvfg?R{X@NuD6Lo_Sq@O@Afc_Vcz&UYN5JBOlDS6#^qd90eb z!?O#lcAHc}8AKIV<6L&LH8or7q)e>`F0gCutJJeIHAL0nArh+jidACQQEI-TrfUeV zvdOA4TnAir$kYf}5nwr^Z?m!K0%k|GUL8ox{WW}6AqPUH!@Qv=H2ZEYHbxp`p*{$ZYRxlAXnSgwZMzlV##QYu=?Jtm!Q_+yMQ$Y)ZlEj}jq3^JmL zDVe4gAa5rgRKbPW8m^)SG_33z0??uAL%d09u~wY6xH;vsZ0T_#bm?o}kvFjUs?(Ma zCT?bgJ52w1|IF3{HuIl{B2&MCNcW2=?{(G<6{(d$_X#F~@Kq#=!sF1I4gvSEroy{z zbU#s#2+~p414RuXdKcj91~>v=5tr(%Z!>qfcmS2fcB{_1FT;Bn*{@N1&VGjK$jOZo z5BQ*CQAdFIZDHp>{Z3YoW`ZP|;f1n*_F_g4!sDS&a`qIeo+Za_uI$D6nZ5Y)(t2hV zGD^0ZK2y9dpH`m}d53^NG>pM{Q0dnRmnE`T{u!%oLVu(@(Q?d(xP$ICuN&>{H5ZK3 zrV&~_ywm%U*gf=U(>@|zx!-&*b*2jLV;(anjWoXwzD0M-*U>W&R3LTy^3Cv1G_&(oc;&sxC>waAew|O_|@jPuB{|4x1 zk?uvTOM1KR-GFa>VjxcAS0bWgF1l?>0#dyO6wZZbDGm_vAP~-S5v7^sAaYy=}O6o3xbsHoc5$+RgB>?{0 z_<;=XH^Vi;T7nNX*mDR#p&6duc=bBndB|`Q5OgToqHS@ksN+$w(N3dWbC=Dp*Vgo6 z%e=33|8V==+yOAy4G_I?2xm3CPVOFutjX$SKk)aE^>y{k?Th1Y3^sR&*_Yh2u^Os7 zXpL51QS^O{teU)Z`8~(TsgW;UmvnZ~n|SyWPk2i_youeOw4R$FxpeRPx--xoAnQTE z#~N>VcVgT`=|NHp8%v2$%?bRQOJo(%{Srtk+T+JoWV7`pACtb_P|&DqkA z8Q+4h0&)|B`{ZQFq#9}a2^@Z2a3W)F6%Iz1wfF5K%vyA*r?(+35OJY~VPVG{bf^ln zM;bY&L@>Kc7r$_MbJ8vTcyy^+rdV%*wyc`Z%mvdbqJH7*`y~%PKj5)VI@?;3udnw-QwA7R`0MDlOj3 zJ)PCv1EzKU=!L~Nqgw~^gjneWA#5@`gA#7&vCq3$V@;ZWg)XP6#w=r4w^sy z?KS-E_Qz*FHQrEsUyZU-@E}uckVx;xwMuqC^4y^WI=AE+vKD@qY_Wp z=kK6fc)6m4p$@mU=6yMLE6L(djPvjt5h0J zoF(@c)eHM`2L$C%=ON~z$0{b#X$VH%!r}LPBI7cSc^HuK3K_Oo>ndol%WFJUr-`QXF+H8(g9D(*D+8g(7W;s6{5ydn z+{HJ{x~61+;RN(v<5%aQ&-1I8VnItC{7m+`e=@|FQ0fSi2*5Q^B@b3o+hy9J2U ztr-AB)&oS214Ohe5E0W!8;I1c=>sBLh1(TwXJRLc_K`wJjQnn=Oz2WzgaOF)k#aLB zPBouqI4Qi>9hP5ZS_fF~wJOwSX7pKS(u}^X;7Z(h!*Z)UtEi~@4bLWP1g`=|R?-)5 zG6!i)nk0&Cu|e#47r zXZ#LejeXcfMLcuDaokQ96kI@m5-1aUAO6T5QJd_Ks~wSHHXMm{1jr021ot6eri3Ge zhymij7I+JTNMsA{kVIb;VA6x7Y!C!4V8QTg(LKa8_`q$p!tuBhTqCBPvt%7@RHN|E z$*2bFK~HB!*k!e=-T8MF!e5Z~+Eoq~tJtt{V@4km`C z&DZ3;*J_sc>7{pqi2a^V6{>a;3j4jGAW-4@!$3!!Hd6Yqb-SH&7IPZn^?F{tI|t&2 zX5r#+y{okxSIhb`4>rmW8pT&As>a+mYrOxm}UKqD(uSs zlPCIEEB&^1mGD?cX1_3!V#pTPba>K2px;SaWEqwvKk`_MN3= za_2pRyONU5$*k~Oc(Xwd+(1`pqro{e%;?J30x)0{a$qTw8#I!Zu3{nE$oxi zl<5QHGy&(yavCux$jE6niJWGWlG7}$Q!*O4rj%#pGcbLP9sgJI8Bvk93vsfF%SeN+-(gE|AO$XM z6UO4|tt|SwoD9dAmElw}0p0&W9|YtE^cU-Slo@AOzW)A(GV-a%(3%+e7~?C%$yN&W z6V=&drn5;pD_z}TP557S^;Nq1YPPE#|9w|$>8h-wS~Rtova+&_$eonT>8orPHRaup z^TfQ1kf}Syv&5&mIiUQG&BuQVoZEx>u*3qh39A=3p3#~;a-?Be%uP%_AxL@_QWBBI z!0^C{=sl%XxLSb{drzb?P?zW^L|ZVqpM6+FC-Lg?c+{;Uy@f>uI7ns4^kH>>=I8T#b?EGOw} z@N|SDRzcGhHb=~uV6($2td`5!Q)GrArm@M$6Z+&395MeV?-TMnTLnz5N@0nqDug9Q zHNqO2VAcP3<#S9i_OdfuTorBT>%q1EO%47}{*mp%W!ISnpY*FEon|zagTh|=S~pC3 z41A=A{!j2rC_J%)8Ge`<~`q*G#MZ1+g{#SOcWRMls&o1l7 z|KgJ{-7@?yv%1{xd{3$lJ3nM&IM70C(c(eYNgWEI8LH&e&k%}amVnZ^P!2@Y>9eO% z{4TMr7SmQS<;GI`Tx4ltWKEbM?tVqZ-1L5eMYVWfM9D?oav?l*Hx6m|xXXjcX=;IF zfZyNVF9R-q3(n∓XTN`tz)>6^mNgU-wm@jIe2;OEs^|u={;fw%B&;e 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

  • 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 z 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 BLY}?!(@lfq&-0Fx>*=Q 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%0AY$kI$m{1cWfx^L?8PhYJn;0JqUE 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%0DZe1tbtK9GO`Tr-< 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 z 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�(NPC>ES^MEGzUNLpQ>iKH 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 z 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%0A>6?w~ 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%0DP8+u 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

      (k*q7}q9ly^nZH^Z88w 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≫Gx5>1g;9*MQl-aKEbUSA3q+^mE?drN83(ll_!w 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്hGl8wVero9cdjw&V-6hUEh^cs@z@uQ;X@$_IN{ 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

    2Xw2J{4;l80>N-vTIBX2KZprwvA} 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 z%0D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%0Dm4)LM*GscqFah07C1@*DetNQYe3 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 z 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π_m)iuct<)u-;XAW>Du&P>V4Xu&oIrG=cfiNYHR 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