From 16dcd0747a741d04c359bc838ecbfbf2ed1f4284 Mon Sep 17 00:00:00 2001 From: flowerpewpew Date: Fri, 3 May 2024 13:44:08 +0100 Subject: [PATCH 1/3] Make it compile on MSVC --- ShapeUpWin.vcxproj | 144 + ShapeUpWin.vcxproj.filters | 30 + ShapeUpWin.vcxproj.user | 4 + lib/raylib-4.5.0_win64_msvc16/CHANGELOG | 1888 ++++++ lib/raylib-4.5.0_win64_msvc16/LICENSE | 16 + lib/raylib-4.5.0_win64_msvc16/README.md | 144 + .../include/raygui.h | 5540 +++++++++++++++++ .../include/raylib.h | 1588 +++++ .../include/raymath.h | 2134 +++++++ lib/raylib-4.5.0_win64_msvc16/include/rlgl.h | 4740 ++++++++++++++ lib/raylib-4.5.0_win64_msvc16/lib/raylib.dll | Bin 0 -> 1697792 bytes lib/raylib-4.5.0_win64_msvc16/lib/raylib.lib | Bin 0 -> 5018124 bytes .../lib/raylibdll.lib | Bin 0 -> 160566 bytes src/main.c | 41 +- src/shaders.h | 768 +++ x64/Debug/ShapeUpWin.exe.recipe | 11 + x64/Debug/ShapeUpWin.ilk | Bin 0 -> 3969088 bytes x64/Debug/ShapeUpWin.log | 109 + x64/Debug/ShapeUpWin.tlog/CL.command.1.tlog | Bin 0 -> 820 bytes x64/Debug/ShapeUpWin.tlog/CL.read.1.tlog | Bin 0 -> 6396 bytes x64/Debug/ShapeUpWin.tlog/CL.write.1.tlog | Bin 0 -> 552 bytes x64/Debug/ShapeUpWin.tlog/Cl.items.tlog | 1 + .../ShapeUpWin.tlog/ShapeUpWin.lastbuildstate | 2 + x64/Debug/ShapeUpWin.tlog/link.command.1.tlog | Bin 0 -> 1530 bytes x64/Debug/ShapeUpWin.tlog/link.read.1.tlog | Bin 0 -> 4178 bytes x64/Debug/ShapeUpWin.tlog/link.write.1.tlog | Bin 0 -> 556 bytes x64/Debug/main.obj | Bin 0 -> 511327 bytes x64/Debug/vc143.idb | Bin 0 -> 68608 bytes x64/Debug/vc143.pdb | Bin 0 -> 118784 bytes 29 files changed, 17151 insertions(+), 9 deletions(-) create mode 100644 ShapeUpWin.vcxproj create mode 100644 ShapeUpWin.vcxproj.filters create mode 100644 ShapeUpWin.vcxproj.user create mode 100644 lib/raylib-4.5.0_win64_msvc16/CHANGELOG create mode 100644 lib/raylib-4.5.0_win64_msvc16/LICENSE create mode 100644 lib/raylib-4.5.0_win64_msvc16/README.md create mode 100644 lib/raylib-4.5.0_win64_msvc16/include/raygui.h create mode 100644 lib/raylib-4.5.0_win64_msvc16/include/raylib.h create mode 100644 lib/raylib-4.5.0_win64_msvc16/include/raymath.h create mode 100644 lib/raylib-4.5.0_win64_msvc16/include/rlgl.h create mode 100644 lib/raylib-4.5.0_win64_msvc16/lib/raylib.dll create mode 100644 lib/raylib-4.5.0_win64_msvc16/lib/raylib.lib create mode 100644 lib/raylib-4.5.0_win64_msvc16/lib/raylibdll.lib create mode 100644 src/shaders.h create mode 100644 x64/Debug/ShapeUpWin.exe.recipe create mode 100644 x64/Debug/ShapeUpWin.ilk create mode 100644 x64/Debug/ShapeUpWin.log create mode 100644 x64/Debug/ShapeUpWin.tlog/CL.command.1.tlog create mode 100644 x64/Debug/ShapeUpWin.tlog/CL.read.1.tlog create mode 100644 x64/Debug/ShapeUpWin.tlog/CL.write.1.tlog create mode 100644 x64/Debug/ShapeUpWin.tlog/Cl.items.tlog create mode 100644 x64/Debug/ShapeUpWin.tlog/ShapeUpWin.lastbuildstate create mode 100644 x64/Debug/ShapeUpWin.tlog/link.command.1.tlog create mode 100644 x64/Debug/ShapeUpWin.tlog/link.read.1.tlog create mode 100644 x64/Debug/ShapeUpWin.tlog/link.write.1.tlog create mode 100644 x64/Debug/main.obj create mode 100644 x64/Debug/vc143.idb create mode 100644 x64/Debug/vc143.pdb diff --git a/ShapeUpWin.vcxproj b/ShapeUpWin.vcxproj new file mode 100644 index 0000000..0ecc33f --- /dev/null +++ b/ShapeUpWin.vcxproj @@ -0,0 +1,144 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 17.0 + Win32Proj + {01b70e71-8a13-4d13-858e-3ded3f60bdf5} + ShapeUpWin + 10.0 + + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + $(VC_IncludePath);$(WindowsSDK_IncludePath);C:\Users\rosie\source\repos\ShapeUpWin\ShapeUpWin\lib\raylib-4.5.0_win64_msvc16\include + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + true + + + Console + true + C:\Users\rosie\source\repos\ShapeUpWin\ShapeUpWin\lib\raylib-4.5.0_win64_msvc16\lib + raylib.lib;winmm.lib;%(AdditionalDependencies) + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/ShapeUpWin.vcxproj.filters b/ShapeUpWin.vcxproj.filters new file mode 100644 index 0000000..a3f06c1 --- /dev/null +++ b/ShapeUpWin.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/ShapeUpWin.vcxproj.user b/ShapeUpWin.vcxproj.user new file mode 100644 index 0000000..88a5509 --- /dev/null +++ b/ShapeUpWin.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/lib/raylib-4.5.0_win64_msvc16/CHANGELOG b/lib/raylib-4.5.0_win64_msvc16/CHANGELOG new file mode 100644 index 0000000..43ab3ab --- /dev/null +++ b/lib/raylib-4.5.0_win64_msvc16/CHANGELOG @@ -0,0 +1,1888 @@ +changelog +--------- + +Current Release: raylib 4.5.0 (18 March 2023) + +------------------------------------------------------------------------- +Release: raylib 4.5 (18 March 2023) +------------------------------------------------------------------------- +KEY CHANGES: + - ADDED: Improved ANGLE support on Desktop platforms + - ADDED: rcamera module, simpler and more extendable + - ADDED: Support for M3D models and M3D/GLTF animations + - ADDED: Support QOA audio format (import/export) + - ADDED: rl_gputex module for compressed textures loading + - REDESIGNED: rlgl module for automatic render-batch limits checking + - REDESIGNED: rshapes module to minimize the rlgl dependency + +Detailed changes: +[core] ADDED: RAYLIB_VERSION_* values to raylib.h (#2856) by @RobLoach +[core] ADDED: Basic gamepad support for Android (#2709) by @deniska +[core] ADDED: Support CAPS/NUM lock keys registering if locked +[core] ADDED: _GNU_SOURCE define on Linux (#2729) +[core] ADDED: SetWindowIcons() to set multiple icon image sizes +[core] `WARNING`: RENAMED: Exported raylib version symbol to raylib_version #2671 +[core] REMOVED: Touch points on touch up events on Android (#2711) by @deniska +[core] REVIEWED: Window position setup on InitWindow() (#2732) by @RandomErrorMessage +[core] REVIEWED: Touchscreen input related functions on Android (#2702) by @deniska +[core] REVIEWED: Viewport scaling on Android after context rebind (#2703) by @deniska +[core] REVIEWED: ScanDirectoryFilesRecursively() (#2704) +[core] REVIEWED: Gamepad mappings with latest gamecontrollerdb (#2725) +[core] REVIEWED: Monitor order check on app initialization +[core] REVIEWED: Application monitor when opening (#2728, #2731) by @RandomErrorMessage +[core] REVIEWED: Gestures module to use GetTime() if available (#2733) by @RobLoach +[core] REVIEWED: Resolve GLFW3 some symbols re-definition of windows.h in glfw3native (#2643) by @daipom +[core] REVIEWED: OpenURL(), string buffer too short sometimes +[core] REVIEWED: GetRandomValue() range limit warning (#2800) by @Pere001 +[core] REVIEWED: UnloadDirectoryFiles() +[core] REVIEWED: GetKeyPressed(), out of range issue (#2814) by @daipom +[core] REVIEWED: GetTime(), renamed variable 'time' to 'nanoSeconds' (#2816) by @jtainer +[core] REVIEWED: LoadShaderFromMemory(), issue with shader linkage +[core] REVIEWED: Avoid possible gamepad index as -1 (#2839) +[core] REVIEWED: SetShaderValue*(), avoid setup uniforms for invalid locations +[core] REVIEWED: GetClipboardText() on PLATFORM_WEB, permissions issues +[core] REVIEWED: Initial window position for display-sized fullscreen (#2742) by @daipom +[core] REVIEWED: Sticky touches input (#2857) by @ImazighenGhost +[core] REVIEWED: Enable GetWindowHandle() on macOS (#2915) by @Not-Nik +[core] REVIEWED: Window position always inits centered in current monitor +[core] REVIEWED: IsWindowFocused() to consider Android App state (#2935) +[core] REVIEWED: GetMonitorWidth() and GetMonitorHeight() (#2934) +[core] REVIEWED: GetWindowHandle() to return Linux window (#2938) +[core] REVIEWED: WindowDropCallback(), additional security check (#2943) +[core] REVIEWED: Security checks for emscripten_run_script() (#2954) +[utils] REVIEWED: TraceLog() message size limit overflow +[rcamera] REDESIGNED: New implementation from scratch (#2563) by @Crydsch +[rcamera] REVIEWED: Make orbital camera work as expected (#2926) by @JeffM2501 +[rcamera] REVIEWED: Multiple reviews on the new implementation +[rcamera] ADDED: UpdateCameraPro(), supporting custom user inputs +[rlgl] ADDED: OpenGL ES 2.0 support on PLATFORM_DESKTOP (#2840) by @wtnbgo +[rlgl] ADDED: Separate blending modes for color and alpha, BLEND_CUSTOM_SEPARATE (#2741) +[rlgl] ADDED: rlSetBlendFactorsSeparate and custom blend mode modification checks (#2741) by @pure01fx +[rlgl] ADDED: RL_TEXTURE_MIPMAP_BIAS_RATIO support to `rlTextureParameters()` for OpenGL 3.3 #2674 +[rlgl] ADDED: rlCubemapParameters() (#2862) by @GithubPrankster +[rlgl] ADDED: rlSetCullFace() (#2797) by @jtainer +[rlgl] REMOVED: Mipmaps software generation for OpenGL 1.1 +[rlgl] REVIEWED: Check for extensions before enabling them (#2706) by @Not-Nik +[rlgl] REVIEWED: SSBO usage to avoid long long data types +[rlgl] REVIEWED: Enable DXT compression on __APPLE__ targets (#2694) by @Not-Nik +[rlgl] REVIEWED: enums exposed and description comments +[rlgl] REVIEWED: rlBindImageTexture(), correct data types (#2808) by @planetis-m +[rlgl] REVIEWED: rlMultMatrixf(), use const pointer (#2807) by @planetis-m +[rlgl] REVIEWED: Expose OpenGL blending mode factors and functions/equations +[rlgl] REVIEWED: rLoadTextureDepth(), issue with depth textures on WebGL (#2824) +[rlgl] REVIEWED: rlUnloadFramebuffer() (#2937) +[raymath] ADDED: Vector2LineAngle() (#2887) +[raymath] REVIEWED: Vector2Angle() (#2829, #2832) by @AlxHnr, @planetis-m +[shapes] ADDED: CheckCollisionPointPoly() (#2685) by @acejacek +[shapes] REVIEWED: DrawPixel*(), use RL_QUADS/RL_TRIANGLES (#2750) by @hatkidchan +[shapes] REVIEWED: DrawLineBezier*(), fix bezier line breaking (#2735, #2767) by @nobytesgiven +[textures] ADDED: ColorBrightness() +[textures] ADDED: ColorTint() +[textures] ADDED: ColorContrast() +[textures] ADDED: Support for PNM images (.ppm, .pgm) +[textures] ADDED: GenImagePerlinNoise() +[textures] ADDED: GenImageText(), generate grayscale image from text byte data +[textures] ADDED: ImageDrawCircleLines(), ImageDrawCircleLinesV() (#2713) by @RobLoach +[textures] ADDED: ImageBlurGaussian() (#2770) by @nobytesgiven +[textures] REVIEWED: Image fileformat support: PIC, PNM +[textures] REVIEWED: ImageTextEx() and ImageDrawTextEx() scaling (#2756) by @hatkidchan +[textures] `WARNING`: REMOVED: DrawTextureQuad() +[textures] `WARNING`: REMOVED: DrawTexturePoly(), function moved to example: `textures_polygon` +[textures] `WARNING`: REMOVED: DrawTextureTiled(),function implementation moved to the textures_tiled.c +[text] ADDED: GetCodepointPrevious() +[text] ADDED: UnloadUTF8(), aligned with LoadUTF8() +[text] `WARNING`: RENAMED: TextCodepointsToUTF8() to LoadUTF8() +[text] `WARNING`: RENAMED: GetCodepoint() -> GetCodepointNext() +[text] REDESIGNED: GetCodepointNext() +[text] REVIEWED: MeasureTextEx(), avoid crash on bad data +[text] REVIEWED: UnloadFontData(), avoid crash on invalid font data +[models] ADDED: Support M3D model file format (meshes and materials) (#2648) by @bztsrc +[models] ADDED: Support for M3D animations (#2648) by @bztsrc +[models] ADDED: GLTF animation support (#2844) by @charles-l +[models] ADDED: DrawCapsule() and DrawCapsuleWires() (#2761) by @IanBand +[models] ADDED: LoadMaterials(), MTL files loading, same code as OBJ loader (#2872) by @JeffM2501 +[models] `WARNING`: REMOVED: UnloadModelKeepMeshes() +[models] `WARNING`: REMOVED: DrawCubeTexture(), DrawCubeTextureRec(), functions moved to new example: `models_draw_cube_texture` +[models] REVIEWED: DrawMesh(), using SHADER_LOC_COLOR_SPECULAR as a material map (#2908) by @haved +[models] REVIEWED: LoadM3D() vertex color support (#2878) by @GithubPrankster, @bztsrc +[models] REVIEWED: GenMeshHeightmap() (#2716) +[models] REVIEWED: LoadIQM() (#2676) +[models] REVIEWED: Simplify .vox signature check (#2752) by @CrezyDud +[models] REVIEWED: LoadIQM(), support bone names loading if available (#2882) by @PencilAmazing +[models] REVIEWED: GenMeshTangents(), avoid crash on missing texcoords data (#2927) +[audio] ADDED: Full support for QOA audio file format +[audio] ADDED: Mixed audio processor (#2929) by @hatkidchan +[audio] ADDED: IsWaveReady()`, IsSoundReady(), IsMusicReady() (#2892) by @RobLoach +[audio] `WARNING`: REMOVED: Multichannel audio API: PlaySoundMulti(), StopSoundMulti() +[audio] REVIEWED: Clear PCM buffer state when closing audio device (#2736) by @veins1 +[audio] REVIEWED: Android backend selected (#2118, #2875) by @planetis-m +[audio] REVIEWED: Change default threading model for COM objects in miniaudio +[multi] ADDED: IsShaderReady(), IsImageReady(), IsFontReady() (#2892) by @RobLoach +[multi] ADDED: IsModelReady(), IsMaterialReady(), IsTextureReady(), IsRenderTextureReady() (#2895) by @RobLoach +[multi] REVIEWED: Multiple code/comment typos by @sDos280 +[multi] REVIEWED: Grammar mistakes and typos (#2914) by @stickM4N +[multi] REVIEWED: Use TRACELOG() macro instead of TraceLog() in internal modules (#2881) by @RobLoach +[examples] ADDED: textures_textured_curve (#2821) by @JeffM2501 +[examples] ADDED: models_draw_cube_texture +[examples] ADDED: models_loading_m3d (#2648) by @bztsrc +[examples] ADDED: shaders_write_depth (#2836) by @BugraAlptekinSari +[examples] ADDED: shaders_hybrid_render (#2919) by @BugraAlptekinSari +[examples] REMOVED: audio_multichannel_sound +[examples] RENAMED: Several shaders for naming consistency (#2707) +[examples] RENAMED: lighting_instanced.fs to lighting_instancing.fs (glsl100) (#2805) by @gtrxAC +[examples] REVIEWED: core_custom_logging.c (#2692) by @hartmannathan +[examples] REVIEWED: core_camera_2d_platformer (#2687) by @skylar779 +[examples] REVIEWED: core_input_gamepad.c (#2903) by @planetis-m +[examples] REVIEWED: core_custom_frame_control +[examples] REVIEWED: core_drop_files (#2943) +[examples] REVIEWED: text_rectangle_bounds (#2746) by @SzieberthAdam +[examples] REVIEWED: textures_image_processing, added gaussian blurring (#2775) by @nobytesgiven +[examples] REVIEWED: models_billboard, highlighting rotation and draw order (#2779) by @nobytesgiven +[examples] REVIEWED: core_loading_thread, join thread on completion (#2845) by @planetis-m +[examples] REVIEWED: models_loading_gltf +[examples] REVIEWED: Shader lighting.fs for GLSL120 (#2651) +[examples] REVIEWED: text_codepoints_loading.c +[parser] REVIEWED: raylib-parser Makefile (#2765) by @Peter0x44 +[build] ADDED: Packaging for distros with deb-based and rpm-based packages (#2877) by @KOLANICH +[build] ADDED: Linkage library -latomic on Linux (only required for ARM32) +[build] ADDED: Required frameworks on macOS (#2793) by @SpexGuy +[build] ADDED: WASM support for Zig build (#2901) by @Not-Nik +[build] ADDED: New raylib examples as VS2022 project (to raylib solution) +[build] REVIEWED: config.h format and inconsistencies +[build] REVIEWED: Zig build to latest master, avoid deprecated functions (#2910) by @star-tek-mb +[build] REVIEWED: CMake project template to easily target raylib version (#2700) by @RobLoach +[build] REVIEWED: PATH for PLATFORM_WEB target (#2647) by @futureapricot +[build] REVIEWED: build.zig to let user decide how to set build mode and linker fixes by @InKryption +[build] REVIEWED: Deprecation error on Android API higher than 23 (#2778) by @anggape +[build] REVIEWED: Android x86 Architecture name (#2783) by @IsaacTCB +[build] REVIEWED: examples/build.zig for the latest Zig version (#2786) by @RomanAkberov +[utils] REVIEWED: ExportDataAsCode() data types (#2787) by @RGDTAB +[build] REVIEWED: Makefile emscripten path (#2785) by @Julianiolo +[build] REVIEWED: Several compilation warnings (for strict rules) +[build] REVIEWED: All github workflows using deprecated actions +[build] REVIEWED: CMake when compiling for web (#2820) by @object71 +[build] REVIEWED: DLL build on Windows (#2951) by @Skaytacium +[build] REVIEWED: Avoid MSVC warnings in raylib project (#2871) by @JeffM2501 +[build] REVIEWED: Paths in .bat files to build examples (#2870) by @masoudd +[build] REVIEWED: CMake, use GLVND for old cmake versions (#2826) by @simendsjo +[build] REVIEWED: Makefile, multiple tweaks +[build] REVIEWED: CI action: linux_examples.yml +[build] REVIEWED: CI action: cmake.yml +[bindings] ADDED: h-raylib (Haskell) by @Anut-py +[bindings] ADDED: raylib-c3 (C3) by @Its-Kenta +[bindings] ADDED: raylib-umka (Umka) by @RobLoach +[bindings] ADDED: chez-raylib (Chez Scheme) by @Yunoinsky +[bindings] ADDED: raylib-python-ctypes (Python) by @sDos280 +[bindings] ADDED: claylib (Common Lisp) by @shelvick +[bindings] ADDED: raylib-vapi (Vala) by @lxmcf +[bindings] ADDED: TurboRaylib (Object Pascal) by @turborium +[bindings] ADDED: Kaylib (Kotlin/Native) by @Its-Kenta +[bindings] ADDED: Raylib-Nelua (Nelua) by @Its-Kenta +[bindings] ADDED: Cyber (Cyber) by @fubark +[bindings] ADDED: raylib-sunder (Sunder) by @ashn-dot-dev +[bindings] ADDED: raylib BQN (#2962) by @Brian-ED +[misc] REVIEWED: Update external libraries to latest versions + +------------------------------------------------------------------------- +Release: raylib 4.2 (11 August 2022) +------------------------------------------------------------------------- +KEY CHANGES: + - REMOVED: extras libraries (raygui, physac, rrem, reasings, raudio.h) moved to independent separate repos + - UPDATED: examples: Added creation and update raylib versions and assigned **DIFFICULTY LEVELS**! + - rres 1.0: A custom resource-processing and packaging file format, including tooling and raylib integration examples + - raygui 3.2: New version of the immediate-mode gui system for tools development with raylib + - raylib_parser: Multiple improvements of the raylib parser to automatize bindings generation + - ADDED: New file system API: Reviewed to be more aligned with raylib conventions and one advance function added + - ADDED: New audio stream processors API (_experimental_): Allowing to add custom audio stream data processors using callbacks + +Detailed changes: +[multi] ADDED: Frequently Asked Questions (FAQ.md) +[multi] REVIEWED: Multiple trace log messages +[multi] REVIEWED: Avoid some float to double promotions +[multi] REVIEWED: Some functions input parametes that should be const +[multi] REVIEWED: Variables initialization, all variables are initialized on declaration +[multi] REVIEWED: Static array buffers are always re-initialized with memset() +[multi] `WARNING`: RENAMED: Some function input parameters from "length" to "size" +[core] ADDED: GetApplicatonDirectory() (#2256, #2285, #2290) by @JeffM2501 +[core] ADDED: raylibVersion symbol, it could be required by some bindings (#2190) +[core] ADDED: SetWindowOpacity() (#2254) by @tusharsingh09 +[core] ADDED: GetRenderWidth() and GetRenderHeight() by @ArnaudValensi +[core] ADDED: EnableEventWaiting() and DisableEventWaiting() +[core] ADDED: GetFileLength() +[core] ADDED: Modules info at initialization +[core] ADDED: Support clipboard copy/paste on web +[core] ADDED: Support OpenURL() on Android platform (#2396) by @futureapricot +[core] ADDED: Support MOUSE_PASSTHROUGH (#2516) +[core] ADDED: GetMouseWheelMoveV() (#2517) by @schveiguy +[core] `WARNING`: REMOVED: LoadStorageValue() / SaveStorageValue(), moved to example +[core] `WARNING`: RENAMED: GetDirectoryFiles() to LoadDirectoryFiles() +[core] `WARNING`: RENAMED: `ClearDroppedFiles()` to `UnloadDroppedFiles()` +[core] `WARNING`: RENAMED: GetDroppedFiles() to LoadDroppedFiles() +[core] `WARNING`: RENAMED: `ClearDirectoryFiles()` to `UnloadDirectoryFiles()` +[core] `WARNING`: REDESIGNED: WaitTime() argument from milliseconds to seconds (#2506) by @flashback-fx +[core] REVIEWED: GetMonitorWidth()/GetMonitorHeight() by @gulrak +[core] REVIEWED: GetDirectoryFiles(), maximum files allocation (#2126) by @ampers0x26 +[core] REVIEWED: Expose MAX_KEYBOARD_KEYS and MAX_MOUSE_BUTTONS (#2127) +[core] REVIEWED: ExportMesh() (#2138) +[core] REVIEWED: Fullscreen switch on PLATFORM_WEB +[core] REVIEWED: GetMouseWheelMove(), fixed bug +[core] REVIEWED: GetApplicationDirectory() on macOS (#2304) +[core] REVIEWED: ToggleFullscreen() +[core] REVIEWED: Initialize/reset CORE.inputs global state (#2360) +[core] REVIEWED: MouseScrollCallback() (#2371) +[core] REVIEWED: SwapScreenBuffers() for PLATFORM_DRM +[core] REVIEWED: WaitTime(), fix regression causing video stuttering (#2503) by @flashback-fx +[core] REVIEWED: Mouse device support on PLATFORM_DRM (#2381) +[core] REVIEWED: Support OpenBSD timming functions +[core] REVIEWED: Improved boolean definitions (#2485) by @noodlecollie +[core] REVIEWED: TakeScreenshot(), use GetWindowScaleDPI() to calculate size in screenshot/recording (#2446) by @gulrak +[core] REVIEWED: Remove fps requirement for drm connector selection (#2468) by @Crydsch +[core] REVIEWED: IsFileExtension() (#2530) +[camera] REVIEWED: Some camera improvements (#2563) +[rlgl] ADDED: Premultiplied alpha blend mode (#2342) by @megagrump +[rlgl] REVIEWED: VR rendering not taking render target size into account (#2424) by @FireFlyForLife +[rlgl] REVIEWED: Set rlgl internal framebuffer (#2420) +[rlgl] REVIEWED: rlGetCompressedFormatName() +[rlgl] REVIEWED: Display OpenGL 4.3 capabilities with a compile flag (#2124) by @GithubPrankster +[rlgl] REVIEWED: rlUpdateTexture() +[rlgl] REVIEWED: Minimize buffer overflow probability +[rlgl] REVIEWED: Fix scissor mode on macOS (#2170) by @ArnaudValensi +[rlgl] REVIEWED: Clear SSBO buffers on loading (#2185) +[rlgl] REVIEWED: rlLoadShaderCode(), improved shader loading code +[rlgl] REVIEWED: Comment notes about custom blend modes (#2260) by @glorantq +[rlgl] REVIEWED: rlGenTextureMipmaps() +[rlgl] REVIEWED: rlTextureParameters() +[raymath] ADDED: Wrap() (#2522) by @Tekkitslime +[raymath] ADDED: Vector2Transform() +[raymath] ADDED: Vector2DistanceSqr() (#2376) by @AnilBK +[raymath] ADDED: Vector3DistanceSqr() (#2376) by @AnilBK +[raymath] ADDED: Vector2ClampValue(), Vector3ClampValue() (#2428) by @saccharineboi +[raymath] ADDED: Vector3RotateByAxisAngle() (#2590) by @Crydsch +[raymath] `WARNING`: REDESIGNED: Vector2Angle() returns radians instead of degrees (#2193) by @schveiguy +[raymath] `WARNING`: REMOVED: MatrixNormalize() (#2412) +[raymath] REVIEWED: Fix inverse length in Vector2Normalize() (#2189) by @HarriP +[raymath] REVIEWED: Vector2Angle() not working as expected (#2196) by @jdeokkim +[raymath] REVIEWED: Vector2Angle() and Vector3Angle() (#2203) by @trikko +[raymath] REVIEWED: QuaternionInvert(), code simplified (#2324) by @megagrump +[raymath] REVIEWED: QuaternionScale() (#2419) by @tana +[raymath] REVIEWED: Vector2Rotate(), optimized (#2340) by @jdeokkim +[raymath] REVIEWED: QuaternionFromMatrix(), QuaternionEquals() (#2591) by @kirigirihitomi +[raymath] REVIEWED: MatrixRotate*() (#2595, #2599) by @GoodNike +[shapes] REVIEWED: CheckCollision*() consistency +[shapes] REVIEWED: DrawRectanglePro(), support TRIANGLES drawing +[textures] ADDED: Support for QOI image format +[textures] REVIEWED: ImageColorTint(), GetImageColor(), ImageDrawRectangleRec(), optimized functions (#2429) by @AnilBK +[textures] REVIEWED: LoadTextureFromImage(), allow texture loading with no data transfer +[textures] REVIEWED: ImageDraw(), comment to note that f32bit is not supported (#2222) +[textures] REVIEWED: DrawTextureNPatch(), avoid batch overflow (#2401) by @JeffM2501 +[textures] REVIEWED: DrawTextureTiled() (#2173) +[textures] REVIEWED: GenImageCellular() (#2178) +[textures] REVIEWED: LoadTextureCubemap() (#2223, #2224) +[textures] REVIEWED: Export format for float 32bit +[textures] REVIEWED: ExportImage(), support export ".jpeg" files +[textures] REVIEWED: ColorAlphaBlend() (#2524) by @royqh1979 +[textures] REVIEWED: ImageResize() (#2572) +[textures] REVIEWED: ImageFromImage() (#2594) by @wiertek +[text] ADDED: ExportFontAsCode() +[text] ADDED: DrawTextCodepoints() (#2308) by @siddharthroy12 +[text] REVIEWED: TextIsEqual(), protect from NULLs (#2121) by @lukekras +[text] REVIEWED: LoadFontEx(), comment to specify how to get the default character set (#2221) by @JeffM2501 +[text] REVIEWED: GenImageFontAtlas(), increase atlas size guesstimate by @megagrump +[text] REVIEWED: GetCodepoint() (#2201) +[text] REVIEWED: GenImageFontAtlas() (#2556) +[text] REVIEWED: ExportFontAsCode() to use given font padding (#2525) by @TheTophatDemon +[models] ADDED: Reference code to load bones id and weight data for animations +[models] `WARNING`: REMOVED: GetRayCollisionModel() (#2405) +[models] REMOVED: GenMeshBinormals() +[models] REVIEWED: External library: vox_loader.h, 64bit issue (#2186) +[models] REVIEWED: Material color loading when no texture material is available (#2298) by @royqh1979 +[models] REVIEWED: Fix Undefined Symbol _ftelli64 in cgltf (#2319) by @audinue +[models] REVIEWED: LoadGLTF(), fix memory leak (#2441, #2442) by @leomonta +[models] REVIEWED: DrawTriangle3D() batch limits check (#2489) +[models] REVIEWED: DrawBillboardPro() (#2494) +[models] REVIEWED: DrawMesh*() issue (#2211) +[models] REVIEWED: ExportMesh() (#2220) +[models] REVIEWED: GenMeshCylinder() (#2225) +[audio] `WARNING`: ADDED: rAudioProcessor pointer to AudioStream struct (used by Sound and Music structs) +[audio] ADDED: SetSoundPan(), SetMusicPan(), SetAudioStreamPan(), panning support (#2205) by ptarabbia +[audio] ADDED: Audio stream input callback (#2212) by ptarabbia +[audio] ADDED: Audio stream processors support (#2212) by ptarabbia +[audio] REVIEWED: GetMusicTimePlayed(), incorrect value after the stream restarted for XM audio (#2092 #2215) by @ptarabbia +[audio] REVIEWED: Turn on interpolation for XM playback (#2216) by @ptarabbia +[audio] REVIEWED: Fix crash with delay example (#2472) by @ptarabbia +[audio] REVIEWED: PlaySoundMulti() (#2231) +[audio] REVIEWED: ExportWaveAsCode() +[audio] REVIEWED: UpdateMusicStream(), reduce dynamic allocations (#2532) by @dbechrd +[audio] REVIEWED: UpdateMusicStream() to support proper stream looping (#2579) by @veins1 +[utils] ADDED: ExportDataAsCode() +[utils] REVIEWED: Force flush stdout after trace messages (#2465) by @nagy +[easings] ADDED: Function descriptions (#2471) by @RobLoach +[camera] REVIEWED: Fix free camera panning in the wrong direction (#2347) by @DavidLyhedDanielsson +[examples] ADDED: core_window_should_close +[examples] ADDED: core_2d_camera_mouse_zoom (#2583) by @JeffM2501 +[examples] ADDED: shapes_top_down_lights (#2199) by @JeffM2501 +[examples] ADDED: textures_fog_of_war +[examples] ADDED: textures_gif_player +[examples] ADDED: text_codepoints_loading +[examples] ADDED: audio_stream_effects +[examples] REMOVED: core_quat_conversion, not working properly +[examples] REMOVED: raudio_standalone, moved to raudio repo +[examples] RENAMED: textures_rectangle -> textures_sprite_anim +[examples] REVIEWED: core_input_gamepad, improve joystick visualisation (#2390) by @kristianlm +[examples] REVIEWED: textures_draw_tiled +[examples] REVIEWED: shaders_mesh_instancing, free allocated matrices (#2425) by @AnilBK +[examples] REVIEWED: shaders_raymarching +[examples] REVIEWED: audio_raw_stream (#2205) by ptarabbia +[examples] REVIEWED: audio_music_stream +[examples] REVIEWED: shaders_mesh_instancing, simplified +[examples] REVIEWED: shaders_basic_lighting, rlights.h simplified +[examples] REVIEWED: All examples descriptions, included creation/update raylib versions +[parser] ADDED: Defines to parser (#2269) by @iskolbin +[parser] ADDED: Aliases to parser (#2444) by @lazaray +[parser] ADDED: Parse struct descriptions (#2214) by @eutro +[parser] ADDED: Parse enum descriptions and value descriptions (#2208) by @eutro +[parser] ADDED: Lua output format for parser by @iskolbin +[parser] ADDED: Makefile for raylib_parser by @iskolbin +[parser] ADDED: Support for truncating parser input (#2464) by @lazaray +[parser] ADDED: Support for calculated defines to parser (#2463) by @lazaray +[parser] REVIEWED: Update parser files (#2125) by @catmanl +[parser] REVIEWED: Fix memory leak in parser (#2136) by @ronnieholm +[parser] REVIEWED: EscapeBackslashes() +[parser] REVIEWED: Parser improvements (#2461 #2462) by @lazaray +[bindings] ADDED: License details for BINDINGS +[bindings] ADDED: dart-raylib (#2149) by @wolfenrain +[bindings] ADDED: raylib-cslo (#2169) by @jasonswearingen +[bindings] ADDED: raylib-d (#2194) by @schveiguy +[bindings] ADDED: raylib-guile (#2202) by @petelliott +[bindings] ADDED: raylib-scopes (#2238) by @salotz +[bindings] ADDED: naylib (Nim) (#2386) by @planetis-m +[bindings] ADDED: raylib.jl (Julia) (#2403) by @irishgreencitrus +[bindings] ADDED: raylib.zig (#2449) by @ryupold +[bindings] ADDED: racket-raylib (#2454) by @eutro +[bindings] ADDED: raylibr (#2611) by @ramiromagno +[bindings] ADDED: Raylib.4.0.Pascal (#2617) by @sysrpl +[bindings] REVIEWED: Multiple bindings updated to raylib 4.0 +[build] ADDED: VS2022 project +[build] ADDED: Support macOS by zig build system (#2175) +[build] ADDED: Support custom modules selection on compilation +[build] ADDED: Minimal web shell for WebAssembly compilation +[build] ADDED: BSD support for zig builds (#2332) by @zigster64 +[build] ADDED: Repology badge (#2367) by @jubalh +[build] ADDED: Support DLL compilation with TCC compiler (#2569) by @audinue +[build] ADDED: Missing examples to VS2022 examples solution +[build] REMOVED: VS2019 project (unmaintained) +[build] REMOVED: SUPPORT_MOUSE_CURSOR_POINT config option +[build] REVIEWED: Fixed RPi make install (#2217) by @wereii +[build] REVIEWED: Fix build results path on Linux and RPi (#2218) by @wereii +[build] REVIEWED: Makefiles debug flag +[build] REVIEWED: Fixed cross-compilation from x86-64 to RPi (#2233) by @pitpit +[build] REVIEWED: All Makefiles, simplified +[build] REVIEWED: All Makefiles, improve organization +[build] REVIEWED: All Makefiles, support CUSTOM_CFLAGS +[build] REVIEWED: Fixed compiling for Android using CMake (#2270) by @hero2002 +[build] REVIEWED: Make zig build functionality available to zig programs (#2271) by @Not-Nik +[build] REVIEWED: Update CMake project template with docs and web (#2274) by @RobLoach +[build] REVIEWED: Update VSCode project to work with latest makefile and web (#2296) by @phil-shenk +[build] REVIEWED: Support audio examples compilation with external glfw (#2329) by @locriacyber +[build] REVIEWED: Fix "make clean" target failing when shell is not cmd (#2338) by @Peter0x44 +[build] REVIEWED: Makefile linkage -latomic, required by miniaudio on ARM 32bit #2452 +[build] REVIEWED: Update raylib-config.cmake (#2374) by @marcogmaia +[build] REVIEWED: Simplify build.zig to not require user to specify raylib path (#2383) by @Hejsil +[build] REVIEWED: Fix OpenGL 4.3 graphics option in CMake (#2427) by @GoldenThumbs +[extras] `WARNING`: REMOVED: physac from raylib sources/examples, use github.com/raysan5/physac +[extras] `WARNING`: REMOVED: raygui from raylib/src/extras, use github.com/raysan5/raygui +[extras] `WARNING`: REMOVED: rmem from raylib/src/extras, moved to github.com/raylib-extras/rmem +[extras] `WARNING`: REMOVED: easings from raylib/src/extras, moved to github.com/raylib-extras/reasings +[extras] `WARNING`: REMOVED: raudio.h from raylib/src, moved to github.com/raysan5/raudio +[misc] REVIEWED: Update some external libraries to latest versions + +------------------------------------------------------------------------- +Release: raylib 4.0 - 8th Anniversary Edition (05 November 2021) +------------------------------------------------------------------------- +KEY CHANGES: + - Naming consistency and coherency: Complete review of the library: syntax, naming, comments, decriptions, logs... + - Event Automation System: Support for input events recording and automatic re-playing, useful for automated testing and more! + - Custom game-loop control: Intended for advance users that want to control the events polling and the timming mechanisms + - rlgl 4.0: Completely decoupling from platform layer and raylib, intended for standalone usage as single-file header-only + - raymath 1.5: Complete review following new conventions, to make it more portable and self-contained + - raygui 3.0: Complete review and official new release, more portable and self-contained, intended for tools development + - raylib_parser: New tool to parse raylib.h and extract all required info into custom output formats (TXT, XML, JSON...) + - Zig and Odin official support + +Detailed changes: +[core] ADDED: Support canvas resizing on web (#1840) by @skylersaleh +[core] ADDED: GetMouseDelta() (#1832) by @adricoin2010 +[core] ADDED: Support additional mouse buttons (#1753) by @lambertwang +[core] ADDED: SetRandomSeed() (#1994) by @TommiSinivuo +[core] ADDED: GetTouchPointId() #1972 +[core] ADDED: EncodeDataBase64() and DecodeDataBase64() +[core] REMOVED: PLATFORM_UWP, difficult to maintain +[core] REMOVED: IsGamepadName() +[core] RENAMED: SwapBuffers() to SwapScreenBuffer() +[core] RENAMED: Wait() to WaitTime() +[core] RENAMED: RayHitInfo to RayCollision (#1781) +[core] RENAMED: GetRayCollisionGround() to GetRayCollisionQuad() (#1781) +[core] REVIEWED: Support mouse wheel on x-axis (#1948) +[core] REVIEWED: DisableCursor() on web by registering an empty mouse click event function in emscripten (#1900) by @grenappels +[core] REVIEWED: LoadShader() and default locations and descriptions +[core] REVIEWED: LoadShaderFromMemory() (#1851) by @Ruminant +[core] REVIEWED: WaitTime(), avoid global variables dependency to make the function is self-contained (#1841) +[core] REVIEWED: SetWindowSize() to work on web (#1847) by @nikki93 +[core] REVIEWED: Raspberry RPI/DRM keyboard blocking render loop (#1879) @luizpestana +[core] REVIEWED: Android multi-touch (#1869) by @humbe +[core] REVIEWED: Implemented GetGamepadName() for emscripten by @nbarkhina +[core] REVIEWED: HighDPI support (#1987) by @ArnaudValensi +[core] REVIEWED: KeyCallback(), register keys independently of the actions +[rlgl] ADDED: GRAPHIC_API_OPENGL_43 +[rlgl] ADDED: rlUpdateVertexBufferElements() (#1915) +[rlgl] ADDED: rlActiveDrawBuffers() (#1911) +[rlgl] ADDED: rlEnableColorBlend()/rlDisableColorBlend() +[rlgl] ADDED: rlGetPixelFormatName() +[rlgl] REVIEWED: rlUpdateVertexBuffer (#1914) by @630Studios +[rlgl] REVIEWED: rlDrawVertexArrayElements() (#1891) +[rlgl] REVIEWED: Wrong normal matrix calculation (#1870) +[raymath] ADDED: Vector3Angle() +[raymath] REVIEWED: QuaternionFromAxisAngle() (#1892) +[raymath] REVIEWED: QuaternionToMatrix() returning transposed result. (#1793) by @object71 +[shapes] ADDED: RenderPolyLinesEx() (#1758) by @lambertwang +[shapes] ADDED: DrawLineBezierCubic() (#2021) by @SAOMDVN +[textures] ADDED: GetImageColor() #2024 +[textures] REMOVED: GenImagePerlinNoise() +[textures] RENAMED: GetTextureData() to LoadImageFromTexture() +[textures] RENAMED: GetScreenData() to LoadImageFromScreen() +[textures] REVIEWED: ExportImage() to use SaveFileData() (#1779) +[textures] REVIEWED: LoadImageAnim() #2005 +[text] ADDED: Security check in case of not valid font +[text] ADDED: `GetGlyphInfo()` to get glyph info for a specific codepoint +[text] ADDED: `GetGlyphAtlasRec()` to get glyph rectangle within the generated font atlas +[text] ADDED: DrawTextPro() with text rotation support, WARNING: DrawTextPro() requires including `rlgl.h`, before it was only dependant on `textures` module. +[text] ADDED: UnloadCodepoints() to safely free loaded codepoints +[text] REMOVED: DrawTextRec() and DrawTextRecEx(), moved to example, those functions could be very specific depending on user needs so it's better to give the user the full source in case of special requirements instead of allowing a function with +10 input parameters. +[text] RENAMED: struct `CharInfo` to `GlyphInfo`, actually that's the correct naming for the data contained. It contains the character glyph metrics and the glyph image; in the past it also contained rectangle within the font atlas but that data has been moved to `Font` struct directly, so, `GlyphInfo` is a more correct name. +[text] RENAMED: `CodepointToUtf8()` to `CodepointToUTF8()`, capitalization of UTF-8 is the correct form, it would also require de hyphen but it can be omitted in this case. +[text] RENAMED: `TextToUtf8()` to `TextCodepointsToUTF8` for consistency and more detail on the functionality. +[text] RENAMED: GetCodepoints() to LoadCodepoints(), now codepoint array data is loaded dynamically instead of reusing a limited static buffer. +[text] RENAMED: GetNextCodepoint() to GetCodepoint() +[models] ADDED: MagikaVoxel VOX models loading +[models] ADDED: GenMeshCone() (#1903) +[models] ADDED: GetModelBoundingBox() +[models] ADDED: DrawBillboardPro() (#1759) by @nobytesgiven +[models] ADDED: DrawCubeTextureRec() (#2001) by @tdgroot +[models] ADDED: DrawCylinderEx() and DrawCylinderWiresEx() (#2049) by @Horrowind +[models] REMOVED: DrawBillboardEx() +[models] RENAMED: MeshBoundingBox() to GetMeshBoundingBox() +[models] RENAMED: MeshTangents() to GenMeshTangents() +[models] RENAMED: MeshBinormals() to GenMeshBinormals() +[models] REVIEWED: GenMeshTangents() (#1877) by @630Studios +[models] REVIEWED: CheckCollisionBoxSphere() by @Crydsch +[models] REVIEWED: GetRayCollisionQuad() by @Crydsch +[models] REVIEWED: LoadGLTF(), fixed missing transformations and nonroot skinning by @MrDiver +[models] REVIEWED: LoadGLTF(), rewriten from scratch, removed animations support (broken) +[models] REVIEWED: Decouple DrawMesh() and DrawMeshInstanced() (#1958) +[models] REVIEWED: Support vertex color attribute for GLTF and IQM (#1790) by @object71 +[models] REVIEWED: DrawBillboardPro() (#1941) by @GithubPrankster +[models] REDESIGNED: Major review of glTF loading functionality (#1849) by @object71 +[audio] ADDED: SeekMusicStream() (#2006) by @GithubPrankster +[audio] REMOVED: GetAudioStreamBufferSizeDefault() +[audio] RENAMED: InitAudioStream() to LoadAudioStream() +[audio] RENAMED: CloseAudioStream() to UnloadAudioStream() +[audio] RENAMED: IsMusicPlaying() to IsMusicStreamPlaying() +[audio] REVIEWED: ExportWaveAsCode() +[audio] REDESIGNED: Use frameCount on audio instead of sampleCount +[utils] REVIEWED: exit() on LOG_FATAL instead of LOG_ERROR (#1796) +[examples] ADDED: core_custom_frame_control +[examples] ADDED: core_basic_screen_manager +[examples] ADDED: core_split_screen (#1806) by @JeffM2501 +[examples] ADDED: core_smooth_pixelperfect (#1771) by @NotManyIdeasDev +[examples] ADDED: shaders_texture_outline (#1883) by @GoldenThumbs +[examples] ADDED: models_loading_vox (#1940) by @procfxgen +[examples] ADDED: rlgl_compute_shader by @TSnake41 (#2088) +[examples] REMOVED: models_material_pbr +[examples] REMOVED: models_gltf_animation +[examples] REVIEWED: core_3d_picking +[examples] REVIEWED: core_input_mouse +[examples] REVIEWED: core_vr_simulator, RenderTexture usage +[examples] REVIEWED: core_window_letterbox, RenderTexture usage +[examples] REVIEWED: shapes_basic_shapes +[examples] REVIEWED: shapes_logo_raylib_anim +[examples] REVIEWED: textures_to_image +[examples] REVIEWED: text_rectangle_bounds +[examples] REVIEWED: text_unicode +[examples] REVIEWED: text_draw_3d +[examples] REVIEWED: models_loading +[examples] REVIEWED: models_skybox (#1792) (#1778) +[examples] REVIEWED: models_mesh_picking +[examples] REVIEWED: models_yaw_pitch_roll +[examples] REVIEWED: models_rlgl_solar_system +[examples] REVIEWED: shaders_custom_uniform, RenderTexture usage +[examples] REVIEWED: shaders_eratosthenes, RenderTexture usage +[examples] REVIEWED: shaders_julia_set, RenderTexture usage +[examples] REVIEWED: shaders_postprocessing, RenderTexture usage +[examples] REVIEWED: shaders_basic_lighting, simplified (#1865) +[examples] REVIEWED: audio_raw_stream.c +[examples] REVIEWED: raudio_standalone +[examples] REVIEWED: raylib_opengl_interop +[examples] REVIEWED: rlgl_standalone.c +[examples] REVIEWED: Resources licenses +[examples] REVIEWED: models resources reorganization +[templates] REMOVED: Moved to a separate repo: https://github.com/raysan5/raylib-game-template +[build] ADDED: Zig build file (#2014) by @TommiSinivuo +[build] ADDED: Android VS2019 solution (#2013) by @Kronka +[build] REMOVED: VS2017 project, outdated +[build] RENAMED: All raylib modules prefixed with 'r' (core -> rcore) +[build] RENAMED: SUPPORT_MOUSE_CURSOR_NATIVE to SUPPORT_MOUSE_CURSOR_POINT +[build] REVIEWED: examples/examples_template.c +[build] REVIEWED: Makefile to latest Emscripten SDK r23 +[build] REVIEWED: Makefile for latest Android NDK r32 LTS +[build] REVIEWED: raylib resource files +[build] Moved some extra raylib libraries to /extras/ directory +[*] UPDATED: Multiple bindings to latest version +[*] UPDATED: Most external libraries to latest versions (except GLFW) +[*] Multiple code improvements and fixes by multiple contributors! + +------------------------------------------------------------------------- +Release: raylib 3.7 (26 April 2021) +------------------------------------------------------------------------- +KEY CHANGES: + - [rlgl] REDESIGNED: Greater abstraction level, some functionality moved to core module + - [rlgl] REVIEWED: Instancing and stereo rendering + - [core] REDESIGNED: VR simulator, fbo/shader exposed to user + - [utils] ADDED: File access callbacks system + - [models] ADDED: glTF animations support (#1551) by @object71 + - [audio] ADDED: Music streaming support from memory (#1606) by @nezvers + - [*] RENAMED: enum types and enum values for consistency + +Detailed changes: +[core] ADDED: LoadVrStereoConfig() +[core] ADDED: UnloadVrStereoConfig() +[core] ADDED: BeginVrStereoMode() +[core] ADDED: EndVrStereoMode() +[core] ADDED: GetCurrentMonitor() (#1485) by @object71 +[core] ADDED: SetGamepadMappings() (#1506) +[core] RENAMED: struct Camera: camera.type to camera.projection +[core] RENAMED: LoadShaderCode() to LoadShaderFromMemory() (#1690) +[core] RENAMED: SetMatrixProjection() to rlSetMatrixProjection() +[core] RENAMED: SetMatrixModelview() to rlSetMatrixModelview() +[core] RENAMED: GetMatrixModelview() to rlGetMatrixModelview() +[core] RENAMED: GetMatrixProjection() to rlGetMatrixProjection() +[core] RENAMED: GetShaderDefault() to rlGetShaderDefault() +[core] RENAMED: GetTextureDefault() to rlGetTextureDefault() +[core] REMOVED: GetShapesTexture() +[core] REMOVED: GetShapesTextureRec() +[core] REMOVED: GetMouseCursor() +[core] REMOVED: SetTraceLogExit() +[core] REVIEWED: GetFileName() and GetDirectoryPath() (#1534) by @gilzoide +[core] REVIEWED: Wait() to support FreeBSD (#1618) +[core] REVIEWED: HighDPI support on macOS retina (#1510) +[core] REDESIGNED: GetFileExtension(), includes the .dot +[core] REDESIGNED: IsFileExtension(), includes the .dot +[core] REDESIGNED: Compresion API to use sdefl/sinfl libs +[rlgl] ADDED: SUPPORT_GL_DETAILS_INFO config flag +[rlgl] REMOVED: GenTexture*() functions (#721) +[rlgl] REVIEWED: rlLoadShaderDefault() +[rlgl] REDESIGNED: rlLoadExtensions(), more details exposed +[raymath] REVIEWED: QuaternionFromEuler() (#1651) +[raymath] REVIEWED: MatrixRotateZYX() (#1642) +[shapes] ADDED: DrawLineBezierQuad() (#1468) by @epsilon-phase +[shapes] ADDED: CheckCollisionLines() +[shapes] ADDED: CheckCollisionPointLine() by @mkupiec1 +[shapes] REVIEWED: CheckCollisionPointTriangle() by @mkupiec1 +[shapes] REDESIGNED: SetShapesTexture() +[shapes] REDESIGNED: DrawCircleSector(), to use float params +[shapes] REDESIGNED: DrawCircleSectorLines(), to use float params +[shapes] REDESIGNED: DrawRing(), to use float params +[shapes] REDESIGNED: DrawRingLines(), to use float params +[textures] ADDED: DrawTexturePoly() and example (#1677) by @chriscamacho +[textures] ADDED: UnloadImageColors() for allocs consistency +[textures] RENAMED: GetImageData() to LoadImageColors() +[textures] REVIEWED: ImageClearBackground() and ImageDrawRectangleRec() (#1487) by @JeffM2501 +[textures] REVIEWED: DrawTexturePro() and DrawRectanglePro() transformations (#1632) by @ChrisDill +[text] REDESIGNED: DrawFPS() +[models] ADDED: UploadMesh() (#1529) +[models] ADDED: UpdateMeshBuffer() +[models] ADDED: DrawMesh() +[models] ADDED: DrawMeshInstanced() +[models] ADDED: UnloadModelAnimations() (#1648) by @object71 +[models] REMOVED: DrawGizmo() +[models] REMOVED: LoadMeshes() +[models] REMOVED: MeshNormalsSmooth() +[models] REVIEWED: DrawLine3D() (#1643) +[audio] REVIEWED: Multichannel sound system (#1548) +[audio] REVIEWED: jar_xm library (#1701) by @jmorel33 +[utils] ADDED: SetLoadFileDataCallback() +[utils] ADDED: SetSaveFileDataCallback() +[utils] ADDED: SetLoadFileTextCallback() +[utils] ADDED: SetSaveFileTextCallback() +[examples] ADDED: text_draw_3d (#1689) by @Demizdor +[examples] ADDED: textures_poly (#1677) by @chriscamacho +[examples] ADDED: models_gltf_model (#1551) by @object71 +[examples] RENAMED: shaders_rlgl_mesh_instanced to shaders_mesh_intancing +[examples] REDESIGNED: shaders_rlgl_mesh_instanced by @moliad +[examples] REDESIGNED: core_vr_simulator +[examples] REDESIGNED: models_yaw_pitch_roll +[build] ADDED: Config flag: SUPPORT_STANDARD_FILEIO +[build] ADDED: Config flag: SUPPORT_WINMM_HIGHRES_TIMER (#1641) +[build] ADDED: Config flag: SUPPORT_GL_DETAILS_INFO +[build] ADDED: Examples projects to VS2019 solution +[build] REVIEWED: Makefile to support PLATFORM_RPI (#1580) +[build] REVIEWED: Multiple typecast warnings by @JeffM2501 +[build] REDESIGNED: VS2019 project build paths +[build] REDESIGNED: CMake build system by @object71 +[*] RENAMED: Several functions parameters for consistency +[*] UPDATED: Multiple bindings to latest version +[*] UPDATED: All external libraries to latest versions +[*] Multiple code improvements and fixes by multiple contributors! + +------------------------------------------------------------------------- +Release: raylib 3.5 - 7th Anniversary Edition (25 December 2020) +------------------------------------------------------------------------- +KEY CHANGES: + - [core] ADDED: PLATFORM_DRM to support RPI4 and other devices (#1388) by @kernelkinetic + - [core] REDESIGNED: Window states management system through FLAGS + - [rlgl] ADDED: RenderBatch type and related functions to allow custom batching (internal only) + - [rlgl] REDESIGNED: Framebuffers API to support multiple attachment types (#721) + - [textures] REDESIGNED: Image*() functions, big performance improvements (software rendering) + - [*] REVIEWED: Multiple functions to replace file accesses by memory accesses + - [*] ADDED: GitHub Actions CI to support multiple raylib build configurations + +Detailed changes: +[core] ADDED: SetWindowState() / ClearWindowState() -> New flags added! +[core] ADDED: IsWindowFocused() +[core] ADDED: GetWindowScaleDPI() +[core] ADDED: GetMonitorRefreshRate() (#1289) by @Shylie +[core] ADDED: IsCursorOnScreen() (#1262) by @ChrisDill +[core] ADDED: SetMouseCursor() and GetMouseCursor() for standard Desktop cursors (#1407) by @chances +[core] REMOVED: struct RenderTexture2D: depthTexture variable +[core] REMOVED: HideWindow() / UnhideWindow() -> Use SetWindowState() +[core] REMOVED: DecorateWindow() / UndecorateWindow() -> Use SetWindowState() +[core] RENAMED: GetExtension() to GetFileExtension() +[core] REVIEWED: Several structs to reduce size and padding +[core] REVIEWED: struct Texture maps to Texture2D and TextureCubemap +[core] REVIEWED: ToggleFullscreen() (#1287) +[core] REVIEWED: InitWindow(), support empty title for window (#1323) +[core] REVIEWED: RPI: Mouse movements are bound to the screen resolution (#1392) (#1410) by @kernelkinetic +[core] REVIEWED: GetPrevDirectoryPath() fixes on Unix-like systems (#1246) by @ivan-cx +[core] REPLACED: rgif.h by msf_gif.h for automatic gif recording +[core] REDESIGNED: GetMouseWheelMove() to return float movement for precise scrolling (#1397) by @Doy-lee +[core] REDESIGNED: GetKeyPressed(), and added GetCharPressed() (#1336) +[core] UWP rework with improvements (#1231) by @Rover656 +[core] Gamepad axis bug fixes and improvement (#1228) by @mmalecot +[core] Updated joystick mappings with latest version of gamecontrollerdb (#1381) by @coderoth +[rlgl] Corrected issue with OpenGL 1.1 support +[rlgl] ADDED: rlDrawMeshInstanced() (#1318) by @seanpringle +[rlgl] ADDED: rlCheckErrors (#1321) by @seanpringle +[rlgl] ADDED: BLEND_SET blending mode (#1251) by @RandomErrorMessage +[rlgl] ADDED: rlSetLineWidth(), rlGetLineWidth(), rlEnableSmoothLines(), rlDisableSmoothLines() (#1457) by @JeffM2501 +[rlgl] RENAMED: rlUnproject() to Vector3Unproject() [raymath] +[rlgl] REVIEWED: Replace rlglDraw() calls by DrawRenderBatch() internal calls +[rlgl] REVIEWED: GenTextureCubemap(), use rlgl functionality only +[rlgl] REVIEWED: rlFramebufferAttach() to support texture layers +[rlgl] REVIEWED: GenDrawCube() and GenDrawQuad() +[rlgl] REVIEWED: Issues with vertex batch overflow (#1223) +[rlgl] REVIEWED: rlUpdateTexture(), issue with offsets +[rlgl] REDESIGNED: GenTexture*() to use the new fbo API (#721) +[raymath] ADDED: Normalize() and Remap() functions (#1247) by @NoorWachid +[raymath] ADDED: Vector2Reflect() (#1400) by @daniel-junior-dube +[raymath] ADDED: Vector2LengthSqr() and Vector3LengthSqr() (#1248) by @ThePituLegend +[raymath] ADDED: Vector2MoveTowards() function (#1233) by @anatagawa +[raymath] REVIEWED: Some functions consistency (#1197) by @Not-Nik +[raymath] REVIEWED: QuaternionFromVector3ToVector3() (#1263) by @jvocaturo +[raymath] REVIEWED: MatrixLookAt(), optimized (#1442) by @RandomErrorMessage +[shapes] ADDED: CheckCollisionLines(), by @Elkantor +[text] Avoid [textures] functions dependencies +[text] ADDED: Config flag: SUPPORT_TEXT_MANIPULATION +[text] ADDED: LoadFontFromMemory() (TTF only) (#1327) +[text] ADDED: UnloadFontData() +[text] RENAMED: FormatText() -> TextFormat() +[text] REVIEWED: Font struct, added charsPadding (#1432) +[text] REVIEWED: TextJoin() +[text] REVIEWED: TextReplace() (#1172) +[text] REVIEWED: LoadBMFont() to load data from memory (#1232) +[text] REVIEWED: GenImageFontAtlas(), fixed offset (#1171) +[text] REDESIGNED: LoadFontData(), reviewed input parameters +[text] REDESIGNED: LoadFontDefault(), some code simplifications +[text] REDESIGNED: LoadFontFromImage(), avoid LoadImageEx() +[text] REDESIGNED: LoadFontData(), avoid GenImageColor(), ImageFormat() +[text] REDESIGNED: LoadBMFont(), avoid ImageCopy(), ImageFormat(), ImageAlphaMask() +[textures] Move Color functions from [core] to [textures] module +[textures] ADDED: ColorAlphaBlend() +[textures] ADDED: GetPixelColor() +[textures] ADDED: SetPixelColor() +[textures] ADDED: LoadImageFromMemory() (#1327) +[textures] ADDED: LoadImageAnim() to load animated sequence of images +[textures] ADDED: DrawTextureTiled() (#1291) - @Demizdor +[textures] ADDED: UpdateTextureRec() +[textures] ADDED: UnloadImageColors(), UnloadImagePalette(), UnloadWaveSamples() +[textures] REMOVED: Config flag: SUPPORT_IMAGE_DRAWING +[textures] REMOVED: LoadImageEx() +[textures] REMOVED: LoadImagePro() +[textures] REMOVED: GetImageDataNormalized(), not exposed in the API +[textures] RENAMED: ImageExtractPalette() to GetImagePalette() +[textures] RENAMED: Fade() to ColorAlpha(), added #define for compatibility +[textures] RENAMED: GetImageData() -> LoadImageColors() +[textures] RENAMED: GetImagePalette() -> LoadImagePalette() +[textures] RENAMED: GetWaveData() -> LoadWaveSamples() +[textures] REVIEWED: GetPixelDataSize() to consider compressed data properly +[textures] REVIEWED: GetTextureData(), allow retrieving 32bit float data +[textures] REVIEWED: ImageDrawText*() params order +[textures] REVIEWED: ColorAlphaBlend(), support tint color +[textures] REVIEWED: ColorAlphaBlend(), integers-version, optimized (#1218) +[textures] REVIEWED: ImageDraw(), consider negative source offset properly (#1283) +[textures] REVIEWED: ImageDraw(), optimizations test (#1218) +[textures] REVIEWED: ImageResizeCanvas(), optimization (#1218) +[textures] REVIEWED: ExportImage(), optimized +[textures] REVIEWED: ImageAlphaPremultiply(), optimization +[textures] REVIEWED: ImageAlphaClear(), minor optimization +[textures] REVIEWED: ImageToPOT(), renamed parameter +[textures] REVIEWED: ImageCrop() (#1218) +[textures] REVIEWED: ImageToPOT() (#1218) +[textures] REVIEWED: ImageAlphaCrop() (#1218) +[textures] REVIEWED: ExportImage(), optimized (#1218) +[textures] REDESIGNED: ImageCrop(), optimized (#1218) +[textures] REDESIGNED: ImageRotateCCW(), optimized (#1218) +[textures] REDESIGNED: ImageRotateCW(), optimized (#1218) +[textures] REDESIGNED: ImageFlipHorizontal(), optimized (#1218) +[textures] REDESIGNED: ImageFlipVertical(), optimized (#1218) +[textures] REDESIGNED: ImageResizeCanvas(), optimized (#1218) +[textures] REDESIGNED: ImageDrawPixel(), optimized +[textures] REDESIGNED: ImageDrawLine(), optimized +[textures] REDESIGNED: ImageDraw(), optimized (#1218) +[textures] REDESIGNED: ImageResize(), optimized (#1218) +[textures] REDESIGNED: ImageFromImage(), optimized (#1218) +[textures] REDESIGNED: ImageDraw(), optimization (#1218) +[textures] REDESIGNED: ImageAlphaClear(), optimized (#1218) +[textures] REDESIGNED: ExportImageAsCode() to use memory buffer (#1232) +[textures] REDESIGNED: ColorFromHSV() +[models] ADDED: DrawTriangle3D() and DrawTriangleStrip3D() +[models] ADDED: UnloadModelKeepMeshes() +[models] REVIEWED: LoadModel(), avoid loading texcoords and normals from model if not existent +[models] REVIEWED: GenMeshCubicmap(), added comments and simplification +[models] REVIEWED: GenMeshCubicmap(), fixed generated normals (#1244) by @GoldenThumbs +[models] REVIEWED: GenMeshPoly(), fixed buffer overflow (#1269) by @frithrah +[models] REVIEWED: LoadOBJ(): Allow for multiple materials in obj files (#1408) by @chriscamacho and @codifies +[models] REVIEWED: LoadIQM() materials loading (#1227) by @sikor666 +[models] REVIEWED: LoadGLTF() to read from memory buffer +[models] REVIEWED: UpdateMesh(), fix extra memory allocated when updating color buffer (#1271) by @4yn +[models] REVIEWED: MeshNormalsSmooth() (#1317) by @seanpringle +[models] REVIEWED: DrawGrid() (#1417) +[models] REDESIGNED: ExportMesh() to use memory buffer (#1232) +[models] REDESIGNED: LoadIQM() and LoadModelAnimations() to use memory buffers +[audio] ADDED: LoadWaveFromMemory() (#1327) +[audio] REMOVED: SetMusicLoopCount() +[audio] REVIEWED: Several functions, sampleCount vs frameCount (#1423) +[audio] REVIEWED: SaveWAV() to use memory write insted of file +[audio] REVIEWED: LoadMusicStream(), support WAV music streaming (#1198) +[audio] REVIEWED: Support multiple WAV sampleSize for MusicStream (#1340) +[audio] REVIEWED: SetAudioBufferPitch() +[audio] REDESIGNED: Audio looping system +[audio] REDESIGNED: LoadSound(): Use memory loading (WAV, OGG, MP3, FLAC) (#1312) +[audio] REDESIGNED: ExportWaveAsCode() to use memory buffers +[utils] ADDED: MemAlloc() / MemFree() (#1440) +[utils] ADDED: UnloadFileData() / UnloadFileText() +[utils] REVIEWED: android_fopen() to support SDCard access +[utils] REDESIGNED: SaveFile*() functions to expose file access results (#1420) +[rmem] REVIEWED: MemPool and other allocators optimization (#1211) by @assyrianic +[examples] ADDED: core/core_window_flags +[examples] ADDED: core/core_quat_conversion by @chriscamacho and @codifies +[examples] ADDED: textures/textures_blend_modes (#1261) by @accidentalrebel +[examples] ADDED: textures/textures_draw_tiled (#1291) by @Demizdor +[examples] ADDED: shaders/shaders_hot_reloading (#1198) +[examples] ADDED: shaders/shaders_rlgl_mesh_instanced (#1318) by @seanpringle +[examples] ADDED: shaders/shaders_multi_sampler2d +[examples] ADDED: others/embedded_files_loading +[examples] REVIEWED: textures/textures_raw_data (#1286) +[examples] REVIEWED: textures/textures_sprite_explosion, replace resources +[examples] REVIEWED: textures/textures_particles_blending, replace resources +[examples] REVIEWED: textures/textures_image_processing, support mouse +[examples] REVIEWED: models/models_skybox to work on OpenGL ES 2.0 +[examples] REVIEWED: audio/resources, use open license resources +[examples] REVIEWED: others/raudio_standalone.c +[build] ADDED: New config.h configuration options exposing multiple #define values +[build] REMOVED: ANGLE VS2017 template project +[build] REVIEWED: All MSVC compile warnings +[build] Updated Makefile for web (#1332) by @rfaile313 +[build] Updated build pipelines to use latest emscripten and Android NDK +[build] Updated emscriptem build script to generate .a on WebAssembly +[build] Updated Android build for Linux, supporting ANDROID_NDK at compile time by @branlix3000 +[build] Updated VSCode project template tasks +[build] Updated VS2017.UWP project template by @Rover656 +[build] Updated Android build pipeline +[build] REMOVED: AppVeyor and Travis CI build systems +[*] Moved raysan5/raylib/games to independent repo: raysan5/raylib-games +[*] Replaced several examples resources with more open licensed alternatives +[*] Updated BINDINGS.md with NEW bindings and added raylib version binding! +[*] Updated all external libraries to latest versions +[*] Multiple code improvements and small fixes + +----------------------------------------------- +Release: raylib 3.0 (01 April 2020) +----------------------------------------------- +KEY CHANGES: + - Global context states used on all modules. + - Custom memory allocators for all modules and dependencies. + - Centralized file access system and memory data loading. + - Structures reviewed to reduce size and always be used as pass-by-value. + - Tracelog messages completely reviewed and categorized. + - raudio module reviewed to accomodate new Music struct and new miniaudio. + - text module reviewed to improve fonts generation and text management functions. + - Multiple new examples added and categorized examples table. + - GitHub Actions CI implemented for Windows, Linux and macOS. + +Detailed changes: +[build] ADDED: VS2017.ANGLE project, by @msmshazan +[build] ADDED: VS2017 project support for x64 platform configuration +[build] ADDED: Makefile for Android building on macOS, by @Yunoinsky +[build] ADDED: Makefile for Android building on Linux, by @pamarcos +[build] REMOVED: VS2015 project +[build] REVIEWED: VSCode project +[build] REVIEWED: Makefile build system +[build] REVIEWED: Android building, by @NimbusFox +[build] REVIEWED: Compilation with CLion IDE, by @Rover656 +[build] REVIEWED: Generation of web examples, by @pamarcos +[build] REVIEWED: Makefiles path to 'shell.html', by @niorad +[build] REVIEWED: VS2017 64bit compilation issues, by @spec-chum +[build] REVIEWED: Multiple fixes on projects building, by @ChrisDill, @JuDelCo, @electronstudio +[core] ADDED: Support touch/mouse indistinctly +[core] ADDED: FLAG_WINDOW_ALWAYS_RUN to avoid pause on minimize +[core] ADDED: Config flag SUPPORT_HALFBUSY_WAIT_LOOP +[core] ADDED: RPI mouse cursor point support on native mode +[core] ADDED: GetWorldToScreen2D()- Get screen space position for a 2d camera world space position, by @arvyy +[core] ADDED: GetScreenToWorld2D() - Get world space position for a 2d camera screen space position, by @arvyy +[core] ADDED: GetWorldToScreenEx() - Get size position for a 3d world space position +[core] ADDED: DirectoryExists() - Check if a directory path exists +[core] ADDED: GetPrevDirectoryPath() - Get previous directory path for a given path +[core] ADDED: CompressData() - Compress data (DEFLATE algorythm) +[core] ADDED: DecompressData() - Decompress data (DEFLATE algorythm) +[core] ADDED: GetWindowPosition() - Get window position XY on monitor +[core] ADDED: LoadFileData() - Load file data as byte array (read) +[core] ADDED: SaveFileData() - Save data to file from byte array (write) +[core] ADDED: LoadFileText() - Load text data from file (read), returns a '\0' terminated string +[core] ADDED: SaveFileText() - Save text data to file (write), string must be '\0' terminated +[core] REMOVED: Show raylib logo at initialization +[core] REVIEWED: GetFileName(), security checks +[core] REVIEWED: LoadStorageValue(), by @danimartin82 +[core] REVIEWED: SaveStorageValue(), by @danimartin82 +[core] REVIEWED: IsMouseButtonReleased(), when press/release events come too fast, by @oswjk +[core] REVIEWED: SetWindowMonitor(), by @DropsOfSerenity +[core] REVIEWED: IsFileExtension() to be case-insensitive +[core] REVIEWED: IsFileExtension() when checking no-extension files +[core] REVIEWED: Default font scale filter for HighDPI mode +[core] REVIEWED: Touch input scaling for PLATFORM_WEB +[core] REVIEWED: RPI input system, by @DarkElvenAngel +[core] REVIEWED: RPI input threads issues +[core] REVIEWED: OpenGL extensions loading and freeing +[core] REVIEWED: GetDirectoryPath() +[core] REVIEWED: Camera2D behavior, by @arvyy +[core] REVIEWED: OpenGL ES 2.0 extensions check +[rlgl] ADDED: Flags to allow frustrum culling near/far distance configuration at compile time +[rlgl] ADDED: Flags to sllow MAX_BATCH_BUFFERING config at compile time +[rlgl] ADDED: GetMatrixProjection(), by @chriscamacho +[rlgl] ADDED: rlUpdateMeshAt() - Update vertex or index data on GPU, at index, by @brankoku +[rlgl] REVIEWED: Vertex padding not zeroed for quads, by @kawa-yoiko +[rlgl] REVIEWED: Read texture data as RGBA from FBO on GLES 2.0 +[rlgl] REVIEWED: LoadShaderCode() for const correctness, by @heretique +[rlgl] REVIEWED: rlLoadTexture() +[rlgl] REVIEWED: rlReadTexturePixels() +[rlgl] REVIEWED: rlUpdateMesh() to supports updating indices, by @brankoku +[rlgl] REVIEWED: GenTextureCubemap(), renamed parameters for consistency +[rlgl] REVIEWED: HDR pixels loading +[raymath] ADDED: MatrixRotateXYZ(), by @chriscamacho +[raymath] RENAMED: Vector3Multiply() to Vector3Scale() +[camera] REVIEWED: Free camera pitch, by @chriscamacho +[camera] REVIEWED: Camera not working properly at z-align, by @Ushio +[shapes] ADDED: DrawTriangleStrip() - Draw a triangle strip defined by points +[shapes] ADDED: DrawEllipse() - Draw ellipse +[shapes] ADDED: DrawEllipseLines() - Draw ellipse outline +[shapes] ADDED: DrawPolyLines() - Draw a polygon outline of n sides +[shapes] REVIEWED: DrawPoly() shape rendering, by @AlexHCC +[textures] ADDED: LoadAnimatedGIF() - Load animated GIF file +[textures] ADDED: GetImageAlphaBorder() - Get image alpha border rectangle +[textures] ADDED: ImageFromImage() - Create an image from another image piece +[textures] ADDED: ImageClearBackground(), by @iamsouravgupta +[textures] ADDED: ImageDrawPixel(), by @iamsouravgupta +[textures] ADDED: ImageDrawCircle(), by @iamsouravgupta +[textures] ADDED: ImageDrawLineEx(), by @iamsouravgupta +[textures] ADDED: ImageDrawPixelV(), by @RobLoach +[textures] ADDED: ImageDrawCircleV(), by @RobLoach +[textures] ADDED: ImageDrawLineV(), by @RobLoach +[textures] ADDED: ImageDrawRectangleV(), by @RobLoach +[textures] ADDED: ImageDrawRectangleRec(), by @RobLoach +[textures] REVIEWED: ImageDrawPixel(), by @RobLoach +[textures] REVIEWED: ImageDrawLine(), by @RobLoach +[textures] REVIEWED: ImageDrawCircle(), by @RobLoach +[textures] REVIEWED: ImageDrawRectangle(), by @RobLoach +[textures] REVIEWED: ImageDraw(), now it supports color tint parameter +[textures] REVIEWED: ImageResizeCanvas() +[textures] REVIEWED: ImageCrop() with security checks +[textures] REVIEWED: ImageAlphaMask() +[textures] REVIEWED: ImageDrawRectangleLines() +[textures] REVIEWED: GetImageData() +[text] ADDED: TextCopy() - Copy one string to another, returns bytes copied +[text] ADDED: GetCodepoints() - Get all codepoints in a string +[text] ADDED: CodepointToUtf8() - Encode codepoint into utf8 text +[text] ADDED: DrawTextCodepoint() - Draw one character (codepoint) +[text] RENAMED: LoadDefaultFont() -> LoadFontDefault() +[text] RENAMED: TextCountCodepoints() -> GetCodepointsCount() +[text] REVIEWED: TextFormat(), to support caching, by @brankoku +[text] REVIEWED: LoadFontData(), generate empty image for space character +[text] REVIEWED: TextSplit() +[text] REVIEWED: TextToInteger() +[text] REVIEWED: GetNextCodepoint(), renamed parameters for clarity +[text] REVIEWED: GenImageFontAtlas(), improved atlas size computing +[text] REDESIGNED: struct Font, character rectangles have been moved out from CharInfo to Font +[text] REDESIGNED: struct CharInfo, now includes directly an Image of the glyph +[text] REDESIGNED: GenImageFontAtlas(), additional recs parameter added +[text] REDESIGNED: ImageTextEx(), to avoid font retrieval from GPU +[models] ADDED: Support rlPushMatrix() and rlPopMatrix() on mesh drawing +[models] ADDED: DrawPoint3D() - Draw a point in 3D space, actually a small line, by @ProfJski +[models] ADDED: Multi texture support for materials in GLTF format, by @Gamerfiend, @chriscamacho +[models] REVIEWED: LoadGLTF(), fixed memory leak, by @jubalh +[models] REVIEWED: LoadIQM(), support multiple animations loading, by @culacant +[models] REVIEWED: GetCollisionRayModel(), to avoid pointers +[models] REVIEWED: CheckCollisionRay*(), parameters renamed +[models] REVIEWED: UnloadMesh(), to avoid pointers +[models] REVIEWED: LoadModel(), memory initialization +[models] REVIEWED: UpdateModelAnimation(), added security checks +[models] REVIEWED: Multiple fixes on models loading, by @jubalh +[models] REVIEWED: Normals updated when using animated meshes, by @@las3rlars +[models] REVIEWED: Compilation when the SUPPORT_MESH_GENERATION not set, by @@Elkantor +[raudio] ADDED: Multi-channel audio playing, by @chriscamacho +[raudio] REMOVED: LoadWaveEx() +[raudio] RENAMED: IsAudioBufferProcessed() to IsAudioStreamProcessed() +[raudio] REVIEWED: Ensure .xm playback starts in the right place, by @illegalinstruction +[raudio] REVIEWED: Fix short non-looping sounds, by @jbosh +[raudio] REVIEWED: Modules playing time to full length +[raudio] REDESIGNED: Replaced Music pointer by struct +[raudio] REDESIGNED: Removed sampleLeft from Music struct +[examples] ADDED: core_scissor_test, by @ChrisDill +[examples] ADDED: core_2d_camera_platformer, by @arvyy +[examples] ADDED: textures_mouse_painting, by @ChrisDill +[examples] ADDED: models_waving_cubes, by @codecat +[examples] ADDED: models_solar_system, by @aldrinmartoq +[examples] ADDED: shaders_fog, by @chriscamacho +[examples] ADDED: shaders_texture_waves, by @Anata +[examples] ADDED: shaders_basic_lighting, by @chriscamacho +[examples] ADDED: shaders_simple_mask, by @chriscamacho +[examples] ADDED: audio_multichannel_sound, by @chriscamacho +[examples] ADDED: shaders_spotlight, by @chriscamacho +[examples] RENAMED: text_sprite_font > text_font_spritefont +[examples] RENAMED: text_ttf_loading > text_font_filters +[examples] RENAMED: text_bmfont_ttf > text_font_loading +[examples] REMOVED: models_obj_viewer +[examples] REMOVED: models_solar_system +[examples] REVIEWED: models_obj_loading > models_loading +[examples] REVIEWED: models_materials_pbr, shader issues +[examples] REVIEWED: core_window_letterbox, detailed explanation, by @jotac0 +[examples] REVIEWED: core_window_letterbox, virtual mouse, by @anatagawa +[games] ADDED: GGJ2020 game - RE-PAIR +[*] Misc fixes and tweaks, by @yaram, @oraoto, @zatherz, @piecedigital, @Shylie +[*] Update ALL supported projects (Notepad++, VS2017) +[*] Update ALL external libraries to latest versions (29.Jan.2020) +[*] Update ALL examples and games +[*] Update BINDINGS list + +----------------------------------------------- +Release: raylib 2.5 (May 2019) +----------------------------------------------- +KEY CHANGES: + - [core] Redesigned Gamepad mechanism, now common to all platforms and gamepads + - [core] HighDPI monitors support with automatic content scaling + - [rlgl] Complete module redesign to use one single internal buffer + - [rlgl] VR system redesign to allow custom device parameters and distortion shader + - [shapes] New drawing shapes available: CircleSector, Ring and RectangleRounded + - [text] New text management API (multiple functions) + - [text] Full Unicode support (utf8 text) + - [textures] Cubemap textures support + - [textures] Quad and N-Patch drawing + - [models] Skeletal model animation support + - [models] Support multiple meshes per model + - [models] Support glTF model loading + +Detailed changes: +[build] REVIEWED: Default raylib and examples Makefile +[build] REVIEWED: Notepad++ NppExec scripts +[build] REVIEWED: VS2015 and VS2017 projects +[build] REVIEWED: Android APK build pipeline +[core] Converted most #defined values as enum values +[core] Complete redesign of RPI input system to use evdev events +[core] ADDED: IsWindowResized() - Check if window has been resized +[core] ADDED: IsWindowHidden() - Check if window is currently hidden +[core] ADDED: UnhideWindow() - Show the window +[core] ADDED: HideWindow() - Hide the window +[core] ADDED: GetWindowHandle() - Get native window handle +[core] ADDED: GetMonitorCount() - Get number of connected monitors +[core] ADDED: GetMonitorWidth() - Get primary monitor width +[core] ADDED: GetMonitorHeight() - Get primary monitor height +[core] ADDED: GetMonitorPhysicalWidth() - Get primary monitor physical width in millimetres +[core] ADDED: GetMonitorPhysicalHeight() - Get primary monitor physical height in millimetres +[core] ADDED: GetMonitorName() - Get the human-readable, UTF-8 encoded name of the primary monitor +[core] ADDED: GetClipboardText() - Get clipboard text content +[core] ADDED: SetClipboardText() - Set clipboard text content +[core] ADDED: ColorFromHSV() - Returns a Color from HSV values +[core] ADDED: FileExists() - Check if file exists +[core] ADDED: GetFileNameWithoutExt() - Get filename string without extension (memory should be freed) +[core] ADDED: GetDirectoryFiles() - Get filenames in a directory path (memory should be freed) +[core] ADDED: ClearDirectoryFiles() - Clear directory files paths buffers (free memory) +[core] ADDED: OpenURL() - Open URL with default system browser (if available) +[core] ADDED: SetMouseOffset() - Set mouse offset +[core] ADDED: SetMouseScale() - Set mouse scaling +[core] REMOVED: ShowLogo() - Activate raylib logo at startup (can be done with flags) +[shapes] ADDED: DrawCircleSector() - Draw a piece of a circle +[shapes] ADDED: DrawCircleSectorLines() - Draw circle sector outline +[shapes] ADDED: DrawRing() - Draw ring +[shapes] ADDED: DrawRingLines() - Draw ring outline +[shapes] ADDED: DrawRectangleRounded() - Draw rectangle with rounded edges +[shapes] ADDED: DrawRectangleRoundedLines() - Draw rectangle with rounded edges outline +[shapes] ADDED: SetShapesTexture() - Define default texture used to draw shapes +[textures] REVIEWED: ExportImage() - Reorder function parameters +[textures] REVIEWED: ImageDrawRectangle() - Remove unneeded parameter +[textures] ADDED: ExportImageAsCode() - Export image as code file defining an array of bytes +[textures] ADDED: LoadTextureCubemap() - Load cubemap from image, multiple image cubemap layouts supported +[textures] ADDED: ImageExtractPalette() - Extract color palette from image to maximum size (memory should be freed) +[textures] ADDED: ImageDrawRectangleLines() - Draw rectangle lines within an image +[textures] ADDED: DrawTextureQuad() - Draw texture quad with tiling and offset parameters +[textures] ADDED: DrawTextureNPatch() - Draws a texture (or part of it) that stretches or shrinks nicely +[models] REVIEWED: LoadMesh() -> LoadMeshes() - Support multiple meshes loading +[models] REVIEWED: LoadMaterial() -> LoadMaterials() - Support multiple materials loading +[models] REVIEWED: ExportMesh() - Reorder parameters +[models] ADDED: DrawCubeWiresV() - Draw cube wires (Vector version) +[models] ADDED: GenMeshPoly() - Generate polygonal mesh +[models] ADDED: SetMaterialTexture() - Set texture for a material map type (MAP_DIFFUSE, MAP_SPECULAR...) +[models] ADDED: SetModelMeshMaterial() - Set material for a mesh +[models] ADDED: LoadModelAnimations() - Load model animations from file +[models] ADDED: UpdateModelAnimation() - Update model animation pose +[models] ADDED: UnloadModelAnimation() - Unload animation data +[models] ADDED: IsModelAnimationValid() - Check model animation skeleton match +[rlgl] Improved internal batching mechanism (multibuffering support, triangle texcoords...) +[rlgl] REVIEWED: rlPushMatrix()/rlPopMatrix() - Now works like OpenGL 1.1 +[rlgl] REVIEWED: SetShaderValue() - More generic, now requires uniform type +[rlgl] REMOVED: SetShaderValuei() - Can be acoomplished with new SetShaderValue() +[rlgl] ADDED: SetShaderValueV() - Set shader uniform value vector +[rlgl] ADDED: SetShaderValueTexture() - Set shader uniform value for texture +[rlgl] ADDED: BeginScissorMode() - Begin scissor mode (define screen area for following drawing) +[rlgl] ADDED: EndScissorMode() - End scissor mode +[rlgl] ADDED: SetVrConfiguration() - Set stereo rendering configuration parameters +[rlgl] REVIEWED: InitVrSimulator() - No input parameter required, use SetVrConfiguration() +[text] REVIEWED: LoadFontEx() - Reorder function parameters +[text] REVIEWED: LoadFontData() - Reorder function parameters +[text] REVIEWED: GenImageFontAtlas() - Reorder function parameters +[text] RENAMED: FormatText() -> TextFormat() +[text] RENAMED: SubText() -> TextSubtext() +[text] ADDED: LoadFontFromImage() - Load font from Image (XNA style) +[text] ADDED: DrawTextRec() - Draw text using font inside rectangle limits +[text] ADDED: DrawTextRecEx() - Draw text using font inside rectangle limits with support for text selection +[text] ADDED: TextIsEqual() - Check if two text string are equal +[text] ADDED: TextLength() - Get text length, checks for '\0' ending +[text] ADDED: TextReplace() - Replace text string (memory should be freed!) +[text] ADDED: TextInsert() - Insert text in a position (memory should be freed!) +[text] ADDED: TextJoin() - Join text strings with delimiter +[text] ADDED: TextSplit() - Split text into multiple strings +[text] ADDED: TextAppend() - Append text at specific position and move cursor! +[text] ADDED: TextFindIndex() - Find first text occurrence within a string +[text] ADDED: TextToUpper() - Get upper case version of provided string +[text] ADDED: TextToLower() - Get lower case version of provided string +[text] ADDED: TextToPascal() - Get Pascal case notation version of provided string +[text] ADDED: TextToInteger() - Get integer value from text (negative values not supported) +[raudio] ADDED: ExportWave() - Export wave data to file +[raudio] ADDED: ExportWaveAsCode() - Export wave sample data to code (.h) +[raudio] ADDED: IsAudioStreamPlaying() - Check if audio stream is playing +[raudio] ADDED: SetAudioStreamVolume() - Set volume for audio stream (1.0 is max level) +[raudio] ADDED: SetAudioStreamPitch() - Set pitch for audio stream (1.0 is base level) +[examples] Complete review of full examples collection, many additions +[examples] ADDED: core_custom_logging - Custom trace log system +[examples] ADDED: core_input_multitouch - Multitouch input example +[examples] ADDED: core_window_letterbox - Window adapted to screen +[examples] ADDED: core_loading_thread - Data loading in second thread +[examples] REVIEWED: core_input_gamepad - Adapted to new gamepad system +[examples] REVIEWED: core_vr_simulator - HMD device parameters and distortion shader should be provided +[examples] ADDED: core_window_scale_letterbox - Windows resizing and letterbox content +[examples] ADDED: shapes_rectangle_scaling_mouse - Scale a rectangle with mouse +[examples] ADDED: shapes_draw_circle_sector - Circle sector drawing +[examples] ADDED: shapes_draw_ring - Ring drawing +[examples] ADDED: shapes_draw_rectangle_rounded - Rounded rectangle drawing +[examples] ADDED: shapes_bouncing_ball - Ball bouncing in the screen +[examples] ADDED: shapes_collision_area - Collision detection and drawing +[examples] ADDED: shapes_following_eyes - Some maths on eyes and mouse +[examples] ADDED: shapes_easings_ball_anim - Ball animation +[examples] ADDED: shapes_easings_box_anim - Box animation +[examples] ADDED: shapes_easings_rectangle_array - Rectangles animation +[examples] REVIEWED: shapes_colors_palette - Reviewed color selection and text displaying +[examples] ADDED: textures_background_scrolling - Scrolling and parallaz background effect +[examples] ADDED: textures_image_npatch - Drawing N-Patch based boxes +[examples] ADDED: textures_sprite_button - Sprite button with sound +[examples] ADDED: textures_sprite_explosion - Sprite explosion with sound +[examples] ADDED: textures_bunnymark - Benchmarking test +[examples] ADDED: text_draw_inside_rectangle - Drawing text inside a delimited rectangle box +[examples] ADDED: text_unicode - Multiple languages text drawing +[examples] ADDED: text_rectangle_bound - Fit text inside a rectangle +[examples] REVIEWED: text_bmfont_ttf - Simplified example +[examples] ADDED: models_animation - Animated models loading and animation playing +[examples] ADDED: models_obj_viewer - Draw and drop models viewer +[examples] ADDED: models_rlgl_solar_system - Solar system simulation using rlgl functionality +[examples] ADDED: models_first_person_maze - 3D maze fps +[examples] ADDED: shaders_palette_switch - Switching color palette on shader +[examples] ADDED: shaders_raymarching - Raymarching shader +[examples] ADDED: shaders_texture_drawing - Texture drawing on GPU +[examples] ADDED: shaders_texture_waves - Texture waves on shader +[examples] ADDED: shaders_julia_set - Julia set fractals +[examples] ADDED: shaders_eratosthenes - Prime number visualization shader +[examples] REVIEWED: audio_raw_stream - Mostly rewritten +[games] ADDED: GGJ19 game - Cat vs Roomba +[*] Updated external libraries to latest version +[*] Multiple bugs corrected (check github issues) + +----------------------------------------------- +Release: raylib 2.0 (July 2018) +----------------------------------------------- +KEY CHANGES: + - Removed external dependencies (GLFW3 and OpenAL) + - Complete redesign of audio module to use miniaudio library + - Support AppVeyor and Travis CI (continuous integration) building + - Reviewed raymath.h for better consistency and performance (inlining) + - Refactor all #define SUPPORT_* into a single config.h + - Support TCC compiler (32bit and 64bit) + +Detailed changes: +[build] REMOVED: GitHub develop branch +[build] REMOVED: External dependencies GLFW and OpenAL +[build] ADDED: Android 64bit ARM support +[build] ADDED: FreeBSD, OpenBSD, NetBSD, Dragon Fly OS support +[build] ADDED: Universal Windows Platform (UWP) support +[build] ADDED: Wayland Linux desktop support +[build] ADDED: AppVeyor CI for automatic Windows builds +[build] ADDED: Travis CI for automatic Linux/macOS builds +[build] ADDED: rglfw (GLFW3 module) to avoid external dependency +[build] ADDED: VS2017 UWP project +[build] ADDED: Builder project template +[build] ADDED: Compiler memory sanitizer for better debug +[build] ADDED: CMake package target and CI auto-deploy tags +[build] ADDED: DEBUG library building support +[build] ADDED: Notepad++ NppExec scripts +[build] REVIEWED: VS2015 and VS2017 projects +[build] REVIEWED: Android APK build pipeline +[core] REVIEWED: Window creation hints to support transparent windows +[core] Unified InitWindow() between platforms +[core] Export Android main entry point +[core] RENAMED: Begin3dMode() to BeginMode3D() +[core] RENAMED: End3dMode() to EndMode3D() +[core] RENAMED: Begin2dMode() to BeginMode2D() +[core] RENAMED: End2dMode() to EndMode2D() +[core] RENAMED: struct Camera to Camera3D +[core] RENAMED: struct SpriteFont to Font -> plus all required functions! +[core] RENAMED: enum TextureFormat to PixelFormat +[core] REVIEWED: Rectangle params int to float +[core] REVIEWED: timing system for macOS +[core] REMOVED: ColorToFloat() +[core] ADDED: GetCurrentTime() on macOS +[core] ADDED: GetTime() +[core] ADDED: struct Vector4 +[core] ADDED: SetTraceLog() to define trace log messages type +[core] ADDED: GetFileName() to get filename from path string +[core] ADDED: ColorToHSV() +[core] ADDED: ColorNormalize() +[core] ADDED: SetWindowSize() to scale Windows in runtime +[core] ADDED: SetMouseScale() to scale mouse input +[core] ADDED: key definitions - KEY_GRAVE, KEY_SLASH, KEY_BACKSLASH +[core] RENAMED: GetHexValue() to ColorToInt() +[core] REVIEWED: Fade() +[core] REVIEWED: InitWindow() to avoid void pointer (safety) +[core] Support camera 3d orthographic projection mode +[shapes] ADDED: DrawRectangleLinesEx() +[textures] Improved pixel formats support (32bit channels) +[textures] Improved textures support for OpenGL 2.1 +[textures] REMOVED: DrawRectangleT() --> Added support to DrawRectangle() +[textures] ADDED: GetPixelDataSize(); pixel data size in bytes (image or texture) +[textures] ADDED: ImageAlphaClear() --> Clear alpha channel to desired color +[textures] ADDED: ImageAlphaCrop() --> Crop image depending on alpha value +[textures] ADDED: ImageAlphaPremultiply() --> Premultiply alpha channel +[textures] ADDED: ImageDrawRectangle() +[textures] ADDED: ImageMipmaps() +[textures] ADDED: GenImageColor() +[textures] ADDED: GetPixelDataSize() +[textures] ADDED: ImageRotateCW() +[textures] ADDED: ImageRotateCCW() +[textures] ADDED: ImageResizeCanvas() +[textures] ADDED: GetImageDataNormalized() +[textures] REVIEWED: ImageFormat() to use normalized data +[textures] REVIEWED: Manual mipmap generation +[textures] REVIEWED: LoadASTC() +[textures] REVIEWED: GenImagePerlinNoise() +[textures] REVIEWED: ImageTextEx() to support UTF8 basic characters +[textures] REVIEWED: GetTextureData() for RPI - requires some work +[textures] Added new example: text drawing on image +[text] Corrected issue with ttf font y-offset +[text] Support SDF font data generation +[text] ADDED: GenImageFontAtlas() +[text] ADDED: LoadFontData() to load data from TTF file +[text] REMOVED: LoadTTF() internal function +[text] REVIEWED: DrawTextEx() - avoid rendering SPACE character! +[text] RENAMED: GetDefaultFont() to GetFontDefault() +[rlgl] ADDED: rlCheckBufferLimit() +[rlgl] ADDED: LoadShaderCode() +[rlgl] ADDED: GetMatrixModelview() +[rlgl] ADDED: SetVrDistortionShader(Shader shader) +[rlgl] REVIEWED: rlLoadTexture() - added mipmaps support, improved compressed textures loading +[rlgl] REVIEWED: rlReadTexturePixels() +[models] Support 4 components mesh.tangent data +[models] Removed tangents generation from LoadOBJ() +[models] ADDED: MeshTangents() +[models] ADDED: MeshBinormals() +[models] ADDED: ExportMesh() +[models] ADDED: GetCollisionRayModel() +[models] RENAMED: CalculateBoundingBox() to MeshBoundingBox() +[models] REMOVED: GetCollisionRayMesh() - does not consider model transform +[models] REVIEWED: LoadMesh() - fallback to default cube mesh if loading fails +[audio] ADDED: Support for MP3 fileformat +[audio] ADDED: IsAudioStreamPlaying() +[audio] ADDED: SetAudioStreamVolume() +[audio] ADDED: SetAudioStreamPitch() +[utils] Corrected issue with SaveImageAs() +[utils] RENAMED: SaveImageAs() to ExportImage() +[utils] REMOVED: rres support - moved to external library (rres.h) +[shaders] REVIEWED: GLSL 120 shaders +[raymath] ADDED: Vector3RotateByQuaternion() +[raymath] REVIEWED: math usage to reduce temp variables +[raymath] REVIEWED: Avoid pointer-based parameters for API consistency +[physac] REVIEWED: physac.h timing system +[examples] Replaced dwarf model by brand new 3d assets: 3d medieval buildings +[examples] Assets cleaning and some replacements +[games] ADDED: GGJ18 game - transmission mission +[games] REVIEWED: Light my Ritual game - improved gameplay drawing +[*] Updated external libraries to latest version +[*] Multiple bugs corrected (check github issues) + +----------------------------------------------- +Release: raylib 1.8.0 (Oct 2017) +----------------------------------------------- +NOTE: + In this release, multiple parts of the library have been reviewed (again) for consistency and simplification. + It exposes more than 30 new functions in comparison with previous version and it improves overall programming experience. + +BIG CHANGES: + - New Image generation functions: Gradient, Checked, Noise, Cellular... + - New Mesh generation functions: Cube, Sphere, Cylinder, Torus, Knot... + - New Shaders and Materials systems to support PBR materials + - Custom Android APK build pipeline with simple Makefile + - Complete review of rlgl layer functionality + - Complete review of raymath functionality + +detailed changes: +[rlgl] RENAMED: rlglLoadTexture() to rlLoadTexture() +[rlgl] RENAMED: rlglLoadRenderTexture() to rlLoadRenderTexture() +[rlgl] RENAMED: rlglUpdateTexture() to rlUpdateTexture() +[rlgl] RENAMED: rlglGenerateMipmaps() to rlGenerateMipmaps() +[rlgl] RENAMED: rlglReadScreenPixels() to rlReadScreenPixels() +[rlgl] RENAMED: rlglReadTexturePixels() to rlReadTexturePixels() +[rlgl] RENAMED: rlglLoadMesh() to rlLoadMesh() +[rlgl] RENAMED: rlglUpdateMesh() to rlUpdateMesh() +[rlgl] RENAMED: rlglDrawMesh() to rlDrawMesh() +[rlgl] RENAMED: rlglUnloadMesh() to rlUnloadMesh() +[rlgl] RENAMED: rlglUnproject() to rlUnproject() +[rlgl] RENAMED: LoadCompressedTexture() to LoadTextureCompressed() +[rlgl] RENAMED: GetDefaultTexture() to GetTextureDefault() +[rlgl] RENAMED: LoadDefaultShader() to LoadShaderDefault() +[rlgl] RENAMED: LoadDefaultShaderLocations() to SetShaderDefaultLocations() +[rlgl] RENAMED: UnloadDefaultShader() to UnLoadShaderDefault() +[rlgl] ADDED: rlGenMapCubemap(), Generate cubemap texture map from HDR texture +[rlgl] ADDED: rlGenMapIrradiance(), Generate irradiance texture map +[rlgl] ADDED: rlGenMapPrefilter(), Generate prefilter texture map +[rlgl] ADDED: rlGenMapBRDF(), Generate BRDF texture map +[rlgl] ADDED: GetVrDeviceInfo(), Get VR device information for some standard devices +[rlgl] REVIEWED: InitVrSimulator(), to accept device parameters as input +[core] ADDED: SetWindowTitle(), Set title for window (only PLATFORM_DESKTOP) +[core] ADDED: GetExtension(), Get file extension +[shapes] REMOVED: DrawRectangleGradient(), replaced by DrawRectangleGradientV() and DrawRectangleGradientH() +[shapes] ADDED: DrawRectangleGradientV(), Draw a vertical-gradient-filled rectangle +[shapes] ADDED: DrawRectangleGradientH(), Draw a horizontal-gradient-filled rectangle +[shapes] ADDED: DrawRectangleGradientEx(), Draw a gradient-filled rectangle with custom vertex colors +[shapes] ADDED: DrawRectangleT(), Draw rectangle using text character +[textures] ADDED: SaveImageAs(), Save image as PNG file +[textures] ADDED: GenImageGradientV(), Generate image: vertical gradient +[textures] ADDED: GenImageGradientH(), Generate image: horizontal gradient +[textures] ADDED: GenImageGradientRadial(), Generate image: radial gradient +[textures] ADDED: GenImageChecked(), Generate image: checked +[textures] ADDED: GenImageWhiteNoise(), Generate image: white noise +[textures] ADDED: GenImagePerlinNoise(), Generate image: perlin noise +[textures] ADDED: GenImageCellular(), Generate image: cellular algorithm. Bigger tileSize means bigger cells +[textures] ADDED: GenTextureCubemap(), Generate cubemap texture from HDR texture +[textures] ADDED: GenTextureIrradiance(), Generate irradiance texture using cubemap data +[textures] ADDED: GenTexturePrefilter(), Generate prefilter texture using cubemap data +[textures] ADDED: GenTextureBRDF(), Generate BRDF texture using cubemap data +[models] REMOVED: LoadMeshEx(), Mesh struct variables can be directly accessed +[models] REMOVED: UpdateMesh(), very ineficient +[models] REMOVED: LoadHeightmap(), use GenMeshHeightmap() and LoadModelFromMesh() +[models] REMOVED: LoadCubicmap(), use GenMeshCubicmap() and LoadModelFromMesh() +[models] RENAMED: LoadDefaultMaterial() to LoadMaterialDefault() +[models] ADDED: GenMeshPlane(), Generate plane mesh (with subdivisions) +[models] ADDED: GenMeshCube(), Generate cuboid mesh +[models] ADDED: GenMeshSphere(), Generate sphere mesh (standard sphere) +[models] ADDED: GenMeshHemiSphere(), Generate half-sphere mesh (no bottom cap) +[models] ADDED: GenMeshCylinder(), Generate cylinder mesh +[models] ADDED: GenMeshTorus(), Generate torus mesh +[models] ADDED: GenMeshKnot(), Generate trefoil knot mesh +[models] ADDED: GenMeshHeightmap(), Generate heightmap mesh from image data +[models] ADDED: GenMeshCubicmap(), Generate cubes-based map mesh from image data +[raymath] REVIEWED: full Matrix functionality to align with GLM in usage +[raymath] RENAMED: Vector3 functions for consistency: Vector*() renamed to Vector3*() +[build] Integrate Android APK building into examples Makefile +[build] Integrate Android APK building into templates Makefiles +[build] Improved Visual Studio 2015 project, folders, references... +[templates] Reviewed the full pack to support Android building +[examples] Reviewed full collection to adapt to raylib changes +[examples] [textures] ADDED: textures_image_generation +[examples] [models] ADDED: models_mesh_generation +[examples] [models] ADDED: models_material_pbr +[examples] [models] ADDED: models_skybox +[examples] [models] ADDED: models_yaw_pitch_roll +[examples] [others] REVIEWED: rlgl_standalone +[examples] [others] REVIEWED: audio_standalone +[github] Moved raylib webpage to own repo: github.com/raysan5/raylib.com +[games] Reviewed game: Koala Seasons +[*] Updated STB libraries to latest version +[*] Multiple bugs corrected (check github issues) + +----------------------------------------------- +Release: raylib 1.7.0 (20 May 2017) +----------------------------------------------- +NOTE: + In this new raylib release, multiple parts of the library have been reviewed for consistency and simplification. + It exposes almost 300 functions, around 30 new functions in comparison with previous version and, again, + it sets a stepping stone towards raylib future. + +BIG changes: + - More than 30 new functions added to the library, check list below. + - Support of configuration flags on every raylib module, to customize library build. + - Improved build system for all supported platforms with a unique Makefile to compile sources. + - Complete review of examples and sample games, added new sample material. + - Support automatic GIF recording of current window, just pressing Ctrl+F12 + - Improved library consistency and organization in general. + +other changes: +[core] Added function: SetWindowIcon(), to setup icon by code +[core] Added function: SetWindowMonitor(), to set current display monitor +[core] Added function: SetWindowMinSize(), to set minimum resize size +[core] Added function: TakeScreenshot(), made public to API (also launched internally with F12) +[core] Added function: GetDirectoryPath(), get directory for a given fileName (with path) +[core] Added function: GetWorkingDirectory(), get current working directory +[core] Added function: ChangeDirectory(), change working directory +[core] Added function: TraceLog(), made public to API +[core] Improved timing system to avoid busy wait loop on frame sync: Wait() +[core] Added support for gamepad on HTML5 platform +[core] Support mouse lock, useful for camera system +[core] Review functions description comments +[rlgl] Removed function: GetStandardShader(), removed internal standard shader +[rlgl] Removed function: CreateLight(), removed internal lighting system +[rlgl] Removed function: DestroyLight(), removed internal lighting system +[rlgl] Removed function: InitVrDevice(), removed VR device render, using simulator +[rlgl] Removed function: CloseVrDevice(), removed VR device render, using simulator +[rlgl] Removed function: IsVrDeviceReady(), removed VR device render, using simulator +[rlgl] Removed function: IsVrSimulator(), removed VR device render, using simulator +[rlgl] Added function: InitVrSimulator(), init VR simulator for selected device +[rlgl] Added function: CloseVrSimulator(), close VR simulator for current device +[rlgl] Added function: IsVrSimulatorReady(), detect if VR device is ready +[rlgl] Added function: BeginVrDrawing(), begin VR simulator stereo rendering +[rlgl] Added function: EndVrDrawing(), end VR simulator stereo rendering +[rlgl] Renamed function: ReadTextFile() to LoadText() and exposed to API +[rlgl] Removed internal lighting system and standard shader, moved to example +[rlgl] Removed Oculus Rift support, moved to oculus_rift example +[rlgl] Removed VR device support and replaced by VR simulator +[shapes] Added function: DrawLineEx(), draw line with QUADS, supports custom line thick +[shapes] Added function: DrawLineBezier(), draw a line using cubic-bezier curves in-out +[shapes] Added function: DrawRectanglePro(), draw a color-filled rectangle with pro parameters +[textures] Removed function: LoadImageFromRES(), redesigning custom RRES fileformat +[textures] Removed function: LoadTextureFromRES(), redesigning custom RRES fileformat +[textures] Removed function: LoadTextureEx(), use instead Image -> LoadImagePro(), LoadImageEx() +[textures] Added function: LoadImagePro()), load image from raw data with parameters +[textures] Review TraceLog() message when image file not found +[text] Renamed function: LoadSpriteFontTTF() to LoadSpriteFontEx(), for consistency +[text] Removed rBMF fileformat support, replaced by .png +[text] Refactor SpriteFont struct (better for rres custom fileformat) +[text] Renamed some variables for consistency +[models] Added function: LoadMesh(), load mesh from file +[models] Added function: LoadMeshEx(), load mesh from vertex data +[models] Added function: UnloadMesh(), unload mesh from memory (RAM and/or VRAM) +[models] Added function: GetCollisionRayMesh(), get collision info between ray and mesh +[models] Added function: GetCollisionRayTriangle(), get collision info between ray and triangle +[models] Added function: GetCollisionRayGround(), get collision info between ray and ground plane +[models] Renamed function: LoadModelEx() to LoadModelFromMesh() +[models] Removed function: DrawLight(), removed internal lighting system +[models] Renamed function: LoadModelEx() to LoadModelFromMesh() for consistency +[models] Removed function: LoadStandardMaterial(), removed internal standard shader +[models] Removed function: LoadModelFromRES(), redesigning custom RRES fileformat +[models] Renamed multiple variables for consistency +[audio] Added function: SetMasterVolume(), define listener volume +[audio] Added function: ResumeSound(), resume a paused sound +[audio] Added function: SetMusicLoopCount(), set number of repeats for a music +[audio] Added function: LoadWaveEx(), load wave from raw audio data +[audio] Added function: WaveCrop(), crop wave audio data +[audio] Added function: WaveFormat(), format audio data +[audio] Removed function: LoadSoundFromRES(), redesigning custom RRES fileformat +[audio] Added support for 32bit audio samples +[audio] Preliminary support for multichannel, limited to mono and stereo +[audio] Make sure buffers are ready for update: UpdateMusicStream() +[utils] Replaced function: GetExtension() by IsFileExtension() and made public to API +[utils] Unified function: TraceLog() between Android and other platforms +[utils] Removed internal function: GetNextPOT(), simplified implementation +[raymath] Added function: QuaternionToEuler(), to work with Euler angles +[raymath] Added function: QuaternionFromEuler(), to work with Euler angles +[raymath] Added multiple Vector2 math functions +[build] Integrate Android source building into Makefile +[example] Added example: shapes_lines_bezier +[example] Added example: text_input_box +[github] Moved gh-pages branch to master/docs +[github] Moved rlua.h and Lua examples to own repo: raylib-lua +[games] Reviewed full games collection +[games] New game added to collection: Koala Seasons +[*] Reviewed and improved examples collection (new assets) +[*] Reorganized library functions, structs, enums +[*] Updated STB libraries to latest version + +----------------------------------------------- +Release: raylib 1.6.0 (20 November 2016) +----------------------------------------------- +NOTE: + This new raylib version commemorates raylib 3rd anniversary and represents another complete review of the library. + It includes some interesting new features and is a stepping stone towards raylib future. + +HUGE changes: +[rlua] Lua BINDING: Complete raylib Lua binding, ALL raylib functions ported to Lua plus the +60 code examples. +[audio] COMPLETE REDESIGN: Improved music support and also raw audio data processing and playing, +20 new functions added. +[physac] COMPLETE REWRITE: Improved performance, functionality and simplified usage, moved to own repository and added multiple examples! + +other changes: + +[core] Corrected issue on OSX with HighDPI display +[core] Added flag to allow resizable window +[core] Allow no default font loading +[core] Corrected old issue with mouse buttons on web +[core] Improved gamepad support, unified across platforms +[core] Gamepad id functionality: GetGamepadName(), IsGamepadName() +[core] Gamepad buttons/axis checking functionality: +[core] Reviewed Android key inputs system, unified with desktop +[rlgl] Redesigned lighting shader system +[rlgl] Updated standard shader for better performance +[rlgl] Support alpha on framebuffer: rlglLoadRenderTexture() +[rlgl] Reviewed UpdateVrTracking() to update camera +[rlgl] Added IsVrSimulator() to check for VR simulator +[shapes] Corrected issue on DrawPolyEx() +[textures] Simplified supported image formats support +[textures] Improved text drawing within an image: ImageDrawText() +[textures] Support image alpha mixing: ImageAlphaMask() +[textures] Support textures filtering: SetTextureFilter() +[textures] Support textures wrap modes: SetTextureWrap() +[text] Improved TTF spritefont generation: LoadSpriteFontTTF() +[text] Improved AngelCode fonts support (unordered chars) +[text] Added TraceLog info on image spritefont loading +[text] Improved text measurement: MeasureTextEx() +[models] Improved OBJ loading flexibility +[models] Reviewed functions: DrawLine3D(), DrawCircle3D() +[models] Removed function: ResolveCollisionCubicmap() +[camera] Redesigned camera system and ported to header-only +[camera] Removed function: UpdateCameraPlayer() +[gestures] Redesigned gestures module to header-only +[audio] Simplified Music loading and playing system +[audio] Added trace on audio device closing +[audio] Reviewed Wave struct, improved flexibility +[audio] Support sound data update: UpdateSound() +[audio] Added support for FLAC audio loading/streaming +[raygui] Removed raygui from raylib repo (moved to own repo) +[build] Added OpenAL static library +[build] Added Visual Studio 2015 projects +[build] Support shared/dynamic raylib compilation +[*] Updated LibOVR to SDK version 1.8 +[*] Updated games to latest raylib version +[*] Improved examples and added new ones +[*] Improved Android support + +----------------------------------------------- +Release: raylib 1.5.0 (18 July 2016) +----------------------------------------------- +NOTE: + Probably this new version is the biggest boost of the library ever, lots of parts of the library have been redesigned, + lots of bugs have been solved and some **AMAZING** new features have been added. + +HUGE changes: +[rlgl] OCULUS RIFT CV1: Added support for VR, not oly Oculus Rift CV1 but also stereo rendering simulator (multiplatform). +[rlgl] MATERIALS SYSTEM: Added support for Materials (.mtl) and multiple material properties: diffuse, specular, normal. +[rlgl] LIGHTING SYSTEM: Added support for up to 8 lights of 3 different types: Omni, Directional and Spot. +[physac] REDESIGNED: Improved performance and simplified usage, physic objects now are managed internally in a second thread! +[audio] CHIPTUNES: Added support for module audio music (.xm, .mod) loading and playing. Multiple mixing channels supported. + +other changes: + +[core] Review Android button inputs +[core] Support Android internal data storage +[core] Renamed WorldToScreen() to GetWorldToScreen() +[core] Removed function SetCustomCursor() +[core] Removed functions BeginDrawingEx(), BeginDrawingPro() +[core] Replaced functions InitDisplay() + InitGraphics() with: InitGraphicsDevice() +[core] Added support for field-of-view Y (fovy) on 3d Camera +[core] Added 2D camera mode functions: Begin2dMode() - End2dMode() +[core] Translate mouse inputs to Android touch/gestures internally +[core] Translate mouse inputs as touch inputs in HTML5 +[core] Improved function GetKeyPressed() to support multiple keys (including function keys) +[core] Improved gamepad support, specially for RaspberryPi (including multiple gamepads support) +[rlgl] Support stereo rendering simulation (duplicate draw calls by viewport, optimized) +[rlgl] Added distortion shader (embeded) to support custom VR simulator: shader_distortion.h +[rlgl] Added support for OpenGL 2.1 on desktop +[rlgl] Improved 2D vs 3D drawing system (lines, triangles, quads) +[rlgl] Improved DXT-ETC1 support on HTML5 +[rlgl] Review function: rlglUnproject() +[rlgl] Removed function: rlglInitGraphics(), integrated into rlglInit() +[rlgl] Updated Mesh and Shader structs +[rlgl] Simplified internal (default) dynamic buffers +[rlgl] Added support for indexed and dynamic mesh data +[rlgl] Set fixed vertex attribs location points +[rlgl] Improved mesh data loading support +[rlgl] Added standard shader (embeded) to support materials and lighting: shader_standard.h +[rlgl] Added light functions: CreateLight(), DestroyLight() +[rlgl] Added wire mode functions: rlDisableWireMode(), rlEnableWireMode() +[rlgl] Review function consistency, added: rlglLoadMesh(), rlglUpdateMesh(), rlglDrawMesh(), rlglUnloadMesh() +[rlgl] Replaced SetCustomShader() by: BeginShaderMode() - EndShaderMode() +[rlgl] Replaced SetBlendMode() by: BeginBlendMode() - EndBlendMode() +[rlgl] Added functions to customize internal matrices: SetMatrixProjection(), SetMatrixModelview() +[rlgl] Unified internal shaders to only one default shader +[rlgl] Added support for render to texture (RenderTexture2D): + LoadRenderTexture() - UnloadRenderTexture() + BeginTextureMode() - EndTextureMode() +[rlgl] Removed SetShaderMap*() functions +[rlgl] Redesigned default buffers usage functions: + LoadDefaultBuffers() - UnloadDefaultBuffers() + UpdateDefaultBuffers() - DrawDefaultBuffers() +[shapes] Corrected bug on GetCollisionRec() +[textures] Added support for Nearest-Neighbor image scaling +[textures] Added functions to draw text on image: ImageDrawText(), ImageDrawTextEx() +[text] Reorganized internal functions: Added LoadImageFont() +[text] Security check for unsupported BMFonts +[models] Split mesh creation from model loading on heightmap and cubicmap +[models] Updated BoundingBox collision detections +[models] Added color parameter to DrawBoundigBox() +[models] Removed function: DrawQuad() +[models] Removed function: SetModelTexture() +[models] Redesigned DrawPlane() to use RL_TRIANGLES +[models] Redesigned DrawRectangleV() to use RL_TRIANGLES +[models] Redesign to accomodate new materials system: LoadMaterial() +[models] Added material functions: LoadDefaultMaterial(), LoadStandardMaterial() +[models] Added MTL material loading support: LoadMTL() +[models] Added function: DrawLight() +[audio] Renamed SoundIsPlaying() to IsSoundPlaying() +[audio] Renamed MusicIsPlaying() to IsMusicPlaying() +[audio] Support multiple Music streams (indexed) +[audio] Support multiple mixing channels +[gestures] Improved and reviewed gestures system +[raymath] Added QuaternionInvert() +[raymath] Removed function: PrintMatrix() +[raygui] Ported to header-only library (https://github.com/raysan5/raygui) +[shaders] Added depth drawing shader (requires a depth texture) +[shaders] Reviewed included shaders and added comments +[OpenAL Soft] Updated to latest version (1.17.2) +[GLFW3] Updated to latest version (3.2) +[stb] Updated to latest headers versions +[GLAD] Converted to header only library and simplified to only used extensions +[*] Reorganize library folders: external libs moved to src/external folder +[*] Reorganize src folder for Android library +[*] Review external dependencies usage +[*] Improved Linux and OSX build systems +[*] Lots of tweaks and bugs corrected all around + +----------------------------------------------- +Release: raylib 1.4.0 (22 February 2016) +----------------------------------------------- +NOTE: + This version supposed another big improvement for raylib, including new modules and new features. + More than 30 new functions have been added to previous raylib version. + Around 8 new examples and +10 new game samples have been added. + +BIG changes: +[textures] IMAGE MANIPULATION: Functions to crop, resize, colorize, flip, dither and even draw image-to-image or text-to-image. +[text] SPRITEFONT SUPPORT: Added support for AngelCode fonts (.fnt) and TrueType fonts (.ttf). +[gestures] REDESIGN: Gestures system simplified and prepared to process generic touch events, including mouse events (multiplatform). +[physac] NEW MODULE: Basic 2D physics support, use colliders and rigidbodies; apply forces to physic objects. + +other changes: + +[rlgl] Removed GLEW library dependency, now using GLAD +[rlgl] Implemented alternative to glGetTexImage() on OpenGL ES +[rlgl] Using depth data on batch drawing +[rlgl] Reviewed glReadPixels() function +[core][rlgl] Reviewed raycast system, now 3D picking works +[core] Android: Reviewed Android App cycle, paused if inactive +[shaders] Implemented Blinn-Phong lighting shading model +[textures] Implemented Floyd-Steinberg dithering - ImageDither() +[text] Added line-break support to DrawText() +[text] Added TrueType Fonts support (using stb_truetype) +[models] Implement function: CalculateBoundingBox(Mesh mesh) +[models] Added functions to check Ray collisions +[models] Improve map resolution control on LoadHeightmap() +[camera] Corrected small-glitch on zoom-in with mouse-wheel +[gestures] Implemented SetGesturesEnabled() to enable only some gestures +[gestures] Implemented GetElapsedTime() on Windows system +[gestures] Support mouse gestures for desktop platforms +[raymath] Complete review of the module and converted to header-only +[easings] Added new module for easing animations +[stb] Updated to latest headers versions +[*] Lots of tweaks around + +----------------------------------------------- +Release: raylib 1.3.0 (01 September 2015) +----------------------------------------------- +NOTE: + This version supposed a big boost for raylib, new modules have been added with lots of features. + Most of the modules have been completely reviewed to accomodate to the new features. + Over 50 new functions have been added to previous raylib version. + Most of the examples have been redone and +10 new advanced examples have been added. + +BIG changes: +[rlgl] SHADERS: Support for model shaders and postprocessing shaders (multiple functions) +[textures] FORMATS: Support for multiple internal formats, including compressed formats +[camera] NEW MODULE: Set of cameras for 3d view: Free, Orbital, 1st person, 3rd person +[gestures] NEW MODULE: Gestures system for Android and HTML5 platforms +[raygui] NEW MODULE: Set of IMGUI elements for tools development (experimental) + +other changes: + +[rlgl] Added check for OpenGL supported extensions +[rlgl] Added function SetBlenMode() to select some predefined blending modes +[core] Added support for drop&drag of external files into running program +[core] Added functions ShowCursor(), HideCursor(), IsCursorHidden() +[core] Renamed function SetFlags() to SetConfigFlags() +[shapes] Simplified some functions to improve performance +[textures] Review of Image struct to support multiple data formats +[textures] Added function LoadImageEx() +[textures] Added function LoadImageRaw() +[textures] Added function LoadTextureEx() +[textures] Simplified function parameters LoadTextureFromImage() +[textures] Added function GetImageData() +[textures] Added function GetTextureData() +[textures] Renamed function ConvertToPOT() to ImageConvertToPOT() +[textures] Added function ImageConvertFormat() +[textures] Added function GenTextureMipmaps() +[text] Added support for Latin-1 Extended characters for default font +[text] Redesigned SpriteFont struct, replaced Character struct by Rectangle +[text] Removed function GetFontBaseSize(), use directly spriteFont.size +[models] Review of struct: Model (added shaders support) +[models] Added 3d collision functions (sphere vs sphere vs box vs box) +[models] Added function DrawCubeTexture() +[models] Added function DrawQuad() +[models] Added function DrawRay() +[models] Simplified funtion DrawPlane() +[models] Removed function DrawPlaneEx() +[models] Simplified funtion DrawGizmo() +[models] Removed function DrawGizmoEx() +[models] Added function LoadModelEx() +[models] Review of function LoadCubicMap() +[models] Added function ResolveCollisionCubicmap() +[audio] Decopupled from raylib, now this module can be used as standalone +[audio] Added function UpdateMusicStream() +[raymath] Complete review of the module +[stb] Updated to latest headers versions +[*] Lots of tweaks around + +----------------------------------------------- +Release: raylib 1.2.2 (31 December 2014) +----------------------------------------------- +[*] Added support for HTML5 compiling (emscripten, asm.js) +[core] Corrected bug on input handling (keyboard and mouse) +[textures] Renamed function CreateTexture() to LoadTextureFromImage() +[textures] Added function ConvertToPOT() +[rlgl] Added support for color tint on models on GL 3.3+ and ES2 +[rlgl] Added support for normals on models +[models] Corrected bug on DrawBillboard() +[models] Corrected bug on DrawHeightmap() +[models] Renamed LoadCubesmap() to LoadCubicmap() +[audio] Added function LoadSoundFromWave() +[makefile] Added support for Linux and OSX compiling +[stb] Updated to latest headers versions +[*] Lots of tweaks around + +--------------------------------------------------------------- +Update: raylib 1.2.1 (17 October 2014) (Small Fixes Update) +--------------------------------------------------------------- +[core] Added function SetupFlags() to preconfigure raylib Window +[core] Corrected bug on fullscreen mode +[rlgl] rlglDrawmodel() - Added rotation on Y axis +[text] MeasureTextEx() - Corrected bug on measures for default font + +----------------------------------------------- +Release: raylib 1.2 (16 September 2014) +----------------------------------------------- +NOTE: + This version supposed a complete redesign of the [core] module to support Android and Raspberry Pi. + Multiples modules have also been tweaked to accomodate to the new platforms, specially [rlgl] + +[core] Added multiple platforms support: Android and Raspberry Pi +[core] InitWindow() - Complete rewrite and split for Android +[core] InitDisplay() - Internal function added to calculate proper display size +[core] InitGraphics() - Internal function where OpenGL graphics are initialized +[core] Complete refactoring of input functions to accomodate to new platforms +[core] Mouse and Keyboard raw data reading functions added for Raspberry Pi +[core] GetTouchX(), GetTouchY() - Added for Android +[core] Added Android callbacks to process inputs and Android activity commands +[rlgl] Adjusted buffers depending on platform +[rlgl] Added security check in case deployed vertex excess buffer size +[rlgl] Adjusted indices type depending on GL version (int or short) +[rlgl] Fallback to VBOs only usage if VAOs not supported on ES2 +[rlgl] rlglLoadModel() stores vbo ids on new Model struct +[textures] Added support for PKM files (ETC1, ETC2 compression support) +[shapes] DrawRectangleV() - Modified, depending on OGL version uses TRIANGLES or QUADS +[text] LoadSpriteFont() - Modified to use LoadImage() +[models] Minor changes on models loading to accomodate to new Model struct +[audio] PauseMusicStream(), ResumeMusicStream() - Added +[audio] Reduced music buffer size to avoid stalls on Raspberry Pi +[src] Added makefile for Windows and RPI +[src] Added resources file (raylib icon and executable info) +[examples] Added makefile for Windows and RPI +[examples] Renamed and merged with test examples for coherence with module names +[templates] Added multiple templates to be use as a base-code for games + +----------------------------------------------- +Release: raylib 1.1.1 (22 July 2014) +----------------------------------------------- +[core] ShowLogo() - To enable raylib logo animation at startup +[core] Corrected bug with window resizing +[rlgl] Redefined colors arrays to use byte instead of float +[rlgl] Removed double buffer system (no performance improvement) +[rlgl] rlglDraw() - Reorganized buffers drawing order +[rlgl] Corrected bug on screen resizing +[shapes] DrawRectangle() - Use QUADS instead of TRIANGLES +[models] DrawSphereWires() - Corrected some issues +[models] LoadOBJ() - Redesigned to support multiple meshes +[models] LoadCubesMap() - Loading a map as cubes (by pixel color) +[textures] Added security check if file doesn't exist +[text] Corrected bug on SpriteFont loading +[examples] Corrected some 3d examples +[test] Added cubesmap loading test + +----------------------------------------------- +Release: raylib 1.1.0 (19 April 2014) +----------------------------------------------- +NOTE: + This version supposed a complete internal redesign of the library to support OpenGL 3.3+ and OpenGL ES 2.0. + New module [rlgl] has been added to 'translate' immediate mode style functions (i.e. rlVertex3f()) to GL 1.1, 3.3+ or ES2. + Another new module [raymath] has also been added with lot of useful 3D math vector-matrix-quaternion functions. + +[rlgl] New module, abstracts OpenGL rendering (multiple versions support) +[raymath] New module, useful 3D math vector-matrix-quaternion functions +[core] Adapt all OpenGL code (initialization, drawing) to use [rlgl] +[shapes] Rewrite all shapes drawing functions to use [rlgl] +[textures] Adapt texture GPU loading to use [rlgl] +[textures] Added support for DDS images (compressed and uncompressed) +[textures] CreateTexture() - Redesigned to add mipmap automatic generation +[textures] DrawTexturePro() - Redesigned and corrected bugs +[models] Rewrite all 3d-shapes drawing functions to use [rlgl] +[models] Adapt model loading and drawing to use [rlgl] +[models] Model struct updated to include texture id +[models] SetModelTexture() - Added, link a texture to a model +[models] DrawModelEx() - Redesigned with extended parameters +[audio] Added music streaming support (OGG files) +[audio] Added support for OGG files as Sound +[audio] PlayMusicStream() - Added, open a new music stream and play it +[audio] StopMusicStream() - Added, stop music stream playing and close stream +[audio] PauseMusicStream() - Added, pause music stream playing +[audio] MusicIsPlaying() - Added, to check if music is playing +[audio] SetMusicVolume() - Added, set volume for music +[audio] GetMusicTimeLength() - Added, get current music time length (in seconds) +[audio] GetMusicTimePlayed() - Added, get current music time played (in seconds) +[utils] Added log tracing functionality - TraceLog(), TraceLogOpen(), TraceLogClose() +[*] Log tracing messages all around the code + +----------------------------------------------- +Release: raylib 1.0.6 (16 March 2014) +----------------------------------------------- +[core] Removed unused lighting-system code +[core] Removed SetPerspective() function, calculated directly +[core] Unload and reload default font on fullscreen toggle +[core] Corrected bug gamepad buttons checking if no gamepad available +[texture] DrawTextureV() - Added, to draw using Vector2 for position +[texture] LoadTexture() - Redesigned, now uses LoadImage() + CreateTexture() +[text] FormatText() - Corrected memory leak bug +[models] Added Matrix struct and related functions +[models] DrawBillboard() - Reviewed, now it works! +[models] DrawBillboardRec() - Reviewed, now it works! +[tests] Added folder with multiple tests for new functions + +----------------------------------------------- +Update: raylib 1.0.5 (28 January 2014) +----------------------------------------------- +[audio] LoadSound() - Corrected a bug, WAV file was not closed! +[core] GetMouseWheelMove() - Added, check mouse wheel Y movement +[texture] CreateTexture2D() renamed to CreateTexture() +[models] LoadHeightmap() - Added, Heightmap can be loaded as a Model +[tool] rREM updated, now supports (partially) drag and drop of files + +----------------------------------------------- +Release: raylib 1.0.4 (23 January 2014) +----------------------------------------------- +[tool] Published a first alpha version of rREM tool (raylib Resource Embedder) +[core] GetRandomValue() - Bug corrected, now works right +[core] Fade() - Added, fades a color to an alpha percentadge +[core] WriteBitmap() - Moved to new module: utils.c, not used anymore +[core] TakeScreenshot() - Now uses WritePNG() (utils.c) +[utils] New module created with utility functions +[utils] WritePNG() - Write a PNG file (used by TakeScreenshot() on core) +[utils] DecompressData() - Added, used for rRES resource data decompresion +[textures] LoadImageFromRES() - Added, load an image from a rRES resource file +[textures] LoadTextureFromRES() - Added, load a texture from a rRES resource file +[audio] LoadSoundFromRES() - Added, load a sound from a rRES resource file +[audio] IsPlaying() - Added, check if a sound is currently playing +[audio] SetVolume() - Added, set the volume for a sound +[audio] SetPitch() - Added, set the pitch for a sound +[examples] ex06a_color_select completed +[examples] ex06b_logo_anim completed +[examples] ex06c_font select completed + +----------------------------------------------- +Release: raylib 1.0.3 (19 December 2013) +----------------------------------------------- +[fonts] Added 8 rBMF free fonts to be used on projects! +[text] LoadSpriteFont() - Now supports rBMF file loading (raylib Bitmap Font) +[examples] ex05a_sprite_fonts completed +[examples] ex05b_rbmf_fonts completed +[core] InitWindowEx() - InitWindow with extended parameters, resizing option and custom cursor! +[core] GetRandomValue() - Added, returns a random value within a range (int) +[core] SetExitKey() - Added, sets a key to exit program (default is ESC) +[core] Custom cursor not drawn when mouse out of screen +[shapes] CheckCollisionPointRec() - Added, check collision between point and rectangle +[shapes] CheckCollisionPointCircle() - Added, check collision between point and circle +[shapes] CheckCollisionPointTriangle() - Added, check collision between point and triangle +[shapes] DrawPoly() - Added, draw regular polygons of n sides, rotation can be defined! + +----------------------------------------------- +Release: raylib 1.0.2 (1 December 2013) +----------------------------------------------- +[text] GetDefaultFont() - Added, get default SpriteFont to be used on DrawTextEx() +[shapes] CheckCollisionRecs() - Added, check collision between rectangles +[shapes] CheckCollisionCircles() - Added, check collision between circles +[shapes] CheckCollisionCircleRec() - Added, check collision circle-rectangle +[shapes] GetCollisionRec() - Added, get collision rectangle +[textures] CreateTexture2D() - Added, create Texture2D from Image data +[audio] Fixed WAV loading function, now audio works! + +----------------------------------------------- +Update: raylib 1.0.1 (28 November 2013) +----------------------------------------------- +[text] DrawText() - Removed spacing parameter +[text] MeasureText() - Removed spacing parameter +[text] DrawFps() - Renamed to DrawFPS() for coherence with similar function +[core] IsKeyPressed() - Change functionality, check if key pressed once +[core] IsKeyDown() - Added, check if key is being pressed +[core] IsKeyReleased() - Change functionality, check if key released once +[core] IsKeyUp() - Added, check if key is being NOT pressed +[core] IsMouseButtonDown() - Added, check if mouse button is being pressed +[core] IsMouseButtonPressed() - Change functionality, check if mouse button pressed once +[core] IsMouseButtonUp() - Added, check if mouse button is NOT being pressed +[core] IsMouseButtonReleased() - Change functionality, check if mouse button released once +[textures] DrawTexturePro() - Added, texture drawing with 'pro' parameters +[examples] Function changes applied to ALL examples + +----------------------------------------------- +Release: raylib 1.0.0 (18 November 2013) +----------------------------------------------- +* Initial version +* 6 Modules provided: + - core: basic window/context creation functions, input management, timing functions + - shapes: basic shapes drawing functions + - textures: image data loading and conversion to OpenGL textures + - text: text drawing, sprite fonts loading, default font loading + - models: basic 3d shapes drawing, OBJ models loading and drawing + - audio: audio device initialization, WAV files loading and playing diff --git a/lib/raylib-4.5.0_win64_msvc16/LICENSE b/lib/raylib-4.5.0_win64_msvc16/LICENSE new file mode 100644 index 0000000..91da62e --- /dev/null +++ b/lib/raylib-4.5.0_win64_msvc16/LICENSE @@ -0,0 +1,16 @@ +Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) + +This software is provided "as-is", without any express or implied warranty. In no event +will the authors be held liable for any damages arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including commercial +applications, and to alter it and redistribute it freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not claim that you + wrote the original software. If you use this software in a product, an acknowledgment + in the product documentation would be appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be misrepresented + as being the original software. + + 3. This notice may not be removed or altered from any source distribution. diff --git a/lib/raylib-4.5.0_win64_msvc16/README.md b/lib/raylib-4.5.0_win64_msvc16/README.md new file mode 100644 index 0000000..05ba5cc --- /dev/null +++ b/lib/raylib-4.5.0_win64_msvc16/README.md @@ -0,0 +1,144 @@ + + +**raylib is a simple and easy-to-use library to enjoy videogames programming.** + +raylib is highly inspired by Borland BGI graphics lib and by XNA framework and it's specially well suited for prototyping, tooling, graphical applications, embedded systems and education. + +*NOTE for ADVENTURERS: raylib is a programming library to enjoy videogames programming; no fancy interface, no visual helpers, no debug button... just coding in the most pure spartan-programmers way.* + +Ready to learn? Jump to [code examples!](https://www.raylib.com/examples.html) + +--- + +
+ +[![GitHub Releases Downloads](https://img.shields.io/github/downloads/raysan5/raylib/total)](https://github.com/raysan5/raylib/releases) +[![GitHub Stars](https://img.shields.io/github/stars/raysan5/raylib?style=flat&label=stars)](https://github.com/raysan5/raylib/stargazers) +[![GitHub commits since tagged version](https://img.shields.io/github/commits-since/raysan5/raylib/4.2.0)](https://github.com/raysan5/raylib/commits/master) +[![GitHub Sponsors](https://img.shields.io/github/sponsors/raysan5?label=sponsors)](https://github.com/sponsors/raysan5) +[![Packaging Status](https://repology.org/badge/tiny-repos/raylib.svg)](https://repology.org/project/raylib/versions) +[![License](https://img.shields.io/badge/license-zlib%2Flibpng-blue.svg)](LICENSE) + +[![Discord Members](https://img.shields.io/discord/426912293134270465.svg?label=Discord&logo=discord)](https://discord.gg/raylib) +[![Subreddit Subscribers](https://img.shields.io/reddit/subreddit-subscribers/raylib?label=reddit%20r%2Fraylib&logo=reddit)](https://www.reddit.com/r/raylib/) +[![Youtube Subscribers](https://img.shields.io/youtube/channel/subscribers/UC8WIBkhYb5sBNqXO1mZ7WSQ?style=flat&label=Youtube&logo=youtube)](https://www.youtube.com/c/raylib) +[![Twitch Status](https://img.shields.io/twitch/status/raysan5?style=flat&label=Twitch&logo=twitch)](https://www.twitch.tv/raysan5) + +[![Windows](https://github.com/raysan5/raylib/workflows/Windows/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3AWindows) +[![Linux](https://github.com/raysan5/raylib/workflows/Linux/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3ALinux) +[![macOS](https://github.com/raysan5/raylib/workflows/macOS/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3AmacOS) +[![Android](https://github.com/raysan5/raylib/workflows/Android/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3AAndroid) +[![WebAssembly](https://github.com/raysan5/raylib/workflows/WebAssembly/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3AWebAssembly) + +[![CMakeBuilds](https://github.com/raysan5/raylib/workflows/CMakeBuilds/badge.svg)](https://github.com/raysan5/raylib/actions?query=workflow%3ACMakeBuilds) +[![Windows Examples](https://github.com/raysan5/raylib/actions/workflows/windows_examples.yml/badge.svg)](https://github.com/raysan5/raylib/actions/workflows/windows_examples.yml) +[![Linux Examples](https://github.com/raysan5/raylib/actions/workflows/linux_examples.yml/badge.svg)](https://github.com/raysan5/raylib/actions/workflows/linux_examples.yml) + +features +-------- + - **NO external dependencies**, all required libraries are [bundled into raylib](https://github.com/raysan5/raylib/tree/master/src/external) + - Multiple platforms supported: **Windows, Linux, MacOS, RPI, Android, HTML5... and more!** + - Written in plain C code (C99) using PascalCase/camelCase notation + - Hardware accelerated with OpenGL (**1.1, 2.1, 3.3, 4.3 or ES 2.0**) + - **Unique OpenGL abstraction layer** (usable as standalone module): [rlgl](https://github.com/raysan5/raylib/blob/master/src/rlgl.h) + - Multiple **Fonts** formats supported (TTF, Image fonts, AngelCode fonts) + - Multiple texture formats supported, including **compressed formats** (DXT, ETC, ASTC) + - **Full 3D support**, including 3D Shapes, Models, Billboards, Heightmaps and more! + - Flexible Materials system, supporting classic maps and **PBR maps** + - **Animated 3D models** supported (skeletal bones animation) (IQM) + - Shaders support, including model and **postprocessing** shaders. + - **Powerful math module** for Vector, Matrix and Quaternion operations: [raymath](https://github.com/raysan5/raylib/blob/master/src/raymath.h) + - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) + - **VR stereo rendering** support with configurable HMD device parameters + - Huge examples collection with [+120 code examples](https://github.com/raysan5/raylib/tree/master/examples)! + - Bindings to [+60 programming languages](https://github.com/raysan5/raylib/blob/master/BINDINGS.md)! + - **Free and open source**. + +basic example +-------------- +This is a basic raylib example, it creates a window and it draws the text `"Congrats! You created your first window!"` in the middle of the screen. Check this example [running live on web here](https://www.raylib.com/examples/core/loader.html?name=core_basic_window). +```c +#include "raylib.h" + +int main(void) +{ + InitWindow(800, 450, "raylib [core] example - basic window"); + + while (!WindowShouldClose()) + { + BeginDrawing(); + ClearBackground(RAYWHITE); + DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY); + EndDrawing(); + } + + CloseWindow(); + + return 0; +} +``` + +build and installation +---------------------- + +raylib binary releases for Windows, Linux, macOS, Android and HTML5 are available at the [Github Releases page](https://github.com/raysan5/raylib/releases). + +raylib is also available via multiple [package managers](https://github.com/raysan5/raylib/issues/613) on multiple OS distributions. + +#### Installing and building raylib on multiple platforms + +[raylib Wiki](https://github.com/raysan5/raylib/wiki#development-platforms) contains detailed instructions on building and usage on multiple platforms. + + - [Working on Windows](https://github.com/raysan5/raylib/wiki/Working-on-Windows) + - [Working on macOS](https://github.com/raysan5/raylib/wiki/Working-on-macOS) + - [Working on GNU Linux](https://github.com/raysan5/raylib/wiki/Working-on-GNU-Linux) + - [Working on Chrome OS](https://github.com/raysan5/raylib/wiki/Working-on-Chrome-OS) + - [Working on FreeBSD](https://github.com/raysan5/raylib/wiki/Working-on-FreeBSD) + - [Working on Raspberry Pi](https://github.com/raysan5/raylib/wiki/Working-on-Raspberry-Pi) + - [Working for Android](https://github.com/raysan5/raylib/wiki/Working-for-Android) + - [Working for Web (HTML5)](https://github.com/raysan5/raylib/wiki/Working-for-Web-(HTML5)) + - [Working anywhere with CMake](https://github.com/raysan5/raylib/wiki/Working-with-CMake) + +*Note that the Wiki is open for edit, if you find some issues while building raylib for your target platform, feel free to edit the Wiki or open an issue related to it.* + +#### Setup raylib with multiple IDEs + +raylib has been developed on Windows platform using [Notepad++](https://notepad-plus-plus.org/) and [MinGW GCC](https://www.mingw-w64.org/) compiler but it can be used with other IDEs on multiple platforms. + +[Projects directory](https://github.com/raysan5/raylib/tree/master/projects) contains several ready-to-use **project templates** to build raylib and code examples with multiple IDEs. + +*Note that there are lots of IDEs supported, some of the provided templates could require some review, so please, if you find some issue with a template or you think they could be improved, feel free to send a PR or open a related issue.* + +learning and docs +------------------ + +raylib is designed to be learned using [the examples](https://github.com/raysan5/raylib/tree/master/examples) as the main reference. There is no standard API documentation but there is a [**cheatsheet**](https://www.raylib.com/cheatsheet/cheatsheet.html) containing all the functions available on the library a short description of each one of them, input parameters and result value names should be intuitive enough to understand how each function works. + +Some additional documentation about raylib design can be found in raylib GitHub Wiki. Here are the relevant links: + + - [raylib cheatsheet](https://www.raylib.com/cheatsheet/cheatsheet.html) + - [raylib architecture](https://github.com/raysan5/raylib/wiki/raylib-architecture) + - [raylib library design](https://github.com/raysan5/raylib/wiki) + - [raylib examples collection](https://github.com/raysan5/raylib/tree/master/examples) + - [raylib games collection](https://github.com/raysan5/raylib-games) + + +contact and networks +--------------------- + +raylib is present in several networks and raylib community is growing everyday. If you are using raylib and enjoying it, feel free to join us in any of these networks. The most active network is our [Discord server](https://discord.gg/raylib)! :) + + - Webpage: [https://www.raylib.com](https://www.raylib.com) + - Discord: [https://discord.gg/raylib](https://discord.gg/raylib) + - Twitter: [https://www.twitter.com/raysan5](https://www.twitter.com/raysan5) + - Twitch: [https://www.twitch.tv/raysan5](https://www.twitch.tv/raysan5) + - Reddit: [https://www.reddit.com/r/raylib](https://www.reddit.com/r/raylib) + - Patreon: [https://www.patreon.com/raylib](https://www.patreon.com/raylib) + - YouTube: [https://www.youtube.com/channel/raylib](https://www.youtube.com/c/raylib) + +license +------- + +raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, BSD-like license that allows static linking with closed source software. Check [LICENSE](LICENSE) for further details. + +raylib uses internally some libraries for window/graphics/inputs management and also to support different file formats loading, all those libraries are embedded with and are available in [src/external](https://github.com/raysan5/raylib/tree/master/src/external) directory. Check [raylib dependencies LICENSES](https://github.com/raysan5/raylib/wiki/raylib-dependencies) on raylib Wiki for details. diff --git a/lib/raylib-4.5.0_win64_msvc16/include/raygui.h b/lib/raylib-4.5.0_win64_msvc16/include/raygui.h new file mode 100644 index 0000000..98de9d8 --- /dev/null +++ b/lib/raylib-4.5.0_win64_msvc16/include/raygui.h @@ -0,0 +1,5540 @@ +/******************************************************************************************* +* +* raygui v4.1-dev - A simple and easy-to-use immediate-mode gui library +* +* DESCRIPTION: +* raygui is a tools-dev-focused immediate-mode-gui library based on raylib but also +* available as a standalone library, as long as input and drawing functions are provided. +* +* FEATURES: +* - Immediate-mode gui, minimal retained data +* - +25 controls provided (basic and advanced) +* - Styling system for colors, font and metrics +* - Icons supported, embedded as a 1-bit icons pack +* - Standalone mode option (custom input/graphics backend) +* - Multiple support tools provided for raygui development +* +* POSSIBLE IMPROVEMENTS: +* - Better standalone mode API for easy plug of custom backends +* - Externalize required inputs, allow user easier customization +* +* LIMITATIONS: +* - No editable multi-line word-wraped text box supported +* - No auto-layout mechanism, up to the user to define controls position and size +* - Standalone mode requires library modification and some user work to plug another backend +* +* NOTES: +* - WARNING: GuiLoadStyle() and GuiLoadStyle{Custom}() functions, allocate memory for +* font atlas recs and glyphs, freeing that memory is (usually) up to the user, +* no unload function is explicitly provided... but note that GuiLoadStyleDefault() unloads +* by default any previously loaded font (texture, recs, glyphs). +* - Global UI alpha (guiAlpha) is applied inside GuiDrawRectangle() and GuiDrawText() functions +* +* CONTROLS PROVIDED: +* # Container/separators Controls +* - WindowBox --> StatusBar, Panel +* - GroupBox --> Line +* - Line +* - Panel --> StatusBar +* - ScrollPanel --> StatusBar +* - TabBar --> Button +* +* # Basic Controls +* - Label +* - LabelButton --> Label +* - Button +* - Toggle +* - ToggleGroup --> Toggle +* - ToggleSlider +* - CheckBox +* - ComboBox +* - DropdownBox +* - TextBox +* - ValueBox --> TextBox +* - Spinner --> Button, ValueBox +* - Slider +* - SliderBar --> Slider +* - ProgressBar +* - StatusBar +* - DummyRec +* - Grid +* +* # Advance Controls +* - ListView +* - ColorPicker --> ColorPanel, ColorBarHue +* - MessageBox --> Window, Label, Button +* - TextInputBox --> Window, Label, TextBox, Button +* +* It also provides a set of functions for styling the controls based on its properties (size, color). +* +* +* RAYGUI STYLE (guiStyle): +* raygui uses a global data array for all gui style properties (allocated on data segment by default), +* when a new style is loaded, it is loaded over the global style... but a default gui style could always be +* recovered with GuiLoadStyleDefault() function, that overwrites the current style to the default one +* +* The global style array size is fixed and depends on the number of controls and properties: +* +* static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)]; +* +* guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB +* +* Note that the first set of BASE properties (by default guiStyle[0..15]) belong to the generic style +* used for all controls, when any of those base values is set, it is automatically populated to all +* controls, so, specific control values overwriting generic style should be set after base values. +* +* After the first BASE set we have the EXTENDED properties (by default guiStyle[16..23]), those +* properties are actually common to all controls and can not be overwritten individually (like BASE ones) +* Some of those properties are: TEXT_SIZE, TEXT_SPACING, LINE_COLOR, BACKGROUND_COLOR +* +* Custom control properties can be defined using the EXTENDED properties for each independent control. +* +* TOOL: rGuiStyler is a visual tool to customize raygui style: github.com/raysan5/rguistyler +* +* +* RAYGUI ICONS (guiIcons): +* raygui could use a global array containing icons data (allocated on data segment by default), +* a custom icons set could be loaded over this array using GuiLoadIcons(), but loaded icons set +* must be same RAYGUI_ICON_SIZE and no more than RAYGUI_ICON_MAX_ICONS will be loaded +* +* Every icon is codified in binary form, using 1 bit per pixel, so, every 16x16 icon +* requires 8 integers (16*16/32) to be stored in memory. +* +* When the icon is draw, actually one quad per pixel is drawn if the bit for that pixel is set. +* +* The global icons array size is fixed and depends on the number of icons and size: +* +* static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS]; +* +* guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB +* +* TOOL: rGuiIcons is a visual tool to customize/create raygui icons: github.com/raysan5/rguiicons +* +* RAYGUI LAYOUT: +* raygui currently does not provide an auto-layout mechanism like other libraries, +* layouts must be defined manually on controls drawing, providing the right bounds Rectangle for it. +* +* TOOL: rGuiLayout is a visual tool to create raygui layouts: github.com/raysan5/rguilayout +* +* CONFIGURATION: +* #define RAYGUI_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RAYGUI_STANDALONE +* Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined +* internally in the library and input management and drawing functions must be provided by +* the user (check library implementation for further details). +* +* #define RAYGUI_NO_ICONS +* Avoid including embedded ricons data (256 icons, 16x16 pixels, 1-bit per pixel, 2KB) +* +* #define RAYGUI_CUSTOM_ICONS +* Includes custom ricons.h header defining a set of custom icons, +* this file can be generated using rGuiIcons tool +* +* #define RAYGUI_DEBUG_RECS_BOUNDS +* Draw control bounds rectangles for debug +* +* #define RAYGUI_DEBUG_TEXT_BOUNDS +* Draw text bounds rectangles for debug +* +* VERSIONS HISTORY: +* 4.1-dev (2024) Current dev version... +* ADDED: guiControlExclusiveMode and guiControlExclusiveRec for exclusive modes +* +* 4.0 (12-Sep-2023) ADDED: GuiToggleSlider() +* ADDED: GuiColorPickerHSV() and GuiColorPanelHSV() +* ADDED: Multiple new icons, mostly compiler related +* ADDED: New DEFAULT properties: TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE +* ADDED: New enum values: GuiTextAlignment, GuiTextAlignmentVertical, GuiTextWrapMode +* ADDED: Support loading styles with custom font charset from external file +* REDESIGNED: GuiTextBox(), support mouse cursor positioning +* REDESIGNED: GuiDrawText(), support multiline and word-wrap modes (read only) +* REDESIGNED: GuiProgressBar() to be more visual, progress affects border color +* REDESIGNED: Global alpha consideration moved to GuiDrawRectangle() and GuiDrawText() +* REDESIGNED: GuiScrollPanel(), get parameters by reference and return result value +* REDESIGNED: GuiToggleGroup(), get parameters by reference and return result value +* REDESIGNED: GuiComboBox(), get parameters by reference and return result value +* REDESIGNED: GuiCheckBox(), get parameters by reference and return result value +* REDESIGNED: GuiSlider(), get parameters by reference and return result value +* REDESIGNED: GuiSliderBar(), get parameters by reference and return result value +* REDESIGNED: GuiProgressBar(), get parameters by reference and return result value +* REDESIGNED: GuiListView(), get parameters by reference and return result value +* REDESIGNED: GuiColorPicker(), get parameters by reference and return result value +* REDESIGNED: GuiColorPanel(), get parameters by reference and return result value +* REDESIGNED: GuiColorBarAlpha(), get parameters by reference and return result value +* REDESIGNED: GuiColorBarHue(), get parameters by reference and return result value +* REDESIGNED: GuiGrid(), get parameters by reference and return result value +* REDESIGNED: GuiGrid(), added extra parameter +* REDESIGNED: GuiListViewEx(), change parameters order +* REDESIGNED: All controls return result as int value +* REVIEWED: GuiScrollPanel() to avoid smallish scroll-bars +* REVIEWED: All examples and specially controls_test_suite +* RENAMED: gui_file_dialog module to gui_window_file_dialog +* UPDATED: All styles to include ISO-8859-15 charset (as much as possible) +* +* 3.6 (10-May-2023) ADDED: New icon: SAND_TIMER +* ADDED: GuiLoadStyleFromMemory() (binary only) +* REVIEWED: GuiScrollBar() horizontal movement key +* REVIEWED: GuiTextBox() crash on cursor movement +* REVIEWED: GuiTextBox(), additional inputs support +* REVIEWED: GuiLabelButton(), avoid text cut +* REVIEWED: GuiTextInputBox(), password input +* REVIEWED: Local GetCodepointNext(), aligned with raylib +* REDESIGNED: GuiSlider*()/GuiScrollBar() to support out-of-bounds +* +* 3.5 (20-Apr-2023) ADDED: GuiTabBar(), based on GuiToggle() +* ADDED: Helper functions to split text in separate lines +* ADDED: Multiple new icons, useful for code editing tools +* REMOVED: Unneeded icon editing functions +* REMOVED: GuiTextBoxMulti(), very limited and broken +* REMOVED: MeasureTextEx() dependency, logic directly implemented +* REMOVED: DrawTextEx() dependency, logic directly implemented +* REVIEWED: GuiScrollBar(), improve mouse-click behaviour +* REVIEWED: Library header info, more info, better organized +* REDESIGNED: GuiTextBox() to support cursor movement +* REDESIGNED: GuiDrawText() to divide drawing by lines +* +* 3.2 (22-May-2022) RENAMED: Some enum values, for unification, avoiding prefixes +* REMOVED: GuiScrollBar(), only internal +* REDESIGNED: GuiPanel() to support text parameter +* REDESIGNED: GuiScrollPanel() to support text parameter +* REDESIGNED: GuiColorPicker() to support text parameter +* REDESIGNED: GuiColorPanel() to support text parameter +* REDESIGNED: GuiColorBarAlpha() to support text parameter +* REDESIGNED: GuiColorBarHue() to support text parameter +* REDESIGNED: GuiTextInputBox() to support password +* +* 3.1 (12-Jan-2022) REVIEWED: Default style for consistency (aligned with rGuiLayout v2.5 tool) +* REVIEWED: GuiLoadStyle() to support compressed font atlas image data and unload previous textures +* REVIEWED: External icons usage logic +* REVIEWED: GuiLine() for centered alignment when including text +* RENAMED: Multiple controls properties definitions to prepend RAYGUI_ +* RENAMED: RICON_ references to RAYGUI_ICON_ for library consistency +* Projects updated and multiple tweaks +* +* 3.0 (04-Nov-2021) Integrated ricons data to avoid external file +* REDESIGNED: GuiTextBoxMulti() +* REMOVED: GuiImageButton*() +* Multiple minor tweaks and bugs corrected +* +* 2.9 (17-Mar-2021) REMOVED: Tooltip API +* 2.8 (03-May-2020) Centralized rectangles drawing to GuiDrawRectangle() +* 2.7 (20-Feb-2020) ADDED: Possible tooltips API +* 2.6 (09-Sep-2019) ADDED: GuiTextInputBox() +* REDESIGNED: GuiListView*(), GuiDropdownBox(), GuiSlider*(), GuiProgressBar(), GuiMessageBox() +* REVIEWED: GuiTextBox(), GuiSpinner(), GuiValueBox(), GuiLoadStyle() +* Replaced property INNER_PADDING by TEXT_PADDING, renamed some properties +* ADDED: 8 new custom styles ready to use +* Multiple minor tweaks and bugs corrected +* +* 2.5 (28-May-2019) Implemented extended GuiTextBox(), GuiValueBox(), GuiSpinner() +* 2.3 (29-Apr-2019) ADDED: rIcons auxiliar library and support for it, multiple controls reviewed +* Refactor all controls drawing mechanism to use control state +* 2.2 (05-Feb-2019) ADDED: GuiScrollBar(), GuiScrollPanel(), reviewed GuiListView(), removed Gui*Ex() controls +* 2.1 (26-Dec-2018) REDESIGNED: GuiCheckBox(), GuiComboBox(), GuiDropdownBox(), GuiToggleGroup() > Use combined text string +* REDESIGNED: Style system (breaking change) +* 2.0 (08-Nov-2018) ADDED: Support controls guiLock and custom fonts +* REVIEWED: GuiComboBox(), GuiListView()... +* 1.9 (09-Oct-2018) REVIEWED: GuiGrid(), GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()... +* 1.8 (01-May-2018) Lot of rework and redesign to align with rGuiStyler and rGuiLayout +* 1.5 (21-Jun-2017) Working in an improved styles system +* 1.4 (15-Jun-2017) Rewritten all GUI functions (removed useless ones) +* 1.3 (12-Jun-2017) Complete redesign of style system +* 1.1 (01-Jun-2017) Complete review of the library +* 1.0 (07-Jun-2016) Converted to header-only by Ramon Santamaria. +* 0.9 (07-Mar-2016) Reviewed and tested by Albert Martos, Ian Eito, Sergio Martinez and Ramon Santamaria. +* 0.8 (27-Aug-2015) Initial release. Implemented by Kevin Gato, Daniel Nicolás and Ramon Santamaria. +* +* DEPENDENCIES: +* raylib 5.0 - Inputs reading (keyboard/mouse), shapes drawing, font loading and text drawing +* +* STANDALONE MODE: +* By default raygui depends on raylib mostly for the inputs and the drawing functionality but that dependency can be disabled +* with the config flag RAYGUI_STANDALONE. In that case is up to the user to provide another backend to cover library needs. +* +* The following functions should be redefined for a custom backend: +* +* - Vector2 GetMousePosition(void); +* - float GetMouseWheelMove(void); +* - bool IsMouseButtonDown(int button); +* - bool IsMouseButtonPressed(int button); +* - bool IsMouseButtonReleased(int button); +* - bool IsKeyDown(int key); +* - bool IsKeyPressed(int key); +* - int GetCharPressed(void); // -- GuiTextBox(), GuiValueBox() +* +* - void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle() +* - void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker() +* +* - Font GetFontDefault(void); // -- GuiLoadStyleDefault() +* - Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle() +* - Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle(), required to load texture from embedded font atlas image +* - void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization) +* - char *LoadFileText(const char *fileName); // -- GuiLoadStyle(), required to load charset data +* - void UnloadFileText(char *text); // -- GuiLoadStyle(), required to unload charset data +* - const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle(), required to find charset/font file from text .rgs +* - int *LoadCodepoints(const char *text, int *count); // -- GuiLoadStyle(), required to load required font codepoints list +* - void UnloadCodepoints(int *codepoints); // -- GuiLoadStyle(), required to unload codepoints list +* - unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle() +* +* CONTRIBUTORS: +* Ramon Santamaria: Supervision, review, redesign, update and maintenance +* Vlad Adrian: Complete rewrite of GuiTextBox() to support extended features (2019) +* Sergio Martinez: Review, testing (2015) and redesign of multiple controls (2018) +* Adria Arranz: Testing and implementation of additional controls (2018) +* Jordi Jorba: Testing and implementation of additional controls (2018) +* Albert Martos: Review and testing of the library (2015) +* Ian Eito: Review and testing of the library (2015) +* Kevin Gato: Initial implementation of basic components (2014) +* Daniel Nicolas: Initial implementation of basic components (2014) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2024 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYGUI_H +#define RAYGUI_H + +#define RAYGUI_VERSION_MAJOR 4 +#define RAYGUI_VERSION_MINOR 1 +#define RAYGUI_VERSION_PATCH 0 +#define RAYGUI_VERSION "4.1-dev" + +#if !defined(RAYGUI_STANDALONE) + #include "raylib.h" +#endif + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RAYGUIAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +// Function specifiers definition +#ifndef RAYGUIAPI + #define RAYGUIAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +// Allow custom memory allocators +#ifndef RAYGUI_MALLOC + #define RAYGUI_MALLOC(sz) malloc(sz) +#endif +#ifndef RAYGUI_CALLOC + #define RAYGUI_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RAYGUI_FREE + #define RAYGUI_FREE(p) free(p) +#endif + +// Simple log system to avoid printf() calls if required +// NOTE: Avoiding those calls, also avoids const strings memory usage +#define RAYGUI_SUPPORT_LOG_INFO +#if defined(RAYGUI_SUPPORT_LOG_INFO) + #define RAYGUI_LOG(...) printf(__VA_ARGS__) +#else + #define RAYGUI_LOG(...) +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +// NOTE: Some types are required for RAYGUI_STANDALONE usage +//---------------------------------------------------------------------------------- +#if defined(RAYGUI_STANDALONE) + #ifndef __cplusplus + // Boolean type + #ifndef true + typedef enum { false, true } bool; + #endif + #endif + + // Vector2 type + typedef struct Vector2 { + float x; + float y; + } Vector2; + + // Vector3 type // -- ConvertHSVtoRGB(), ConvertRGBtoHSV() + typedef struct Vector3 { + float x; + float y; + float z; + } Vector3; + + // Color type, RGBA (32bit) + typedef struct Color { + unsigned char r; + unsigned char g; + unsigned char b; + unsigned char a; + } Color; + + // Rectangle type + typedef struct Rectangle { + float x; + float y; + float width; + float height; + } Rectangle; + + // TODO: Texture2D type is very coupled to raylib, required by Font type + // It should be redesigned to be provided by user + typedef struct Texture2D { + unsigned int id; // OpenGL texture id + int width; // Texture base width + int height; // Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) + } Texture2D; + + // Image, pixel data stored in CPU memory (RAM) + typedef struct Image { + void *data; // Image raw data + int width; // Image base width + int height; // Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) + } Image; + + // GlyphInfo, font characters glyphs info + typedef struct GlyphInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + Image image; // Character image data + } GlyphInfo; + + // TODO: Font type is very coupled to raylib, mostly required by GuiLoadStyle() + // It should be redesigned to be provided by user + typedef struct Font { + int baseSize; // Base size (default chars height) + int glyphCount; // Number of glyph characters + int glyphPadding; // Padding around the glyph characters + Texture2D texture; // Texture atlas containing the glyphs + Rectangle *recs; // Rectangles in texture for the glyphs + GlyphInfo *glyphs; // Glyphs info data + } Font; +#endif + +// Style property +// NOTE: Used when exporting style as code for convenience +typedef struct GuiStyleProp { + unsigned short controlId; // Control identifier + unsigned short propertyId; // Property identifier + int propertyValue; // Property value +} GuiStyleProp; + +/* +// Controls text style -NOT USED- +// NOTE: Text style is defined by control +typedef struct GuiTextStyle { + unsigned int size; + int charSpacing; + int lineSpacing; + int alignmentH; + int alignmentV; + int padding; +} GuiTextStyle; +*/ + +// Gui control state +typedef enum { + STATE_NORMAL = 0, + STATE_FOCUSED, + STATE_PRESSED, + STATE_DISABLED +} GuiState; + +// Gui control text alignment +typedef enum { + TEXT_ALIGN_LEFT = 0, + TEXT_ALIGN_CENTER, + TEXT_ALIGN_RIGHT +} GuiTextAlignment; + +// Gui control text alignment vertical +// NOTE: Text vertical position inside the text bounds +typedef enum { + TEXT_ALIGN_TOP = 0, + TEXT_ALIGN_MIDDLE, + TEXT_ALIGN_BOTTOM +} GuiTextAlignmentVertical; + +// Gui control text wrap mode +// NOTE: Useful for multiline text +typedef enum { + TEXT_WRAP_NONE = 0, + TEXT_WRAP_CHAR, + TEXT_WRAP_WORD +} GuiTextWrapMode; + +// Gui controls +typedef enum { + // Default -> populates to all controls when set + DEFAULT = 0, + + // Basic controls + LABEL, // Used also for: LABELBUTTON + BUTTON, + TOGGLE, // Used also for: TOGGLEGROUP + SLIDER, // Used also for: SLIDERBAR, TOGGLESLIDER + PROGRESSBAR, + CHECKBOX, + COMBOBOX, + DROPDOWNBOX, + TEXTBOX, // Used also for: TEXTBOXMULTI + VALUEBOX, + SPINNER, // Uses: BUTTON, VALUEBOX + LISTVIEW, + COLORPICKER, + SCROLLBAR, + STATUSBAR +} GuiControl; + +// Gui base properties for every control +// NOTE: RAYGUI_MAX_PROPS_BASE properties (by default 16 properties) +typedef enum { + BORDER_COLOR_NORMAL = 0, // Control border color in STATE_NORMAL + BASE_COLOR_NORMAL, // Control base color in STATE_NORMAL + TEXT_COLOR_NORMAL, // Control text color in STATE_NORMAL + BORDER_COLOR_FOCUSED, // Control border color in STATE_FOCUSED + BASE_COLOR_FOCUSED, // Control base color in STATE_FOCUSED + TEXT_COLOR_FOCUSED, // Control text color in STATE_FOCUSED + BORDER_COLOR_PRESSED, // Control border color in STATE_PRESSED + BASE_COLOR_PRESSED, // Control base color in STATE_PRESSED + TEXT_COLOR_PRESSED, // Control text color in STATE_PRESSED + BORDER_COLOR_DISABLED, // Control border color in STATE_DISABLED + BASE_COLOR_DISABLED, // Control base color in STATE_DISABLED + TEXT_COLOR_DISABLED, // Control text color in STATE_DISABLED + BORDER_WIDTH, // Control border size, 0 for no border + //TEXT_SIZE, // Control text size (glyphs max height) -> GLOBAL for all controls + //TEXT_SPACING, // Control text spacing between glyphs -> GLOBAL for all controls + //TEXT_LINE_SPACING // Control text spacing between lines -> GLOBAL for all controls + TEXT_PADDING, // Control text padding, not considering border + TEXT_ALIGNMENT, // Control text horizontal alignment inside control text bound (after border and padding) + //TEXT_WRAP_MODE // Control text wrap-mode inside text bounds -> GLOBAL for all controls +} GuiControlProperty; + +// TODO: Which text styling properties should be global or per-control? +// At this moment TEXT_PADDING and TEXT_ALIGNMENT is configured and saved per control while +// TEXT_SIZE, TEXT_SPACING, TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE are global and +// should be configured by user as needed while defining the UI layout + +// Gui extended properties depend on control +// NOTE: RAYGUI_MAX_PROPS_EXTENDED properties (by default, max 8 properties) +//---------------------------------------------------------------------------------- +// DEFAULT extended properties +// NOTE: Those properties are common to all controls or global +// WARNING: We only have 8 slots for those properties by default!!! -> New global control: TEXT? +typedef enum { + TEXT_SIZE = 16, // Text size (glyphs max height) + TEXT_SPACING, // Text spacing between glyphs + LINE_COLOR, // Line control color + BACKGROUND_COLOR, // Background color + TEXT_LINE_SPACING, // Text spacing between lines + TEXT_ALIGNMENT_VERTICAL, // Text vertical alignment inside text bounds (after border and padding) + TEXT_WRAP_MODE // Text wrap-mode inside text bounds + //TEXT_DECORATION // Text decoration: 0-None, 1-Underline, 2-Line-through, 3-Overline + //TEXT_DECORATION_THICK // Text decoration line thickness +} GuiDefaultProperty; + +// Other possible text properties: +// TEXT_WEIGHT // Normal, Italic, Bold -> Requires specific font change +// TEXT_INDENT // Text indentation -> Now using TEXT_PADDING... + +// Label +//typedef enum { } GuiLabelProperty; + +// Button/Spinner +//typedef enum { } GuiButtonProperty; + +// Toggle/ToggleGroup +typedef enum { + GROUP_PADDING = 16, // ToggleGroup separation between toggles +} GuiToggleProperty; + +// Slider/SliderBar +typedef enum { + SLIDER_WIDTH = 16, // Slider size of internal bar + SLIDER_PADDING // Slider/SliderBar internal bar padding +} GuiSliderProperty; + +// ProgressBar +typedef enum { + PROGRESS_PADDING = 16, // ProgressBar internal padding +} GuiProgressBarProperty; + +// ScrollBar +typedef enum { + ARROWS_SIZE = 16, // ScrollBar arrows size + ARROWS_VISIBLE, // ScrollBar arrows visible + SCROLL_SLIDER_PADDING, // ScrollBar slider internal padding + SCROLL_SLIDER_SIZE, // ScrollBar slider size + SCROLL_PADDING, // ScrollBar scroll padding from arrows + SCROLL_SPEED, // ScrollBar scrolling speed +} GuiScrollBarProperty; + +// CheckBox +typedef enum { + CHECK_PADDING = 16 // CheckBox internal check padding +} GuiCheckBoxProperty; + +// ComboBox +typedef enum { + COMBO_BUTTON_WIDTH = 16, // ComboBox right button width + COMBO_BUTTON_SPACING // ComboBox button separation +} GuiComboBoxProperty; + +// DropdownBox +typedef enum { + ARROW_PADDING = 16, // DropdownBox arrow separation from border and items + DROPDOWN_ITEMS_SPACING // DropdownBox items separation +} GuiDropdownBoxProperty; + +// TextBox/TextBoxMulti/ValueBox/Spinner +typedef enum { + TEXT_READONLY = 16, // TextBox in read-only mode: 0-text editable, 1-text no-editable +} GuiTextBoxProperty; + +// Spinner +typedef enum { + SPIN_BUTTON_WIDTH = 16, // Spinner left/right buttons width + SPIN_BUTTON_SPACING, // Spinner buttons separation +} GuiSpinnerProperty; + +// ListView +typedef enum { + LIST_ITEMS_HEIGHT = 16, // ListView items height + LIST_ITEMS_SPACING, // ListView items separation + SCROLLBAR_WIDTH, // ListView scrollbar size (usually width) + SCROLLBAR_SIDE, // ListView scrollbar side (0-SCROLLBAR_LEFT_SIDE, 1-SCROLLBAR_RIGHT_SIDE) +} GuiListViewProperty; + +// ColorPicker +typedef enum { + COLOR_SELECTOR_SIZE = 16, + HUEBAR_WIDTH, // ColorPicker right hue bar width + HUEBAR_PADDING, // ColorPicker right hue bar separation from panel + HUEBAR_SELECTOR_HEIGHT, // ColorPicker right hue bar selector height + HUEBAR_SELECTOR_OVERFLOW // ColorPicker right hue bar selector overflow +} GuiColorPickerProperty; + +#define SCROLLBAR_LEFT_SIDE 0 +#define SCROLLBAR_RIGHT_SIDE 1 + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +// ... + +//---------------------------------------------------------------------------------- +// Module Functions Declaration +//---------------------------------------------------------------------------------- + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Global gui state control functions +RAYGUIAPI void GuiEnable(void); // Enable gui controls (global state) +RAYGUIAPI void GuiDisable(void); // Disable gui controls (global state) +RAYGUIAPI void GuiLock(void); // Lock gui controls (global state) +RAYGUIAPI void GuiUnlock(void); // Unlock gui controls (global state) +RAYGUIAPI bool GuiIsLocked(void); // Check if gui is locked (global state) +RAYGUIAPI void GuiSetAlpha(float alpha); // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f +RAYGUIAPI void GuiSetState(int state); // Set gui state (global state) +RAYGUIAPI int GuiGetState(void); // Get gui state (global state) + +// Font set/get functions +RAYGUIAPI void GuiSetFont(Font font); // Set gui custom font (global state) +RAYGUIAPI Font GuiGetFont(void); // Get gui custom font (global state) + +// Style set/get functions +RAYGUIAPI void GuiSetStyle(int control, int property, int value); // Set one style property +RAYGUIAPI int GuiGetStyle(int control, int property); // Get one style property + +// Styles loading functions +RAYGUIAPI void GuiLoadStyle(const char *fileName); // Load style file over global style variable (.rgs) +RAYGUIAPI void GuiLoadStyleDefault(void); // Load style default over global style + +// Tooltips management functions +RAYGUIAPI void GuiEnableTooltip(void); // Enable gui tooltips (global state) +RAYGUIAPI void GuiDisableTooltip(void); // Disable gui tooltips (global state) +RAYGUIAPI void GuiSetTooltip(const char *tooltip); // Set tooltip string + +// Icons functionality +RAYGUIAPI const char *GuiIconText(int iconId, const char *text); // Get text with icon id prepended (if supported) +#if !defined(RAYGUI_NO_ICONS) +RAYGUIAPI void GuiSetIconScale(int scale); // Set default icon drawing size +RAYGUIAPI unsigned int *GuiGetIcons(void); // Get raygui icons data pointer +RAYGUIAPI char **GuiLoadIcons(const char *fileName, bool loadIconsName); // Load raygui icons file (.rgi) into internal icons data +RAYGUIAPI void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color); // Draw icon using pixel size at specified position +#endif + +// Controls +//---------------------------------------------------------------------------------------------------------- +// Container/separator controls, useful for controls organization +RAYGUIAPI int GuiWindowBox(Rectangle bounds, const char *title); // Window Box control, shows a window that can be closed +RAYGUIAPI int GuiGroupBox(Rectangle bounds, const char *text); // Group Box control with text name +RAYGUIAPI int GuiLine(Rectangle bounds, const char *text); // Line separator control, could contain text +RAYGUIAPI int GuiPanel(Rectangle bounds, const char *text); // Panel control, useful to group controls +RAYGUIAPI int GuiTabBar(Rectangle bounds, const char **text, int count, int *active); // Tab Bar control, returns TAB to be closed or -1 +RAYGUIAPI int GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll, Rectangle *view); // Scroll Panel control + +// Basic controls set +RAYGUIAPI int GuiLabel(Rectangle bounds, const char *text); // Label control +RAYGUIAPI int GuiButton(Rectangle bounds, const char *text); // Button control, returns true when clicked +RAYGUIAPI int GuiLabelButton(Rectangle bounds, const char *text); // Label button control, returns true when clicked +RAYGUIAPI int GuiToggle(Rectangle bounds, const char *text, bool *active); // Toggle Button control +RAYGUIAPI int GuiToggleGroup(Rectangle bounds, const char *text, int *active); // Toggle Group control +RAYGUIAPI int GuiToggleSlider(Rectangle bounds, const char *text, int *active); // Toggle Slider control +RAYGUIAPI int GuiCheckBox(Rectangle bounds, const char *text, bool *checked); // Check Box control, returns true when active +RAYGUIAPI int GuiComboBox(Rectangle bounds, const char *text, int *active); // Combo Box control + +RAYGUIAPI int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode); // Dropdown Box control +RAYGUIAPI int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Spinner control +RAYGUIAPI int GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Value Box control, updates input text with numbers +RAYGUIAPI int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control, updates input text + +RAYGUIAPI int GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider control +RAYGUIAPI int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Slider Bar control +RAYGUIAPI int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue); // Progress Bar control +RAYGUIAPI int GuiStatusBar(Rectangle bounds, const char *text); // Status Bar control, shows info text +RAYGUIAPI int GuiDummyRec(Rectangle bounds, const char *text); // Dummy control for placeholders +RAYGUIAPI int GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs, Vector2 *mouseCell); // Grid control + +// Advance controls set +RAYGUIAPI int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active); // List View control +RAYGUIAPI int GuiListViewEx(Rectangle bounds, const char **text, int count, int *scrollIndex, int *active, int *focus); // List View with extended parameters +RAYGUIAPI int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons); // Message Box control, displays a message +RAYGUIAPI int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text, int textMaxSize, bool *secretViewActive); // Text Input Box control, ask for text, supports secret +RAYGUIAPI int GuiColorPicker(Rectangle bounds, const char *text, Color *color); // Color Picker control (multiple color controls) +RAYGUIAPI int GuiColorPanel(Rectangle bounds, const char *text, Color *color); // Color Panel control +RAYGUIAPI int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha); // Color Bar Alpha control +RAYGUIAPI int GuiColorBarHue(Rectangle bounds, const char *text, float *value); // Color Bar Hue control +RAYGUIAPI int GuiColorPickerHSV(Rectangle bounds, const char *text, Vector3 *colorHsv); // Color Picker control that avoids conversion to RGB on each call (multiple color controls) +RAYGUIAPI int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv); // Color Panel control that updates Hue-Saturation-Value color value, used by GuiColorPickerHSV() +//---------------------------------------------------------------------------------------------------------- + +#if !defined(RAYGUI_NO_ICONS) + +#if !defined(RAYGUI_CUSTOM_ICONS) +//---------------------------------------------------------------------------------- +// Icons enumeration +//---------------------------------------------------------------------------------- +typedef enum { + ICON_NONE = 0, + ICON_FOLDER_FILE_OPEN = 1, + ICON_FILE_SAVE_CLASSIC = 2, + ICON_FOLDER_OPEN = 3, + ICON_FOLDER_SAVE = 4, + ICON_FILE_OPEN = 5, + ICON_FILE_SAVE = 6, + ICON_FILE_EXPORT = 7, + ICON_FILE_ADD = 8, + ICON_FILE_DELETE = 9, + ICON_FILETYPE_TEXT = 10, + ICON_FILETYPE_AUDIO = 11, + ICON_FILETYPE_IMAGE = 12, + ICON_FILETYPE_PLAY = 13, + ICON_FILETYPE_VIDEO = 14, + ICON_FILETYPE_INFO = 15, + ICON_FILE_COPY = 16, + ICON_FILE_CUT = 17, + ICON_FILE_PASTE = 18, + ICON_CURSOR_HAND = 19, + ICON_CURSOR_POINTER = 20, + ICON_CURSOR_CLASSIC = 21, + ICON_PENCIL = 22, + ICON_PENCIL_BIG = 23, + ICON_BRUSH_CLASSIC = 24, + ICON_BRUSH_PAINTER = 25, + ICON_WATER_DROP = 26, + ICON_COLOR_PICKER = 27, + ICON_RUBBER = 28, + ICON_COLOR_BUCKET = 29, + ICON_TEXT_T = 30, + ICON_TEXT_A = 31, + ICON_SCALE = 32, + ICON_RESIZE = 33, + ICON_FILTER_POINT = 34, + ICON_FILTER_BILINEAR = 35, + ICON_CROP = 36, + ICON_CROP_ALPHA = 37, + ICON_SQUARE_TOGGLE = 38, + ICON_SYMMETRY = 39, + ICON_SYMMETRY_HORIZONTAL = 40, + ICON_SYMMETRY_VERTICAL = 41, + ICON_LENS = 42, + ICON_LENS_BIG = 43, + ICON_EYE_ON = 44, + ICON_EYE_OFF = 45, + ICON_FILTER_TOP = 46, + ICON_FILTER = 47, + ICON_TARGET_POINT = 48, + ICON_TARGET_SMALL = 49, + ICON_TARGET_BIG = 50, + ICON_TARGET_MOVE = 51, + ICON_CURSOR_MOVE = 52, + ICON_CURSOR_SCALE = 53, + ICON_CURSOR_SCALE_RIGHT = 54, + ICON_CURSOR_SCALE_LEFT = 55, + ICON_UNDO = 56, + ICON_REDO = 57, + ICON_REREDO = 58, + ICON_MUTATE = 59, + ICON_ROTATE = 60, + ICON_REPEAT = 61, + ICON_SHUFFLE = 62, + ICON_EMPTYBOX = 63, + ICON_TARGET = 64, + ICON_TARGET_SMALL_FILL = 65, + ICON_TARGET_BIG_FILL = 66, + ICON_TARGET_MOVE_FILL = 67, + ICON_CURSOR_MOVE_FILL = 68, + ICON_CURSOR_SCALE_FILL = 69, + ICON_CURSOR_SCALE_RIGHT_FILL = 70, + ICON_CURSOR_SCALE_LEFT_FILL = 71, + ICON_UNDO_FILL = 72, + ICON_REDO_FILL = 73, + ICON_REREDO_FILL = 74, + ICON_MUTATE_FILL = 75, + ICON_ROTATE_FILL = 76, + ICON_REPEAT_FILL = 77, + ICON_SHUFFLE_FILL = 78, + ICON_EMPTYBOX_SMALL = 79, + ICON_BOX = 80, + ICON_BOX_TOP = 81, + ICON_BOX_TOP_RIGHT = 82, + ICON_BOX_RIGHT = 83, + ICON_BOX_BOTTOM_RIGHT = 84, + ICON_BOX_BOTTOM = 85, + ICON_BOX_BOTTOM_LEFT = 86, + ICON_BOX_LEFT = 87, + ICON_BOX_TOP_LEFT = 88, + ICON_BOX_CENTER = 89, + ICON_BOX_CIRCLE_MASK = 90, + ICON_POT = 91, + ICON_ALPHA_MULTIPLY = 92, + ICON_ALPHA_CLEAR = 93, + ICON_DITHERING = 94, + ICON_MIPMAPS = 95, + ICON_BOX_GRID = 96, + ICON_GRID = 97, + ICON_BOX_CORNERS_SMALL = 98, + ICON_BOX_CORNERS_BIG = 99, + ICON_FOUR_BOXES = 100, + ICON_GRID_FILL = 101, + ICON_BOX_MULTISIZE = 102, + ICON_ZOOM_SMALL = 103, + ICON_ZOOM_MEDIUM = 104, + ICON_ZOOM_BIG = 105, + ICON_ZOOM_ALL = 106, + ICON_ZOOM_CENTER = 107, + ICON_BOX_DOTS_SMALL = 108, + ICON_BOX_DOTS_BIG = 109, + ICON_BOX_CONCENTRIC = 110, + ICON_BOX_GRID_BIG = 111, + ICON_OK_TICK = 112, + ICON_CROSS = 113, + ICON_ARROW_LEFT = 114, + ICON_ARROW_RIGHT = 115, + ICON_ARROW_DOWN = 116, + ICON_ARROW_UP = 117, + ICON_ARROW_LEFT_FILL = 118, + ICON_ARROW_RIGHT_FILL = 119, + ICON_ARROW_DOWN_FILL = 120, + ICON_ARROW_UP_FILL = 121, + ICON_AUDIO = 122, + ICON_FX = 123, + ICON_WAVE = 124, + ICON_WAVE_SINUS = 125, + ICON_WAVE_SQUARE = 126, + ICON_WAVE_TRIANGULAR = 127, + ICON_CROSS_SMALL = 128, + ICON_PLAYER_PREVIOUS = 129, + ICON_PLAYER_PLAY_BACK = 130, + ICON_PLAYER_PLAY = 131, + ICON_PLAYER_PAUSE = 132, + ICON_PLAYER_STOP = 133, + ICON_PLAYER_NEXT = 134, + ICON_PLAYER_RECORD = 135, + ICON_MAGNET = 136, + ICON_LOCK_CLOSE = 137, + ICON_LOCK_OPEN = 138, + ICON_CLOCK = 139, + ICON_TOOLS = 140, + ICON_GEAR = 141, + ICON_GEAR_BIG = 142, + ICON_BIN = 143, + ICON_HAND_POINTER = 144, + ICON_LASER = 145, + ICON_COIN = 146, + ICON_EXPLOSION = 147, + ICON_1UP = 148, + ICON_PLAYER = 149, + ICON_PLAYER_JUMP = 150, + ICON_KEY = 151, + ICON_DEMON = 152, + ICON_TEXT_POPUP = 153, + ICON_GEAR_EX = 154, + ICON_CRACK = 155, + ICON_CRACK_POINTS = 156, + ICON_STAR = 157, + ICON_DOOR = 158, + ICON_EXIT = 159, + ICON_MODE_2D = 160, + ICON_MODE_3D = 161, + ICON_CUBE = 162, + ICON_CUBE_FACE_TOP = 163, + ICON_CUBE_FACE_LEFT = 164, + ICON_CUBE_FACE_FRONT = 165, + ICON_CUBE_FACE_BOTTOM = 166, + ICON_CUBE_FACE_RIGHT = 167, + ICON_CUBE_FACE_BACK = 168, + ICON_CAMERA = 169, + ICON_SPECIAL = 170, + ICON_LINK_NET = 171, + ICON_LINK_BOXES = 172, + ICON_LINK_MULTI = 173, + ICON_LINK = 174, + ICON_LINK_BROKE = 175, + ICON_TEXT_NOTES = 176, + ICON_NOTEBOOK = 177, + ICON_SUITCASE = 178, + ICON_SUITCASE_ZIP = 179, + ICON_MAILBOX = 180, + ICON_MONITOR = 181, + ICON_PRINTER = 182, + ICON_PHOTO_CAMERA = 183, + ICON_PHOTO_CAMERA_FLASH = 184, + ICON_HOUSE = 185, + ICON_HEART = 186, + ICON_CORNER = 187, + ICON_VERTICAL_BARS = 188, + ICON_VERTICAL_BARS_FILL = 189, + ICON_LIFE_BARS = 190, + ICON_INFO = 191, + ICON_CROSSLINE = 192, + ICON_HELP = 193, + ICON_FILETYPE_ALPHA = 194, + ICON_FILETYPE_HOME = 195, + ICON_LAYERS_VISIBLE = 196, + ICON_LAYERS = 197, + ICON_WINDOW = 198, + ICON_HIDPI = 199, + ICON_FILETYPE_BINARY = 200, + ICON_HEX = 201, + ICON_SHIELD = 202, + ICON_FILE_NEW = 203, + ICON_FOLDER_ADD = 204, + ICON_ALARM = 205, + ICON_CPU = 206, + ICON_ROM = 207, + ICON_STEP_OVER = 208, + ICON_STEP_INTO = 209, + ICON_STEP_OUT = 210, + ICON_RESTART = 211, + ICON_BREAKPOINT_ON = 212, + ICON_BREAKPOINT_OFF = 213, + ICON_BURGER_MENU = 214, + ICON_CASE_SENSITIVE = 215, + ICON_REG_EXP = 216, + ICON_FOLDER = 217, + ICON_FILE = 218, + ICON_SAND_TIMER = 219, + ICON_WARNING = 220, + ICON_HELP_BOX = 221, + ICON_INFO_BOX = 222, + ICON_223 = 223, + ICON_224 = 224, + ICON_225 = 225, + ICON_226 = 226, + ICON_227 = 227, + ICON_228 = 228, + ICON_229 = 229, + ICON_230 = 230, + ICON_231 = 231, + ICON_232 = 232, + ICON_233 = 233, + ICON_234 = 234, + ICON_235 = 235, + ICON_236 = 236, + ICON_237 = 237, + ICON_238 = 238, + ICON_239 = 239, + ICON_240 = 240, + ICON_241 = 241, + ICON_242 = 242, + ICON_243 = 243, + ICON_244 = 244, + ICON_245 = 245, + ICON_246 = 246, + ICON_247 = 247, + ICON_248 = 248, + ICON_249 = 249, + ICON_250 = 250, + ICON_251 = 251, + ICON_252 = 252, + ICON_253 = 253, + ICON_254 = 254, + ICON_255 = 255, +} GuiIconName; +#endif + +#endif + +#if defined(__cplusplus) +} // Prevents name mangling of functions +#endif + +#endif // RAYGUI_H + +/*********************************************************************************** +* +* RAYGUI IMPLEMENTATION +* +************************************************************************************/ + +#if defined(RAYGUI_IMPLEMENTATION) + +#include // Required for: FILE, fopen(), fclose(), fprintf(), feof(), fscanf(), vsprintf() [GuiLoadStyle(), GuiLoadIcons()] +#include // Required for: malloc(), calloc(), free() [GuiLoadStyle(), GuiLoadIcons()] +#include // Required for: strlen() [GuiTextBox(), GuiValueBox()], memset(), memcpy() +#include // Required for: va_list, va_start(), vfprintf(), va_end() [TextFormat()] +#include // Required for: roundf() [GuiColorPicker()] + +#ifdef __cplusplus + #define RAYGUI_CLITERAL(name) name +#else + #define RAYGUI_CLITERAL(name) (name) +#endif + +// Check if two rectangles are equal, used to validate a slider bounds as an id +#ifndef CHECK_BOUNDS_ID + #define CHECK_BOUNDS_ID(src, dst) ((src.x == dst.x) && (src.y == dst.y) && (src.width == dst.width) && (src.height == dst.height)) +#endif + +#if !defined(RAYGUI_NO_ICONS) && !defined(RAYGUI_CUSTOM_ICONS) + +// Embedded icons, no external file provided +#define RAYGUI_ICON_SIZE 16 // Size of icons in pixels (squared) +#define RAYGUI_ICON_MAX_ICONS 256 // Maximum number of icons +#define RAYGUI_ICON_MAX_NAME_LENGTH 32 // Maximum length of icon name id + +// Icons data is defined by bit array (every bit represents one pixel) +// Those arrays are stored as unsigned int data arrays, so, +// every array element defines 32 pixels (bits) of information +// One icon is defined by 8 int, (8 int * 32 bit = 256 bit = 16*16 pixels) +// NOTE: Number of elemens depend on RAYGUI_ICON_SIZE (by default 16x16 pixels) +#define RAYGUI_ICON_DATA_ELEMENTS (RAYGUI_ICON_SIZE*RAYGUI_ICON_SIZE/32) + +//---------------------------------------------------------------------------------- +// Icons data for all gui possible icons (allocated on data segment by default) +// +// NOTE 1: Every icon is codified in binary form, using 1 bit per pixel, so, +// every 16x16 icon requires 8 integers (16*16/32) to be stored +// +// NOTE 2: A different icon set could be loaded over this array using GuiLoadIcons(), +// but loaded icons set must be same RAYGUI_ICON_SIZE and no more than RAYGUI_ICON_MAX_ICONS +// +// guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB +//---------------------------------------------------------------------------------- +static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS] = { + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_NONE + 0x3ff80000, 0x2f082008, 0x2042207e, 0x40027fc2, 0x40024002, 0x40024002, 0x40024002, 0x00007ffe, // ICON_FOLDER_FILE_OPEN + 0x3ffe0000, 0x44226422, 0x400247e2, 0x5ffa4002, 0x57ea500a, 0x500a500a, 0x40025ffa, 0x00007ffe, // ICON_FILE_SAVE_CLASSIC + 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x41024002, 0x44424282, 0x793e4102, 0x00000100, // ICON_FOLDER_OPEN + 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x41024102, 0x44424102, 0x793e4282, 0x00000000, // ICON_FOLDER_SAVE + 0x3ff00000, 0x201c2010, 0x20042004, 0x21042004, 0x24442284, 0x21042104, 0x20042104, 0x00003ffc, // ICON_FILE_OPEN + 0x3ff00000, 0x201c2010, 0x20042004, 0x21042004, 0x21042104, 0x22842444, 0x20042104, 0x00003ffc, // ICON_FILE_SAVE + 0x3ff00000, 0x201c2010, 0x00042004, 0x20041004, 0x20844784, 0x00841384, 0x20042784, 0x00003ffc, // ICON_FILE_EXPORT + 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x22042204, 0x22042f84, 0x20042204, 0x00003ffc, // ICON_FILE_ADD + 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x25042884, 0x25042204, 0x20042884, 0x00003ffc, // ICON_FILE_DELETE + 0x3ff00000, 0x201c2010, 0x20042004, 0x20042ff4, 0x20042ff4, 0x20042ff4, 0x20042004, 0x00003ffc, // ICON_FILETYPE_TEXT + 0x3ff00000, 0x201c2010, 0x27042004, 0x244424c4, 0x26442444, 0x20642664, 0x20042004, 0x00003ffc, // ICON_FILETYPE_AUDIO + 0x3ff00000, 0x201c2010, 0x26042604, 0x20042004, 0x35442884, 0x2414222c, 0x20042004, 0x00003ffc, // ICON_FILETYPE_IMAGE + 0x3ff00000, 0x201c2010, 0x20c42004, 0x22442144, 0x22442444, 0x20c42144, 0x20042004, 0x00003ffc, // ICON_FILETYPE_PLAY + 0x3ff00000, 0x3ffc2ff0, 0x3f3c2ff4, 0x3dbc2eb4, 0x3dbc2bb4, 0x3f3c2eb4, 0x3ffc2ff4, 0x00002ff4, // ICON_FILETYPE_VIDEO + 0x3ff00000, 0x201c2010, 0x21842184, 0x21842004, 0x21842184, 0x21842184, 0x20042184, 0x00003ffc, // ICON_FILETYPE_INFO + 0x0ff00000, 0x381c0810, 0x28042804, 0x28042804, 0x28042804, 0x28042804, 0x20102ffc, 0x00003ff0, // ICON_FILE_COPY + 0x00000000, 0x701c0000, 0x079c1e14, 0x55a000f0, 0x079c00f0, 0x701c1e14, 0x00000000, 0x00000000, // ICON_FILE_CUT + 0x01c00000, 0x13e41bec, 0x3f841004, 0x204420c4, 0x20442044, 0x20442044, 0x207c2044, 0x00003fc0, // ICON_FILE_PASTE + 0x00000000, 0x3aa00fe0, 0x2abc2aa0, 0x2aa42aa4, 0x20042aa4, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_CURSOR_HAND + 0x00000000, 0x003c000c, 0x030800c8, 0x30100c10, 0x10202020, 0x04400840, 0x01800280, 0x00000000, // ICON_CURSOR_POINTER + 0x00000000, 0x00180000, 0x01f00078, 0x03e007f0, 0x07c003e0, 0x04000e40, 0x00000000, 0x00000000, // ICON_CURSOR_CLASSIC + 0x00000000, 0x04000000, 0x11000a00, 0x04400a80, 0x01100220, 0x00580088, 0x00000038, 0x00000000, // ICON_PENCIL + 0x04000000, 0x15000a00, 0x50402880, 0x14102820, 0x05040a08, 0x015c028c, 0x007c00bc, 0x00000000, // ICON_PENCIL_BIG + 0x01c00000, 0x01400140, 0x01400140, 0x0ff80140, 0x0ff80808, 0x0aa80808, 0x0aa80aa8, 0x00000ff8, // ICON_BRUSH_CLASSIC + 0x1ffc0000, 0x5ffc7ffe, 0x40004000, 0x00807f80, 0x01c001c0, 0x01c001c0, 0x01c001c0, 0x00000080, // ICON_BRUSH_PAINTER + 0x00000000, 0x00800000, 0x01c00080, 0x03e001c0, 0x07f003e0, 0x036006f0, 0x000001c0, 0x00000000, // ICON_WATER_DROP + 0x00000000, 0x3e003800, 0x1f803f80, 0x0c201e40, 0x02080c10, 0x00840104, 0x00380044, 0x00000000, // ICON_COLOR_PICKER + 0x00000000, 0x07800300, 0x1fe00fc0, 0x3f883fd0, 0x0e021f04, 0x02040402, 0x00f00108, 0x00000000, // ICON_RUBBER + 0x00c00000, 0x02800140, 0x08200440, 0x20081010, 0x2ffe3004, 0x03f807fc, 0x00e001f0, 0x00000040, // ICON_COLOR_BUCKET + 0x00000000, 0x21843ffc, 0x01800180, 0x01800180, 0x01800180, 0x01800180, 0x03c00180, 0x00000000, // ICON_TEXT_T + 0x00800000, 0x01400180, 0x06200340, 0x0c100620, 0x1ff80c10, 0x380c1808, 0x70067004, 0x0000f80f, // ICON_TEXT_A + 0x78000000, 0x50004000, 0x00004800, 0x03c003c0, 0x03c003c0, 0x00100000, 0x0002000a, 0x0000000e, // ICON_SCALE + 0x75560000, 0x5e004002, 0x54001002, 0x41001202, 0x408200fe, 0x40820082, 0x40820082, 0x00006afe, // ICON_RESIZE + 0x00000000, 0x3f003f00, 0x3f003f00, 0x3f003f00, 0x00400080, 0x001c0020, 0x001c001c, 0x00000000, // ICON_FILTER_POINT + 0x6d800000, 0x00004080, 0x40804080, 0x40800000, 0x00406d80, 0x001c0020, 0x001c001c, 0x00000000, // ICON_FILTER_BILINEAR + 0x40080000, 0x1ffe2008, 0x14081008, 0x11081208, 0x10481088, 0x10081028, 0x10047ff8, 0x00001002, // ICON_CROP + 0x00100000, 0x3ffc0010, 0x2ab03550, 0x22b02550, 0x20b02150, 0x20302050, 0x2000fff0, 0x00002000, // ICON_CROP_ALPHA + 0x40000000, 0x1ff82000, 0x04082808, 0x01082208, 0x00482088, 0x00182028, 0x35542008, 0x00000002, // ICON_SQUARE_TOGGLE + 0x00000000, 0x02800280, 0x06c006c0, 0x0ea00ee0, 0x1e901eb0, 0x3e883e98, 0x7efc7e8c, 0x00000000, // ICON_SYMMETRY + 0x01000000, 0x05600100, 0x1d480d50, 0x7d423d44, 0x3d447d42, 0x0d501d48, 0x01000560, 0x00000100, // ICON_SYMMETRY_HORIZONTAL + 0x01800000, 0x04200240, 0x10080810, 0x00001ff8, 0x00007ffe, 0x0ff01ff8, 0x03c007e0, 0x00000180, // ICON_SYMMETRY_VERTICAL + 0x00000000, 0x010800f0, 0x02040204, 0x02040204, 0x07f00308, 0x1c000e00, 0x30003800, 0x00000000, // ICON_LENS + 0x00000000, 0x061803f0, 0x08240c0c, 0x08040814, 0x0c0c0804, 0x23f01618, 0x18002400, 0x00000000, // ICON_LENS_BIG + 0x00000000, 0x00000000, 0x1c7007c0, 0x638e3398, 0x1c703398, 0x000007c0, 0x00000000, 0x00000000, // ICON_EYE_ON + 0x00000000, 0x10002000, 0x04700fc0, 0x610e3218, 0x1c703098, 0x001007a0, 0x00000008, 0x00000000, // ICON_EYE_OFF + 0x00000000, 0x00007ffc, 0x40047ffc, 0x10102008, 0x04400820, 0x02800280, 0x02800280, 0x00000100, // ICON_FILTER_TOP + 0x00000000, 0x40027ffe, 0x10082004, 0x04200810, 0x02400240, 0x02400240, 0x01400240, 0x000000c0, // ICON_FILTER + 0x00800000, 0x00800080, 0x00000080, 0x3c9e0000, 0x00000000, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_POINT + 0x00800000, 0x00800080, 0x00800080, 0x3f7e01c0, 0x008001c0, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_SMALL + 0x00800000, 0x00800080, 0x03e00080, 0x3e3e0220, 0x03e00220, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_BIG + 0x01000000, 0x04400280, 0x01000100, 0x43842008, 0x43849ab2, 0x01002008, 0x04400100, 0x01000280, // ICON_TARGET_MOVE + 0x01000000, 0x04400280, 0x01000100, 0x41042108, 0x41049ff2, 0x01002108, 0x04400100, 0x01000280, // ICON_CURSOR_MOVE + 0x781e0000, 0x500a4002, 0x04204812, 0x00000240, 0x02400000, 0x48120420, 0x4002500a, 0x0000781e, // ICON_CURSOR_SCALE + 0x00000000, 0x20003c00, 0x24002800, 0x01000200, 0x00400080, 0x00140024, 0x003c0004, 0x00000000, // ICON_CURSOR_SCALE_RIGHT + 0x00000000, 0x0004003c, 0x00240014, 0x00800040, 0x02000100, 0x28002400, 0x3c002000, 0x00000000, // ICON_CURSOR_SCALE_LEFT + 0x00000000, 0x00100020, 0x10101fc8, 0x10001020, 0x10001000, 0x10001000, 0x00001fc0, 0x00000000, // ICON_UNDO + 0x00000000, 0x08000400, 0x080813f8, 0x00080408, 0x00080008, 0x00080008, 0x000003f8, 0x00000000, // ICON_REDO + 0x00000000, 0x3ffc0000, 0x20042004, 0x20002000, 0x20402000, 0x3f902020, 0x00400020, 0x00000000, // ICON_REREDO + 0x00000000, 0x3ffc0000, 0x20042004, 0x27fc2004, 0x20202000, 0x3fc82010, 0x00200010, 0x00000000, // ICON_MUTATE + 0x00000000, 0x0ff00000, 0x10081818, 0x11801008, 0x10001180, 0x18101020, 0x00100fc8, 0x00000020, // ICON_ROTATE + 0x00000000, 0x04000200, 0x240429fc, 0x20042204, 0x20442004, 0x3f942024, 0x00400020, 0x00000000, // ICON_REPEAT + 0x00000000, 0x20001000, 0x22104c0e, 0x00801120, 0x11200040, 0x4c0e2210, 0x10002000, 0x00000000, // ICON_SHUFFLE + 0x7ffe0000, 0x50024002, 0x44024802, 0x41024202, 0x40424082, 0x40124022, 0x4002400a, 0x00007ffe, // ICON_EMPTYBOX + 0x00800000, 0x03e00080, 0x08080490, 0x3c9e0808, 0x08080808, 0x03e00490, 0x00800080, 0x00000000, // ICON_TARGET + 0x00800000, 0x00800080, 0x00800080, 0x3ffe01c0, 0x008001c0, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_SMALL_FILL + 0x00800000, 0x00800080, 0x03e00080, 0x3ffe03e0, 0x03e003e0, 0x00800080, 0x00800080, 0x00000000, // ICON_TARGET_BIG_FILL + 0x01000000, 0x07c00380, 0x01000100, 0x638c2008, 0x638cfbbe, 0x01002008, 0x07c00100, 0x01000380, // ICON_TARGET_MOVE_FILL + 0x01000000, 0x07c00380, 0x01000100, 0x610c2108, 0x610cfffe, 0x01002108, 0x07c00100, 0x01000380, // ICON_CURSOR_MOVE_FILL + 0x781e0000, 0x6006700e, 0x04204812, 0x00000240, 0x02400000, 0x48120420, 0x700e6006, 0x0000781e, // ICON_CURSOR_SCALE_FILL + 0x00000000, 0x38003c00, 0x24003000, 0x01000200, 0x00400080, 0x000c0024, 0x003c001c, 0x00000000, // ICON_CURSOR_SCALE_RIGHT_FILL + 0x00000000, 0x001c003c, 0x0024000c, 0x00800040, 0x02000100, 0x30002400, 0x3c003800, 0x00000000, // ICON_CURSOR_SCALE_LEFT_FILL + 0x00000000, 0x00300020, 0x10301ff8, 0x10001020, 0x10001000, 0x10001000, 0x00001fc0, 0x00000000, // ICON_UNDO_FILL + 0x00000000, 0x0c000400, 0x0c081ff8, 0x00080408, 0x00080008, 0x00080008, 0x000003f8, 0x00000000, // ICON_REDO_FILL + 0x00000000, 0x3ffc0000, 0x20042004, 0x20002000, 0x20402000, 0x3ff02060, 0x00400060, 0x00000000, // ICON_REREDO_FILL + 0x00000000, 0x3ffc0000, 0x20042004, 0x27fc2004, 0x20202000, 0x3ff82030, 0x00200030, 0x00000000, // ICON_MUTATE_FILL + 0x00000000, 0x0ff00000, 0x10081818, 0x11801008, 0x10001180, 0x18301020, 0x00300ff8, 0x00000020, // ICON_ROTATE_FILL + 0x00000000, 0x06000200, 0x26042ffc, 0x20042204, 0x20442004, 0x3ff42064, 0x00400060, 0x00000000, // ICON_REPEAT_FILL + 0x00000000, 0x30001000, 0x32107c0e, 0x00801120, 0x11200040, 0x7c0e3210, 0x10003000, 0x00000000, // ICON_SHUFFLE_FILL + 0x00000000, 0x30043ffc, 0x24042804, 0x21042204, 0x20442084, 0x20142024, 0x3ffc200c, 0x00000000, // ICON_EMPTYBOX_SMALL + 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX + 0x00000000, 0x23c43ffc, 0x23c423c4, 0x200423c4, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_TOP + 0x00000000, 0x3e043ffc, 0x3e043e04, 0x20043e04, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_TOP_RIGHT + 0x00000000, 0x20043ffc, 0x20042004, 0x3e043e04, 0x3e043e04, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_RIGHT + 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x3e042004, 0x3e043e04, 0x3ffc3e04, 0x00000000, // ICON_BOX_BOTTOM_RIGHT + 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x23c42004, 0x23c423c4, 0x3ffc23c4, 0x00000000, // ICON_BOX_BOTTOM + 0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x207c2004, 0x207c207c, 0x3ffc207c, 0x00000000, // ICON_BOX_BOTTOM_LEFT + 0x00000000, 0x20043ffc, 0x20042004, 0x207c207c, 0x207c207c, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_LEFT + 0x00000000, 0x207c3ffc, 0x207c207c, 0x2004207c, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_TOP_LEFT + 0x00000000, 0x20043ffc, 0x20042004, 0x23c423c4, 0x23c423c4, 0x20042004, 0x3ffc2004, 0x00000000, // ICON_BOX_CENTER + 0x7ffe0000, 0x40024002, 0x47e24182, 0x4ff247e2, 0x47e24ff2, 0x418247e2, 0x40024002, 0x00007ffe, // ICON_BOX_CIRCLE_MASK + 0x7fff0000, 0x40014001, 0x40014001, 0x49555ddd, 0x4945495d, 0x400149c5, 0x40014001, 0x00007fff, // ICON_POT + 0x7ffe0000, 0x53327332, 0x44ce4cce, 0x41324332, 0x404e40ce, 0x48125432, 0x4006540e, 0x00007ffe, // ICON_ALPHA_MULTIPLY + 0x7ffe0000, 0x53327332, 0x44ce4cce, 0x41324332, 0x5c4e40ce, 0x44124432, 0x40065c0e, 0x00007ffe, // ICON_ALPHA_CLEAR + 0x7ffe0000, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x00007ffe, // ICON_DITHERING + 0x07fe0000, 0x1ffa0002, 0x7fea000a, 0x402a402a, 0x5b2a512a, 0x5128552a, 0x40205128, 0x00007fe0, // ICON_MIPMAPS + 0x00000000, 0x1ff80000, 0x12481248, 0x12481ff8, 0x1ff81248, 0x12481248, 0x00001ff8, 0x00000000, // ICON_BOX_GRID + 0x12480000, 0x7ffe1248, 0x12481248, 0x12487ffe, 0x7ffe1248, 0x12481248, 0x12487ffe, 0x00001248, // ICON_GRID + 0x00000000, 0x1c380000, 0x1c3817e8, 0x08100810, 0x08100810, 0x17e81c38, 0x00001c38, 0x00000000, // ICON_BOX_CORNERS_SMALL + 0x700e0000, 0x700e5ffa, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x5ffa700e, 0x0000700e, // ICON_BOX_CORNERS_BIG + 0x3f7e0000, 0x21422142, 0x21422142, 0x00003f7e, 0x21423f7e, 0x21422142, 0x3f7e2142, 0x00000000, // ICON_FOUR_BOXES + 0x00000000, 0x3bb80000, 0x3bb83bb8, 0x3bb80000, 0x3bb83bb8, 0x3bb80000, 0x3bb83bb8, 0x00000000, // ICON_GRID_FILL + 0x7ffe0000, 0x7ffe7ffe, 0x77fe7000, 0x77fe77fe, 0x777e7700, 0x777e777e, 0x777e777e, 0x0000777e, // ICON_BOX_MULTISIZE + 0x781e0000, 0x40024002, 0x00004002, 0x01800000, 0x00000180, 0x40020000, 0x40024002, 0x0000781e, // ICON_ZOOM_SMALL + 0x781e0000, 0x40024002, 0x00004002, 0x03c003c0, 0x03c003c0, 0x40020000, 0x40024002, 0x0000781e, // ICON_ZOOM_MEDIUM + 0x781e0000, 0x40024002, 0x07e04002, 0x07e007e0, 0x07e007e0, 0x400207e0, 0x40024002, 0x0000781e, // ICON_ZOOM_BIG + 0x781e0000, 0x5ffa4002, 0x1ff85ffa, 0x1ff81ff8, 0x1ff81ff8, 0x5ffa1ff8, 0x40025ffa, 0x0000781e, // ICON_ZOOM_ALL + 0x00000000, 0x2004381c, 0x00002004, 0x00000000, 0x00000000, 0x20040000, 0x381c2004, 0x00000000, // ICON_ZOOM_CENTER + 0x00000000, 0x1db80000, 0x10081008, 0x10080000, 0x00001008, 0x10081008, 0x00001db8, 0x00000000, // ICON_BOX_DOTS_SMALL + 0x35560000, 0x00002002, 0x00002002, 0x00002002, 0x00002002, 0x00002002, 0x35562002, 0x00000000, // ICON_BOX_DOTS_BIG + 0x7ffe0000, 0x40024002, 0x48124ff2, 0x49924812, 0x48124992, 0x4ff24812, 0x40024002, 0x00007ffe, // ICON_BOX_CONCENTRIC + 0x00000000, 0x10841ffc, 0x10841084, 0x1ffc1084, 0x10841084, 0x10841084, 0x00001ffc, 0x00000000, // ICON_BOX_GRID_BIG + 0x00000000, 0x00000000, 0x10000000, 0x04000800, 0x01040200, 0x00500088, 0x00000020, 0x00000000, // ICON_OK_TICK + 0x00000000, 0x10080000, 0x04200810, 0x01800240, 0x02400180, 0x08100420, 0x00001008, 0x00000000, // ICON_CROSS + 0x00000000, 0x02000000, 0x00800100, 0x00200040, 0x00200010, 0x00800040, 0x02000100, 0x00000000, // ICON_ARROW_LEFT + 0x00000000, 0x00400000, 0x01000080, 0x04000200, 0x04000800, 0x01000200, 0x00400080, 0x00000000, // ICON_ARROW_RIGHT + 0x00000000, 0x00000000, 0x00000000, 0x08081004, 0x02200410, 0x00800140, 0x00000000, 0x00000000, // ICON_ARROW_DOWN + 0x00000000, 0x00000000, 0x01400080, 0x04100220, 0x10040808, 0x00000000, 0x00000000, 0x00000000, // ICON_ARROW_UP + 0x00000000, 0x02000000, 0x03800300, 0x03e003c0, 0x03e003f0, 0x038003c0, 0x02000300, 0x00000000, // ICON_ARROW_LEFT_FILL + 0x00000000, 0x00400000, 0x01c000c0, 0x07c003c0, 0x07c00fc0, 0x01c003c0, 0x004000c0, 0x00000000, // ICON_ARROW_RIGHT_FILL + 0x00000000, 0x00000000, 0x00000000, 0x0ff81ffc, 0x03e007f0, 0x008001c0, 0x00000000, 0x00000000, // ICON_ARROW_DOWN_FILL + 0x00000000, 0x00000000, 0x01c00080, 0x07f003e0, 0x1ffc0ff8, 0x00000000, 0x00000000, 0x00000000, // ICON_ARROW_UP_FILL + 0x00000000, 0x18a008c0, 0x32881290, 0x24822686, 0x26862482, 0x12903288, 0x08c018a0, 0x00000000, // ICON_AUDIO + 0x00000000, 0x04800780, 0x004000c0, 0x662000f0, 0x08103c30, 0x130a0e18, 0x0000318e, 0x00000000, // ICON_FX + 0x00000000, 0x00800000, 0x08880888, 0x2aaa0a8a, 0x0a8a2aaa, 0x08880888, 0x00000080, 0x00000000, // ICON_WAVE + 0x00000000, 0x00600000, 0x01080090, 0x02040108, 0x42044204, 0x24022402, 0x00001800, 0x00000000, // ICON_WAVE_SINUS + 0x00000000, 0x07f80000, 0x04080408, 0x04080408, 0x04080408, 0x7c0e0408, 0x00000000, 0x00000000, // ICON_WAVE_SQUARE + 0x00000000, 0x00000000, 0x00a00040, 0x22084110, 0x08021404, 0x00000000, 0x00000000, 0x00000000, // ICON_WAVE_TRIANGULAR + 0x00000000, 0x00000000, 0x04200000, 0x01800240, 0x02400180, 0x00000420, 0x00000000, 0x00000000, // ICON_CROSS_SMALL + 0x00000000, 0x18380000, 0x12281428, 0x10a81128, 0x112810a8, 0x14281228, 0x00001838, 0x00000000, // ICON_PLAYER_PREVIOUS + 0x00000000, 0x18000000, 0x11801600, 0x10181060, 0x10601018, 0x16001180, 0x00001800, 0x00000000, // ICON_PLAYER_PLAY_BACK + 0x00000000, 0x00180000, 0x01880068, 0x18080608, 0x06081808, 0x00680188, 0x00000018, 0x00000000, // ICON_PLAYER_PLAY + 0x00000000, 0x1e780000, 0x12481248, 0x12481248, 0x12481248, 0x12481248, 0x00001e78, 0x00000000, // ICON_PLAYER_PAUSE + 0x00000000, 0x1ff80000, 0x10081008, 0x10081008, 0x10081008, 0x10081008, 0x00001ff8, 0x00000000, // ICON_PLAYER_STOP + 0x00000000, 0x1c180000, 0x14481428, 0x15081488, 0x14881508, 0x14281448, 0x00001c18, 0x00000000, // ICON_PLAYER_NEXT + 0x00000000, 0x03c00000, 0x08100420, 0x10081008, 0x10081008, 0x04200810, 0x000003c0, 0x00000000, // ICON_PLAYER_RECORD + 0x00000000, 0x0c3007e0, 0x13c81818, 0x14281668, 0x14281428, 0x1c381c38, 0x08102244, 0x00000000, // ICON_MAGNET + 0x07c00000, 0x08200820, 0x3ff80820, 0x23882008, 0x21082388, 0x20082108, 0x1ff02008, 0x00000000, // ICON_LOCK_CLOSE + 0x07c00000, 0x08000800, 0x3ff80800, 0x23882008, 0x21082388, 0x20082108, 0x1ff02008, 0x00000000, // ICON_LOCK_OPEN + 0x01c00000, 0x0c180770, 0x3086188c, 0x60832082, 0x60034781, 0x30062002, 0x0c18180c, 0x01c00770, // ICON_CLOCK + 0x0a200000, 0x1b201b20, 0x04200e20, 0x04200420, 0x04700420, 0x0e700e70, 0x0e700e70, 0x04200e70, // ICON_TOOLS + 0x01800000, 0x3bdc318c, 0x0ff01ff8, 0x7c3e1e78, 0x1e787c3e, 0x1ff80ff0, 0x318c3bdc, 0x00000180, // ICON_GEAR + 0x01800000, 0x3ffc318c, 0x1c381ff8, 0x781e1818, 0x1818781e, 0x1ff81c38, 0x318c3ffc, 0x00000180, // ICON_GEAR_BIG + 0x00000000, 0x08080ff8, 0x08081ffc, 0x0aa80aa8, 0x0aa80aa8, 0x0aa80aa8, 0x08080aa8, 0x00000ff8, // ICON_BIN + 0x00000000, 0x00000000, 0x20043ffc, 0x08043f84, 0x04040f84, 0x04040784, 0x000007fc, 0x00000000, // ICON_HAND_POINTER + 0x00000000, 0x24400400, 0x00001480, 0x6efe0e00, 0x00000e00, 0x24401480, 0x00000400, 0x00000000, // ICON_LASER + 0x00000000, 0x03c00000, 0x08300460, 0x11181118, 0x11181118, 0x04600830, 0x000003c0, 0x00000000, // ICON_COIN + 0x00000000, 0x10880080, 0x06c00810, 0x366c07e0, 0x07e00240, 0x00001768, 0x04200240, 0x00000000, // ICON_EXPLOSION + 0x00000000, 0x3d280000, 0x2528252c, 0x3d282528, 0x05280528, 0x05e80528, 0x00000000, 0x00000000, // ICON_1UP + 0x01800000, 0x03c003c0, 0x018003c0, 0x0ff007e0, 0x0bd00bd0, 0x0a500bd0, 0x02400240, 0x02400240, // ICON_PLAYER + 0x01800000, 0x03c003c0, 0x118013c0, 0x03c81ff8, 0x07c003c8, 0x04400440, 0x0c080478, 0x00000000, // ICON_PLAYER_JUMP + 0x3ff80000, 0x30183ff8, 0x30183018, 0x3ff83ff8, 0x03000300, 0x03c003c0, 0x03e00300, 0x000003e0, // ICON_KEY + 0x3ff80000, 0x3ff83ff8, 0x33983ff8, 0x3ff83398, 0x3ff83ff8, 0x00000540, 0x0fe00aa0, 0x00000fe0, // ICON_DEMON + 0x00000000, 0x0ff00000, 0x20041008, 0x25442004, 0x10082004, 0x06000bf0, 0x00000300, 0x00000000, // ICON_TEXT_POPUP + 0x00000000, 0x11440000, 0x07f00be8, 0x1c1c0e38, 0x1c1c0c18, 0x07f00e38, 0x11440be8, 0x00000000, // ICON_GEAR_EX + 0x00000000, 0x20080000, 0x0c601010, 0x07c00fe0, 0x07c007c0, 0x0c600fe0, 0x20081010, 0x00000000, // ICON_CRACK + 0x00000000, 0x20080000, 0x0c601010, 0x04400fe0, 0x04405554, 0x0c600fe0, 0x20081010, 0x00000000, // ICON_CRACK_POINTS + 0x00000000, 0x00800080, 0x01c001c0, 0x1ffc3ffe, 0x03e007f0, 0x07f003e0, 0x0c180770, 0x00000808, // ICON_STAR + 0x0ff00000, 0x08180810, 0x08100818, 0x0a100810, 0x08180810, 0x08100818, 0x08100810, 0x00001ff8, // ICON_DOOR + 0x0ff00000, 0x08100810, 0x08100810, 0x10100010, 0x4f902010, 0x10102010, 0x08100010, 0x00000ff0, // ICON_EXIT + 0x00040000, 0x001f000e, 0x0ef40004, 0x12f41284, 0x0ef41214, 0x10040004, 0x7ffc3004, 0x10003000, // ICON_MODE_2D + 0x78040000, 0x501f600e, 0x0ef44004, 0x12f41284, 0x0ef41284, 0x10140004, 0x7ffc300c, 0x10003000, // ICON_MODE_3D + 0x7fe00000, 0x50286030, 0x47fe4804, 0x44224402, 0x44224422, 0x241275e2, 0x0c06140a, 0x000007fe, // ICON_CUBE + 0x7fe00000, 0x5ff87ff0, 0x47fe4ffc, 0x44224402, 0x44224422, 0x241275e2, 0x0c06140a, 0x000007fe, // ICON_CUBE_FACE_TOP + 0x7fe00000, 0x50386030, 0x47c2483c, 0x443e443e, 0x443e443e, 0x241e75fe, 0x0c06140e, 0x000007fe, // ICON_CUBE_FACE_LEFT + 0x7fe00000, 0x50286030, 0x47fe4804, 0x47fe47fe, 0x47fe47fe, 0x27fe77fe, 0x0ffe17fe, 0x000007fe, // ICON_CUBE_FACE_FRONT + 0x7fe00000, 0x50286030, 0x47fe4804, 0x44224402, 0x44224422, 0x3bf27be2, 0x0bfe1bfa, 0x000007fe, // ICON_CUBE_FACE_BOTTOM + 0x7fe00000, 0x70286030, 0x7ffe7804, 0x7c227c02, 0x7c227c22, 0x3c127de2, 0x0c061c0a, 0x000007fe, // ICON_CUBE_FACE_RIGHT + 0x7fe00000, 0x6fe85ff0, 0x781e77e4, 0x7be27be2, 0x7be27be2, 0x24127be2, 0x0c06140a, 0x000007fe, // ICON_CUBE_FACE_BACK + 0x00000000, 0x2a0233fe, 0x22022602, 0x22022202, 0x2a022602, 0x00a033fe, 0x02080110, 0x00000000, // ICON_CAMERA + 0x00000000, 0x200c3ffc, 0x000c000c, 0x3ffc000c, 0x30003000, 0x30003000, 0x3ffc3004, 0x00000000, // ICON_SPECIAL + 0x00000000, 0x0022003e, 0x012201e2, 0x0100013e, 0x01000100, 0x79000100, 0x4f004900, 0x00007800, // ICON_LINK_NET + 0x00000000, 0x44007c00, 0x45004600, 0x00627cbe, 0x00620022, 0x45007cbe, 0x44004600, 0x00007c00, // ICON_LINK_BOXES + 0x00000000, 0x0044007c, 0x0010007c, 0x3f100010, 0x3f1021f0, 0x3f100010, 0x3f0021f0, 0x00000000, // ICON_LINK_MULTI + 0x00000000, 0x0044007c, 0x00440044, 0x0010007c, 0x00100010, 0x44107c10, 0x440047f0, 0x00007c00, // ICON_LINK + 0x00000000, 0x0044007c, 0x00440044, 0x0000007c, 0x00000010, 0x44007c10, 0x44004550, 0x00007c00, // ICON_LINK_BROKE + 0x02a00000, 0x22a43ffc, 0x20042004, 0x20042ff4, 0x20042ff4, 0x20042ff4, 0x20042004, 0x00003ffc, // ICON_TEXT_NOTES + 0x3ffc0000, 0x20042004, 0x245e27c4, 0x27c42444, 0x2004201e, 0x201e2004, 0x20042004, 0x00003ffc, // ICON_NOTEBOOK + 0x00000000, 0x07e00000, 0x04200420, 0x24243ffc, 0x24242424, 0x24242424, 0x3ffc2424, 0x00000000, // ICON_SUITCASE + 0x00000000, 0x0fe00000, 0x08200820, 0x40047ffc, 0x7ffc5554, 0x40045554, 0x7ffc4004, 0x00000000, // ICON_SUITCASE_ZIP + 0x00000000, 0x20043ffc, 0x3ffc2004, 0x13c81008, 0x100813c8, 0x10081008, 0x1ff81008, 0x00000000, // ICON_MAILBOX + 0x00000000, 0x40027ffe, 0x5ffa5ffa, 0x5ffa5ffa, 0x40025ffa, 0x03c07ffe, 0x1ff81ff8, 0x00000000, // ICON_MONITOR + 0x0ff00000, 0x6bfe7ffe, 0x7ffe7ffe, 0x68167ffe, 0x08106816, 0x08100810, 0x0ff00810, 0x00000000, // ICON_PRINTER + 0x3ff80000, 0xfffe2008, 0x870a8002, 0x904a888a, 0x904a904a, 0x870a888a, 0xfffe8002, 0x00000000, // ICON_PHOTO_CAMERA + 0x0fc00000, 0xfcfe0cd8, 0x8002fffe, 0x84428382, 0x84428442, 0x80028382, 0xfffe8002, 0x00000000, // ICON_PHOTO_CAMERA_FLASH + 0x00000000, 0x02400180, 0x08100420, 0x20041008, 0x23c42004, 0x22442244, 0x3ffc2244, 0x00000000, // ICON_HOUSE + 0x00000000, 0x1c700000, 0x3ff83ef8, 0x3ff83ff8, 0x0fe01ff0, 0x038007c0, 0x00000100, 0x00000000, // ICON_HEART + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000000, 0xe000c000, // ICON_CORNER + 0x00000000, 0x14001c00, 0x15c01400, 0x15401540, 0x155c1540, 0x15541554, 0x1ddc1554, 0x00000000, // ICON_VERTICAL_BARS + 0x00000000, 0x03000300, 0x1b001b00, 0x1b601b60, 0x1b6c1b60, 0x1b6c1b6c, 0x1b6c1b6c, 0x00000000, // ICON_VERTICAL_BARS_FILL + 0x00000000, 0x00000000, 0x403e7ffe, 0x7ffe403e, 0x7ffe0000, 0x43fe43fe, 0x00007ffe, 0x00000000, // ICON_LIFE_BARS + 0x7ffc0000, 0x43844004, 0x43844284, 0x43844004, 0x42844284, 0x42844284, 0x40044384, 0x00007ffc, // ICON_INFO + 0x40008000, 0x10002000, 0x04000800, 0x01000200, 0x00400080, 0x00100020, 0x00040008, 0x00010002, // ICON_CROSSLINE + 0x00000000, 0x1ff01ff0, 0x18301830, 0x1f001830, 0x03001f00, 0x00000300, 0x03000300, 0x00000000, // ICON_HELP + 0x3ff00000, 0x2abc3550, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x00003ffc, // ICON_FILETYPE_ALPHA + 0x3ff00000, 0x201c2010, 0x22442184, 0x28142424, 0x29942814, 0x2ff42994, 0x20042004, 0x00003ffc, // ICON_FILETYPE_HOME + 0x07fe0000, 0x04020402, 0x7fe20402, 0x44224422, 0x44224422, 0x402047fe, 0x40204020, 0x00007fe0, // ICON_LAYERS_VISIBLE + 0x07fe0000, 0x04020402, 0x7c020402, 0x44024402, 0x44024402, 0x402047fe, 0x40204020, 0x00007fe0, // ICON_LAYERS + 0x00000000, 0x40027ffe, 0x7ffe4002, 0x40024002, 0x40024002, 0x40024002, 0x7ffe4002, 0x00000000, // ICON_WINDOW + 0x09100000, 0x09f00910, 0x09100910, 0x00000910, 0x24a2779e, 0x27a224a2, 0x709e20a2, 0x00000000, // ICON_HIDPI + 0x3ff00000, 0x201c2010, 0x2a842e84, 0x2e842a84, 0x2ba42004, 0x2aa42aa4, 0x20042ba4, 0x00003ffc, // ICON_FILETYPE_BINARY + 0x00000000, 0x00000000, 0x00120012, 0x4a5e4bd2, 0x485233d2, 0x00004bd2, 0x00000000, 0x00000000, // ICON_HEX + 0x01800000, 0x381c0660, 0x23c42004, 0x23c42044, 0x13c82204, 0x08101008, 0x02400420, 0x00000180, // ICON_SHIELD + 0x007e0000, 0x20023fc2, 0x40227fe2, 0x400a403a, 0x400a400a, 0x400a400a, 0x4008400e, 0x00007ff8, // ICON_FILE_NEW + 0x00000000, 0x0042007e, 0x40027fc2, 0x44024002, 0x5f024402, 0x44024402, 0x7ffe4002, 0x00000000, // ICON_FOLDER_ADD + 0x44220000, 0x12482244, 0xf3cf0000, 0x14280420, 0x48122424, 0x08100810, 0x1ff81008, 0x03c00420, // ICON_ALARM + 0x0aa00000, 0x1ff80aa0, 0x1068700e, 0x1008706e, 0x1008700e, 0x1008700e, 0x0aa01ff8, 0x00000aa0, // ICON_CPU + 0x07e00000, 0x04201db8, 0x04a01c38, 0x04a01d38, 0x04a01d38, 0x04a01d38, 0x04201d38, 0x000007e0, // ICON_ROM + 0x00000000, 0x03c00000, 0x3c382ff0, 0x3c04380c, 0x01800000, 0x03c003c0, 0x00000180, 0x00000000, // ICON_STEP_OVER + 0x01800000, 0x01800180, 0x01800180, 0x03c007e0, 0x00000180, 0x01800000, 0x03c003c0, 0x00000180, // ICON_STEP_INTO + 0x01800000, 0x07e003c0, 0x01800180, 0x01800180, 0x00000180, 0x01800000, 0x03c003c0, 0x00000180, // ICON_STEP_OUT + 0x00000000, 0x0ff003c0, 0x181c1c34, 0x303c301c, 0x30003000, 0x1c301800, 0x03c00ff0, 0x00000000, // ICON_RESTART + 0x00000000, 0x00000000, 0x07e003c0, 0x0ff00ff0, 0x0ff00ff0, 0x03c007e0, 0x00000000, 0x00000000, // ICON_BREAKPOINT_ON + 0x00000000, 0x00000000, 0x042003c0, 0x08100810, 0x08100810, 0x03c00420, 0x00000000, 0x00000000, // ICON_BREAKPOINT_OFF + 0x00000000, 0x00000000, 0x1ff81ff8, 0x1ff80000, 0x00001ff8, 0x1ff81ff8, 0x00000000, 0x00000000, // ICON_BURGER_MENU + 0x00000000, 0x00000000, 0x00880070, 0x0c880088, 0x1e8810f8, 0x3e881288, 0x00000000, 0x00000000, // ICON_CASE_SENSITIVE + 0x00000000, 0x02000000, 0x07000a80, 0x07001fc0, 0x02000a80, 0x00300030, 0x00000000, 0x00000000, // ICON_REG_EXP + 0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x40024002, 0x40024002, 0x7ffe4002, 0x00000000, // ICON_FOLDER + 0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x00003ffc, // ICON_FILE + 0x1ff00000, 0x20082008, 0x17d02fe8, 0x05400ba0, 0x09200540, 0x23881010, 0x2fe827c8, 0x00001ff0, // ICON_SAND_TIMER + 0x01800000, 0x02400240, 0x05a00420, 0x09900990, 0x11881188, 0x21842004, 0x40024182, 0x00003ffc, // ICON_WARNING + 0x7ffe0000, 0x4ff24002, 0x4c324ff2, 0x4f824c02, 0x41824f82, 0x41824002, 0x40024182, 0x00007ffe, // ICON_HELP_BOX + 0x7ffe0000, 0x41824002, 0x40024182, 0x41824182, 0x41824182, 0x41824182, 0x40024182, 0x00007ffe, // ICON_INFO_BOX + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_223 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_224 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_225 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_226 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_227 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_228 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_229 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_230 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_231 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_232 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_233 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_234 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_235 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_236 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_237 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_238 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_239 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_240 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_241 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_242 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_243 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_244 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_245 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_246 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_247 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_248 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_249 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_250 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_251 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_252 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_253 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_254 + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // ICON_255 +}; + +// NOTE: A pointer to current icons array should be defined +static unsigned int *guiIconsPtr = guiIcons; + +#endif // !RAYGUI_NO_ICONS && !RAYGUI_CUSTOM_ICONS + +#ifndef RAYGUI_ICON_SIZE + #define RAYGUI_ICON_SIZE 0 +#endif + +// WARNING: Those values define the total size of the style data array, +// if changed, previous saved styles could become incompatible +#define RAYGUI_MAX_CONTROLS 16 // Maximum number of controls +#define RAYGUI_MAX_PROPS_BASE 16 // Maximum number of base properties +#define RAYGUI_MAX_PROPS_EXTENDED 8 // Maximum number of extended properties + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +// Gui control property style color element +typedef enum { BORDER = 0, BASE, TEXT, OTHER } GuiPropertyElement; + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +static GuiState guiState = STATE_NORMAL; // Gui global state, if !STATE_NORMAL, forces defined state + +static Font guiFont = { 0 }; // Gui current font (WARNING: highly coupled to raylib) +static bool guiLocked = false; // Gui lock state (no inputs processed) +static float guiAlpha = 1.0f; // Gui controls transparency + +static unsigned int guiIconScale = 1; // Gui icon default scale (if icons enabled) + +static bool guiTooltip = false; // Tooltip enabled/disabled +static const char *guiTooltipPtr = NULL; // Tooltip string pointer (string provided by user) + +static bool guiControlExclusiveMode = false; // Gui control exclusive mode (no inputs processed except current control) +static Rectangle guiControlExclusiveRec = { 0 }; // Gui control exclusive bounds rectangle, used as an unique identifier + +static int textBoxCursorIndex = 0; // Cursor index, shared by all GuiTextBox*() +//static int blinkCursorFrameCounter = 0; // Frame counter for cursor blinking +static int autoCursorCooldownCounter = 0; // Cooldown frame counter for automatic cursor movement on key-down +static int autoCursorDelayCounter = 0; // Delay frame counter for automatic cursor movement + +//---------------------------------------------------------------------------------- +// Style data array for all gui style properties (allocated on data segment by default) +// +// NOTE 1: First set of BASE properties are generic to all controls but could be individually +// overwritten per control, first set of EXTENDED properties are generic to all controls and +// can not be overwritten individually but custom EXTENDED properties can be used by control +// +// NOTE 2: A new style set could be loaded over this array using GuiLoadStyle(), +// but default gui style could always be recovered with GuiLoadStyleDefault() +// +// guiStyle size is by default: 16*(16 + 8) = 384*4 = 1536 bytes = 1.5 KB +//---------------------------------------------------------------------------------- +static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)] = { 0 }; + +static bool guiStyleLoaded = false; // Style loaded flag for lazy style initialization + +//---------------------------------------------------------------------------------- +// Standalone Mode Functions Declaration +// +// NOTE: raygui depend on some raylib input and drawing functions +// To use raygui as standalone library, below functions must be defined by the user +//---------------------------------------------------------------------------------- +#if defined(RAYGUI_STANDALONE) + +#define KEY_RIGHT 262 +#define KEY_LEFT 263 +#define KEY_DOWN 264 +#define KEY_UP 265 +#define KEY_BACKSPACE 259 +#define KEY_ENTER 257 + +#define MOUSE_LEFT_BUTTON 0 + +// Input required functions +//------------------------------------------------------------------------------- +static Vector2 GetMousePosition(void); +static float GetMouseWheelMove(void); +static bool IsMouseButtonDown(int button); +static bool IsMouseButtonPressed(int button); +static bool IsMouseButtonReleased(int button); + +static bool IsKeyDown(int key); +static bool IsKeyPressed(int key); +static int GetCharPressed(void); // -- GuiTextBox(), GuiValueBox() +//------------------------------------------------------------------------------- + +// Drawing required functions +//------------------------------------------------------------------------------- +static void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle() +static void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker() +//------------------------------------------------------------------------------- + +// Text required functions +//------------------------------------------------------------------------------- +static Font GetFontDefault(void); // -- GuiLoadStyleDefault() +static Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle(), load font + +static Texture2D LoadTextureFromImage(Image image); // -- GuiLoadStyle(), required to load texture from embedded font atlas image +static void SetShapesTexture(Texture2D tex, Rectangle rec); // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization) + +static char *LoadFileText(const char *fileName); // -- GuiLoadStyle(), required to load charset data +static void UnloadFileText(char *text); // -- GuiLoadStyle(), required to unload charset data + +static const char *GetDirectoryPath(const char *filePath); // -- GuiLoadStyle(), required to find charset/font file from text .rgs + +static int *LoadCodepoints(const char *text, int *count); // -- GuiLoadStyle(), required to load required font codepoints list +static void UnloadCodepoints(int *codepoints); // -- GuiLoadStyle(), required to unload codepoints list + +static unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle() +//------------------------------------------------------------------------------- + +// raylib functions already implemented in raygui +//------------------------------------------------------------------------------- +static Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value +static int ColorToInt(Color color); // Returns hexadecimal value for a Color +static bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +static const char *TextFormat(const char *text, ...); // Formatting of text with variables to 'embed' +static const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +static int TextToInteger(const char *text); // Get integer value from text + +static int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded text +static const char *CodepointToUTF8(int codepoint, int *byteSize); // Encode codepoint into UTF-8 text (char array size returned as parameter) + +static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); // Draw rectangle vertical gradient +//------------------------------------------------------------------------------- + +#endif // RAYGUI_STANDALONE + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +static void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize); // Load style from memory (binary only) + +static int GetTextWidth(const char *text); // Gui get text width using gui font and style +static Rectangle GetTextBounds(int control, Rectangle bounds); // Get text bounds considering control bounds +static const char *GetTextIcon(const char *text, int *iconId); // Get text icon if provided and move text cursor + +static void GuiDrawText(const char *text, Rectangle textBounds, int alignment, Color tint); // Gui draw text using default font +static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color); // Gui draw rectangle using default raygui style + +static const char **GuiTextSplit(const char *text, char delimiter, int *count, int *textRow); // Split controls text into multiple strings +static Vector3 ConvertHSVtoRGB(Vector3 hsv); // Convert color data from HSV to RGB +static Vector3 ConvertRGBtoHSV(Vector3 rgb); // Convert color data from RGB to HSV + +static int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue); // Scroll bar control, used by GuiScrollPanel() +static void GuiTooltip(Rectangle controlRec); // Draw tooltip using control rec position + +static Color GuiFade(Color color, float alpha); // Fade color by an alpha factor + +//---------------------------------------------------------------------------------- +// Gui Setup Functions Definition +//---------------------------------------------------------------------------------- +// Enable gui global state +// NOTE: We check for STATE_DISABLED to avoid messing custom global state setups +void GuiEnable(void) { if (guiState == STATE_DISABLED) guiState = STATE_NORMAL; } + +// Disable gui global state +// NOTE: We check for STATE_NORMAL to avoid messing custom global state setups +void GuiDisable(void) { if (guiState == STATE_NORMAL) guiState = STATE_DISABLED; } + +// Lock gui global state +void GuiLock(void) { guiLocked = true; } + +// Unlock gui global state +void GuiUnlock(void) { guiLocked = false; } + +// Check if gui is locked (global state) +bool GuiIsLocked(void) { return guiLocked; } + +// Set gui controls alpha global state +void GuiSetAlpha(float alpha) +{ + if (alpha < 0.0f) alpha = 0.0f; + else if (alpha > 1.0f) alpha = 1.0f; + + guiAlpha = alpha; +} + +// Set gui state (global state) +void GuiSetState(int state) { guiState = (GuiState)state; } + +// Get gui state (global state) +int GuiGetState(void) { return guiState; } + +// Set custom gui font +// NOTE: Font loading/unloading is external to raygui +void GuiSetFont(Font font) +{ + if (font.texture.id > 0) + { + // NOTE: If we try to setup a font but default style has not been + // lazily loaded before, it will be overwritten, so we need to force + // default style loading first + if (!guiStyleLoaded) GuiLoadStyleDefault(); + + guiFont = font; + } +} + +// Get custom gui font +Font GuiGetFont(void) +{ + return guiFont; +} + +// Set control style property value +void GuiSetStyle(int control, int property, int value) +{ + if (!guiStyleLoaded) GuiLoadStyleDefault(); + guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value; + + // Default properties are propagated to all controls + if ((control == 0) && (property < RAYGUI_MAX_PROPS_BASE)) + { + for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) guiStyle[i*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property] = value; + } +} + +// Get control style property value +int GuiGetStyle(int control, int property) +{ + if (!guiStyleLoaded) GuiLoadStyleDefault(); + return guiStyle[control*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED) + property]; +} + +//---------------------------------------------------------------------------------- +// Gui Controls Functions Definition +//---------------------------------------------------------------------------------- + +// Window Box control +int GuiWindowBox(Rectangle bounds, const char *title) +{ + // Window title bar height (including borders) + // NOTE: This define is also used by GuiMessageBox() and GuiTextInputBox() + #if !defined(RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT) + #define RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT 24 + #endif + + int result = 0; + //GuiState state = guiState; + + int statusBarHeight = RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT; + + Rectangle statusBar = { bounds.x, bounds.y, bounds.width, (float)statusBarHeight }; + if (bounds.height < statusBarHeight*2.0f) bounds.height = statusBarHeight*2.0f; + + Rectangle windowPanel = { bounds.x, bounds.y + (float)statusBarHeight - 1, bounds.width, bounds.height - (float)statusBarHeight + 1 }; + Rectangle closeButtonRec = { statusBar.x + statusBar.width - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - 20, + statusBar.y + statusBarHeight/2.0f - 18.0f/2.0f, 18, 18 }; + + // Update control + //-------------------------------------------------------------------- + // NOTE: Logic is directly managed by button + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiStatusBar(statusBar, title); // Draw window header as status bar + GuiPanel(windowPanel, NULL); // Draw window base + + // Draw window close button + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); +#if defined(RAYGUI_NO_ICONS) + result = GuiButton(closeButtonRec, "x"); +#else + result = GuiButton(closeButtonRec, GuiIconText(ICON_CROSS_SMALL, NULL)); +#endif + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + //-------------------------------------------------------------------- + + return result; // Window close button clicked: result = 1 +} + +// Group Box control with text name +int GuiGroupBox(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_GROUPBOX_LINE_THICK) + #define RAYGUI_GROUPBOX_LINE_THICK 1 + #endif + + int result = 0; + GuiState state = guiState; + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, RAYGUI_GROUPBOX_LINE_THICK }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y, RAYGUI_GROUPBOX_LINE_THICK, bounds.height }, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR))); + + GuiLine(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y - GuiGetStyle(DEFAULT, TEXT_SIZE)/2, bounds.width, (float)GuiGetStyle(DEFAULT, TEXT_SIZE) }, text); + //-------------------------------------------------------------------- + + return result; +} + +// Line control +int GuiLine(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_LINE_ORIGIN_SIZE) + #define RAYGUI_LINE_MARGIN_TEXT 12 + #endif + #if !defined(RAYGUI_LINE_TEXT_PADDING) + #define RAYGUI_LINE_TEXT_PADDING 4 + #endif + + int result = 0; + GuiState state = guiState; + + Color color = GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED : LINE_COLOR)); + + // Draw control + //-------------------------------------------------------------------- + if (text == NULL) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height/2, bounds.width, 1 }, 0, BLANK, color); + else + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(text) + 2; + textBounds.height = bounds.height; + textBounds.x = bounds.x + RAYGUI_LINE_MARGIN_TEXT; + textBounds.y = bounds.y; + + // Draw line with embedded text label: "--- text --------------" + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height/2, RAYGUI_LINE_MARGIN_TEXT - RAYGUI_LINE_TEXT_PADDING, 1 }, 0, BLANK, color); + GuiDrawText(text, textBounds, TEXT_ALIGN_LEFT, color); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + 12 + textBounds.width + 4, bounds.y + bounds.height/2, bounds.width - textBounds.width - RAYGUI_LINE_MARGIN_TEXT - RAYGUI_LINE_TEXT_PADDING, 1 }, 0, BLANK, color); + } + //-------------------------------------------------------------------- + + return result; +} + +// Panel control +int GuiPanel(Rectangle bounds, const char *text) +{ + #if !defined(RAYGUI_PANEL_BORDER_WIDTH) + #define RAYGUI_PANEL_BORDER_WIDTH 1 + #endif + + int result = 0; + GuiState state = guiState; + + // Text will be drawn as a header bar (if provided) + Rectangle statusBar = { bounds.x, bounds.y, bounds.width, (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT }; + if ((text != NULL) && (bounds.height < RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT*2.0f)) bounds.height = RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT*2.0f; + + if (text != NULL) + { + // Move panel bounds after the header bar + bounds.y += (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 1; + bounds.height -= (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 1; + } + + // Draw control + //-------------------------------------------------------------------- + if (text != NULL) GuiStatusBar(statusBar, text); // Draw panel header as status bar + + GuiDrawRectangle(bounds, RAYGUI_PANEL_BORDER_WIDTH, GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BORDER_COLOR_DISABLED: LINE_COLOR)), + GetColor(GuiGetStyle(DEFAULT, (state == STATE_DISABLED)? BASE_COLOR_DISABLED : BACKGROUND_COLOR))); + //-------------------------------------------------------------------- + + return result; +} + +// Tab Bar control +// NOTE: Using GuiToggle() for the TABS +int GuiTabBar(Rectangle bounds, const char **text, int count, int *active) +{ + #define RAYGUI_TABBAR_ITEM_WIDTH 160 + + int result = -1; + //GuiState state = guiState; + + Rectangle tabBounds = { bounds.x, bounds.y, RAYGUI_TABBAR_ITEM_WIDTH, bounds.height }; + + if (*active < 0) *active = 0; + else if (*active > count - 1) *active = count - 1; + + int offsetX = 0; // Required in case tabs go out of screen + offsetX = (*active + 2)*RAYGUI_TABBAR_ITEM_WIDTH - GetScreenWidth(); + if (offsetX < 0) offsetX = 0; + + bool toggle = false; // Required for individual toggles + + // Draw control + //-------------------------------------------------------------------- + for (int i = 0; i < count; i++) + { + tabBounds.x = bounds.x + (RAYGUI_TABBAR_ITEM_WIDTH + 4)*i - offsetX; + + if (tabBounds.x < GetScreenWidth()) + { + // Draw tabs as toggle controls + int textAlignment = GuiGetStyle(TOGGLE, TEXT_ALIGNMENT); + int textPadding = GuiGetStyle(TOGGLE, TEXT_PADDING); + GuiSetStyle(TOGGLE, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(TOGGLE, TEXT_PADDING, 8); + + if (i == (*active)) + { + toggle = true; + GuiToggle(tabBounds, GuiIconText(12, text[i]), &toggle); + } + else + { + toggle = false; + GuiToggle(tabBounds, GuiIconText(12, text[i]), &toggle); + if (toggle) *active = i; + } + + // Close tab with middle mouse button pressed + if (CheckCollisionPointRec(GetMousePosition(), tabBounds) && IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) result = i; + + GuiSetStyle(TOGGLE, TEXT_PADDING, textPadding); + GuiSetStyle(TOGGLE, TEXT_ALIGNMENT, textAlignment); + + // Draw tab close button + // NOTE: Only draw close button for current tab: if (CheckCollisionPointRec(mousePosition, tabBounds)) + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); +#if defined(RAYGUI_NO_ICONS) + if (GuiButton(RAYGUI_CLITERAL(Rectangle){ tabBounds.x + tabBounds.width - 14 - 5, tabBounds.y + 5, 14, 14 }, "x")) result = i; +#else + if (GuiButton(RAYGUI_CLITERAL(Rectangle){ tabBounds.x + tabBounds.width - 14 - 5, tabBounds.y + 5, 14, 14 }, GuiIconText(ICON_CROSS_SMALL, NULL))) result = i; +#endif + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlignment); + } + } + + // Draw tab-bar bottom line + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, bounds.width, 1 }, 0, BLANK, GetColor(GuiGetStyle(TOGGLE, BORDER_COLOR_NORMAL))); + //-------------------------------------------------------------------- + + return result; // Return as result the current TAB closing requested +} + +// Scroll Panel control +int GuiScrollPanel(Rectangle bounds, const char *text, Rectangle content, Vector2 *scroll, Rectangle *view) +{ + #define RAYGUI_MIN_SCROLLBAR_WIDTH 40 + #define RAYGUI_MIN_SCROLLBAR_HEIGHT 40 + #define RAYGUI_MIN_MOUSE_WHEEL_SPEED 20 + + int result = 0; + GuiState state = guiState; + + Rectangle temp = { 0 }; + if (view == NULL) view = &temp; + + Vector2 scrollPos = { 0.0f, 0.0f }; + if (scroll != NULL) scrollPos = *scroll; + + // Text will be drawn as a header bar (if provided) + Rectangle statusBar = { bounds.x, bounds.y, bounds.width, (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT }; + if (bounds.height < RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT*2.0f) bounds.height = RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT*2.0f; + + if (text != NULL) + { + // Move panel bounds after the header bar + bounds.y += (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 1; + bounds.height -= (float)RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + 1; + } + + bool hasHorizontalScrollBar = (content.width > bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH))? true : false; + bool hasVerticalScrollBar = (content.height > bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH))? true : false; + + // Recheck to account for the other scrollbar being visible + if (!hasHorizontalScrollBar) hasHorizontalScrollBar = (hasVerticalScrollBar && (content.width > (bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false; + if (!hasVerticalScrollBar) hasVerticalScrollBar = (hasHorizontalScrollBar && (content.height > (bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH))))? true : false; + + int horizontalScrollBarWidth = hasHorizontalScrollBar? GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH) : 0; + int verticalScrollBarWidth = hasVerticalScrollBar? GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH) : 0; + Rectangle horizontalScrollBar = { + (float)((GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)bounds.x + verticalScrollBarWidth : (float)bounds.x) + GuiGetStyle(DEFAULT, BORDER_WIDTH), + (float)bounds.y + bounds.height - horizontalScrollBarWidth - GuiGetStyle(DEFAULT, BORDER_WIDTH), + (float)bounds.width - verticalScrollBarWidth - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH), + (float)horizontalScrollBarWidth + }; + Rectangle verticalScrollBar = { + (float)((GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH) : (float)bounds.x + bounds.width - verticalScrollBarWidth - GuiGetStyle(DEFAULT, BORDER_WIDTH)), + (float)bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), + (float)verticalScrollBarWidth, + (float)bounds.height - horizontalScrollBarWidth - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) + }; + + // Make sure scroll bars have a minimum width/height + if (horizontalScrollBar.width < RAYGUI_MIN_SCROLLBAR_WIDTH) horizontalScrollBar.width = RAYGUI_MIN_SCROLLBAR_WIDTH; + if (verticalScrollBar.height < RAYGUI_MIN_SCROLLBAR_HEIGHT) verticalScrollBar.height = RAYGUI_MIN_SCROLLBAR_HEIGHT; + + // Calculate view area (area without the scrollbars) + *view = (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? + RAYGUI_CLITERAL(Rectangle){ bounds.x + verticalScrollBarWidth + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth } : + RAYGUI_CLITERAL(Rectangle){ bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.y + GuiGetStyle(DEFAULT, BORDER_WIDTH), bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth, bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth }; + + // Clip view area to the actual content size + if (view->width > content.width) view->width = content.width; + if (view->height > content.height) view->height = content.height; + + float horizontalMin = hasHorizontalScrollBar? ((GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)-verticalScrollBarWidth : 0) - (float)GuiGetStyle(DEFAULT, BORDER_WIDTH) : (((float)GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)-verticalScrollBarWidth : 0) - (float)GuiGetStyle(DEFAULT, BORDER_WIDTH); + float horizontalMax = hasHorizontalScrollBar? content.width - bounds.width + (float)verticalScrollBarWidth + GuiGetStyle(DEFAULT, BORDER_WIDTH) - (((float)GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (float)verticalScrollBarWidth : 0) : (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH); + float verticalMin = hasVerticalScrollBar? 0.0f : -1.0f; + float verticalMax = hasVerticalScrollBar? content.height - bounds.height + (float)horizontalScrollBarWidth + (float)GuiGetStyle(DEFAULT, BORDER_WIDTH) : (float)-GuiGetStyle(DEFAULT, BORDER_WIDTH); + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + +#if defined(SUPPORT_SCROLLBAR_KEY_INPUT) + if (hasHorizontalScrollBar) + { + if (IsKeyDown(KEY_RIGHT)) scrollPos.x -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + if (IsKeyDown(KEY_LEFT)) scrollPos.x += GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + } + + if (hasVerticalScrollBar) + { + if (IsKeyDown(KEY_DOWN)) scrollPos.y -= GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + if (IsKeyDown(KEY_UP)) scrollPos.y += GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + } +#endif + float wheelMove = GetMouseWheelMove(); + + // Set scrolling speed with mouse wheel based on ratio between bounds and content + Vector2 mouseWheelSpeed = { content.width / bounds.width, content.height / bounds.height }; + if (mouseWheelSpeed.x < RAYGUI_MIN_MOUSE_WHEEL_SPEED) mouseWheelSpeed.x = RAYGUI_MIN_MOUSE_WHEEL_SPEED; + if (mouseWheelSpeed.y < RAYGUI_MIN_MOUSE_WHEEL_SPEED) mouseWheelSpeed.y = RAYGUI_MIN_MOUSE_WHEEL_SPEED; + + // Horizontal and vertical scrolling with mouse wheel + if (hasHorizontalScrollBar && (IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_LEFT_SHIFT))) scrollPos.x += wheelMove*mouseWheelSpeed.x; + else scrollPos.y += wheelMove*mouseWheelSpeed.y; // Vertical scroll + } + } + + // Normalize scroll values + if (scrollPos.x > -horizontalMin) scrollPos.x = -horizontalMin; + if (scrollPos.x < -horizontalMax) scrollPos.x = -horizontalMax; + if (scrollPos.y > -verticalMin) scrollPos.y = -verticalMin; + if (scrollPos.y < -verticalMax) scrollPos.y = -verticalMax; + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (text != NULL) GuiStatusBar(statusBar, text); // Draw panel header as status bar + + GuiDrawRectangle(bounds, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR))); // Draw background + + // Save size of the scrollbar slider + const int slider = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + + // Draw horizontal scrollbar if visible + if (hasHorizontalScrollBar) + { + // Change scrollbar slider size to show the diff in size between the content width and the widget width + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth)/(int)content.width)*((int)bounds.width - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - verticalScrollBarWidth))); + scrollPos.x = (float)-GuiScrollBar(horizontalScrollBar, (int)-scrollPos.x, (int)horizontalMin, (int)horizontalMax); + } + else scrollPos.x = 0.0f; + + // Draw vertical scrollbar if visible + if (hasVerticalScrollBar) + { + // Change scrollbar slider size to show the diff in size between the content height and the widget height + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)(((bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth)/(int)content.height)*((int)bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) - horizontalScrollBarWidth))); + scrollPos.y = (float)-GuiScrollBar(verticalScrollBar, (int)-scrollPos.y, (int)verticalMin, (int)verticalMax); + } + else scrollPos.y = 0.0f; + + // Draw detail corner rectangle if both scroll bars are visible + if (hasHorizontalScrollBar && hasVerticalScrollBar) + { + Rectangle corner = { (GuiGetStyle(LISTVIEW, SCROLLBAR_SIDE) == SCROLLBAR_LEFT_SIDE)? (bounds.x + GuiGetStyle(DEFAULT, BORDER_WIDTH) + 2) : (horizontalScrollBar.x + horizontalScrollBar.width + 2), verticalScrollBar.y + verticalScrollBar.height + 2, (float)horizontalScrollBarWidth - 4, (float)verticalScrollBarWidth - 4 }; + GuiDrawRectangle(corner, 0, BLANK, GetColor(GuiGetStyle(LISTVIEW, TEXT + (state*3)))); + } + + // Draw scrollbar lines depending on current state + GuiDrawRectangle(bounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + (state*3))), BLANK); + + // Set scrollbar slider size back to the way it was before + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, slider); + //-------------------------------------------------------------------- + + if (scroll != NULL) *scroll = scrollPos; + + return result; +} + +// Label control +int GuiLabel(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + //... + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Button control, returns true when clicked +int GuiButton(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) result = 1; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(BUTTON, BORDER_WIDTH), GetColor(GuiGetStyle(BUTTON, BORDER + (state*3))), GetColor(GuiGetStyle(BUTTON, BASE + (state*3)))); + GuiDrawText(text, GetTextBounds(BUTTON, bounds), GuiGetStyle(BUTTON, TEXT_ALIGNMENT), GetColor(GuiGetStyle(BUTTON, TEXT + (state*3)))); + + if (state == STATE_FOCUSED) GuiTooltip(bounds); + //------------------------------------------------------------------ + + return result; // Button pressed: result = 1 +} + +// Label button control +int GuiLabelButton(Rectangle bounds, const char *text) +{ + GuiState state = guiState; + bool pressed = false; + + // NOTE: We force bounds.width to be all text + float textWidth = (float)GetTextWidth(text); + if ((bounds.width - 2*GuiGetStyle(LABEL, BORDER_WIDTH) - 2*GuiGetStyle(LABEL, TEXT_PADDING)) < textWidth) bounds.width = textWidth + 2*GuiGetStyle(LABEL, BORDER_WIDTH) + 2*GuiGetStyle(LABEL, TEXT_PADDING) + 2; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check checkbox state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return pressed; +} + +// Toggle Button control +int GuiToggle(Rectangle bounds, const char *text, bool *active) +{ + int result = 0; + GuiState state = guiState; + + bool temp = false; + if (active == NULL) active = &temp; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check toggle button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + state = STATE_NORMAL; + *active = !(*active); + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_NORMAL) + { + GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, ((*active)? BORDER_COLOR_PRESSED : (BORDER + state*3)))), GetColor(GuiGetStyle(TOGGLE, ((*active)? BASE_COLOR_PRESSED : (BASE + state*3))))); + GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TOGGLE, ((*active)? TEXT_COLOR_PRESSED : (TEXT + state*3))))); + } + else + { + GuiDrawRectangle(bounds, GuiGetStyle(TOGGLE, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, BORDER + state*3)), GetColor(GuiGetStyle(TOGGLE, BASE + state*3))); + GuiDrawText(text, GetTextBounds(TOGGLE, bounds), GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TOGGLE, TEXT + state*3))); + } + + if (state == STATE_FOCUSED) GuiTooltip(bounds); + //-------------------------------------------------------------------- + + return result; +} + +// Toggle Group control +int GuiToggleGroup(Rectangle bounds, const char *text, int *active) +{ + #if !defined(RAYGUI_TOGGLEGROUP_MAX_ITEMS) + #define RAYGUI_TOGGLEGROUP_MAX_ITEMS 32 + #endif + + int result = 0; + float initBoundsX = bounds.x; + + int temp = 0; + if (active == NULL) active = &temp; + + bool toggle = false; // Required for individual toggles + + // Get substrings items from text (items pointers) + int rows[RAYGUI_TOGGLEGROUP_MAX_ITEMS] = { 0 }; + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, rows); + + int prevRow = rows[0]; + + for (int i = 0; i < itemCount; i++) + { + if (prevRow != rows[i]) + { + bounds.x = initBoundsX; + bounds.y += (bounds.height + GuiGetStyle(TOGGLE, GROUP_PADDING)); + prevRow = rows[i]; + } + + if (i == (*active)) + { + toggle = true; + GuiToggle(bounds, items[i], &toggle); + } + else + { + toggle = false; + GuiToggle(bounds, items[i], &toggle); + if (toggle) *active = i; + } + + bounds.x += (bounds.width + GuiGetStyle(TOGGLE, GROUP_PADDING)); + } + + return result; +} + +// Toggle Slider control extended +int GuiToggleSlider(Rectangle bounds, const char *text, int *active) +{ + int result = 0; + GuiState state = guiState; + + int temp = 0; + if (active == NULL) active = &temp; + + //bool toggle = false; // Required for individual toggles + + // Get substrings items from text (items pointers) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + Rectangle slider = { + 0, // Calculated later depending on the active toggle + bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + (bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - (itemCount + 1)*GuiGetStyle(SLIDER, SLIDER_PADDING))/itemCount, + bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + (*active)++; + result = 1; + } + else state = STATE_FOCUSED; + } + + if ((*active) && (state != STATE_FOCUSED)) state = STATE_PRESSED; + } + + if (*active >= itemCount) *active = 0; + slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH) + (*active + 1)*GuiGetStyle(SLIDER, SLIDER_PADDING) + (*active)*slider.width; + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), GetColor(GuiGetStyle(TOGGLE, BORDER + (state*3))), + GetColor(GuiGetStyle(TOGGLE, BASE_COLOR_NORMAL))); + + // Draw internal slider + if (state == STATE_NORMAL) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_FOCUSED))); + else if (state == STATE_PRESSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + + // Draw text in slider + if (text != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(text); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = slider.x + slider.width/2 - textBounds.width/2; + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(items[*active], textBounds, GuiGetStyle(TOGGLE, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(TOGGLE, TEXT + (state*3))), guiAlpha)); + } + //-------------------------------------------------------------------- + + return result; +} + +// Check Box control, returns 1 when state changed +int GuiCheckBox(Rectangle bounds, const char *text, bool *checked) +{ + int result = 0; + GuiState state = guiState; + + bool temp = false; + if (checked == NULL) checked = &temp; + + Rectangle textBounds = { 0 }; + + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(CHECKBOX, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + if (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(CHECKBOX, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + Rectangle totalBounds = { + (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT)? textBounds.x : bounds.x, + bounds.y, + bounds.width + textBounds.width + GuiGetStyle(CHECKBOX, TEXT_PADDING), + bounds.height, + }; + + // Check checkbox state + if (CheckCollisionPointRec(mousePoint, totalBounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + *checked = !(*checked); + result = 1; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(CHECKBOX, BORDER_WIDTH), GetColor(GuiGetStyle(CHECKBOX, BORDER + (state*3))), BLANK); + + if (*checked) + { + Rectangle check = { bounds.x + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING), + bounds.y + GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING), + bounds.width - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)), + bounds.height - 2*(GuiGetStyle(CHECKBOX, BORDER_WIDTH) + GuiGetStyle(CHECKBOX, CHECK_PADDING)) }; + GuiDrawRectangle(check, 0, BLANK, GetColor(GuiGetStyle(CHECKBOX, TEXT + state*3))); + } + + GuiDrawText(text, textBounds, (GuiGetStyle(CHECKBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Combo Box control +int GuiComboBox(Rectangle bounds, const char *text, int *active) +{ + int result = 0; + GuiState state = guiState; + + int temp = 0; + if (active == NULL) active = &temp; + + bounds.width -= (GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH) + GuiGetStyle(COMBOBOX, COMBO_BUTTON_SPACING)); + + Rectangle selector = { (float)bounds.x + bounds.width + GuiGetStyle(COMBOBOX, COMBO_BUTTON_SPACING), + (float)bounds.y, (float)GuiGetStyle(COMBOBOX, COMBO_BUTTON_WIDTH), (float)bounds.height }; + + // Get substrings items from text (items pointers, lengths and count) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + if (*active < 0) *active = 0; + else if (*active > (itemCount - 1)) *active = itemCount - 1; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && (itemCount > 1) && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + if (CheckCollisionPointRec(mousePoint, bounds) || + CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + *active += 1; + if (*active >= itemCount) *active = 0; // Cyclic combobox + } + + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + // Draw combo box main + GuiDrawRectangle(bounds, GuiGetStyle(COMBOBOX, BORDER_WIDTH), GetColor(GuiGetStyle(COMBOBOX, BORDER + (state*3))), GetColor(GuiGetStyle(COMBOBOX, BASE + (state*3)))); + GuiDrawText(items[*active], GetTextBounds(COMBOBOX, bounds), GuiGetStyle(COMBOBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(COMBOBOX, TEXT + (state*3)))); + + // Draw selector using a custom button + // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 1); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + GuiButton(selector, TextFormat("%i/%i", *active + 1, itemCount)); + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign); + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + //-------------------------------------------------------------------- + + return result; +} + +// Dropdown Box control +// NOTE: Returns mouse click +int GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode) +{ + int result = 0; + GuiState state = guiState; + + int itemSelected = *active; + int itemFocused = -1; + + // Get substrings items from text (items pointers, lengths and count) + int itemCount = 0; + const char **items = GuiTextSplit(text, ';', &itemCount, NULL); + + Rectangle boundsOpen = bounds; + boundsOpen.height = (itemCount + 1)*(bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + Rectangle itemBounds = bounds; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && (editMode || !guiLocked) && (itemCount > 1) && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + if (editMode) + { + state = STATE_PRESSED; + + // Check if mouse has been pressed or released outside limits + if (!CheckCollisionPointRec(mousePoint, boundsOpen)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) result = 1; + } + + // Check if already selected item has been pressed again + if (CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) result = 1; + + // Check focused and selected item + for (int i = 0; i < itemCount; i++) + { + // Update item rectangle y position for next item + itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + if (CheckCollisionPointRec(mousePoint, itemBounds)) + { + itemFocused = i; + if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) + { + itemSelected = i; + result = 1; // Item selected + } + break; + } + } + + itemBounds = bounds; + } + else + { + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + result = 1; + state = STATE_PRESSED; + } + else state = STATE_FOCUSED; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (editMode) GuiPanel(boundsOpen, NULL); + + GuiDrawRectangle(bounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER + state*3)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE + state*3))); + GuiDrawText(items[itemSelected], GetTextBounds(DROPDOWNBOX, bounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + state*3))); + + if (editMode) + { + // Draw visible items + for (int i = 0; i < itemCount; i++) + { + // Update item rectangle y position for next item + itemBounds.y += (bounds.height + GuiGetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING)); + + if (i == itemSelected) + { + GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_PRESSED)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_PRESSED))); + GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_PRESSED))); + } + else if (i == itemFocused) + { + GuiDrawRectangle(itemBounds, GuiGetStyle(DROPDOWNBOX, BORDER_WIDTH), GetColor(GuiGetStyle(DROPDOWNBOX, BORDER_COLOR_FOCUSED)), GetColor(GuiGetStyle(DROPDOWNBOX, BASE_COLOR_FOCUSED))); + GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_FOCUSED))); + } + else GuiDrawText(items[i], GetTextBounds(DROPDOWNBOX, itemBounds), GuiGetStyle(DROPDOWNBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(DROPDOWNBOX, TEXT_COLOR_NORMAL))); + } + } + + // Draw arrows (using icon if available) +#if defined(RAYGUI_NO_ICONS) + GuiDrawText("v", RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - GuiGetStyle(DROPDOWNBOX, ARROW_PADDING), bounds.y + bounds.height/2 - 2, 10, 10 }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); +#else + GuiDrawText("#120#", RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - GuiGetStyle(DROPDOWNBOX, ARROW_PADDING), bounds.y + bounds.height/2 - 6, 10, 10 }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); // ICON_ARROW_DOWN_FILL +#endif + //-------------------------------------------------------------------- + + *active = itemSelected; + + // TODO: Use result to return more internal states: mouse-press out-of-bounds, mouse-press over selected-item... + return result; // Mouse click: result = 1 +} + +// Text Box control +// NOTE: Returns true on ENTER pressed (useful for data validation) +int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode) +{ + #if !defined(RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN) + #define RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN 40 // Frames to wait for autocursor movement + #endif + #if !defined(RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) + #define RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY 1 // Frames delay for autocursor movement + #endif + + int result = 0; + GuiState state = guiState; + + bool multiline = false; // TODO: Consider multiline text input + int wrapMode = GuiGetStyle(DEFAULT, TEXT_WRAP_MODE); + + Rectangle textBounds = GetTextBounds(TEXTBOX, bounds); + int textWidth = GetTextWidth(text) - GetTextWidth(text + textBoxCursorIndex); + int textIndexOffset = 0; // Text index offset to start drawing in the box + + // Cursor rectangle + // NOTE: Position X value should be updated + Rectangle cursor = { + textBounds.x + textWidth + GuiGetStyle(DEFAULT, TEXT_SPACING), + textBounds.y + textBounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE), + 2, + (float)GuiGetStyle(DEFAULT, TEXT_SIZE)*2 + }; + + if (cursor.height >= bounds.height) cursor.height = bounds.height - GuiGetStyle(TEXTBOX, BORDER_WIDTH)*2; + if (cursor.y < (bounds.y + GuiGetStyle(TEXTBOX, BORDER_WIDTH))) cursor.y = bounds.y + GuiGetStyle(TEXTBOX, BORDER_WIDTH); + + // Mouse cursor rectangle + // NOTE: Initialized outside of screen + Rectangle mouseCursor = cursor; + mouseCursor.x = -1; + mouseCursor.width = 1; + + // Auto-cursor movement logic + // NOTE: Cursor moves automatically when key down after some time + if (IsKeyDown(KEY_LEFT) || IsKeyDown(KEY_RIGHT) || IsKeyDown(KEY_UP) || IsKeyDown(KEY_DOWN) || IsKeyDown(KEY_BACKSPACE) || IsKeyDown(KEY_DELETE)) autoCursorCooldownCounter++; + else + { + autoCursorCooldownCounter = 0; // GLOBAL: Cursor cooldown counter + autoCursorDelayCounter = 0; // GLOBAL: Cursor delay counter + } + + // Blink-cursor frame counter + //if (!autoCursorMode) blinkCursorFrameCounter++; + //else blinkCursorFrameCounter = 0; + + // Update control + //-------------------------------------------------------------------- + // WARNING: Text editing is only supported under certain conditions: + if ((state != STATE_DISABLED) && // Control not disabled + !GuiGetStyle(TEXTBOX, TEXT_READONLY) && // TextBox not on read-only mode + !guiLocked && // Gui not locked + !guiControlExclusiveMode && // No gui slider on dragging + (wrapMode == TEXT_WRAP_NONE)) // No wrap mode + { + Vector2 mousePosition = GetMousePosition(); + + if (editMode) + { + state = STATE_PRESSED; + + // If text does not fit in the textbox and current cursor position is out of bounds, + // we add an index offset to text for drawing only what requires depending on cursor + while (textWidth >= textBounds.width) + { + int nextCodepointSize = 0; + GetCodepointNext(text + textIndexOffset, &nextCodepointSize); + + textIndexOffset += nextCodepointSize; + + textWidth = GetTextWidth(text + textIndexOffset) - GetTextWidth(text + textBoxCursorIndex); + } + + int textLength = (int)strlen(text); // Get current text length + int codepoint = GetCharPressed(); // Get Unicode codepoint + if (multiline && IsKeyPressed(KEY_ENTER)) codepoint = (int)'\n'; + + if (textBoxCursorIndex > textLength) textBoxCursorIndex = textLength; + + // Encode codepoint as UTF-8 + int codepointSize = 0; + const char *charEncoded = CodepointToUTF8(codepoint, &codepointSize); + + // Add codepoint to text, at current cursor position + // NOTE: Make sure we do not overflow buffer size + if (((multiline && (codepoint == (int)'\n')) || (codepoint >= 32)) && ((textLength + codepointSize) < textSize)) + { + // Move forward data from cursor position + for (int i = (textLength + codepointSize); i > textBoxCursorIndex; i--) text[i] = text[i - codepointSize]; + + // Add new codepoint in current cursor position + for (int i = 0; i < codepointSize; i++) text[textBoxCursorIndex + i] = charEncoded[i]; + + textBoxCursorIndex += codepointSize; + textLength += codepointSize; + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + + // Move cursor to start + if ((textLength > 0) && IsKeyPressed(KEY_HOME)) textBoxCursorIndex = 0; + + // Move cursor to end + if ((textLength > textBoxCursorIndex) && IsKeyPressed(KEY_END)) textBoxCursorIndex = textLength; + + // Delete codepoint from text, after current cursor position + if ((textLength > textBoxCursorIndex) && (IsKeyPressed(KEY_DELETE) || (IsKeyDown(KEY_DELETE) && (autoCursorCooldownCounter >= RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN)))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_DELETE) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int nextCodepointSize = 0; + GetCodepointNext(text + textBoxCursorIndex, &nextCodepointSize); + + // Move backward text from cursor position + for (int i = textBoxCursorIndex; i < textLength; i++) text[i] = text[i + nextCodepointSize]; + + textLength -= codepointSize; + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + } + + // Delete codepoint from text, before current cursor position + if ((textLength > 0) && (IsKeyPressed(KEY_BACKSPACE) || (IsKeyDown(KEY_BACKSPACE) && (autoCursorCooldownCounter >= RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN)))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_BACKSPACE) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int prevCodepointSize = 0; + GetCodepointPrevious(text + textBoxCursorIndex, &prevCodepointSize); + + // Move backward text from cursor position + for (int i = (textBoxCursorIndex - prevCodepointSize); i < textLength; i++) text[i] = text[i + prevCodepointSize]; + + // Prevent cursor index from decrementing past 0 + if (textBoxCursorIndex > 0) + { + textBoxCursorIndex -= codepointSize; + textLength -= codepointSize; + } + + // Make sure text last character is EOL + text[textLength] = '\0'; + } + } + + // Move cursor position with keys + if (IsKeyPressed(KEY_LEFT) || (IsKeyDown(KEY_LEFT) && (autoCursorCooldownCounter > RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_LEFT) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int prevCodepointSize = 0; + GetCodepointPrevious(text + textBoxCursorIndex, &prevCodepointSize); + + if (textBoxCursorIndex >= prevCodepointSize) textBoxCursorIndex -= prevCodepointSize; + } + } + else if (IsKeyPressed(KEY_RIGHT) || (IsKeyDown(KEY_RIGHT) && (autoCursorCooldownCounter > RAYGUI_TEXTBOX_AUTO_CURSOR_COOLDOWN))) + { + autoCursorDelayCounter++; + + if (IsKeyPressed(KEY_RIGHT) || (autoCursorDelayCounter%RAYGUI_TEXTBOX_AUTO_CURSOR_DELAY) == 0) // Delay every movement some frames + { + int nextCodepointSize = 0; + GetCodepointNext(text + textBoxCursorIndex, &nextCodepointSize); + + if ((textBoxCursorIndex + nextCodepointSize) <= textLength) textBoxCursorIndex += nextCodepointSize; + } + } + + // Move cursor position with mouse + if (CheckCollisionPointRec(mousePosition, textBounds)) // Mouse hover text + { + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/(float)guiFont.baseSize; + int codepointIndex = 0; + float glyphWidth = 0.0f; + float widthToMouseX = 0; + int mouseCursorIndex = 0; + + for (int i = textIndexOffset; i < textLength; i++) + { + codepoint = GetCodepointNext(&text[i], &codepointSize); + codepointIndex = GetGlyphIndex(guiFont, codepoint); + + if (guiFont.glyphs[codepointIndex].advanceX == 0) glyphWidth = ((float)guiFont.recs[codepointIndex].width*scaleFactor); + else glyphWidth = ((float)guiFont.glyphs[codepointIndex].advanceX*scaleFactor); + + if (mousePosition.x <= (textBounds.x + (widthToMouseX + glyphWidth/2))) + { + mouseCursor.x = textBounds.x + widthToMouseX; + mouseCursorIndex = i; + break; + } + + widthToMouseX += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + + // Check if mouse cursor is at the last position + int textEndWidth = GetTextWidth(text + textIndexOffset); + if (GetMousePosition().x >= (textBounds.x + textEndWidth - glyphWidth/2)) + { + mouseCursor.x = textBounds.x + textEndWidth; + mouseCursorIndex = (int)strlen(text); + } + + // Place cursor at required index on mouse click + if ((mouseCursor.x >= 0) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + cursor.x = mouseCursor.x; + textBoxCursorIndex = mouseCursorIndex; + } + } + else mouseCursor.x = -1; + + // Recalculate cursor position.y depending on textBoxCursorIndex + cursor.x = bounds.x + GuiGetStyle(TEXTBOX, TEXT_PADDING) + GetTextWidth(text + textIndexOffset) - GetTextWidth(text + textBoxCursorIndex) + GuiGetStyle(DEFAULT, TEXT_SPACING); + //if (multiline) cursor.y = GetTextLines() + + // Finish text editing on ENTER or mouse click outside bounds + if ((!multiline && IsKeyPressed(KEY_ENTER)) || + (!CheckCollisionPointRec(mousePosition, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) + { + textBoxCursorIndex = 0; // GLOBAL: Reset the shared cursor index + result = 1; + } + } + else + { + if (CheckCollisionPointRec(mousePosition, bounds)) + { + state = STATE_FOCUSED; + + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + textBoxCursorIndex = (int)strlen(text); // GLOBAL: Place cursor index to the end of current text + result = 1; + } + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_PRESSED) + { + GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED))); + } + else if (state == STATE_DISABLED) + { + GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_DISABLED))); + } + else GuiDrawRectangle(bounds, GuiGetStyle(TEXTBOX, BORDER_WIDTH), GetColor(GuiGetStyle(TEXTBOX, BORDER + (state*3))), BLANK); + + // Draw text considering index offset if required + // NOTE: Text index offset depends on cursor position + GuiDrawText(text + textIndexOffset, textBounds, GuiGetStyle(TEXTBOX, TEXT_ALIGNMENT), GetColor(GuiGetStyle(TEXTBOX, TEXT + (state*3)))); + + // Draw cursor + if (editMode && !GuiGetStyle(TEXTBOX, TEXT_READONLY)) + { + //if (autoCursorMode || ((blinkCursorFrameCounter/40)%2 == 0)) + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))); + + // Draw mouse position cursor (if required) + if (mouseCursor.x >= 0) GuiDrawRectangle(mouseCursor, 0, BLANK, GetColor(GuiGetStyle(TEXTBOX, BORDER_COLOR_PRESSED))); + } + else if (state == STATE_FOCUSED) GuiTooltip(bounds); + //-------------------------------------------------------------------- + + return result; // Mouse button pressed: result = 1 +} + +/* +// Text Box control with multiple lines and word-wrap +// NOTE: This text-box is readonly, no editing supported by default +bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode) +{ + bool pressed = false; + + GuiSetStyle(TEXTBOX, TEXT_READONLY, 1); + GuiSetStyle(DEFAULT, TEXT_WRAP_MODE, TEXT_WRAP_WORD); // WARNING: If wrap mode enabled, text editing is not supported + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_TOP); + + // TODO: Implement methods to calculate cursor position properly + pressed = GuiTextBox(bounds, text, textSize, editMode); + + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_MIDDLE); + GuiSetStyle(DEFAULT, TEXT_WRAP_MODE, TEXT_WRAP_NONE); + GuiSetStyle(TEXTBOX, TEXT_READONLY, 0); + + return pressed; +} +*/ + +// Spinner control, returns selected value +int GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode) +{ + int result = 1; + GuiState state = guiState; + + int tempValue = *value; + + Rectangle spinner = { bounds.x + GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH) + GuiGetStyle(SPINNER, SPIN_BUTTON_SPACING), bounds.y, + bounds.width - 2*(GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH) + GuiGetStyle(SPINNER, SPIN_BUTTON_SPACING)), bounds.height }; + Rectangle leftButtonBound = { (float)bounds.x, (float)bounds.y, (float)GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH), (float)bounds.height }; + Rectangle rightButtonBound = { (float)bounds.x + bounds.width - GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH), (float)bounds.y, (float)GuiGetStyle(SPINNER, SPIN_BUTTON_WIDTH), (float)bounds.height }; + + Rectangle textBounds = { 0 }; + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(SPINNER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + if (GuiGetStyle(SPINNER, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SPINNER, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check spinner state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + +#if defined(RAYGUI_NO_ICONS) + if (GuiButton(leftButtonBound, "<")) tempValue--; + if (GuiButton(rightButtonBound, ">")) tempValue++; +#else + if (GuiButton(leftButtonBound, GuiIconText(ICON_ARROW_LEFT_FILL, NULL))) tempValue--; + if (GuiButton(rightButtonBound, GuiIconText(ICON_ARROW_RIGHT_FILL, NULL))) tempValue++; +#endif + + if (!editMode) + { + if (tempValue < minValue) tempValue = minValue; + if (tempValue > maxValue) tempValue = maxValue; + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + result = GuiValueBox(spinner, NULL, &tempValue, minValue, maxValue, editMode); + + // Draw value selector custom buttons + // NOTE: BORDER_WIDTH and TEXT_ALIGNMENT forced values + int tempBorderWidth = GuiGetStyle(BUTTON, BORDER_WIDTH); + int tempTextAlign = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, BORDER_WIDTH, GuiGetStyle(SPINNER, BORDER_WIDTH)); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, tempTextAlign); + GuiSetStyle(BUTTON, BORDER_WIDTH, tempBorderWidth); + + // Draw text label if provided + GuiDrawText(text, textBounds, (GuiGetStyle(SPINNER, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + *value = tempValue; + return result; +} + +// Value Box control, updates input text with numbers +// NOTE: Requires static variables: frameCounter +int GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode) +{ + #if !defined(RAYGUI_VALUEBOX_MAX_CHARS) + #define RAYGUI_VALUEBOX_MAX_CHARS 32 + #endif + + int result = 0; + GuiState state = guiState; + + char textValue[RAYGUI_VALUEBOX_MAX_CHARS + 1] = "\0"; + sprintf(textValue, "%i", *value); + + Rectangle textBounds = { 0 }; + if (text != NULL) + { + textBounds.width = (float)GetTextWidth(text) + 2; + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(VALUEBOX, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + if (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_LEFT) textBounds.x = bounds.x - textBounds.width - GuiGetStyle(VALUEBOX, TEXT_PADDING); + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + bool valueHasChanged = false; + + if (editMode) + { + state = STATE_PRESSED; + + int keyCount = (int)strlen(textValue); + + // Only allow keys in range [48..57] + if (keyCount < RAYGUI_VALUEBOX_MAX_CHARS) + { + if (GetTextWidth(textValue) < bounds.width) + { + int key = GetCharPressed(); + if ((key >= 48) && (key <= 57)) + { + textValue[keyCount] = (char)key; + keyCount++; + valueHasChanged = true; + } + } + } + + // Delete text + if (keyCount > 0) + { + if (IsKeyPressed(KEY_BACKSPACE)) + { + keyCount--; + textValue[keyCount] = '\0'; + valueHasChanged = true; + } + } + + if (valueHasChanged) *value = TextToInteger(textValue); + + // NOTE: We are not clamp values until user input finishes + //if (*value > maxValue) *value = maxValue; + //else if (*value < minValue) *value = minValue; + + if (IsKeyPressed(KEY_ENTER) || (!CheckCollisionPointRec(mousePoint, bounds) && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))) + { + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + + result = 1; + } + } + else + { + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + + if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) result = 1; + } + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + Color baseColor = BLANK; + if (state == STATE_PRESSED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_PRESSED)); + else if (state == STATE_DISABLED) baseColor = GetColor(GuiGetStyle(VALUEBOX, BASE_COLOR_DISABLED)); + + GuiDrawRectangle(bounds, GuiGetStyle(VALUEBOX, BORDER_WIDTH), GetColor(GuiGetStyle(VALUEBOX, BORDER + (state*3))), baseColor); + GuiDrawText(textValue, GetTextBounds(VALUEBOX, bounds), TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(VALUEBOX, TEXT + (state*3)))); + + // Draw cursor + if (editMode) + { + // NOTE: ValueBox internal text is always centered + Rectangle cursor = { bounds.x + GetTextWidth(textValue)/2 + bounds.width/2 + 1, bounds.y + 2*GuiGetStyle(VALUEBOX, BORDER_WIDTH), 4, bounds.height - 4*GuiGetStyle(VALUEBOX, BORDER_WIDTH) }; + GuiDrawRectangle(cursor, 0, BLANK, GetColor(GuiGetStyle(VALUEBOX, BORDER_COLOR_PRESSED))); + } + + // Draw text label if provided + GuiDrawText(text, textBounds, (GuiGetStyle(VALUEBOX, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT)? TEXT_ALIGN_LEFT : TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(LABEL, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Slider control with pro parameters +// NOTE: Other GuiSlider*() controls use this one +int GuiSliderPro(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue, int sliderWidth) +{ + int result = 0; + GuiState state = guiState; + + float temp = (maxValue - minValue)/2.0f; + if (value == NULL) value = &temp; + float oldValue = *value; + + Rectangle slider = { bounds.x, bounds.y + GuiGetStyle(SLIDER, BORDER_WIDTH) + GuiGetStyle(SLIDER, SLIDER_PADDING), + 0, bounds.height - 2*GuiGetStyle(SLIDER, BORDER_WIDTH) - 2*GuiGetStyle(SLIDER, SLIDER_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + // Get equivalent value and slider position from mousePosition.x + *value = (maxValue - minValue)*((mousePoint.x - bounds.x - sliderWidth/2)/(bounds.width-sliderWidth)) + minValue; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + if (!CheckCollisionPointRec(mousePoint, slider)) + { + // Get equivalent value and slider position from mousePosition.x + *value = (maxValue - minValue)*((mousePoint.x - bounds.x - sliderWidth/2)/(bounds.width-sliderWidth)) + minValue; + } + } + else state = STATE_FOCUSED; + } + + if (*value > maxValue) *value = maxValue; + else if (*value < minValue) *value = minValue; + } + + // Control value change check + if (oldValue == *value) result = 0; + else result = 1; + + // Slider bar limits check + int sliderValue = (int)(((*value - minValue)/(maxValue - minValue))*(bounds.width - sliderWidth - GuiGetStyle(SLIDER, BORDER_WIDTH))); + if (sliderWidth > 0) // Slider + { + slider.x += sliderValue; + slider.width = (float)sliderWidth; + if (slider.x <= (bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH))) slider.x = bounds.x + GuiGetStyle(SLIDER, BORDER_WIDTH); + else if ((slider.x + slider.width) >= (bounds.x + bounds.width)) slider.x = bounds.x + bounds.width - slider.width - GuiGetStyle(SLIDER, BORDER_WIDTH); + } + else if (sliderWidth == 0) // SliderBar + { + slider.x += GuiGetStyle(SLIDER, BORDER_WIDTH); + slider.width = (float)sliderValue; + if (slider.width > bounds.width) slider.width = bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SLIDER, BORDER_WIDTH), GetColor(GuiGetStyle(SLIDER, BORDER + (state*3))), GetColor(GuiGetStyle(SLIDER, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED))); + + // Draw slider internal bar (depends on state) + if (state == STATE_NORMAL) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BASE_COLOR_PRESSED))); + else if (state == STATE_FOCUSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_FOCUSED))); + else if (state == STATE_PRESSED) GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, TEXT_COLOR_PRESSED))); + + // Draw left/right text if provided + if (textLeft != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textLeft); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x - textBounds.width - GuiGetStyle(SLIDER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(SLIDER, TEXT + (state*3)))); + } + + if (textRight != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textRight); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(SLIDER, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(SLIDER, TEXT + (state*3)))); + } + //-------------------------------------------------------------------- + + return result; +} + +// Slider control extended, returns selected value and has text +int GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, GuiGetStyle(SLIDER, SLIDER_WIDTH)); +} + +// Slider Bar control extended, returns selected value +int GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + return GuiSliderPro(bounds, textLeft, textRight, value, minValue, maxValue, 0); +} + +// Progress Bar control extended, shows current progress value +int GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float *value, float minValue, float maxValue) +{ + int result = 0; + GuiState state = guiState; + + float temp = (maxValue - minValue)/2.0f; + if (value == NULL) value = &temp; + + // Progress bar + Rectangle progress = { bounds.x + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), + bounds.y + GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) + GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING), 0, + bounds.height - 2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) - 2*GuiGetStyle(PROGRESSBAR, PROGRESS_PADDING) }; + + // Update control + //-------------------------------------------------------------------- + if (*value > maxValue) *value = maxValue; + + // WARNING: Working with floats could lead to rounding issues + if ((state != STATE_DISABLED)) progress.width = (float)(*value/(maxValue - minValue))*bounds.width - ((*value >= maxValue)? (float)(2*GuiGetStyle(PROGRESSBAR, BORDER_WIDTH)) : 0.0f); + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_DISABLED) + { + GuiDrawRectangle(bounds, GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), GetColor(GuiGetStyle(PROGRESSBAR, BORDER + (state*3))), BLANK); + } + else + { + if (*value > minValue) + { + // Draw progress bar with colored border, more visual + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, (int)progress.width + (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height - 2 }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + bounds.height - 1, (int)progress.width + (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + } + else GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + + if (*value >= maxValue) GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + progress.width + 1, bounds.y, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_FOCUSED))); + else + { + // Draw borders not yet reached by value + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + (int)progress.width + 1, bounds.y, bounds.width - (int)progress.width - 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + (int)progress.width + 1, bounds.y + bounds.height - 1, bounds.width - (int)progress.width - 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH) }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ bounds.x + bounds.width - 1, bounds.y + 1, (float)GuiGetStyle(PROGRESSBAR, BORDER_WIDTH), bounds.height - 2 }, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BORDER_COLOR_NORMAL))); + } + + // Draw slider internal progress bar (depends on state) + GuiDrawRectangle(progress, 0, BLANK, GetColor(GuiGetStyle(PROGRESSBAR, BASE_COLOR_PRESSED))); + } + + // Draw left/right text if provided + if (textLeft != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textLeft); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x - textBounds.width - GuiGetStyle(PROGRESSBAR, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textLeft, textBounds, TEXT_ALIGN_RIGHT, GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3)))); + } + + if (textRight != NULL) + { + Rectangle textBounds = { 0 }; + textBounds.width = (float)GetTextWidth(textRight); + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + textBounds.x = bounds.x + bounds.width + GuiGetStyle(PROGRESSBAR, TEXT_PADDING); + textBounds.y = bounds.y + bounds.height/2 - GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + + GuiDrawText(textRight, textBounds, TEXT_ALIGN_LEFT, GetColor(GuiGetStyle(PROGRESSBAR, TEXT + (state*3)))); + } + //-------------------------------------------------------------------- + + return result; +} + +// Status Bar control +int GuiStatusBar(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), GetColor(GuiGetStyle(STATUSBAR, BORDER + (state*3))), GetColor(GuiGetStyle(STATUSBAR, BASE + (state*3)))); + GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), GetColor(GuiGetStyle(STATUSBAR, TEXT + (state*3)))); + //-------------------------------------------------------------------- + + return result; +} + +// Dummy rectangle control, intended for placeholding +int GuiDummyRec(Rectangle bounds, const char *text) +{ + int result = 0; + GuiState state = guiState; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check button state + if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = STATE_PRESSED; + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, 0, BLANK, GetColor(GuiGetStyle(DEFAULT, (state != STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED))); + GuiDrawText(text, GetTextBounds(DEFAULT, bounds), TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(BUTTON, (state != STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED))); + //------------------------------------------------------------------ + + return result; +} + +// List View control +int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int *active) +{ + int result = 0; + int itemCount = 0; + const char **items = NULL; + + if (text != NULL) items = GuiTextSplit(text, ';', &itemCount, NULL); + + result = GuiListViewEx(bounds, items, itemCount, scrollIndex, active, NULL); + + return result; +} + +// List View control with extended parameters +int GuiListViewEx(Rectangle bounds, const char **text, int count, int *scrollIndex, int *active, int *focus) +{ + int result = 0; + GuiState state = guiState; + + int itemFocused = (focus == NULL)? -1 : *focus; + int itemSelected = (active == NULL)? -1 : *active; + + // Check if we need a scroll bar + bool useScrollBar = false; + if ((GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING))*count > bounds.height) useScrollBar = true; + + // Define base item rectangle [0] + Rectangle itemBounds = { 0 }; + itemBounds.x = bounds.x + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING); + itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) + GuiGetStyle(DEFAULT, BORDER_WIDTH); + itemBounds.width = bounds.width - 2*GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) - GuiGetStyle(DEFAULT, BORDER_WIDTH); + itemBounds.height = (float)GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT); + if (useScrollBar) itemBounds.width -= GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH); + + // Get items on the list + int visibleItems = (int)bounds.height/(GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + if (visibleItems > count) visibleItems = count; + + int startIndex = (scrollIndex == NULL)? 0 : *scrollIndex; + if ((startIndex < 0) || (startIndex > (count - visibleItems))) startIndex = 0; + int endIndex = startIndex + visibleItems; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + Vector2 mousePoint = GetMousePosition(); + + // Check mouse inside list view + if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + + // Check focused and selected item + for (int i = 0; i < visibleItems; i++) + { + if (CheckCollisionPointRec(mousePoint, itemBounds)) + { + itemFocused = startIndex + i; + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + if (itemSelected == (startIndex + i)) itemSelected = -1; + else itemSelected = startIndex + i; + } + break; + } + + // Update item rectangle y position for next item + itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + } + + if (useScrollBar) + { + int wheelMove = (int)GetMouseWheelMove(); + startIndex -= wheelMove; + + if (startIndex < 0) startIndex = 0; + else if (startIndex > (count - visibleItems)) startIndex = count - visibleItems; + + endIndex = startIndex + visibleItems; + if (endIndex > count) endIndex = count; + } + } + else itemFocused = -1; + + // Reset item rectangle y to [0] + itemBounds.y = bounds.y + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING) + GuiGetStyle(DEFAULT, BORDER_WIDTH); + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(DEFAULT, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR))); // Draw background + + // Draw visible items + for (int i = 0; ((i < visibleItems) && (text != NULL)); i++) + { + if (state == STATE_DISABLED) + { + if ((startIndex + i) == itemSelected) GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_DISABLED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_DISABLED))); + + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_DISABLED))); + } + else + { + if (((startIndex + i) == itemSelected) && (active != NULL)) + { + // Draw item selected + GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_PRESSED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_PRESSED))); + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_PRESSED))); + } + else if (((startIndex + i) == itemFocused)) // && (focus != NULL)) // NOTE: We want items focused, despite not returned! + { + // Draw item focused + GuiDrawRectangle(itemBounds, GuiGetStyle(LISTVIEW, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER_COLOR_FOCUSED)), GetColor(GuiGetStyle(LISTVIEW, BASE_COLOR_FOCUSED))); + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_FOCUSED))); + } + else + { + // Draw item normal + GuiDrawText(text[startIndex + i], GetTextBounds(DEFAULT, itemBounds), GuiGetStyle(LISTVIEW, TEXT_ALIGNMENT), GetColor(GuiGetStyle(LISTVIEW, TEXT_COLOR_NORMAL))); + } + } + + // Update item rectangle y position for next item + itemBounds.y += (GuiGetStyle(LISTVIEW, LIST_ITEMS_HEIGHT) + GuiGetStyle(LISTVIEW, LIST_ITEMS_SPACING)); + } + + if (useScrollBar) + { + Rectangle scrollBarBounds = { + bounds.x + bounds.width - GuiGetStyle(LISTVIEW, BORDER_WIDTH) - GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH), + bounds.y + GuiGetStyle(LISTVIEW, BORDER_WIDTH), (float)GuiGetStyle(LISTVIEW, SCROLLBAR_WIDTH), + bounds.height - 2*GuiGetStyle(DEFAULT, BORDER_WIDTH) + }; + + // Calculate percentage of visible items and apply same percentage to scrollbar + float percentVisible = (float)(endIndex - startIndex)/count; + float sliderSize = bounds.height*percentVisible; + + int prevSliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); // Save default slider size + int prevScrollSpeed = GuiGetStyle(SCROLLBAR, SCROLL_SPEED); // Save default scroll speed + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, (int)sliderSize); // Change slider size + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, count - visibleItems); // Change scroll speed + + startIndex = GuiScrollBar(scrollBarBounds, startIndex, 0, count - visibleItems); + + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, prevScrollSpeed); // Reset scroll speed to default + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, prevSliderSize); // Reset slider size to default + } + //-------------------------------------------------------------------- + + if (active != NULL) *active = itemSelected; + if (focus != NULL) *focus = itemFocused; + if (scrollIndex != NULL) *scrollIndex = startIndex; + + return result; +} + +// Color Panel control - Color (RGBA) variant. +int GuiColorPanel(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + + Vector3 vcolor = { (float)color->r/255.0f, (float)color->g/255.0f, (float)color->b/255.0f }; + Vector3 hsv = ConvertRGBtoHSV(vcolor); + Vector3 prevHsv = hsv; // workaround to see if GuiColorPanelHSV modifies the hsv. + + GuiColorPanelHSV(bounds, text, &hsv); + + // Check if the hsv was changed, only then change the color. + // This is necessary, because the Color->HSV->Color conversion has precision errors. + // Thus the assignment from HSV to Color should only be made, if the HSV has a new user-entered value. + // Otherwise GuiColorPanel would often modify it's color without user input. + // TODO: GuiColorPanelHSV could return 1 if the slider was dragged, to simplify this check. + if (hsv.x != prevHsv.x || hsv.y != prevHsv.y || hsv.z != prevHsv.z) + { + Vector3 rgb = ConvertHSVtoRGB(hsv); + + // NOTE: Vector3ToColor() only available on raylib 1.8.1 + *color = RAYGUI_CLITERAL(Color){ (unsigned char)(255.0f*rgb.x), + (unsigned char)(255.0f*rgb.y), + (unsigned char)(255.0f*rgb.z), + color->a }; + } + return result; +} + +// Color Bar Alpha control +// NOTE: Returns alpha value normalized [0..1] +int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha) +{ + #if !defined(RAYGUI_COLORBARALPHA_CHECKED_SIZE) + #define RAYGUI_COLORBARALPHA_CHECKED_SIZE 10 + #endif + + int result = 0; + GuiState state = guiState; + Rectangle selector = { (float)bounds.x + (*alpha)*bounds.width - GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT)/2, (float)bounds.y - GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW), (float)GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT), (float)bounds.height + GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW)*2 }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + *alpha = (mousePoint.x - bounds.x)/bounds.width; + if (*alpha <= 0.0f) *alpha = 0.0f; + if (*alpha >= 1.0f) *alpha = 1.0f; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + *alpha = (mousePoint.x - bounds.x)/bounds.width; + if (*alpha <= 0.0f) *alpha = 0.0f; + if (*alpha >= 1.0f) *alpha = 1.0f; + //selector.x = bounds.x + (int)(((alpha - 0)/(100 - 0))*(bounds.width - 2*GuiGetStyle(SLIDER, BORDER_WIDTH))) - selector.width/2; + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + + // Draw alpha bar: checked background + if (state != STATE_DISABLED) + { + int checksX = (int)bounds.width/RAYGUI_COLORBARALPHA_CHECKED_SIZE; + int checksY = (int)bounds.height/RAYGUI_COLORBARALPHA_CHECKED_SIZE; + + for (int x = 0; x < checksX; x++) + { + for (int y = 0; y < checksY; y++) + { + Rectangle check = { bounds.x + x*RAYGUI_COLORBARALPHA_CHECKED_SIZE, bounds.y + y*RAYGUI_COLORBARALPHA_CHECKED_SIZE, RAYGUI_COLORBARALPHA_CHECKED_SIZE, RAYGUI_COLORBARALPHA_CHECKED_SIZE }; + GuiDrawRectangle(check, 0, BLANK, ((x + y)%2)? Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.4f) : Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.4f)); + } + } + + DrawRectangleGradientEx(bounds, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, RAYGUI_CLITERAL(Color){ 255, 255, 255, 0 }, Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 0, 255 }, guiAlpha)); + } + else DrawRectangleGradientEx(bounds, Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha)); + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + + // Draw alpha bar: selector + GuiDrawRectangle(selector, 0, BLANK, GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3))); + //-------------------------------------------------------------------- + + return result; +} + +// Color Bar Hue control +// Returns hue value normalized [0..1] +// NOTE: Other similar bars (for reference): +// Color GuiColorBarSat() [WHITE->color] +// Color GuiColorBarValue() [BLACK->color], HSV/HSL +// float GuiColorBarLuminance() [BLACK->WHITE] +int GuiColorBarHue(Rectangle bounds, const char *text, float *hue) +{ + int result = 0; + GuiState state = guiState; + Rectangle selector = { (float)bounds.x - GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW), (float)bounds.y + (*hue)/360.0f*bounds.height - GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT)/2, (float)bounds.width + GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW)*2, (float)GuiGetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT) }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + *hue = (mousePoint.y - bounds.y)*360/bounds.height; + if (*hue <= 0.0f) *hue = 0.0f; + if (*hue >= 359.0f) *hue = 359.0f; + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds) || CheckCollisionPointRec(mousePoint, selector)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + *hue = (mousePoint.y - bounds.y)*360/bounds.height; + if (*hue <= 0.0f) *hue = 0.0f; + if (*hue >= 359.0f) *hue = 359.0f; + + } + else state = STATE_FOCUSED; + + /*if (IsKeyDown(KEY_UP)) + { + hue -= 2.0f; + if (hue <= 0.0f) hue = 0.0f; + } + else if (IsKeyDown(KEY_DOWN)) + { + hue += 2.0f; + if (hue >= 360.0f) hue = 360.0f; + }*/ + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state != STATE_DISABLED) + { + // Draw hue bar:color bars + // TODO: Use directly DrawRectangleGradientEx(bounds, color1, color2, color2, color1); + DrawRectangleGradientV((int)bounds.x, (int)(bounds.y), (int)bounds.width, (int)ceilf(bounds.height/6), Fade(RAYGUI_CLITERAL(Color){ 255, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 255, 0, 255 }, guiAlpha)); + DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + bounds.height/6), (int)bounds.width, (int)ceilf(bounds.height/6), Fade(RAYGUI_CLITERAL(Color){ 255, 255, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 255, 0, 255 }, guiAlpha)); + DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + 2*(bounds.height/6)), (int)bounds.width, (int)ceilf(bounds.height/6), Fade(RAYGUI_CLITERAL(Color){ 0, 255, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 255, 255, 255 }, guiAlpha)); + DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + 3*(bounds.height/6)), (int)bounds.width, (int)ceilf(bounds.height/6), Fade(RAYGUI_CLITERAL(Color){ 0, 255, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 255, 255 }, guiAlpha)); + DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + 4*(bounds.height/6)), (int)bounds.width, (int)ceilf(bounds.height/6), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 0, 255, 255 }, guiAlpha)); + DrawRectangleGradientV((int)bounds.x, (int)(bounds.y + 5*(bounds.height/6)), (int)bounds.width, (int)(bounds.height/6), Fade(RAYGUI_CLITERAL(Color){ 255, 0, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 0, 0, 255 }, guiAlpha)); + } + else DrawRectangleGradientV((int)bounds.x, (int)bounds.y, (int)bounds.width, (int)bounds.height, Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), guiAlpha), Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), guiAlpha)); + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + + // Draw hue bar: selector + GuiDrawRectangle(selector, 0, BLANK, GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3))); + //-------------------------------------------------------------------- + + return result; +} + +// Color Picker control +// NOTE: It's divided in multiple controls: +// Color GuiColorPanel(Rectangle bounds, Color color) +// float GuiColorBarAlpha(Rectangle bounds, float alpha) +// float GuiColorBarHue(Rectangle bounds, float value) +// NOTE: bounds define GuiColorPanel() size +// NOTE: this picker converts RGB to HSV, which can cause the Hue control to jump. If you have this problem, consider using the HSV variant instead +int GuiColorPicker(Rectangle bounds, const char *text, Color *color) +{ + int result = 0; + + Color temp = { 200, 0, 0, 255 }; + if (color == NULL) color = &temp; + + GuiColorPanel(bounds, NULL, color); + + Rectangle boundsHue = { (float)bounds.x + bounds.width + GuiGetStyle(COLORPICKER, HUEBAR_PADDING), (float)bounds.y, (float)GuiGetStyle(COLORPICKER, HUEBAR_WIDTH), (float)bounds.height }; + //Rectangle boundsAlpha = { bounds.x, bounds.y + bounds.height + GuiGetStyle(COLORPICKER, BARS_PADDING), bounds.width, GuiGetStyle(COLORPICKER, BARS_THICK) }; + + // NOTE: this conversion can cause low hue-resolution, if the r, g and b value are very similar, which causes the hue bar to shift around when only the GuiColorPanel is used. + Vector3 hsv = ConvertRGBtoHSV(RAYGUI_CLITERAL(Vector3){ (*color).r/255.0f, (*color).g/255.0f, (*color).b/255.0f }); + + GuiColorBarHue(boundsHue, NULL, &hsv.x); + + //color.a = (unsigned char)(GuiColorBarAlpha(boundsAlpha, (float)color.a/255.0f)*255.0f); + Vector3 rgb = ConvertHSVtoRGB(hsv); + + *color = RAYGUI_CLITERAL(Color){ (unsigned char)roundf(rgb.x*255.0f), (unsigned char)roundf(rgb.y*255.0f), (unsigned char)roundf(rgb.z*255.0f), (*color).a }; + + return result; +} + +// Color Picker control that avoids conversion to RGB and back to HSV on each call, thus avoiding jittering. +// The user can call ConvertHSVtoRGB() to convert *colorHsv value to RGB. +// NOTE: It's divided in multiple controls: +// int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +// int GuiColorBarAlpha(Rectangle bounds, const char *text, float *alpha) +// float GuiColorBarHue(Rectangle bounds, float value) +// NOTE: bounds define GuiColorPanelHSV() size +int GuiColorPickerHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +{ + int result = 0; + + Vector3 tempHsv = { 0 }; + + if (colorHsv == NULL) + { + const Vector3 tempColor = { 200.0f/255.0f, 0.0f, 0.0f }; + tempHsv = ConvertRGBtoHSV(tempColor); + colorHsv = &tempHsv; + } + + GuiColorPanelHSV(bounds, NULL, colorHsv); + + const Rectangle boundsHue = { (float)bounds.x + bounds.width + GuiGetStyle(COLORPICKER, HUEBAR_PADDING), (float)bounds.y, (float)GuiGetStyle(COLORPICKER, HUEBAR_WIDTH), (float)bounds.height }; + + GuiColorBarHue(boundsHue, NULL, &colorHsv->x); + + return result; +} + +// Color Panel control - HSV variant +int GuiColorPanelHSV(Rectangle bounds, const char *text, Vector3 *colorHsv) +{ + int result = 0; + GuiState state = guiState; + Vector2 pickerSelector = { 0 }; + + const Color colWhite = { 255, 255, 255, 255 }; + const Color colBlack = { 0, 0, 0, 255 }; + + pickerSelector.x = bounds.x + (float)colorHsv->y*bounds.width; // HSV: Saturation + pickerSelector.y = bounds.y + (1.0f - (float)colorHsv->z)*bounds.height; // HSV: Value + + Vector3 maxHue = { colorHsv->x, 1.0f, 1.0f }; + Vector3 rgbHue = ConvertHSVtoRGB(maxHue); + Color maxHueCol = { (unsigned char)(255.0f*rgbHue.x), + (unsigned char)(255.0f*rgbHue.y), + (unsigned char)(255.0f*rgbHue.z), 255 }; + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + pickerSelector = mousePoint; + + if (pickerSelector.x < bounds.x) pickerSelector.x = bounds.x; + if (pickerSelector.x > bounds.x + bounds.width) pickerSelector.x = bounds.x + bounds.width; + if (pickerSelector.y < bounds.y) pickerSelector.y = bounds.y; + if (pickerSelector.y > bounds.y + bounds.height) pickerSelector.y = bounds.y + bounds.height; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + colorHsv->y = colorPick.x; + colorHsv->z = 1.0f - colorPick.y; + + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + { + state = STATE_PRESSED; + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; + pickerSelector = mousePoint; + + // Calculate color from picker + Vector2 colorPick = { pickerSelector.x - bounds.x, pickerSelector.y - bounds.y }; + + colorPick.x /= (float)bounds.width; // Get normalized value on x + colorPick.y /= (float)bounds.height; // Get normalized value on y + + colorHsv->y = colorPick.x; + colorHsv->z = 1.0f - colorPick.y; + } + else state = STATE_FOCUSED; + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state != STATE_DISABLED) + { + DrawRectangleGradientEx(bounds, Fade(colWhite, guiAlpha), Fade(colWhite, guiAlpha), Fade(maxHueCol, guiAlpha), Fade(maxHueCol, guiAlpha)); + DrawRectangleGradientEx(bounds, Fade(colBlack, 0), Fade(colBlack, guiAlpha), Fade(colBlack, guiAlpha), Fade(colBlack, 0)); + + // Draw color picker: selector + Rectangle selector = { pickerSelector.x - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, pickerSelector.y - GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE)/2, (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE), (float)GuiGetStyle(COLORPICKER, COLOR_SELECTOR_SIZE) }; + GuiDrawRectangle(selector, 0, BLANK, colWhite); + } + else + { + DrawRectangleGradientEx(bounds, Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BASE_COLOR_DISABLED)), 0.1f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(colBlack, 0.6f), guiAlpha), Fade(Fade(GetColor(GuiGetStyle(COLORPICKER, BORDER_COLOR_DISABLED)), 0.6f), guiAlpha)); + } + + GuiDrawRectangle(bounds, GuiGetStyle(COLORPICKER, BORDER_WIDTH), GetColor(GuiGetStyle(COLORPICKER, BORDER + state*3)), BLANK); + //-------------------------------------------------------------------- + + return result; +} + +// Message Box control +int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons) +{ + #if !defined(RAYGUI_MESSAGEBOX_BUTTON_HEIGHT) + #define RAYGUI_MESSAGEBOX_BUTTON_HEIGHT 24 + #endif + #if !defined(RAYGUI_MESSAGEBOX_BUTTON_PADDING) + #define RAYGUI_MESSAGEBOX_BUTTON_PADDING 12 + #endif + + int result = -1; // Returns clicked button from buttons list, 0 refers to closed window button + + int buttonCount = 0; + const char **buttonsText = GuiTextSplit(buttons, ';', &buttonCount, NULL); + Rectangle buttonBounds = { 0 }; + buttonBounds.x = bounds.x + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + buttonBounds.y = bounds.y + bounds.height - RAYGUI_MESSAGEBOX_BUTTON_HEIGHT - RAYGUI_MESSAGEBOX_BUTTON_PADDING; + buttonBounds.width = (bounds.width - RAYGUI_MESSAGEBOX_BUTTON_PADDING*(buttonCount + 1))/buttonCount; + buttonBounds.height = RAYGUI_MESSAGEBOX_BUTTON_HEIGHT; + + int textWidth = GetTextWidth(message) + 2; + + Rectangle textBounds = { 0 }; + textBounds.x = bounds.x + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + RAYGUI_MESSAGEBOX_BUTTON_PADDING; + textBounds.width = bounds.width - RAYGUI_MESSAGEBOX_BUTTON_PADDING*2; + textBounds.height = bounds.height - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - 3*RAYGUI_MESSAGEBOX_BUTTON_PADDING - RAYGUI_MESSAGEBOX_BUTTON_HEIGHT; + + // Draw control + //-------------------------------------------------------------------- + if (GuiWindowBox(bounds, title)) result = 0; + + int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(textBounds, message); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment); + + prevTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + for (int i = 0; i < buttonCount; i++) + { + if (GuiButton(buttonBounds, buttonsText[i])) result = i + 1; + buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING); + } + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevTextAlignment); + //-------------------------------------------------------------------- + + return result; +} + +// Text Input Box control, ask for text +int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text, int textMaxSize, bool *secretViewActive) +{ + #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT) + #define RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT 24 + #endif + #if !defined(RAYGUI_TEXTINPUTBOX_BUTTON_PADDING) + #define RAYGUI_TEXTINPUTBOX_BUTTON_PADDING 12 + #endif + #if !defined(RAYGUI_TEXTINPUTBOX_HEIGHT) + #define RAYGUI_TEXTINPUTBOX_HEIGHT 26 + #endif + + // Used to enable text edit mode + // WARNING: No more than one GuiTextInputBox() should be open at the same time + static bool textEditMode = false; + + int result = -1; + + int buttonCount = 0; + const char **buttonsText = GuiTextSplit(buttons, ';', &buttonCount, NULL); + Rectangle buttonBounds = { 0 }; + buttonBounds.x = bounds.x + RAYGUI_TEXTINPUTBOX_BUTTON_PADDING; + buttonBounds.y = bounds.y + bounds.height - RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING; + buttonBounds.width = (bounds.width - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING*(buttonCount + 1))/buttonCount; + buttonBounds.height = RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT; + + int messageInputHeight = (int)bounds.height - RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - GuiGetStyle(STATUSBAR, BORDER_WIDTH) - RAYGUI_TEXTINPUTBOX_BUTTON_HEIGHT - 2*RAYGUI_TEXTINPUTBOX_BUTTON_PADDING; + + Rectangle textBounds = { 0 }; + if (message != NULL) + { + int textSize = GetTextWidth(message) + 2; + + textBounds.x = bounds.x + bounds.width/2 - textSize/2; + textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + messageInputHeight/4 - (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/2; + textBounds.width = (float)textSize; + textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + } + + Rectangle textBoxBounds = { 0 }; + textBoxBounds.x = bounds.x + RAYGUI_TEXTINPUTBOX_BUTTON_PADDING; + textBoxBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT - RAYGUI_TEXTINPUTBOX_HEIGHT/2; + if (message == NULL) textBoxBounds.y = bounds.y + 24 + RAYGUI_TEXTINPUTBOX_BUTTON_PADDING; + else textBoxBounds.y += (messageInputHeight/2 + messageInputHeight/4); + textBoxBounds.width = bounds.width - RAYGUI_TEXTINPUTBOX_BUTTON_PADDING*2; + textBoxBounds.height = RAYGUI_TEXTINPUTBOX_HEIGHT; + + // Draw control + //-------------------------------------------------------------------- + if (GuiWindowBox(bounds, title)) result = 0; + + // Draw message if available + if (message != NULL) + { + int prevTextAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(textBounds, message); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, prevTextAlignment); + } + + if (secretViewActive != NULL) + { + static char stars[] = "****************"; + if (GuiTextBox(RAYGUI_CLITERAL(Rectangle){ textBoxBounds.x, textBoxBounds.y, textBoxBounds.width - 4 - RAYGUI_TEXTINPUTBOX_HEIGHT, textBoxBounds.height }, + ((*secretViewActive == 1) || textEditMode)? text : stars, textMaxSize, textEditMode)) textEditMode = !textEditMode; + + GuiToggle(RAYGUI_CLITERAL(Rectangle){ textBoxBounds.x + textBoxBounds.width - RAYGUI_TEXTINPUTBOX_HEIGHT, textBoxBounds.y, RAYGUI_TEXTINPUTBOX_HEIGHT, RAYGUI_TEXTINPUTBOX_HEIGHT }, (*secretViewActive == 1)? "#44#" : "#45#", secretViewActive); + } + else + { + if (GuiTextBox(textBoxBounds, text, textMaxSize, textEditMode)) textEditMode = !textEditMode; + } + + int prevBtnTextAlignment = GuiGetStyle(BUTTON, TEXT_ALIGNMENT); + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + for (int i = 0; i < buttonCount; i++) + { + if (GuiButton(buttonBounds, buttonsText[i])) result = i + 1; + buttonBounds.x += (buttonBounds.width + RAYGUI_MESSAGEBOX_BUTTON_PADDING); + } + + if (result >= 0) textEditMode = false; + + GuiSetStyle(BUTTON, TEXT_ALIGNMENT, prevBtnTextAlignment); + //-------------------------------------------------------------------- + + return result; // Result is the pressed button index +} + +// Grid control +// NOTE: Returns grid mouse-hover selected cell +// About drawing lines at subpixel spacing, simple put, not easy solution: +// https://stackoverflow.com/questions/4435450/2d-opengl-drawing-lines-that-dont-exactly-fit-pixel-raster +int GuiGrid(Rectangle bounds, const char *text, float spacing, int subdivs, Vector2 *mouseCell) +{ + // Grid lines alpha amount + #if !defined(RAYGUI_GRID_ALPHA) + #define RAYGUI_GRID_ALPHA 0.15f + #endif + + int result = 0; + GuiState state = guiState; + + Vector2 mousePoint = GetMousePosition(); + Vector2 currentMouseCell = { -1, -1 }; + + float spaceWidth = spacing/(float)subdivs; + int linesV = (int)(bounds.width/spaceWidth) + 1; + int linesH = (int)(bounds.height/spaceWidth) + 1; + + int color = GuiGetStyle(DEFAULT, LINE_COLOR); + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked && !guiControlExclusiveMode) + { + if (CheckCollisionPointRec(mousePoint, bounds)) + { + // NOTE: Cell values must be the upper left of the cell the mouse is in + currentMouseCell.x = floorf((mousePoint.x - bounds.x)/spacing); + currentMouseCell.y = floorf((mousePoint.y - bounds.y)/spacing); + } + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + if (state == STATE_DISABLED) color = GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED); + + if (subdivs > 0) + { + // Draw vertical grid lines + for (int i = 0; i < linesV; i++) + { + Rectangle lineV = { bounds.x + spacing*i/subdivs, bounds.y, 1, bounds.height }; + GuiDrawRectangle(lineV, 0, BLANK, ((i%subdivs) == 0)? GuiFade(GetColor(color), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(color), RAYGUI_GRID_ALPHA)); + } + + // Draw horizontal grid lines + for (int i = 0; i < linesH; i++) + { + Rectangle lineH = { bounds.x, bounds.y + spacing*i/subdivs, bounds.width, 1 }; + GuiDrawRectangle(lineH, 0, BLANK, ((i%subdivs) == 0)? GuiFade(GetColor(color), RAYGUI_GRID_ALPHA*4) : GuiFade(GetColor(color), RAYGUI_GRID_ALPHA)); + } + } + + if (mouseCell != NULL) *mouseCell = currentMouseCell; + return result; +} + +//---------------------------------------------------------------------------------- +// Tooltip management functions +// NOTE: Tooltips requires some global variables: tooltipPtr +//---------------------------------------------------------------------------------- +// Enable gui tooltips (global state) +void GuiEnableTooltip(void) { guiTooltip = true; } + +// Disable gui tooltips (global state) +void GuiDisableTooltip(void) { guiTooltip = false; } + +// Set tooltip string +void GuiSetTooltip(const char *tooltip) { guiTooltipPtr = tooltip; } + +//---------------------------------------------------------------------------------- +// Styles loading functions +//---------------------------------------------------------------------------------- + +// Load raygui style file (.rgs) +// NOTE: By default a binary file is expected, that file could contain a custom font, +// in that case, custom font image atlas is GRAY+ALPHA and pixel data can be compressed (DEFLATE) +void GuiLoadStyle(const char *fileName) +{ + #define MAX_LINE_BUFFER_SIZE 256 + + bool tryBinary = false; + if (!guiStyleLoaded) GuiLoadStyleDefault(); + + // Try reading the files as text file first + FILE *rgsFile = fopen(fileName, "rt"); + + if (rgsFile != NULL) + { + char buffer[MAX_LINE_BUFFER_SIZE] = { 0 }; + fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile); + + if (buffer[0] == '#') + { + int controlId = 0; + int propertyId = 0; + unsigned int propertyValue = 0; + + while (!feof(rgsFile)) + { + switch (buffer[0]) + { + case 'p': + { + // Style property: p + + sscanf(buffer, "p %d %d 0x%x", &controlId, &propertyId, &propertyValue); + GuiSetStyle(controlId, propertyId, (int)propertyValue); + + } break; + case 'f': + { + // Style font: f + + int fontSize = 0; + char charmapFileName[256] = { 0 }; + char fontFileName[256] = { 0 }; + sscanf(buffer, "f %d %s %[^\r\n]s", &fontSize, charmapFileName, fontFileName); + + Font font = { 0 }; + int *codepoints = NULL; + int codepointCount = 0; + + if (charmapFileName[0] != '0') + { + // Load text data from file + // NOTE: Expected an UTF-8 array of codepoints, no separation + char *textData = LoadFileText(TextFormat("%s/%s", GetDirectoryPath(fileName), charmapFileName)); + codepoints = LoadCodepoints(textData, &codepointCount); + UnloadFileText(textData); + } + + if (fontFileName[0] != '\0') + { + // In case a font is already loaded and it is not default internal font, unload it + if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture); + + if (codepointCount > 0) font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, codepoints, codepointCount); + else font = LoadFontEx(TextFormat("%s/%s", GetDirectoryPath(fileName), fontFileName), fontSize, NULL, 0); // Default to 95 standard codepoints + } + + // If font texture not properly loaded, revert to default font and size/spacing + if (font.texture.id == 0) + { + font = GetFontDefault(); + GuiSetStyle(DEFAULT, TEXT_SIZE, 10); + GuiSetStyle(DEFAULT, TEXT_SPACING, 1); + } + + UnloadCodepoints(codepoints); + + if ((font.texture.id > 0) && (font.glyphCount > 0)) GuiSetFont(font); + + } break; + default: break; + } + + fgets(buffer, MAX_LINE_BUFFER_SIZE, rgsFile); + } + } + else tryBinary = true; + + fclose(rgsFile); + } + + if (tryBinary) + { + rgsFile = fopen(fileName, "rb"); + + if (rgsFile != NULL) + { + fseek(rgsFile, 0, SEEK_END); + int fileDataSize = ftell(rgsFile); + fseek(rgsFile, 0, SEEK_SET); + + if (fileDataSize > 0) + { + unsigned char *fileData = (unsigned char *)RAYGUI_MALLOC(fileDataSize*sizeof(unsigned char)); + fread(fileData, sizeof(unsigned char), fileDataSize, rgsFile); + + GuiLoadStyleFromMemory(fileData, fileDataSize); + + RAYGUI_FREE(fileData); + } + + fclose(rgsFile); + } + } +} + +// Load style default over global style +void GuiLoadStyleDefault(void) +{ + // We set this variable first to avoid cyclic function calls + // when calling GuiSetStyle() and GuiGetStyle() + guiStyleLoaded = true; + + // Initialize default LIGHT style property values + // WARNING: Default value are applied to all controls on set but + // they can be overwritten later on for every custom control + GuiSetStyle(DEFAULT, BORDER_COLOR_NORMAL, 0x838383ff); + GuiSetStyle(DEFAULT, BASE_COLOR_NORMAL, 0xc9c9c9ff); + GuiSetStyle(DEFAULT, TEXT_COLOR_NORMAL, 0x686868ff); + GuiSetStyle(DEFAULT, BORDER_COLOR_FOCUSED, 0x5bb2d9ff); + GuiSetStyle(DEFAULT, BASE_COLOR_FOCUSED, 0xc9effeff); + GuiSetStyle(DEFAULT, TEXT_COLOR_FOCUSED, 0x6c9bbcff); + GuiSetStyle(DEFAULT, BORDER_COLOR_PRESSED, 0x0492c7ff); + GuiSetStyle(DEFAULT, BASE_COLOR_PRESSED, 0x97e8ffff); + GuiSetStyle(DEFAULT, TEXT_COLOR_PRESSED, 0x368bafff); + GuiSetStyle(DEFAULT, BORDER_COLOR_DISABLED, 0xb5c1c2ff); + GuiSetStyle(DEFAULT, BASE_COLOR_DISABLED, 0xe6e9e9ff); + GuiSetStyle(DEFAULT, TEXT_COLOR_DISABLED, 0xaeb7b8ff); + GuiSetStyle(DEFAULT, BORDER_WIDTH, 1); + GuiSetStyle(DEFAULT, TEXT_PADDING, 0); + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + + // Initialize default extended property values + // NOTE: By default, extended property values are initialized to 0 + GuiSetStyle(DEFAULT, TEXT_SIZE, 10); // DEFAULT, shared by all controls + GuiSetStyle(DEFAULT, TEXT_SPACING, 1); // DEFAULT, shared by all controls + GuiSetStyle(DEFAULT, LINE_COLOR, 0x90abb5ff); // DEFAULT specific property + GuiSetStyle(DEFAULT, BACKGROUND_COLOR, 0xf5f5f5ff); // DEFAULT specific property + GuiSetStyle(DEFAULT, TEXT_LINE_SPACING, 15); // DEFAULT, 15 pixels between lines + GuiSetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL, TEXT_ALIGN_MIDDLE); // DEFAULT, text aligned vertically to middle of text-bounds + + // Initialize control-specific property values + // NOTE: Those properties are in default list but require specific values by control type + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(BUTTON, BORDER_WIDTH, 2); + GuiSetStyle(SLIDER, TEXT_PADDING, 4); + GuiSetStyle(PROGRESSBAR, TEXT_PADDING, 4); + GuiSetStyle(CHECKBOX, TEXT_PADDING, 4); + GuiSetStyle(CHECKBOX, TEXT_ALIGNMENT, TEXT_ALIGN_RIGHT); + GuiSetStyle(DROPDOWNBOX, TEXT_PADDING, 0); + GuiSetStyle(DROPDOWNBOX, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiSetStyle(TEXTBOX, TEXT_PADDING, 4); + GuiSetStyle(TEXTBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(VALUEBOX, TEXT_PADDING, 0); + GuiSetStyle(VALUEBOX, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(SPINNER, TEXT_PADDING, 0); + GuiSetStyle(SPINNER, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + GuiSetStyle(STATUSBAR, TEXT_PADDING, 8); + GuiSetStyle(STATUSBAR, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT); + + // Initialize extended property values + // NOTE: By default, extended property values are initialized to 0 + GuiSetStyle(TOGGLE, GROUP_PADDING, 2); + GuiSetStyle(SLIDER, SLIDER_WIDTH, 16); + GuiSetStyle(SLIDER, SLIDER_PADDING, 1); + GuiSetStyle(PROGRESSBAR, PROGRESS_PADDING, 1); + GuiSetStyle(CHECKBOX, CHECK_PADDING, 1); + GuiSetStyle(COMBOBOX, COMBO_BUTTON_WIDTH, 32); + GuiSetStyle(COMBOBOX, COMBO_BUTTON_SPACING, 2); + GuiSetStyle(DROPDOWNBOX, ARROW_PADDING, 16); + GuiSetStyle(DROPDOWNBOX, DROPDOWN_ITEMS_SPACING, 2); + GuiSetStyle(SPINNER, SPIN_BUTTON_WIDTH, 24); + GuiSetStyle(SPINNER, SPIN_BUTTON_SPACING, 2); + GuiSetStyle(SCROLLBAR, BORDER_WIDTH, 0); + GuiSetStyle(SCROLLBAR, ARROWS_VISIBLE, 0); + GuiSetStyle(SCROLLBAR, ARROWS_SIZE, 6); + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING, 0); + GuiSetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE, 16); + GuiSetStyle(SCROLLBAR, SCROLL_PADDING, 0); + GuiSetStyle(SCROLLBAR, SCROLL_SPEED, 12); + GuiSetStyle(LISTVIEW, LIST_ITEMS_HEIGHT, 28); + GuiSetStyle(LISTVIEW, LIST_ITEMS_SPACING, 2); + GuiSetStyle(LISTVIEW, SCROLLBAR_WIDTH, 12); + GuiSetStyle(LISTVIEW, SCROLLBAR_SIDE, SCROLLBAR_RIGHT_SIDE); + GuiSetStyle(COLORPICKER, COLOR_SELECTOR_SIZE, 8); + GuiSetStyle(COLORPICKER, HUEBAR_WIDTH, 16); + GuiSetStyle(COLORPICKER, HUEBAR_PADDING, 8); + GuiSetStyle(COLORPICKER, HUEBAR_SELECTOR_HEIGHT, 8); + GuiSetStyle(COLORPICKER, HUEBAR_SELECTOR_OVERFLOW, 2); + + if (guiFont.texture.id != GetFontDefault().texture.id) + { + // Unload previous font texture + UnloadTexture(guiFont.texture); + RL_FREE(guiFont.recs); + RL_FREE(guiFont.glyphs); + guiFont.recs = NULL; + guiFont.glyphs = NULL; + + // Setup default raylib font + guiFont = GetFontDefault(); + + // NOTE: Default raylib font character 95 is a white square + Rectangle whiteChar = guiFont.recs[95]; + + // NOTE: We set up a 1px padding on char rectangle to avoid pixel bleeding on MSAA filtering + SetShapesTexture(guiFont.texture, RAYGUI_CLITERAL(Rectangle){ whiteChar.x + 1, whiteChar.y + 1, whiteChar.width - 2, whiteChar.height - 2 }); + } +} + +// Get text with icon id prepended +// NOTE: Useful to add icons by name id (enum) instead of +// a number that can change between ricon versions +const char *GuiIconText(int iconId, const char *text) +{ +#if defined(RAYGUI_NO_ICONS) + return NULL; +#else + static char buffer[1024] = { 0 }; + static char iconBuffer[16] = { 0 }; + + if (text != NULL) + { + memset(buffer, 0, 1024); + sprintf(buffer, "#%03i#", iconId); + + for (int i = 5; i < 1024; i++) + { + buffer[i] = text[i - 5]; + if (text[i - 5] == '\0') break; + } + + return buffer; + } + else + { + sprintf(iconBuffer, "#%03i#", iconId); + + return iconBuffer; + } +#endif +} + +#if !defined(RAYGUI_NO_ICONS) +// Get full icons data pointer +unsigned int *GuiGetIcons(void) { return guiIconsPtr; } + +// Load raygui icons file (.rgi) +// NOTE: In case nameIds are required, they can be requested with loadIconsName, +// they are returned as a guiIconsName[iconCount][RAYGUI_ICON_MAX_NAME_LENGTH], +// WARNING: guiIconsName[]][] memory should be manually freed! +char **GuiLoadIcons(const char *fileName, bool loadIconsName) +{ + // Style File Structure (.rgi) + // ------------------------------------------------------ + // Offset | Size | Type | Description + // ------------------------------------------------------ + // 0 | 4 | char | Signature: "rGI " + // 4 | 2 | short | Version: 100 + // 6 | 2 | short | reserved + + // 8 | 2 | short | Num icons (N) + // 10 | 2 | short | Icons size (Options: 16, 32, 64) (S) + + // Icons name id (32 bytes per name id) + // foreach (icon) + // { + // 12+32*i | 32 | char | Icon NameId + // } + + // Icons data: One bit per pixel, stored as unsigned int array (depends on icon size) + // S*S pixels/32bit per unsigned int = K unsigned int per icon + // foreach (icon) + // { + // ... | K | unsigned int | Icon Data + // } + + FILE *rgiFile = fopen(fileName, "rb"); + + char **guiIconsName = NULL; + + if (rgiFile != NULL) + { + char signature[5] = { 0 }; + short version = 0; + short reserved = 0; + short iconCount = 0; + short iconSize = 0; + + fread(signature, 1, 4, rgiFile); + fread(&version, sizeof(short), 1, rgiFile); + fread(&reserved, sizeof(short), 1, rgiFile); + fread(&iconCount, sizeof(short), 1, rgiFile); + fread(&iconSize, sizeof(short), 1, rgiFile); + + if ((signature[0] == 'r') && + (signature[1] == 'G') && + (signature[2] == 'I') && + (signature[3] == ' ')) + { + if (loadIconsName) + { + guiIconsName = (char **)RAYGUI_MALLOC(iconCount*sizeof(char **)); + for (int i = 0; i < iconCount; i++) + { + guiIconsName[i] = (char *)RAYGUI_MALLOC(RAYGUI_ICON_MAX_NAME_LENGTH); + fread(guiIconsName[i], 1, RAYGUI_ICON_MAX_NAME_LENGTH, rgiFile); + } + } + else fseek(rgiFile, iconCount*RAYGUI_ICON_MAX_NAME_LENGTH, SEEK_CUR); + + // Read icons data directly over internal icons array + fread(guiIconsPtr, sizeof(unsigned int), iconCount*(iconSize*iconSize/32), rgiFile); + } + + fclose(rgiFile); + } + + return guiIconsName; +} + +// Draw selected icon using rectangles pixel-by-pixel +void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color) +{ + #define BIT_CHECK(a,b) ((a) & (1u<<(b))) + + for (int i = 0, y = 0; i < RAYGUI_ICON_SIZE*RAYGUI_ICON_SIZE/32; i++) + { + for (int k = 0; k < 32; k++) + { + if (BIT_CHECK(guiIconsPtr[iconId*RAYGUI_ICON_DATA_ELEMENTS + i], k)) + { + #if !defined(RAYGUI_STANDALONE) + GuiDrawRectangle(RAYGUI_CLITERAL(Rectangle){ (float)posX + (k%RAYGUI_ICON_SIZE)*pixelSize, (float)posY + y*pixelSize, (float)pixelSize, (float)pixelSize }, 0, BLANK, color); + #endif + } + + if ((k == 15) || (k == 31)) y++; + } + } +} + +// Set icon drawing size +void GuiSetIconScale(int scale) +{ + if (scale >= 1) guiIconScale = scale; +} + +#endif // !RAYGUI_NO_ICONS + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- + +// Load style from memory +// WARNING: Binary files only +static void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize) +{ + unsigned char *fileDataPtr = (unsigned char *)fileData; + + char signature[5] = { 0 }; + short version = 0; + short reserved = 0; + int propertyCount = 0; + + memcpy(signature, fileDataPtr, 4); + memcpy(&version, fileDataPtr + 4, sizeof(short)); + memcpy(&reserved, fileDataPtr + 4 + 2, sizeof(short)); + memcpy(&propertyCount, fileDataPtr + 4 + 2 + 2, sizeof(int)); + fileDataPtr += 12; + + if ((signature[0] == 'r') && + (signature[1] == 'G') && + (signature[2] == 'S') && + (signature[3] == ' ')) + { + short controlId = 0; + short propertyId = 0; + unsigned int propertyValue = 0; + + for (int i = 0; i < propertyCount; i++) + { + memcpy(&controlId, fileDataPtr, sizeof(short)); + memcpy(&propertyId, fileDataPtr + 2, sizeof(short)); + memcpy(&propertyValue, fileDataPtr + 2 + 2, sizeof(unsigned int)); + fileDataPtr += 8; + + if (controlId == 0) // DEFAULT control + { + // If a DEFAULT property is loaded, it is propagated to all controls + // NOTE: All DEFAULT properties should be defined first in the file + GuiSetStyle(0, (int)propertyId, propertyValue); + + if (propertyId < RAYGUI_MAX_PROPS_BASE) for (int i = 1; i < RAYGUI_MAX_CONTROLS; i++) GuiSetStyle(i, (int)propertyId, propertyValue); + } + else GuiSetStyle((int)controlId, (int)propertyId, propertyValue); + } + + // Font loading is highly dependant on raylib API to load font data and image + +#if !defined(RAYGUI_STANDALONE) + // Load custom font if available + int fontDataSize = 0; + memcpy(&fontDataSize, fileDataPtr, sizeof(int)); + fileDataPtr += 4; + + if (fontDataSize > 0) + { + Font font = { 0 }; + int fontType = 0; // 0-Normal, 1-SDF + + memcpy(&font.baseSize, fileDataPtr, sizeof(int)); + memcpy(&font.glyphCount, fileDataPtr + 4, sizeof(int)); + memcpy(&fontType, fileDataPtr + 4 + 4, sizeof(int)); + fileDataPtr += 12; + + // Load font white rectangle + Rectangle fontWhiteRec = { 0 }; + memcpy(&fontWhiteRec, fileDataPtr, sizeof(Rectangle)); + fileDataPtr += 16; + + // Load font image parameters + int fontImageUncompSize = 0; + int fontImageCompSize = 0; + memcpy(&fontImageUncompSize, fileDataPtr, sizeof(int)); + memcpy(&fontImageCompSize, fileDataPtr + 4, sizeof(int)); + fileDataPtr += 8; + + Image imFont = { 0 }; + imFont.mipmaps = 1; + memcpy(&imFont.width, fileDataPtr, sizeof(int)); + memcpy(&imFont.height, fileDataPtr + 4, sizeof(int)); + memcpy(&imFont.format, fileDataPtr + 4 + 4, sizeof(int)); + fileDataPtr += 12; + + if ((fontImageCompSize > 0) && (fontImageCompSize != fontImageUncompSize)) + { + // Compressed font atlas image data (DEFLATE), it requires DecompressData() + int dataUncompSize = 0; + unsigned char *compData = (unsigned char *)RAYGUI_MALLOC(fontImageCompSize); + memcpy(compData, fileDataPtr, fontImageCompSize); + fileDataPtr += fontImageCompSize; + + imFont.data = DecompressData(compData, fontImageCompSize, &dataUncompSize); + + // Security check, dataUncompSize must match the provided fontImageUncompSize + if (dataUncompSize != fontImageUncompSize) RAYGUI_LOG("WARNING: Uncompressed font atlas image data could be corrupted"); + + RAYGUI_FREE(compData); + } + else + { + // Font atlas image data is not compressed + imFont.data = (unsigned char *)RAYGUI_MALLOC(fontImageUncompSize); + memcpy(imFont.data, fileDataPtr, fontImageUncompSize); + fileDataPtr += fontImageUncompSize; + } + + if (font.texture.id != GetFontDefault().texture.id) UnloadTexture(font.texture); + font.texture = LoadTextureFromImage(imFont); + + RAYGUI_FREE(imFont.data); + + // Validate font atlas texture was loaded correctly + if (font.texture.id != 0) + { + // Load font recs data + int recsDataSize = font.glyphCount*sizeof(Rectangle); + int recsDataCompressedSize = 0; + + // WARNING: Version 400 adds the compression size parameter + if (version >= 400) + { + // RGS files version 400 support compressed recs data + memcpy(&recsDataCompressedSize, fileDataPtr, sizeof(int)); + fileDataPtr += sizeof(int); + } + + if ((recsDataCompressedSize > 0) && (recsDataCompressedSize != recsDataSize)) + { + // Recs data is compressed, uncompress it + unsigned char *recsDataCompressed = (unsigned char *)RAYGUI_MALLOC(recsDataCompressedSize); + + memcpy(recsDataCompressed, fileDataPtr, recsDataCompressedSize); + fileDataPtr += recsDataCompressedSize; + + int recsDataUncompSize = 0; + font.recs = (Rectangle *)DecompressData(recsDataCompressed, recsDataCompressedSize, &recsDataUncompSize); + + // Security check, data uncompressed size must match the expected original data size + if (recsDataUncompSize != recsDataSize) RAYGUI_LOG("WARNING: Uncompressed font recs data could be corrupted"); + + RAYGUI_FREE(recsDataCompressed); + } + else + { + // Recs data is uncompressed + font.recs = (Rectangle *)RAYGUI_CALLOC(font.glyphCount, sizeof(Rectangle)); + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.recs[i], fileDataPtr, sizeof(Rectangle)); + fileDataPtr += sizeof(Rectangle); + } + } + + // Load font glyphs info data + int glyphsDataSize = font.glyphCount*16; // 16 bytes data per glyph + int glyphsDataCompressedSize = 0; + + // WARNING: Version 400 adds the compression size parameter + if (version >= 400) + { + // RGS files version 400 support compressed glyphs data + memcpy(&glyphsDataCompressedSize, fileDataPtr, sizeof(int)); + fileDataPtr += sizeof(int); + } + + // Allocate required glyphs space to fill with data + font.glyphs = (GlyphInfo *)RAYGUI_CALLOC(font.glyphCount, sizeof(GlyphInfo)); + + if ((glyphsDataCompressedSize > 0) && (glyphsDataCompressedSize != glyphsDataSize)) + { + // Glyphs data is compressed, uncompress it + unsigned char *glypsDataCompressed = (unsigned char *)RAYGUI_MALLOC(glyphsDataCompressedSize); + + memcpy(glypsDataCompressed, fileDataPtr, glyphsDataCompressedSize); + fileDataPtr += glyphsDataCompressedSize; + + int glyphsDataUncompSize = 0; + unsigned char *glyphsDataUncomp = DecompressData(glypsDataCompressed, glyphsDataCompressedSize, &glyphsDataUncompSize); + + // Security check, data uncompressed size must match the expected original data size + if (glyphsDataUncompSize != glyphsDataSize) RAYGUI_LOG("WARNING: Uncompressed font glyphs data could be corrupted"); + + unsigned char *glyphsDataUncompPtr = glyphsDataUncomp; + + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.glyphs[i].value, glyphsDataUncompPtr, sizeof(int)); + memcpy(&font.glyphs[i].offsetX, glyphsDataUncompPtr + 4, sizeof(int)); + memcpy(&font.glyphs[i].offsetY, glyphsDataUncompPtr + 8, sizeof(int)); + memcpy(&font.glyphs[i].advanceX, glyphsDataUncompPtr + 12, sizeof(int)); + glyphsDataUncompPtr += 16; + } + + RAYGUI_FREE(glypsDataCompressed); + RAYGUI_FREE(glyphsDataUncomp); + } + else + { + // Glyphs data is uncompressed + for (int i = 0; i < font.glyphCount; i++) + { + memcpy(&font.glyphs[i].value, fileDataPtr, sizeof(int)); + memcpy(&font.glyphs[i].offsetX, fileDataPtr + 4, sizeof(int)); + memcpy(&font.glyphs[i].offsetY, fileDataPtr + 8, sizeof(int)); + memcpy(&font.glyphs[i].advanceX, fileDataPtr + 12, sizeof(int)); + fileDataPtr += 16; + } + } + } + else font = GetFontDefault(); // Fallback in case of errors loading font atlas texture + + GuiSetFont(font); + + // Set font texture source rectangle to be used as white texture to draw shapes + // NOTE: It makes possible to draw shapes and text (full UI) in a single draw call + if ((fontWhiteRec.x > 0) && + (fontWhiteRec.y > 0) && + (fontWhiteRec.width > 0) && + (fontWhiteRec.height > 0)) SetShapesTexture(font.texture, fontWhiteRec); + } +#endif + } +} + +// Gui get text width considering icon +static int GetTextWidth(const char *text) +{ + #if !defined(ICON_TEXT_PADDING) + #define ICON_TEXT_PADDING 4 + #endif + + Vector2 textSize = { 0 }; + int textIconOffset = 0; + + if ((text != NULL) && (text[0] != '\0')) + { + if (text[0] == '#') + { + for (int i = 1; (i < 5) && (text[i] != '\0'); i++) + { + if (text[i] == '#') + { + textIconOffset = i; + break; + } + } + } + + text += textIconOffset; + + // Make sure guiFont is set, GuiGetStyle() initializes it lazynessly + float fontSize = (float)GuiGetStyle(DEFAULT, TEXT_SIZE); + + // Custom MeasureText() implementation + if ((guiFont.texture.id > 0) && (text != NULL)) + { + // Get size in bytes of text, considering end of line and line break + int size = 0; + for (int i = 0; i < MAX_LINE_BUFFER_SIZE; i++) + { + if ((text[i] != '\0') && (text[i] != '\n')) size++; + else break; + } + + float scaleFactor = fontSize/(float)guiFont.baseSize; + textSize.y = (float)guiFont.baseSize*scaleFactor; + float glyphWidth = 0.0f; + + for (int i = 0, codepointSize = 0; i < size; i += codepointSize) + { + int codepoint = GetCodepointNext(&text[i], &codepointSize); + int codepointIndex = GetGlyphIndex(guiFont, codepoint); + + if (guiFont.glyphs[codepointIndex].advanceX == 0) glyphWidth = ((float)guiFont.recs[codepointIndex].width*scaleFactor); + else glyphWidth = ((float)guiFont.glyphs[codepointIndex].advanceX*scaleFactor); + + textSize.x += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + } + + if (textIconOffset > 0) textSize.x += (RAYGUI_ICON_SIZE - ICON_TEXT_PADDING); + } + + return (int)textSize.x; +} + +// Get text bounds considering control bounds +static Rectangle GetTextBounds(int control, Rectangle bounds) +{ + Rectangle textBounds = bounds; + + textBounds.x = bounds.x + GuiGetStyle(control, BORDER_WIDTH); + textBounds.y = bounds.y + GuiGetStyle(control, BORDER_WIDTH) + GuiGetStyle(control, TEXT_PADDING); + textBounds.width = bounds.width - 2*GuiGetStyle(control, BORDER_WIDTH) - 2*GuiGetStyle(control, TEXT_PADDING); + textBounds.height = bounds.height - 2*GuiGetStyle(control, BORDER_WIDTH) - 2*GuiGetStyle(control, TEXT_PADDING); // NOTE: Text is processed line per line! + + // Depending on control, TEXT_PADDING and TEXT_ALIGNMENT properties could affect the text-bounds + switch (control) + { + case COMBOBOX: + case DROPDOWNBOX: + case LISTVIEW: + // TODO: Special cases (no label): COMBOBOX, DROPDOWNBOX, LISTVIEW + case SLIDER: + case CHECKBOX: + case VALUEBOX: + case SPINNER: + // TODO: More special cases (label on side): SLIDER, CHECKBOX, VALUEBOX, SPINNER + default: + { + // TODO: WARNING: TEXT_ALIGNMENT is already considered in GuiDrawText() + if (GuiGetStyle(control, TEXT_ALIGNMENT) == TEXT_ALIGN_RIGHT) textBounds.x -= GuiGetStyle(control, TEXT_PADDING); + else textBounds.x += GuiGetStyle(control, TEXT_PADDING); + } + break; + } + + return textBounds; +} + +// Get text icon if provided and move text cursor +// NOTE: We support up to 999 values for iconId +static const char *GetTextIcon(const char *text, int *iconId) +{ +#if !defined(RAYGUI_NO_ICONS) + *iconId = -1; + if (text[0] == '#') // Maybe we have an icon! + { + char iconValue[4] = { 0 }; // Maximum length for icon value: 3 digits + '\0' + + int pos = 1; + while ((pos < 4) && (text[pos] >= '0') && (text[pos] <= '9')) + { + iconValue[pos - 1] = text[pos]; + pos++; + } + + if (text[pos] == '#') + { + *iconId = TextToInteger(iconValue); + + // Move text pointer after icon + // WARNING: If only icon provided, it could point to EOL character: '\0' + if (*iconId >= 0) text += (pos + 1); + } + } +#endif + + return text; +} + +// Get text divided into lines (by line-breaks '\n') +const char **GetTextLines(const char *text, int *count) +{ + #define RAYGUI_MAX_TEXT_LINES 128 + + static const char *lines[RAYGUI_MAX_TEXT_LINES] = { 0 }; + for (int i = 0; i < RAYGUI_MAX_TEXT_LINES; i++) lines[i] = NULL; // Init NULL pointers to substrings + + int textSize = (int)strlen(text); + + lines[0] = text; + int len = 0; + *count = 1; + //int lineSize = 0; // Stores current line size, not returned + + for (int i = 0, k = 0; (i < textSize) && (*count < RAYGUI_MAX_TEXT_LINES); i++) + { + if (text[i] == '\n') + { + //lineSize = len; + k++; + lines[k] = &text[i + 1]; // WARNING: next value is valid? + len = 0; + *count += 1; + } + else len++; + } + + //lines[*count - 1].size = len; + + return lines; +} + +// Get text width to next space for provided string +static float GetNextSpaceWidth(const char *text, int *nextSpaceIndex) +{ + float width = 0; + int codepointByteCount = 0; + int codepoint = 0; + int index = 0; + float glyphWidth = 0; + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/guiFont.baseSize; + + for (int i = 0; text[i] != '\0'; i++) + { + if (text[i] != ' ') + { + codepoint = GetCodepoint(&text[i], &codepointByteCount); + index = GetGlyphIndex(guiFont, codepoint); + glyphWidth = (guiFont.glyphs[index].advanceX == 0)? guiFont.recs[index].width*scaleFactor : guiFont.glyphs[index].advanceX*scaleFactor; + width += (glyphWidth + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + else + { + *nextSpaceIndex = i; + break; + } + } + + return width; +} + +// Gui draw text using default font +static void GuiDrawText(const char *text, Rectangle textBounds, int alignment, Color tint) +{ + #define TEXT_VALIGN_PIXEL_OFFSET(h) ((int)h%2) // Vertical alignment for pixel perfect + + #if !defined(ICON_TEXT_PADDING) + #define ICON_TEXT_PADDING 4 + #endif + + if ((text == NULL) || (text[0] == '\0')) return; // Security check + + // PROCEDURE: + // - Text is processed line per line + // - For every line, horizontal alignment is defined + // - For all text, vertical alignment is defined (multiline text only) + // - For every line, wordwrap mode is checked (useful for GuitextBox(), read-only) + + // Get text lines (using '\n' as delimiter) to be processed individually + // WARNING: We can't use GuiTextSplit() function because it can be already used + // before the GuiDrawText() call and its buffer is static, it would be overriden :( + int lineCount = 0; + const char **lines = GetTextLines(text, &lineCount); + + // Text style variables + //int alignment = GuiGetStyle(DEFAULT, TEXT_ALIGNMENT); + int alignmentVertical = GuiGetStyle(DEFAULT, TEXT_ALIGNMENT_VERTICAL); + int wrapMode = GuiGetStyle(DEFAULT, TEXT_WRAP_MODE); // Wrap-mode only available in read-only mode, no for text editing + + // TODO: WARNING: This totalHeight is not valid for vertical alignment in case of word-wrap + float totalHeight = (float)(lineCount*GuiGetStyle(DEFAULT, TEXT_SIZE) + (lineCount - 1)*GuiGetStyle(DEFAULT, TEXT_SIZE)/2); + float posOffsetY = 0.0f; + + for (int i = 0; i < lineCount; i++) + { + int iconId = 0; + lines[i] = GetTextIcon(lines[i], &iconId); // Check text for icon and move cursor + + // Get text position depending on alignment and iconId + //--------------------------------------------------------------------------------- + Vector2 textBoundsPosition = { textBounds.x, textBounds.y }; + float textBoundsWidthOffset = 0.0f; + + // NOTE: We get text size after icon has been processed + // WARNING: GetTextWidth() also processes text icon to get width! -> Really needed? + int textSizeX = GetTextWidth(lines[i]); + + // If text requires an icon, add size to measure + if (iconId >= 0) + { + textSizeX += RAYGUI_ICON_SIZE*guiIconScale; + + // WARNING: If only icon provided, text could be pointing to EOF character: '\0' +#if !defined(RAYGUI_NO_ICONS) + if ((lines[i] != NULL) && (lines[i][0] != '\0')) textSizeX += ICON_TEXT_PADDING; +#endif + } + + // Check guiTextAlign global variables + switch (alignment) + { + case TEXT_ALIGN_LEFT: textBoundsPosition.x = textBounds.x; break; + case TEXT_ALIGN_CENTER: textBoundsPosition.x = textBounds.x + textBounds.width/2 - textSizeX/2; break; + case TEXT_ALIGN_RIGHT: textBoundsPosition.x = textBounds.x + textBounds.width - textSizeX; break; + default: break; + } + + if (textSizeX > textBounds.width && (lines[i] != NULL) && (lines[i][0] != '\0')) textBoundsPosition.x = textBounds.x; + + switch (alignmentVertical) + { + // Only valid in case of wordWrap = 0; + case TEXT_ALIGN_TOP: textBoundsPosition.y = textBounds.y + posOffsetY; break; + case TEXT_ALIGN_MIDDLE: textBoundsPosition.y = textBounds.y + posOffsetY + textBounds.height/2 - totalHeight/2 + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height); break; + case TEXT_ALIGN_BOTTOM: textBoundsPosition.y = textBounds.y + posOffsetY + textBounds.height - totalHeight + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height); break; + default: break; + } + + // NOTE: Make sure we get pixel-perfect coordinates, + // In case of decimals we got weird text positioning + textBoundsPosition.x = (float)((int)textBoundsPosition.x); + textBoundsPosition.y = (float)((int)textBoundsPosition.y); + //--------------------------------------------------------------------------------- + + // Draw text (with icon if available) + //--------------------------------------------------------------------------------- +#if !defined(RAYGUI_NO_ICONS) + if (iconId >= 0) + { + // NOTE: We consider icon height, probably different than text size + GuiDrawIcon(iconId, (int)textBoundsPosition.x, (int)(textBounds.y + textBounds.height/2 - RAYGUI_ICON_SIZE*guiIconScale/2 + TEXT_VALIGN_PIXEL_OFFSET(textBounds.height)), guiIconScale, tint); + textBoundsPosition.x += (float)(RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING); + textBoundsWidthOffset = (float)(RAYGUI_ICON_SIZE*guiIconScale + ICON_TEXT_PADDING); + } +#endif + // Get size in bytes of text, + // considering end of line and line break + int lineSize = 0; + for (int c = 0; (lines[i][c] != '\0') && (lines[i][c] != '\n') && (lines[i][c] != '\r'); c++, lineSize++){ } + float scaleFactor = (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/guiFont.baseSize; + + int lastSpaceIndex = 0; + bool tempWrapCharMode = false; + + int textOffsetY = 0; + float textOffsetX = 0.0f; + float glyphWidth = 0; + + int ellipsisWidth = GetTextWidth("..."); + bool overflowReached = false; + for (int c = 0, codepointSize = 0; c < lineSize; c += codepointSize) + { + int codepoint = GetCodepointNext(&lines[i][c], &codepointSize); + int index = GetGlyphIndex(guiFont, codepoint); + + // NOTE: Normally we exit the decoding sequence as soon as a bad byte is found (and return 0x3f) + // but we need to draw all of the bad bytes using the '?' symbol moving one byte + if (codepoint == 0x3f) codepointSize = 1; // TODO: Review not recognized codepoints size + + // Get glyph width to check if it goes out of bounds + if (guiFont.glyphs[index].advanceX == 0) glyphWidth = ((float)guiFont.recs[index].width*scaleFactor); + else glyphWidth = (float)guiFont.glyphs[index].advanceX*scaleFactor; + + // Wrap mode text measuring, to validate if + // it can be drawn or a new line is required + if (wrapMode == TEXT_WRAP_CHAR) + { + // Jump to next line if current character reach end of the box limits + if ((textOffsetX + glyphWidth) > textBounds.width - textBoundsWidthOffset) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + + if (tempWrapCharMode) // Wrap at char level when too long words + { + wrapMode = TEXT_WRAP_WORD; + tempWrapCharMode = false; + } + } + } + else if (wrapMode == TEXT_WRAP_WORD) + { + if (codepoint == 32) lastSpaceIndex = c; + + // Get width to next space in line + int nextSpaceIndex = 0; + float nextSpaceWidth = GetNextSpaceWidth(lines[i] + c, &nextSpaceIndex); + + int nextSpaceIndex2 = 0; + float nextWordSize = GetNextSpaceWidth(lines[i] + lastSpaceIndex + 1, &nextSpaceIndex2); + + if (nextWordSize > textBounds.width - textBoundsWidthOffset) + { + // Considering the case the next word is longer than bounds + tempWrapCharMode = true; + wrapMode = TEXT_WRAP_CHAR; + } + else if ((textOffsetX + nextSpaceWidth) > textBounds.width - textBoundsWidthOffset) + { + textOffsetX = 0.0f; + textOffsetY += GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + } + } + + if (codepoint == '\n') break; // WARNING: Lines are already processed manually, no need to keep drawing after this codepoint + else + { + // TODO: There are multiple types of spaces in Unicode, + // maybe it's a good idea to add support for more: http://jkorpela.fi/chars/spaces.html + if ((codepoint != ' ') && (codepoint != '\t')) // Do not draw codepoints with no glyph + { + if (wrapMode == TEXT_WRAP_NONE) + { + // Draw only required text glyphs fitting the textBounds.width + if (textSizeX > textBounds.width) + { + if (textOffsetX <= (textBounds.width - glyphWidth - textBoundsWidthOffset - ellipsisWidth)) + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + else if (!overflowReached) + { + overflowReached = true; + + for (int j = 0; j < ellipsisWidth; j += ellipsisWidth/3) + { + DrawTextCodepoint(guiFont, '.', RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX + j, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + } + else + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + else if ((wrapMode == TEXT_WRAP_CHAR) || (wrapMode == TEXT_WRAP_WORD)) + { + // Draw only glyphs inside the bounds + if ((textBoundsPosition.y + textOffsetY) <= (textBounds.y + textBounds.height - GuiGetStyle(DEFAULT, TEXT_SIZE))) + { + DrawTextCodepoint(guiFont, codepoint, RAYGUI_CLITERAL(Vector2){ textBoundsPosition.x + textOffsetX, textBoundsPosition.y + textOffsetY }, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), GuiFade(tint, guiAlpha)); + } + } + } + + if (guiFont.glyphs[index].advanceX == 0) textOffsetX += ((float)guiFont.recs[index].width*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + else textOffsetX += ((float)guiFont.glyphs[index].advanceX*scaleFactor + (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + } + } + + if (wrapMode == TEXT_WRAP_NONE) posOffsetY += (float)GuiGetStyle(DEFAULT, TEXT_LINE_SPACING); + else if ((wrapMode == TEXT_WRAP_CHAR) || (wrapMode == TEXT_WRAP_WORD)) posOffsetY += (textOffsetY + (float)GuiGetStyle(DEFAULT, TEXT_LINE_SPACING)); + //--------------------------------------------------------------------------------- + } + +#if defined(RAYGUI_DEBUG_TEXT_BOUNDS) + GuiDrawRectangle(textBounds, 0, WHITE, Fade(BLUE, 0.4f)); +#endif +} + +// Gui draw rectangle using default raygui plain style with borders +static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color) +{ + if (color.a > 0) + { + // Draw rectangle filled with color + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, GuiFade(color, guiAlpha)); + } + + if (borderWidth > 0) + { + // Draw rectangle border lines with color + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x + (int)rec.width - borderWidth, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, GuiFade(borderColor, guiAlpha)); + DrawRectangle((int)rec.x, (int)rec.y + (int)rec.height - borderWidth, (int)rec.width, borderWidth, GuiFade(borderColor, guiAlpha)); + } + +#if defined(RAYGUI_DEBUG_RECS_BOUNDS) + DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, Fade(RED, 0.4f)); +#endif +} + +// Draw tooltip using control bounds +static void GuiTooltip(Rectangle controlRec) +{ + if (!guiLocked && guiTooltip && (guiTooltipPtr != NULL) && !guiControlExclusiveMode) + { + Vector2 textSize = MeasureTextEx(GuiGetFont(), guiTooltipPtr, (float)GuiGetStyle(DEFAULT, TEXT_SIZE), (float)GuiGetStyle(DEFAULT, TEXT_SPACING)); + + if ((controlRec.x + textSize.x + 16) > GetScreenWidth()) controlRec.x -= (textSize.x + 16 - controlRec.width); + + GuiPanel(RAYGUI_CLITERAL(Rectangle){ controlRec.x, controlRec.y + controlRec.height + 4, textSize.x + 16, GuiGetStyle(DEFAULT, TEXT_SIZE) + 8.f }, NULL); + + int textPadding = GuiGetStyle(LABEL, TEXT_PADDING); + int textAlignment = GuiGetStyle(LABEL, TEXT_ALIGNMENT); + GuiSetStyle(LABEL, TEXT_PADDING, 0); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER); + GuiLabel(RAYGUI_CLITERAL(Rectangle){ controlRec.x, controlRec.y + controlRec.height + 4, textSize.x + 16, GuiGetStyle(DEFAULT, TEXT_SIZE) + 8.f }, guiTooltipPtr); + GuiSetStyle(LABEL, TEXT_ALIGNMENT, textAlignment); + GuiSetStyle(LABEL, TEXT_PADDING, textPadding); + } +} + +// Split controls text into multiple strings +// Also check for multiple columns (required by GuiToggleGroup()) +static const char **GuiTextSplit(const char *text, char delimiter, int *count, int *textRow) +{ + // NOTE: Current implementation returns a copy of the provided string with '\0' (string end delimiter) + // inserted between strings defined by "delimiter" parameter. No memory is dynamically allocated, + // all used memory is static... it has some limitations: + // 1. Maximum number of possible split strings is set by RAYGUI_TEXTSPLIT_MAX_ITEMS + // 2. Maximum size of text to split is RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE + // NOTE: Those definitions could be externally provided if required + + // TODO: HACK: GuiTextSplit() - Review how textRows are returned to user + // textRow is an externally provided array of integers that stores row number for every splitted string + + #if !defined(RAYGUI_TEXTSPLIT_MAX_ITEMS) + #define RAYGUI_TEXTSPLIT_MAX_ITEMS 128 + #endif + #if !defined(RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE) + #define RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE 1024 + #endif + + static const char *result[RAYGUI_TEXTSPLIT_MAX_ITEMS] = { NULL }; // String pointers array (points to buffer data) + static char buffer[RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE] = { 0 }; // Buffer data (text input copy with '\0' added) + memset(buffer, 0, RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE); + + result[0] = buffer; + int counter = 1; + + if (textRow != NULL) textRow[0] = 0; + + // Count how many substrings we have on text and point to every one + for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++) + { + buffer[i] = text[i]; + if (buffer[i] == '\0') break; + else if ((buffer[i] == delimiter) || (buffer[i] == '\n')) + { + result[counter] = buffer + i + 1; + + if (textRow != NULL) + { + if (buffer[i] == '\n') textRow[counter] = textRow[counter - 1] + 1; + else textRow[counter] = textRow[counter - 1]; + } + + buffer[i] = '\0'; // Set an end of string at this point + + counter++; + if (counter > RAYGUI_TEXTSPLIT_MAX_ITEMS) break; + } + } + + *count = counter; + + return result; +} + +// Convert color data from RGB to HSV +// NOTE: Color data should be passed normalized +static Vector3 ConvertRGBtoHSV(Vector3 rgb) +{ + Vector3 hsv = { 0 }; + float min = 0.0f; + float max = 0.0f; + float delta = 0.0f; + + min = (rgb.x < rgb.y)? rgb.x : rgb.y; + min = (min < rgb.z)? min : rgb.z; + + max = (rgb.x > rgb.y)? rgb.x : rgb.y; + max = (max > rgb.z)? max : rgb.z; + + hsv.z = max; // Value + delta = max - min; + + if (delta < 0.00001f) + { + hsv.y = 0.0f; + hsv.x = 0.0f; // Undefined, maybe NAN? + return hsv; + } + + if (max > 0.0f) + { + // NOTE: If max is 0, this divide would cause a crash + hsv.y = (delta/max); // Saturation + } + else + { + // NOTE: If max is 0, then r = g = b = 0, s = 0, h is undefined + hsv.y = 0.0f; + hsv.x = 0.0f; // Undefined, maybe NAN? + return hsv; + } + + // NOTE: Comparing float values could not work properly + if (rgb.x >= max) hsv.x = (rgb.y - rgb.z)/delta; // Between yellow & magenta + else + { + if (rgb.y >= max) hsv.x = 2.0f + (rgb.z - rgb.x)/delta; // Between cyan & yellow + else hsv.x = 4.0f + (rgb.x - rgb.y)/delta; // Between magenta & cyan + } + + hsv.x *= 60.0f; // Convert to degrees + + if (hsv.x < 0.0f) hsv.x += 360.0f; + + return hsv; +} + +// Convert color data from HSV to RGB +// NOTE: Color data should be passed normalized +static Vector3 ConvertHSVtoRGB(Vector3 hsv) +{ + Vector3 rgb = { 0 }; + float hh = 0.0f, p = 0.0f, q = 0.0f, t = 0.0f, ff = 0.0f; + long i = 0; + + // NOTE: Comparing float values could not work properly + if (hsv.y <= 0.0f) + { + rgb.x = hsv.z; + rgb.y = hsv.z; + rgb.z = hsv.z; + return rgb; + } + + hh = hsv.x; + if (hh >= 360.0f) hh = 0.0f; + hh /= 60.0f; + + i = (long)hh; + ff = hh - i; + p = hsv.z*(1.0f - hsv.y); + q = hsv.z*(1.0f - (hsv.y*ff)); + t = hsv.z*(1.0f - (hsv.y*(1.0f - ff))); + + switch (i) + { + case 0: + { + rgb.x = hsv.z; + rgb.y = t; + rgb.z = p; + } break; + case 1: + { + rgb.x = q; + rgb.y = hsv.z; + rgb.z = p; + } break; + case 2: + { + rgb.x = p; + rgb.y = hsv.z; + rgb.z = t; + } break; + case 3: + { + rgb.x = p; + rgb.y = q; + rgb.z = hsv.z; + } break; + case 4: + { + rgb.x = t; + rgb.y = p; + rgb.z = hsv.z; + } break; + case 5: + default: + { + rgb.x = hsv.z; + rgb.y = p; + rgb.z = q; + } break; + } + + return rgb; +} + +// Scroll bar control (used by GuiScrollPanel()) +static int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue) +{ + GuiState state = guiState; + + // Is the scrollbar horizontal or vertical? + bool isVertical = (bounds.width > bounds.height)? false : true; + + // The size (width or height depending on scrollbar type) of the spinner buttons + const int spinnerSize = GuiGetStyle(SCROLLBAR, ARROWS_VISIBLE)? + (isVertical? (int)bounds.width - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH) : + (int)bounds.height - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH)) : 0; + + // Arrow buttons [<] [>] [∧] [∨] + Rectangle arrowUpLeft = { 0 }; + Rectangle arrowDownRight = { 0 }; + + // Actual area of the scrollbar excluding the arrow buttons + Rectangle scrollbar = { 0 }; + + // Slider bar that moves --[///]----- + Rectangle slider = { 0 }; + + // Normalize value + if (value > maxValue) value = maxValue; + if (value < minValue) value = minValue; + + int valueRange = maxValue - minValue; + if (valueRange <= 0) valueRange = 1; + + int sliderSize = GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_SIZE); + if (sliderSize < 1) sliderSize = 1; // TODO: Consider a minimum slider size + + // Calculate rectangles for all of the components + arrowUpLeft = RAYGUI_CLITERAL(Rectangle){ + (float)bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), + (float)bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), + (float)spinnerSize, (float)spinnerSize }; + + if (isVertical) + { + arrowDownRight = RAYGUI_CLITERAL(Rectangle){ (float)bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)bounds.y + bounds.height - spinnerSize - GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)spinnerSize, (float)spinnerSize }; + scrollbar = RAYGUI_CLITERAL(Rectangle){ bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING), arrowUpLeft.y + arrowUpLeft.height, bounds.width - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING)), bounds.height - arrowUpLeft.height - arrowDownRight.height - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH) }; + + // Make sure the slider won't get outside of the scrollbar + sliderSize = (sliderSize >= scrollbar.height)? ((int)scrollbar.height - 2) : sliderSize; + slider = RAYGUI_CLITERAL(Rectangle){ + bounds.x + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), + scrollbar.y + (int)(((float)(value - minValue)/valueRange)*(scrollbar.height - sliderSize)), + bounds.width - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)), + (float)sliderSize }; + } + else // horizontal + { + arrowDownRight = RAYGUI_CLITERAL(Rectangle){ (float)bounds.x + bounds.width - spinnerSize - GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH), (float)spinnerSize, (float)spinnerSize }; + scrollbar = RAYGUI_CLITERAL(Rectangle){ arrowUpLeft.x + arrowUpLeft.width, bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING), bounds.width - arrowUpLeft.width - arrowDownRight.width - 2*GuiGetStyle(SCROLLBAR, BORDER_WIDTH), bounds.height - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_PADDING)) }; + + // Make sure the slider won't get outside of the scrollbar + sliderSize = (sliderSize >= scrollbar.width)? ((int)scrollbar.width - 2) : sliderSize; + slider = RAYGUI_CLITERAL(Rectangle){ + scrollbar.x + (int)(((float)(value - minValue)/valueRange)*(scrollbar.width - sliderSize)), + bounds.y + GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING), + (float)sliderSize, + bounds.height - 2*(GuiGetStyle(SCROLLBAR, BORDER_WIDTH) + GuiGetStyle(SCROLLBAR, SCROLL_SLIDER_PADDING)) }; + } + + // Update control + //-------------------------------------------------------------------- + if ((state != STATE_DISABLED) && !guiLocked) + { + Vector2 mousePoint = GetMousePosition(); + + if (guiControlExclusiveMode) // Allows to keep dragging outside of bounds + { + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON) && + !CheckCollisionPointRec(mousePoint, arrowUpLeft) && + !CheckCollisionPointRec(mousePoint, arrowDownRight)) + { + if (CHECK_BOUNDS_ID(bounds, guiControlExclusiveRec)) + { + state = STATE_PRESSED; + + if (isVertical) value = (int)(((float)(mousePoint.y - scrollbar.y - slider.height/2)*valueRange)/(scrollbar.height - slider.height) + minValue); + else value = (int)(((float)(mousePoint.x - scrollbar.x - slider.width/2)*valueRange)/(scrollbar.width - slider.width) + minValue); + } + } + else + { + guiControlExclusiveMode = false; + guiControlExclusiveRec = RAYGUI_CLITERAL(Rectangle){ 0, 0, 0, 0 }; + } + } + else if (CheckCollisionPointRec(mousePoint, bounds)) + { + state = STATE_FOCUSED; + + // Handle mouse wheel + int wheel = (int)GetMouseWheelMove(); + if (wheel != 0) value += wheel; + + // Handle mouse button down + if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + { + guiControlExclusiveMode = true; + guiControlExclusiveRec = bounds; // Store bounds as an identifier when dragging starts + + // Check arrows click + if (CheckCollisionPointRec(mousePoint, arrowUpLeft)) value -= valueRange/GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + else if (CheckCollisionPointRec(mousePoint, arrowDownRight)) value += valueRange/GuiGetStyle(SCROLLBAR, SCROLL_SPEED); + else if (!CheckCollisionPointRec(mousePoint, slider)) + { + // If click on scrollbar position but not on slider, place slider directly on that position + if (isVertical) value = (int)(((float)(mousePoint.y - scrollbar.y - slider.height/2)*valueRange)/(scrollbar.height - slider.height) + minValue); + else value = (int)(((float)(mousePoint.x - scrollbar.x - slider.width/2)*valueRange)/(scrollbar.width - slider.width) + minValue); + } + + state = STATE_PRESSED; + } + + // Keyboard control on mouse hover scrollbar + /* + if (isVertical) + { + if (IsKeyDown(KEY_DOWN)) value += 5; + else if (IsKeyDown(KEY_UP)) value -= 5; + } + else + { + if (IsKeyDown(KEY_RIGHT)) value += 5; + else if (IsKeyDown(KEY_LEFT)) value -= 5; + } + */ + } + + // Normalize value + if (value > maxValue) value = maxValue; + if (value < minValue) value = minValue; + } + //-------------------------------------------------------------------- + + // Draw control + //-------------------------------------------------------------------- + GuiDrawRectangle(bounds, GuiGetStyle(SCROLLBAR, BORDER_WIDTH), GetColor(GuiGetStyle(LISTVIEW, BORDER + state*3)), GetColor(GuiGetStyle(DEFAULT, BORDER_COLOR_DISABLED))); // Draw the background + + GuiDrawRectangle(scrollbar, 0, BLANK, GetColor(GuiGetStyle(BUTTON, BASE_COLOR_NORMAL))); // Draw the scrollbar active area background + GuiDrawRectangle(slider, 0, BLANK, GetColor(GuiGetStyle(SLIDER, BORDER + state*3))); // Draw the slider bar + + // Draw arrows (using icon if available) + if (GuiGetStyle(SCROLLBAR, ARROWS_VISIBLE)) + { +#if defined(RAYGUI_NO_ICONS) + GuiDrawText(isVertical? "^" : "<", + RAYGUI_CLITERAL(Rectangle){ arrowUpLeft.x, arrowUpLeft.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); + GuiDrawText(isVertical? "v" : ">", + RAYGUI_CLITERAL(Rectangle){ arrowDownRight.x, arrowDownRight.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(DROPDOWNBOX, TEXT + (state*3)))); +#else + GuiDrawText(isVertical? "#121#" : "#118#", + RAYGUI_CLITERAL(Rectangle){ arrowUpLeft.x, arrowUpLeft.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3))); // ICON_ARROW_UP_FILL / ICON_ARROW_LEFT_FILL + GuiDrawText(isVertical? "#120#" : "#119#", + RAYGUI_CLITERAL(Rectangle){ arrowDownRight.x, arrowDownRight.y, isVertical? bounds.width : bounds.height, isVertical? bounds.width : bounds.height }, + TEXT_ALIGN_CENTER, GetColor(GuiGetStyle(SCROLLBAR, TEXT + state*3))); // ICON_ARROW_DOWN_FILL / ICON_ARROW_RIGHT_FILL +#endif + } + //-------------------------------------------------------------------- + + return value; +} + +// Color fade-in or fade-out, alpha goes from 0.0f to 1.0f +// WARNING: It multiplies current alpha by alpha scale factor +static Color GuiFade(Color color, float alpha) +{ + if (alpha < 0.0f) alpha = 0.0f; + else if (alpha > 1.0f) alpha = 1.0f; + + Color result = { color.r, color.g, color.b, (unsigned char)(color.a*alpha) }; + + return result; +} + +#if defined(RAYGUI_STANDALONE) +// Returns a Color struct from hexadecimal value +static Color GetColor(int hexValue) +{ + Color color; + + color.r = (unsigned char)(hexValue >> 24) & 0xFF; + color.g = (unsigned char)(hexValue >> 16) & 0xFF; + color.b = (unsigned char)(hexValue >> 8) & 0xFF; + color.a = (unsigned char)hexValue & 0xFF; + + return color; +} + +// Returns hexadecimal value for a Color +static int ColorToInt(Color color) +{ + return (((int)color.r << 24) | ((int)color.g << 16) | ((int)color.b << 8) | (int)color.a); +} + +// Check if point is inside rectangle +static bool CheckCollisionPointRec(Vector2 point, Rectangle rec) +{ + bool collision = false; + + if ((point.x >= rec.x) && (point.x <= (rec.x + rec.width)) && + (point.y >= rec.y) && (point.y <= (rec.y + rec.height))) collision = true; + + return collision; +} + +// Formatting of text with variables to 'embed' +static const char *TextFormat(const char *text, ...) +{ + #if !defined(RAYGUI_TEXTFORMAT_MAX_SIZE) + #define RAYGUI_TEXTFORMAT_MAX_SIZE 256 + #endif + + static char buffer[RAYGUI_TEXTFORMAT_MAX_SIZE]; + + va_list args; + va_start(args, text); + vsprintf(buffer, text, args); + va_end(args); + + return buffer; +} + +// Draw rectangle with vertical gradient fill color +// NOTE: This function is only used by GuiColorPicker() +static void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2) +{ + Rectangle bounds = { (float)posX, (float)posY, (float)width, (float)height }; + DrawRectangleGradientEx(bounds, color1, color2, color2, color1); +} + +// Split string into multiple strings +const char **TextSplit(const char *text, char delimiter, int *count) +{ + // NOTE: Current implementation returns a copy of the provided string with '\0' (string end delimiter) + // inserted between strings defined by "delimiter" parameter. No memory is dynamically allocated, + // all used memory is static... it has some limitations: + // 1. Maximum number of possible split strings is set by RAYGUI_TEXTSPLIT_MAX_ITEMS + // 2. Maximum size of text to split is RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE + + #if !defined(RAYGUI_TEXTSPLIT_MAX_ITEMS) + #define RAYGUI_TEXTSPLIT_MAX_ITEMS 128 + #endif + #if !defined(RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE) + #define RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE 1024 + #endif + + static const char *result[RAYGUI_TEXTSPLIT_MAX_ITEMS] = { NULL }; + static char buffer[RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE] = { 0 }; + memset(buffer, 0, RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE); + + result[0] = buffer; + int counter = 0; + + if (text != NULL) + { + counter = 1; + + // Count how many substrings we have on text and point to every one + for (int i = 0; i < RAYGUI_TEXTSPLIT_MAX_TEXT_SIZE; i++) + { + buffer[i] = text[i]; + if (buffer[i] == '\0') break; + else if (buffer[i] == delimiter) + { + buffer[i] = '\0'; // Set an end of string at this point + result[counter] = buffer + i + 1; + counter++; + + if (counter == RAYGUI_TEXTSPLIT_MAX_ITEMS) break; + } + } + } + + *count = counter; + return result; +} + +// Get integer value from text +// NOTE: This function replaces atoi() [stdlib.h] +static int TextToInteger(const char *text) +{ + int value = 0; + int sign = 1; + + if ((text[0] == '+') || (text[0] == '-')) + { + if (text[0] == '-') sign = -1; + text++; + } + + for (int i = 0; ((text[i] >= '0') && (text[i] <= '9')); ++i) value = value*10 + (int)(text[i] - '0'); + + return value*sign; +} + +// Encode codepoint into UTF-8 text (char array size returned as parameter) +static const char *CodepointToUTF8(int codepoint, int *byteSize) +{ + static char utf8[6] = { 0 }; + int size = 0; + + if (codepoint <= 0x7f) + { + utf8[0] = (char)codepoint; + size = 1; + } + else if (codepoint <= 0x7ff) + { + utf8[0] = (char)(((codepoint >> 6) & 0x1f) | 0xc0); + utf8[1] = (char)((codepoint & 0x3f) | 0x80); + size = 2; + } + else if (codepoint <= 0xffff) + { + utf8[0] = (char)(((codepoint >> 12) & 0x0f) | 0xe0); + utf8[1] = (char)(((codepoint >> 6) & 0x3f) | 0x80); + utf8[2] = (char)((codepoint & 0x3f) | 0x80); + size = 3; + } + else if (codepoint <= 0x10ffff) + { + utf8[0] = (char)(((codepoint >> 18) & 0x07) | 0xf0); + utf8[1] = (char)(((codepoint >> 12) & 0x3f) | 0x80); + utf8[2] = (char)(((codepoint >> 6) & 0x3f) | 0x80); + utf8[3] = (char)((codepoint & 0x3f) | 0x80); + size = 4; + } + + *byteSize = size; + + return utf8; +} + +// Get next codepoint in a UTF-8 encoded text, scanning until '\0' is found +// When a invalid UTF-8 byte is encountered we exit as soon as possible and a '?'(0x3f) codepoint is returned +// Total number of bytes processed are returned as a parameter +// NOTE: the standard says U+FFFD should be returned in case of errors +// but that character is not supported by the default font in raylib +static int GetCodepointNext(const char *text, int *codepointSize) +{ + const char *ptr = text; + int codepoint = 0x3f; // Codepoint (defaults to '?') + *codepointSize = 1; + + // Get current codepoint and bytes processed + if (0xf0 == (0xf8 & ptr[0])) + { + // 4 byte UTF-8 codepoint + if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80) || ((ptr[3] & 0xC0) ^ 0x80)) { return codepoint; } //10xxxxxx checks + codepoint = ((0x07 & ptr[0]) << 18) | ((0x3f & ptr[1]) << 12) | ((0x3f & ptr[2]) << 6) | (0x3f & ptr[3]); + *codepointSize = 4; + } + else if (0xe0 == (0xf0 & ptr[0])) + { + // 3 byte UTF-8 codepoint */ + if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80)) { return codepoint; } //10xxxxxx checks + codepoint = ((0x0f & ptr[0]) << 12) | ((0x3f & ptr[1]) << 6) | (0x3f & ptr[2]); + *codepointSize = 3; + } + else if (0xc0 == (0xe0 & ptr[0])) + { + // 2 byte UTF-8 codepoint + if ((ptr[1] & 0xC0) ^ 0x80) { return codepoint; } //10xxxxxx checks + codepoint = ((0x1f & ptr[0]) << 6) | (0x3f & ptr[1]); + *codepointSize = 2; + } + else if (0x00 == (0x80 & ptr[0])) + { + // 1 byte UTF-8 codepoint + codepoint = ptr[0]; + *codepointSize = 1; + } + + return codepoint; +} +#endif // RAYGUI_STANDALONE + +#endif // RAYGUI_IMPLEMENTATION diff --git a/lib/raylib-4.5.0_win64_msvc16/include/raylib.h b/lib/raylib-4.5.0_win64_msvc16/include/raylib.h new file mode 100644 index 0000000..4cd9e43 --- /dev/null +++ b/lib/raylib-4.5.0_win64_msvc16/include/raylib.h @@ -0,0 +1,1588 @@ +/********************************************************************************************** +* +* raylib v4.5 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) +* +* FEATURES: +* - NO external dependencies, all required libraries included with raylib +* - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, +* MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5. +* - Written in plain C code (C99) in PascalCase/camelCase notation +* - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile) +* - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] +* - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts) +* - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) +* - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! +* - Flexible Materials system, supporting classic maps and PBR maps +* - Animated 3D models supported (skeletal bones animation) (IQM) +* - Shaders support, including Model shaders and Postprocessing shaders +* - Powerful math module for Vector, Matrix and Quaternion operations: [raymath] +* - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) +* - VR stereo rendering with configurable HMD device parameters +* - Bindings to multiple programming languages available! +* +* NOTES: +* - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text] +* - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2) +* - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2) +* - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2) +* +* DEPENDENCIES (included): +* [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP) +* [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP) +* [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management +* +* OPTIONAL DEPENDENCIES (included): +* [rcore] msf_gif (Miles Fogle) for GIF recording +* [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm +* [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm +* [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) +* [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG) +* [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms +* [rtext] stb_truetype (Sean Barret) for ttf fonts loading +* [rtext] stb_rect_pack (Sean Barret) for rectangles packing +* [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation +* [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) +* [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF) +* [rmodels] Model3D (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d) +* [raudio] dr_wav (David Reid) for WAV audio file loading +* [raudio] dr_flac (David Reid) for FLAC audio file loading +* [raudio] dr_mp3 (David Reid) for MP3 audio file loading +* [raudio] stb_vorbis (Sean Barret) for OGG audio loading +* [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading +* [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading +* +* +* LICENSE: zlib/libpng +* +* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYLIB_H +#define RAYLIB_H + +#include // Required for: va_list - Only used by TraceLogCallback + +#define RAYLIB_VERSION_MAJOR 4 +#define RAYLIB_VERSION_MINOR 5 +#define RAYLIB_VERSION_PATCH 0 +#define RAYLIB_VERSION "4.5" + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #if defined(__TINYC__) + #define __declspec(x) __attribute__((x)) + #endif + #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +#ifndef RLAPI + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +//---------------------------------------------------------------------------------- +// Some basic Defines +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +// Allow custom memory allocators +// NOTE: Require recompiling raylib sources +#ifndef RL_MALLOC + #define RL_MALLOC(sz) malloc(sz) +#endif +#ifndef RL_CALLOC + #define RL_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RL_REALLOC + #define RL_REALLOC(ptr,sz) realloc(ptr,sz) +#endif +#ifndef RL_FREE + #define RL_FREE(ptr) free(ptr) +#endif + +// NOTE: MSVC C++ compiler does not support compound literals (C99 feature) +// Plain structures in C++ (without constructors) can be initialized with { } +#if defined(__cplusplus) + #define CLITERAL(type) type +#else + #define CLITERAL(type) (type) +#endif + +// NOTE: We set some defines with some data types declared by raylib +// Other modules (raymath, rlgl) also require some of those types, so, +// to be able to use those other modules as standalone (not depending on raylib) +// this defines are very useful for internal check and avoid type (re)definitions +#define RL_COLOR_TYPE +#define RL_RECTANGLE_TYPE +#define RL_VECTOR2_TYPE +#define RL_VECTOR3_TYPE +#define RL_VECTOR4_TYPE +#define RL_QUATERNION_TYPE +#define RL_MATRIX_TYPE + +// Some Basic Colors +// NOTE: Custom raylib color palette for amazing visuals on WHITE background +#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray +#define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray +#define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray +#define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow +#define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold +#define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange +#define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink +#define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red +#define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon +#define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green +#define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime +#define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green +#define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue +#define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue +#define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue +#define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple +#define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet +#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple +#define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige +#define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown +#define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown + +#define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White +#define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black +#define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent) +#define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta +#define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo) + +//---------------------------------------------------------------------------------- +// Structures Definition +//---------------------------------------------------------------------------------- +// Boolean type +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) + typedef enum bool { false = 0, true = !false } bool; + #define RL_BOOL_TYPE +#endif + +// Vector2, 2 components +typedef struct Vector2 { + float x; // Vector x component + float y; // Vector y component +} Vector2; + +// Vector3, 3 components +typedef struct Vector3 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component +} Vector3; + +// Vector4, 4 components +typedef struct Vector4 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component + float w; // Vector w component +} Vector4; + +// Quaternion, 4 components (Vector4 alias) +typedef Vector4 Quaternion; + +// Matrix, 4x4 components, column major, OpenGL style, right-handed +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; + +// Color, 4 components, R8G8B8A8 (32bit) +typedef struct Color { + unsigned char r; // Color red value + unsigned char g; // Color green value + unsigned char b; // Color blue value + unsigned char a; // Color alpha value +} Color; + +// Rectangle, 4 components +typedef struct Rectangle { + float x; // Rectangle top-left corner position x + float y; // Rectangle top-left corner position y + float width; // Rectangle width + float height; // Rectangle height +} Rectangle; + +// Image, pixel data stored in CPU memory (RAM) +typedef struct Image { + void *data; // Image raw data + int width; // Image base width + int height; // Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) +} Image; + +// Texture, tex data stored in GPU memory (VRAM) +typedef struct Texture { + unsigned int id; // OpenGL texture id + int width; // Texture base width + int height; // Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) +} Texture; + +// Texture2D, same as Texture +typedef Texture Texture2D; + +// TextureCubemap, same as Texture +typedef Texture TextureCubemap; + +// RenderTexture, fbo for texture rendering +typedef struct RenderTexture { + unsigned int id; // OpenGL framebuffer object id + Texture texture; // Color buffer attachment texture + Texture depth; // Depth buffer attachment texture +} RenderTexture; + +// RenderTexture2D, same as RenderTexture +typedef RenderTexture RenderTexture2D; + +// NPatchInfo, n-patch layout info +typedef struct NPatchInfo { + Rectangle source; // Texture source rectangle + int left; // Left border offset + int top; // Top border offset + int right; // Right border offset + int bottom; // Bottom border offset + int layout; // Layout of the n-patch: 3x3, 1x3 or 3x1 +} NPatchInfo; + +// GlyphInfo, font characters glyphs info +typedef struct GlyphInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + Image image; // Character image data +} GlyphInfo; + +// Font, font texture and GlyphInfo array data +typedef struct Font { + int baseSize; // Base size (default chars height) + int glyphCount; // Number of glyph characters + int glyphPadding; // Padding around the glyph characters + Texture2D texture; // Texture atlas containing the glyphs + Rectangle *recs; // Rectangles in texture for the glyphs + GlyphInfo *glyphs; // Glyphs info data +} Font; + +// Camera, defines position/orientation in 3d space +typedef struct Camera3D { + Vector3 position; // Camera position + Vector3 target; // Camera target it looks-at + Vector3 up; // Camera up vector (rotation over its axis) + float fovy; // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic + int projection; // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC +} Camera3D; + +typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D + +// Camera2D, defines position/orientation in 2d space +typedef struct Camera2D { + Vector2 offset; // Camera offset (displacement from target) + Vector2 target; // Camera target (rotation and zoom origin) + float rotation; // Camera rotation in degrees + float zoom; // Camera zoom (scaling), should be 1.0f by default +} Camera2D; + +// Mesh, vertex data and vao/vbo +typedef struct Mesh { + int vertexCount; // Number of vertices stored in arrays + int triangleCount; // Number of triangles stored (indexed or not) + + // Vertex attributes data + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + float *texcoords2; // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5) + float *normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2) + float *tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) + unsigned short *indices; // Vertex indices (in case vertex data comes indexed) + + // Animation vertex data + float *animVertices; // Animated vertex positions (after bones transformations) + float *animNormals; // Animated normals (after bones transformations) + unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning) + float *boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning) + + // OpenGL identifiers + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int *vboId; // OpenGL Vertex Buffer Objects id (default vertex data) +} Mesh; + +// Shader +typedef struct Shader { + unsigned int id; // Shader program id + int *locs; // Shader locations array (RL_MAX_SHADER_LOCATIONS) +} Shader; + +// MaterialMap +typedef struct MaterialMap { + Texture2D texture; // Material map texture + Color color; // Material map color + float value; // Material map value +} MaterialMap; + +// Material, includes shader and maps +typedef struct Material { + Shader shader; // Material shader + MaterialMap *maps; // Material maps array (MAX_MATERIAL_MAPS) + float params[4]; // Material generic parameters (if required) +} Material; + +// Transform, vertex transformation data +typedef struct Transform { + Vector3 translation; // Translation + Quaternion rotation; // Rotation + Vector3 scale; // Scale +} Transform; + +// Bone, skeletal animation bone +typedef struct BoneInfo { + char name[32]; // Bone name + int parent; // Bone parent +} BoneInfo; + +// Model, meshes, materials and animation data +typedef struct Model { + Matrix transform; // Local transform matrix + + int meshCount; // Number of meshes + int materialCount; // Number of materials + Mesh *meshes; // Meshes array + Material *materials; // Materials array + int *meshMaterial; // Mesh material number + + // Animation data + int boneCount; // Number of bones + BoneInfo *bones; // Bones information (skeleton) + Transform *bindPose; // Bones base transformation (pose) +} Model; + +// ModelAnimation +typedef struct ModelAnimation { + int boneCount; // Number of bones + int frameCount; // Number of animation frames + BoneInfo *bones; // Bones information (skeleton) + Transform **framePoses; // Poses array by frame +} ModelAnimation; + +// Ray, ray for raycasting +typedef struct Ray { + Vector3 position; // Ray position (origin) + Vector3 direction; // Ray direction +} Ray; + +// RayCollision, ray hit information +typedef struct RayCollision { + bool hit; // Did the ray hit something? + float distance; // Distance to the nearest hit + Vector3 point; // Point of the nearest hit + Vector3 normal; // Surface normal of hit +} RayCollision; + +// BoundingBox +typedef struct BoundingBox { + Vector3 min; // Minimum vertex box-corner + Vector3 max; // Maximum vertex box-corner +} BoundingBox; + +// Wave, audio wave data +typedef struct Wave { + unsigned int frameCount; // Total number of frames (considering channels) + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) + void *data; // Buffer data pointer +} Wave; + +// Opaque structs declaration +// NOTE: Actual structs are defined internally in raudio module +typedef struct rAudioBuffer rAudioBuffer; +typedef struct rAudioProcessor rAudioProcessor; + +// AudioStream, custom audio stream +typedef struct AudioStream { + rAudioBuffer *buffer; // Pointer to internal data used by the audio system + rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects + + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) +} AudioStream; + +// Sound +typedef struct Sound { + AudioStream stream; // Audio stream + unsigned int frameCount; // Total number of frames (considering channels) +} Sound; + +// Music, audio stream, anything longer than ~10 seconds should be streamed +typedef struct Music { + AudioStream stream; // Audio stream + unsigned int frameCount; // Total number of frames (considering channels) + bool looping; // Music looping enable + + int ctxType; // Type of music context (audio filetype) + void *ctxData; // Audio context data, depends on type +} Music; + +// VrDeviceInfo, Head-Mounted-Display device parameters +typedef struct VrDeviceInfo { + int hResolution; // Horizontal resolution in pixels + int vResolution; // Vertical resolution in pixels + float hScreenSize; // Horizontal size in meters + float vScreenSize; // Vertical size in meters + float vScreenCenter; // Screen center in meters + float eyeToScreenDistance; // Distance between eye and display in meters + float lensSeparationDistance; // Lens separation distance in meters + float interpupillaryDistance; // IPD (distance between pupils) in meters + float lensDistortionValues[4]; // Lens distortion constant parameters + float chromaAbCorrection[4]; // Chromatic aberration correction parameters +} VrDeviceInfo; + +// VrStereoConfig, VR stereo rendering configuration for simulator +typedef struct VrStereoConfig { + Matrix projection[2]; // VR projection matrices (per eye) + Matrix viewOffset[2]; // VR view offset matrices (per eye) + float leftLensCenter[2]; // VR left lens center + float rightLensCenter[2]; // VR right lens center + float leftScreenCenter[2]; // VR left screen center + float rightScreenCenter[2]; // VR right screen center + float scale[2]; // VR distortion scale + float scaleIn[2]; // VR distortion scale in +} VrStereoConfig; + +// File path list +typedef struct FilePathList { + unsigned int capacity; // Filepaths max entries + unsigned int count; // Filepaths entries count + char **paths; // Filepaths entries +} FilePathList; + +//---------------------------------------------------------------------------------- +// Enumerators Definition +//---------------------------------------------------------------------------------- +// System/Window config flags +// NOTE: Every bit registers one state (use it with bit masks) +// By default all flags are set to 0 +typedef enum { + FLAG_VSYNC_HINT = 0x00000040, // Set to try enabling V-Sync on GPU + FLAG_FULLSCREEN_MODE = 0x00000002, // Set to run program in fullscreen + FLAG_WINDOW_RESIZABLE = 0x00000004, // Set to allow resizable window + FLAG_WINDOW_UNDECORATED = 0x00000008, // Set to disable window decoration (frame and buttons) + FLAG_WINDOW_HIDDEN = 0x00000080, // Set to hide window + FLAG_WINDOW_MINIMIZED = 0x00000200, // Set to minimize window (iconify) + FLAG_WINDOW_MAXIMIZED = 0x00000400, // Set to maximize window (expanded to monitor) + FLAG_WINDOW_UNFOCUSED = 0x00000800, // Set to window non focused + FLAG_WINDOW_TOPMOST = 0x00001000, // Set to window always on top + FLAG_WINDOW_ALWAYS_RUN = 0x00000100, // Set to allow windows running while minimized + FLAG_WINDOW_TRANSPARENT = 0x00000010, // Set to allow transparent framebuffer + FLAG_WINDOW_HIGHDPI = 0x00002000, // Set to support HighDPI + FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED + FLAG_MSAA_4X_HINT = 0x00000020, // Set to try enabling MSAA 4X + FLAG_INTERLACED_HINT = 0x00010000 // Set to try enabling interlaced video format (for V3D) +} ConfigFlags; + +// Trace log level +// NOTE: Organized by priority level +typedef enum { + LOG_ALL = 0, // Display all logs + LOG_TRACE, // Trace logging, intended for internal use only + LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds + LOG_INFO, // Info logging, used for program execution info + LOG_WARNING, // Warning logging, used on recoverable failures + LOG_ERROR, // Error logging, used on unrecoverable failures + LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) + LOG_NONE // Disable logging +} TraceLogLevel; + +// Keyboard keys (US keyboard layout) +// NOTE: Use GetKeyPressed() to allow redefining +// required keys for alternative layouts +typedef enum { + KEY_NULL = 0, // Key: NULL, used for no key pressed + // Alphanumeric keys + KEY_APOSTROPHE = 39, // Key: ' + KEY_COMMA = 44, // Key: , + KEY_MINUS = 45, // Key: - + KEY_PERIOD = 46, // Key: . + KEY_SLASH = 47, // Key: / + KEY_ZERO = 48, // Key: 0 + KEY_ONE = 49, // Key: 1 + KEY_TWO = 50, // Key: 2 + KEY_THREE = 51, // Key: 3 + KEY_FOUR = 52, // Key: 4 + KEY_FIVE = 53, // Key: 5 + KEY_SIX = 54, // Key: 6 + KEY_SEVEN = 55, // Key: 7 + KEY_EIGHT = 56, // Key: 8 + KEY_NINE = 57, // Key: 9 + KEY_SEMICOLON = 59, // Key: ; + KEY_EQUAL = 61, // Key: = + KEY_A = 65, // Key: A | a + KEY_B = 66, // Key: B | b + KEY_C = 67, // Key: C | c + KEY_D = 68, // Key: D | d + KEY_E = 69, // Key: E | e + KEY_F = 70, // Key: F | f + KEY_G = 71, // Key: G | g + KEY_H = 72, // Key: H | h + KEY_I = 73, // Key: I | i + KEY_J = 74, // Key: J | j + KEY_K = 75, // Key: K | k + KEY_L = 76, // Key: L | l + KEY_M = 77, // Key: M | m + KEY_N = 78, // Key: N | n + KEY_O = 79, // Key: O | o + KEY_P = 80, // Key: P | p + KEY_Q = 81, // Key: Q | q + KEY_R = 82, // Key: R | r + KEY_S = 83, // Key: S | s + KEY_T = 84, // Key: T | t + KEY_U = 85, // Key: U | u + KEY_V = 86, // Key: V | v + KEY_W = 87, // Key: W | w + KEY_X = 88, // Key: X | x + KEY_Y = 89, // Key: Y | y + KEY_Z = 90, // Key: Z | z + KEY_LEFT_BRACKET = 91, // Key: [ + KEY_BACKSLASH = 92, // Key: '\' + KEY_RIGHT_BRACKET = 93, // Key: ] + KEY_GRAVE = 96, // Key: ` + // Function keys + KEY_SPACE = 32, // Key: Space + KEY_ESCAPE = 256, // Key: Esc + KEY_ENTER = 257, // Key: Enter + KEY_TAB = 258, // Key: Tab + KEY_BACKSPACE = 259, // Key: Backspace + KEY_INSERT = 260, // Key: Ins + KEY_DELETE = 261, // Key: Del + KEY_RIGHT = 262, // Key: Cursor right + KEY_LEFT = 263, // Key: Cursor left + KEY_DOWN = 264, // Key: Cursor down + KEY_UP = 265, // Key: Cursor up + KEY_PAGE_UP = 266, // Key: Page up + KEY_PAGE_DOWN = 267, // Key: Page down + KEY_HOME = 268, // Key: Home + KEY_END = 269, // Key: End + KEY_CAPS_LOCK = 280, // Key: Caps lock + KEY_SCROLL_LOCK = 281, // Key: Scroll down + KEY_NUM_LOCK = 282, // Key: Num lock + KEY_PRINT_SCREEN = 283, // Key: Print screen + KEY_PAUSE = 284, // Key: Pause + KEY_F1 = 290, // Key: F1 + KEY_F2 = 291, // Key: F2 + KEY_F3 = 292, // Key: F3 + KEY_F4 = 293, // Key: F4 + KEY_F5 = 294, // Key: F5 + KEY_F6 = 295, // Key: F6 + KEY_F7 = 296, // Key: F7 + KEY_F8 = 297, // Key: F8 + KEY_F9 = 298, // Key: F9 + KEY_F10 = 299, // Key: F10 + KEY_F11 = 300, // Key: F11 + KEY_F12 = 301, // Key: F12 + KEY_LEFT_SHIFT = 340, // Key: Shift left + KEY_LEFT_CONTROL = 341, // Key: Control left + KEY_LEFT_ALT = 342, // Key: Alt left + KEY_LEFT_SUPER = 343, // Key: Super left + KEY_RIGHT_SHIFT = 344, // Key: Shift right + KEY_RIGHT_CONTROL = 345, // Key: Control right + KEY_RIGHT_ALT = 346, // Key: Alt right + KEY_RIGHT_SUPER = 347, // Key: Super right + KEY_KB_MENU = 348, // Key: KB menu + // Keypad keys + KEY_KP_0 = 320, // Key: Keypad 0 + KEY_KP_1 = 321, // Key: Keypad 1 + KEY_KP_2 = 322, // Key: Keypad 2 + KEY_KP_3 = 323, // Key: Keypad 3 + KEY_KP_4 = 324, // Key: Keypad 4 + KEY_KP_5 = 325, // Key: Keypad 5 + KEY_KP_6 = 326, // Key: Keypad 6 + KEY_KP_7 = 327, // Key: Keypad 7 + KEY_KP_8 = 328, // Key: Keypad 8 + KEY_KP_9 = 329, // Key: Keypad 9 + KEY_KP_DECIMAL = 330, // Key: Keypad . + KEY_KP_DIVIDE = 331, // Key: Keypad / + KEY_KP_MULTIPLY = 332, // Key: Keypad * + KEY_KP_SUBTRACT = 333, // Key: Keypad - + KEY_KP_ADD = 334, // Key: Keypad + + KEY_KP_ENTER = 335, // Key: Keypad Enter + KEY_KP_EQUAL = 336, // Key: Keypad = + // Android key buttons + KEY_BACK = 4, // Key: Android back button + KEY_MENU = 82, // Key: Android menu button + KEY_VOLUME_UP = 24, // Key: Android volume up button + KEY_VOLUME_DOWN = 25 // Key: Android volume down button +} KeyboardKey; + +// Add backwards compatibility support for deprecated names +#define MOUSE_LEFT_BUTTON MOUSE_BUTTON_LEFT +#define MOUSE_RIGHT_BUTTON MOUSE_BUTTON_RIGHT +#define MOUSE_MIDDLE_BUTTON MOUSE_BUTTON_MIDDLE + +// Mouse buttons +typedef enum { + MOUSE_BUTTON_LEFT = 0, // Mouse button left + MOUSE_BUTTON_RIGHT = 1, // Mouse button right + MOUSE_BUTTON_MIDDLE = 2, // Mouse button middle (pressed wheel) + MOUSE_BUTTON_SIDE = 3, // Mouse button side (advanced mouse device) + MOUSE_BUTTON_EXTRA = 4, // Mouse button extra (advanced mouse device) + MOUSE_BUTTON_FORWARD = 5, // Mouse button forward (advanced mouse device) + MOUSE_BUTTON_BACK = 6, // Mouse button back (advanced mouse device) +} MouseButton; + +// Mouse cursor +typedef enum { + MOUSE_CURSOR_DEFAULT = 0, // Default pointer shape + MOUSE_CURSOR_ARROW = 1, // Arrow shape + MOUSE_CURSOR_IBEAM = 2, // Text writing cursor shape + MOUSE_CURSOR_CROSSHAIR = 3, // Cross shape + MOUSE_CURSOR_POINTING_HAND = 4, // Pointing hand cursor + MOUSE_CURSOR_RESIZE_EW = 5, // Horizontal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NS = 6, // Vertical resize/move arrow shape + MOUSE_CURSOR_RESIZE_NWSE = 7, // Top-left to bottom-right diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NESW = 8, // The top-right to bottom-left diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_ALL = 9, // The omnidirectional resize/move cursor shape + MOUSE_CURSOR_NOT_ALLOWED = 10 // The operation-not-allowed shape +} MouseCursor; + +// Gamepad buttons +typedef enum { + GAMEPAD_BUTTON_UNKNOWN = 0, // Unknown button, just for error checking + GAMEPAD_BUTTON_LEFT_FACE_UP, // Gamepad left DPAD up button + GAMEPAD_BUTTON_LEFT_FACE_RIGHT, // Gamepad left DPAD right button + GAMEPAD_BUTTON_LEFT_FACE_DOWN, // Gamepad left DPAD down button + GAMEPAD_BUTTON_LEFT_FACE_LEFT, // Gamepad left DPAD left button + GAMEPAD_BUTTON_RIGHT_FACE_UP, // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y) + GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, // Gamepad right button right (i.e. PS3: Square, Xbox: X) + GAMEPAD_BUTTON_RIGHT_FACE_DOWN, // Gamepad right button down (i.e. PS3: Cross, Xbox: A) + GAMEPAD_BUTTON_RIGHT_FACE_LEFT, // Gamepad right button left (i.e. PS3: Circle, Xbox: B) + GAMEPAD_BUTTON_LEFT_TRIGGER_1, // Gamepad top/back trigger left (first), it could be a trailing button + GAMEPAD_BUTTON_LEFT_TRIGGER_2, // Gamepad top/back trigger left (second), it could be a trailing button + GAMEPAD_BUTTON_RIGHT_TRIGGER_1, // Gamepad top/back trigger right (one), it could be a trailing button + GAMEPAD_BUTTON_RIGHT_TRIGGER_2, // Gamepad top/back trigger right (second), it could be a trailing button + GAMEPAD_BUTTON_MIDDLE_LEFT, // Gamepad center buttons, left one (i.e. PS3: Select) + GAMEPAD_BUTTON_MIDDLE, // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX) + GAMEPAD_BUTTON_MIDDLE_RIGHT, // Gamepad center buttons, right one (i.e. PS3: Start) + GAMEPAD_BUTTON_LEFT_THUMB, // Gamepad joystick pressed button left + GAMEPAD_BUTTON_RIGHT_THUMB // Gamepad joystick pressed button right +} GamepadButton; + +// Gamepad axis +typedef enum { + GAMEPAD_AXIS_LEFT_X = 0, // Gamepad left stick X axis + GAMEPAD_AXIS_LEFT_Y = 1, // Gamepad left stick Y axis + GAMEPAD_AXIS_RIGHT_X = 2, // Gamepad right stick X axis + GAMEPAD_AXIS_RIGHT_Y = 3, // Gamepad right stick Y axis + GAMEPAD_AXIS_LEFT_TRIGGER = 4, // Gamepad back trigger left, pressure level: [1..-1] + GAMEPAD_AXIS_RIGHT_TRIGGER = 5 // Gamepad back trigger right, pressure level: [1..-1] +} GamepadAxis; + +// Material map index +typedef enum { + MATERIAL_MAP_ALBEDO = 0, // Albedo material (same as: MATERIAL_MAP_DIFFUSE) + MATERIAL_MAP_METALNESS, // Metalness material (same as: MATERIAL_MAP_SPECULAR) + MATERIAL_MAP_NORMAL, // Normal material + MATERIAL_MAP_ROUGHNESS, // Roughness material + MATERIAL_MAP_OCCLUSION, // Ambient occlusion material + MATERIAL_MAP_EMISSION, // Emission material + MATERIAL_MAP_HEIGHT, // Heightmap material + MATERIAL_MAP_CUBEMAP, // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_IRRADIANCE, // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_PREFILTER, // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_BRDF // Brdf material +} MaterialMapIndex; + +#define MATERIAL_MAP_DIFFUSE MATERIAL_MAP_ALBEDO +#define MATERIAL_MAP_SPECULAR MATERIAL_MAP_METALNESS + +// Shader location index +typedef enum { + SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position + SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 + SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 + SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal + SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent + SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color + SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection + SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) + SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection + SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) + SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal + SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view + SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color + SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color + SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color + SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE) + SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR) + SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal + SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness + SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion + SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission + SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height + SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap + SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance + SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter + SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf +} ShaderLocationIndex; + +#define SHADER_LOC_MAP_DIFFUSE SHADER_LOC_MAP_ALBEDO +#define SHADER_LOC_MAP_SPECULAR SHADER_LOC_MAP_METALNESS + +// Shader uniform data type +typedef enum { + SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float + SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) + SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) + SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) + SHADER_UNIFORM_INT, // Shader uniform type: int + SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) + SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) + SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) + SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d +} ShaderUniformDataType; + +// Shader attribute data types +typedef enum { + SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float + SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) + SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) + SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) +} ShaderAttributeDataType; + +// Pixel formats +// NOTE: Support depends on OpenGL version and platform +typedef enum { + PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp + PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp + PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp + PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp + PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} PixelFormat; + +// Texture parameters: filter mode +// NOTE 1: Filtering considers mipmaps if available in the texture +// NOTE 2: Filter is accordingly set for minification and magnification +typedef enum { + TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation + TEXTURE_FILTER_BILINEAR, // Linear filtering + TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} TextureFilter; + +// Texture parameters: wrap mode +typedef enum { + TEXTURE_WRAP_REPEAT = 0, // Repeats texture in tiled mode + TEXTURE_WRAP_CLAMP, // Clamps texture to edge pixel in tiled mode + TEXTURE_WRAP_MIRROR_REPEAT, // Mirrors and repeats the texture in tiled mode + TEXTURE_WRAP_MIRROR_CLAMP // Mirrors and clamps to border the texture in tiled mode +} TextureWrap; + +// Cubemap layouts +typedef enum { + CUBEMAP_LAYOUT_AUTO_DETECT = 0, // Automatically detect layout type + CUBEMAP_LAYOUT_LINE_VERTICAL, // Layout is defined by a vertical line with faces + CUBEMAP_LAYOUT_LINE_HORIZONTAL, // Layout is defined by a horizontal line with faces + CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR, // Layout is defined by a 3x4 cross with cubemap faces + CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE, // Layout is defined by a 4x3 cross with cubemap faces + CUBEMAP_LAYOUT_PANORAMA // Layout is defined by a panorama image (equirrectangular map) +} CubemapLayout; + +// Font type, defines generation method +typedef enum { + FONT_DEFAULT = 0, // Default font generation, anti-aliased + FONT_BITMAP, // Bitmap font generation, no anti-aliasing + FONT_SDF // SDF font generation, requires external shader +} FontType; + +// Color blending modes (pre-defined) +typedef enum { + BLEND_ALPHA = 0, // Blend textures considering alpha (default) + BLEND_ADDITIVE, // Blend textures adding colors + BLEND_MULTIPLIED, // Blend textures multiplying colors + BLEND_ADD_COLORS, // Blend textures adding colors (alternative) + BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) + BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha + BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) + BLEND_CUSTOM_SEPARATE // Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate()) +} BlendMode; + +// Gesture +// NOTE: Provided as bit-wise flags to enable only desired gestures +typedef enum { + GESTURE_NONE = 0, // No gesture + GESTURE_TAP = 1, // Tap gesture + GESTURE_DOUBLETAP = 2, // Double tap gesture + GESTURE_HOLD = 4, // Hold gesture + GESTURE_DRAG = 8, // Drag gesture + GESTURE_SWIPE_RIGHT = 16, // Swipe right gesture + GESTURE_SWIPE_LEFT = 32, // Swipe left gesture + GESTURE_SWIPE_UP = 64, // Swipe up gesture + GESTURE_SWIPE_DOWN = 128, // Swipe down gesture + GESTURE_PINCH_IN = 256, // Pinch in gesture + GESTURE_PINCH_OUT = 512 // Pinch out gesture +} Gesture; + +// Camera system modes +typedef enum { + CAMERA_CUSTOM = 0, // Custom camera + CAMERA_FREE, // Free camera + CAMERA_ORBITAL, // Orbital camera + CAMERA_FIRST_PERSON, // First person camera + CAMERA_THIRD_PERSON // Third person camera +} CameraMode; + +// Camera projection +typedef enum { + CAMERA_PERSPECTIVE = 0, // Perspective projection + CAMERA_ORTHOGRAPHIC // Orthographic projection +} CameraProjection; + +// N-patch layout +typedef enum { + NPATCH_NINE_PATCH = 0, // Npatch layout: 3x3 tiles + NPATCH_THREE_PATCH_VERTICAL, // Npatch layout: 1x3 tiles + NPATCH_THREE_PATCH_HORIZONTAL // Npatch layout: 3x1 tiles +} NPatchLayout; + +// Callbacks to hook some internal functions +// WARNING: These callbacks are intended for advance users +typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args); // Logging: Redirect trace log messages +typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, unsigned int *bytesRead); // FileIO: Load binary data +typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, unsigned int bytesToWrite); // FileIO: Save binary data +typedef char *(*LoadFileTextCallback)(const char *fileName); // FileIO: Load text data +typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data + +//------------------------------------------------------------------------------------ +// Global Variables Definition +//------------------------------------------------------------------------------------ +// It's lonely here... + +//------------------------------------------------------------------------------------ +// Window and Graphics Device Functions (Module: core) +//------------------------------------------------------------------------------------ + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Window-related functions +RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context +RLAPI bool WindowShouldClose(void); // Check if KEY_ESCAPE pressed or Close icon pressed +RLAPI void CloseWindow(void); // Close window and unload OpenGL context +RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully +RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen +RLAPI bool IsWindowHidden(void); // Check if window is currently hidden (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMinimized(void); // Check if window is currently minimized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMaximized(void); // Check if window is currently maximized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowFocused(void); // Check if window is currently focused (only PLATFORM_DESKTOP) +RLAPI bool IsWindowResized(void); // Check if window has been resized last frame +RLAPI bool IsWindowState(unsigned int flag); // Check if one specific window flag is enabled +RLAPI void SetWindowState(unsigned int flags); // Set window configuration state using flags (only PLATFORM_DESKTOP) +RLAPI void ClearWindowState(unsigned int flags); // Clear window configuration state flags +RLAPI void ToggleFullscreen(void); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) +RLAPI void MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) +RLAPI void MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) +RLAPI void RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) +RLAPI void SetWindowIcon(Image image); // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) +RLAPI void SetWindowIcons(Image *images, int count); // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP) +RLAPI void SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP) +RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) +RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode) +RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) +RLAPI void SetWindowSize(int width, int height); // Set window dimensions +RLAPI void SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) +RLAPI void *GetWindowHandle(void); // Get native window handle +RLAPI int GetScreenWidth(void); // Get current screen width +RLAPI int GetScreenHeight(void); // Get current screen height +RLAPI int GetRenderWidth(void); // Get current render width (it considers HiDPI) +RLAPI int GetRenderHeight(void); // Get current render height (it considers HiDPI) +RLAPI int GetMonitorCount(void); // Get number of connected monitors +RLAPI int GetCurrentMonitor(void); // Get current connected monitor +RLAPI Vector2 GetMonitorPosition(int monitor); // Get specified monitor position +RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width (current video mode used by monitor) +RLAPI int GetMonitorHeight(int monitor); // Get specified monitor height (current video mode used by monitor) +RLAPI int GetMonitorPhysicalWidth(int monitor); // Get specified monitor physical width in millimetres +RLAPI int GetMonitorPhysicalHeight(int monitor); // Get specified monitor physical height in millimetres +RLAPI int GetMonitorRefreshRate(int monitor); // Get specified monitor refresh rate +RLAPI Vector2 GetWindowPosition(void); // Get window position XY on monitor +RLAPI Vector2 GetWindowScaleDPI(void); // Get window scale DPI factor +RLAPI const char *GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the primary monitor +RLAPI void SetClipboardText(const char *text); // Set clipboard text content +RLAPI const char *GetClipboardText(void); // Get clipboard text content +RLAPI void EnableEventWaiting(void); // Enable waiting for events on EndDrawing(), no automatic event polling +RLAPI void DisableEventWaiting(void); // Disable waiting for events on EndDrawing(), automatic events polling + +// Custom frame control functions +// NOTE: Those functions are intended for advance users that want full control over the frame processing +// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents() +// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL +RLAPI void SwapScreenBuffer(void); // Swap back buffer with front buffer (screen drawing) +RLAPI void PollInputEvents(void); // Register all input events +RLAPI void WaitTime(double seconds); // Wait for some time (halt program execution) + +// Cursor-related functions +RLAPI void ShowCursor(void); // Shows cursor +RLAPI void HideCursor(void); // Hides cursor +RLAPI bool IsCursorHidden(void); // Check if cursor is not visible +RLAPI void EnableCursor(void); // Enables cursor (unlock cursor) +RLAPI void DisableCursor(void); // Disables cursor (lock cursor) +RLAPI bool IsCursorOnScreen(void); // Check if cursor is on the screen + +// Drawing-related functions +RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color) +RLAPI void BeginDrawing(void); // Setup canvas (framebuffer) to start drawing +RLAPI void EndDrawing(void); // End canvas drawing and swap buffers (double buffering) +RLAPI void BeginMode2D(Camera2D camera); // Begin 2D mode with custom camera (2D) +RLAPI void EndMode2D(void); // Ends 2D mode with custom camera +RLAPI void BeginMode3D(Camera3D camera); // Begin 3D mode with custom camera (3D) +RLAPI void EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode +RLAPI void BeginTextureMode(RenderTexture2D target); // Begin drawing to render texture +RLAPI void EndTextureMode(void); // Ends drawing to render texture +RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing +RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader) +RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied, subtract, custom) +RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending) +RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing) +RLAPI void EndScissorMode(void); // End scissor mode +RLAPI void BeginVrStereoMode(VrStereoConfig config); // Begin stereo rendering (requires VR simulator) +RLAPI void EndVrStereoMode(void); // End stereo rendering (requires VR simulator) + +// VR stereo config functions for VR simulator +RLAPI VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device); // Load VR stereo config for VR simulator device parameters +RLAPI void UnloadVrStereoConfig(VrStereoConfig config); // Unload VR stereo config + +// Shader management functions +// NOTE: Shader functionality is not available on OpenGL 1.1 +RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations +RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations +RLAPI bool IsShaderReady(Shader shader); // Check if a shader is ready +RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location +RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location +RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value +RLAPI void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count); // Set shader uniform value vector +RLAPI void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat); // Set shader uniform value (matrix 4x4) +RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d) +RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM) + +// Screen-space-related functions +RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Get a ray trace from mouse position +RLAPI Matrix GetCameraMatrix(Camera camera); // Get camera transform matrix (view matrix) +RLAPI Matrix GetCameraMatrix2D(Camera2D camera); // Get camera 2d transform matrix +RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Get the screen space position for a 3d world space position +RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position +RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position +RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Get the screen space position for a 2d camera world space position + +// Timing-related functions +RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum) +RLAPI int GetFPS(void); // Get current FPS +RLAPI float GetFrameTime(void); // Get time in seconds for last frame drawn (delta time) +RLAPI double GetTime(void); // Get elapsed time in seconds since InitWindow() + +// Misc. functions +RLAPI int GetRandomValue(int min, int max); // Get a random value between min and max (both included) +RLAPI void SetRandomSeed(unsigned int seed); // Set the seed for the random number generator +RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format) +RLAPI void SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS) + +RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) +RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level +RLAPI void *MemAlloc(unsigned int size); // Internal memory allocator +RLAPI void *MemRealloc(void *ptr, unsigned int size); // Internal memory reallocator +RLAPI void MemFree(void *ptr); // Internal memory free + +RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available) + +// Set custom callbacks +// WARNING: Callbacks setup is intended for advance users +RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log +RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader +RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver +RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader +RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver + +// Files management functions +RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead); // Load file data as byte array (read) +RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData() +RLAPI bool SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite); // Save data to file from byte array (write), returns true on success +RLAPI bool ExportDataAsCode(const unsigned char *data, unsigned int size, const char *fileName); // Export data to code (.h), returns true on success +RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string +RLAPI void UnloadFileText(char *text); // Unload file text data allocated by LoadFileText() +RLAPI bool SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success +RLAPI bool FileExists(const char *fileName); // Check if file exists +RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists +RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) +RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) +RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png') +RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string +RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) +RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) +RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) +RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) +RLAPI const char *GetApplicationDirectory(void); // Get the directory if the running application (uses static string) +RLAPI bool ChangeDirectory(const char *dir); // Change working directory, return true on success +RLAPI bool IsPathFile(const char *path); // Check if a given path is a file or a directory +RLAPI FilePathList LoadDirectoryFiles(const char *dirPath); // Load directory filepaths +RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan +RLAPI void UnloadDirectoryFiles(FilePathList files); // Unload filepaths +RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window +RLAPI FilePathList LoadDroppedFiles(void); // Load dropped filepaths +RLAPI void UnloadDroppedFiles(FilePathList files); // Unload dropped filepaths +RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time) + +// Compression/Encoding functionality +RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *compDataSize); // Compress data (DEFLATE algorithm), memory must be MemFree() +RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // Decompress data (DEFLATE algorithm), memory must be MemFree() +RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize); // Encode data to Base64 string, memory must be MemFree() +RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize); // Decode Base64 string data, memory must be MemFree() + +//------------------------------------------------------------------------------------ +// Input Handling Functions (Module: core) +//------------------------------------------------------------------------------------ + +// Input-related functions: keyboard +RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once +RLAPI bool IsKeyDown(int key); // Check if a key is being pressed +RLAPI bool IsKeyReleased(int key); // Check if a key has been released once +RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed +RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) +RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty +RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty + +// Input-related functions: gamepads +RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available +RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id +RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once +RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed +RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once +RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed +RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed +RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad +RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis +RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) + +// Input-related functions: mouse +RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once +RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed +RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once +RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed +RLAPI int GetMouseX(void); // Get mouse position X +RLAPI int GetMouseY(void); // Get mouse position Y +RLAPI Vector2 GetMousePosition(void); // Get mouse position XY +RLAPI Vector2 GetMouseDelta(void); // Get mouse delta between frames +RLAPI void SetMousePosition(int x, int y); // Set mouse position XY +RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset +RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling +RLAPI float GetMouseWheelMove(void); // Get mouse wheel movement for X or Y, whichever is larger +RLAPI Vector2 GetMouseWheelMoveV(void); // Get mouse wheel movement for both X and Y +RLAPI void SetMouseCursor(int cursor); // Set mouse cursor + +// Input-related functions: touch +RLAPI int GetTouchX(void); // Get touch position X for touch point 0 (relative to screen size) +RLAPI int GetTouchY(void); // Get touch position Y for touch point 0 (relative to screen size) +RLAPI Vector2 GetTouchPosition(int index); // Get touch position XY for a touch point index (relative to screen size) +RLAPI int GetTouchPointId(int index); // Get touch point identifier for given index +RLAPI int GetTouchPointCount(void); // Get number of touch points + +//------------------------------------------------------------------------------------ +// Gestures and Touch Handling Functions (Module: rgestures) +//------------------------------------------------------------------------------------ +RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags +RLAPI bool IsGestureDetected(int gesture); // Check if a gesture have been detected +RLAPI int GetGestureDetected(void); // Get latest detected gesture +RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds +RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector +RLAPI float GetGestureDragAngle(void); // Get gesture drag angle +RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta +RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle + +//------------------------------------------------------------------------------------ +// Camera System Functions (Module: rcamera) +//------------------------------------------------------------------------------------ +RLAPI void UpdateCamera(Camera *camera, int mode); // Update camera position for selected mode +RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom); // Update camera movement/rotation + +//------------------------------------------------------------------------------------ +// Basic Shapes Drawing Functions (Module: shapes) +//------------------------------------------------------------------------------------ +// Set texture and rectangle to be used on shapes drawing +// NOTE: It can be useful when using basic shapes and one single font, +// defining a font char white rectangle would allow drawing everything in a single draw call +RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing + +// Basic shapes drawing functions +RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel +RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version) +RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line +RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (Vector version) +RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line defining thickness +RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line using cubic-bezier curves in-out +RLAPI void DrawLineBezierQuad(Vector2 startPos, Vector2 endPos, Vector2 controlPos, float thick, Color color); // Draw line using quadratic bezier curves with a control point +RLAPI void DrawLineBezierCubic(Vector2 startPos, Vector2 endPos, Vector2 startControlPos, Vector2 endControlPos, float thick, Color color); // Draw line using cubic bezier curves with 2 control points +RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color); // Draw lines sequence +RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle +RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle +RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline +RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle +RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) +RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline +RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse +RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline +RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring +RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline +RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) +RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters +RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle +RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle +RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors +RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline +RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color); // Draw rectangle outline with extended parameters +RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges +RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline +RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!) +RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points (first vertex is the center) +RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) +RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides +RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters + +// Basic shapes collision detection functions +RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles +RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles +RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle +RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle +RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle +RLAPI bool CheckCollisionPointPoly(Vector2 point, Vector2 *points, int pointCount); // Check if point is within a polygon described by array of vertices +RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference +RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] +RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision + +//------------------------------------------------------------------------------------ +// Texture Loading and Drawing Functions (Module: textures) +//------------------------------------------------------------------------------------ + +// Image loading functions +// NOTE: These functions do not require GPU access +RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM) +RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data +RLAPI Image LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data) +RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. '.png' +RLAPI Image LoadImageFromTexture(Texture2D texture); // Load image from GPU texture data +RLAPI Image LoadImageFromScreen(void); // Load image from screen buffer and (screenshot) +RLAPI bool IsImageReady(Image image); // Check if an image is ready +RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM) +RLAPI bool ExportImage(Image image, const char *fileName); // Export image data to file, returns true on success +RLAPI bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success + +// Image generation functions +RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color +RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom); // Generate image: vertical gradient +RLAPI Image GenImageGradientH(int width, int height, Color left, Color right); // Generate image: horizontal gradient +RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient +RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked +RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise +RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise +RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm, bigger tileSize means bigger cells +RLAPI Image GenImageText(int width, int height, const char *text); // Generate image: grayscale image from text data + +// Image manipulation functions +RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) +RLAPI Image ImageFromImage(Image image, Rectangle rec); // Create an image from another image piece +RLAPI Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font) +RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); // Create an image from text (custom sprite font) +RLAPI void ImageFormat(Image *image, int newFormat); // Convert image data to desired format +RLAPI void ImageToPOT(Image *image, Color fill); // Convert image to POT (power-of-two) +RLAPI void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle +RLAPI void ImageAlphaCrop(Image *image, float threshold); // Crop image depending on alpha value +RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color +RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image +RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel +RLAPI void ImageBlurGaussian(Image *image, int blurSize); // Apply Gaussian blur using a box blur approximation +RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm) +RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm) +RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color +RLAPI void ImageMipmaps(Image *image); // Compute all mipmap levels for a provided image +RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) +RLAPI void ImageFlipVertical(Image *image); // Flip image vertically +RLAPI void ImageFlipHorizontal(Image *image); // Flip image horizontally +RLAPI void ImageRotateCW(Image *image); // Rotate image clockwise 90deg +RLAPI void ImageRotateCCW(Image *image); // Rotate image counter-clockwise 90deg +RLAPI void ImageColorTint(Image *image, Color color); // Modify image color: tint +RLAPI void ImageColorInvert(Image *image); // Modify image color: invert +RLAPI void ImageColorGrayscale(Image *image); // Modify image color: grayscale +RLAPI void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100) +RLAPI void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255) +RLAPI void ImageColorReplace(Image *image, Color color, Color replace); // Modify image color: replace color +RLAPI Color *LoadImageColors(Image image); // Load color data from image as a Color array (RGBA - 32bit) +RLAPI Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorCount); // Load colors palette from image as a Color array (RGBA - 32bit) +RLAPI void UnloadImageColors(Color *colors); // Unload color data loaded with LoadImageColors() +RLAPI void UnloadImagePalette(Color *colors); // Unload colors palette loaded with LoadImagePalette() +RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold); // Get image alpha border rectangle +RLAPI Color GetImageColor(Image image, int x, int y); // Get image pixel color at (x, y) position + +// Image drawing functions +// NOTE: Image software-rendering functions (CPU) +RLAPI void ImageClearBackground(Image *dst, Color color); // Clear image background with given color +RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); // Draw pixel within an image +RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version) +RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image +RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version) +RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw a filled circle within an image +RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw a filled circle within an image (Vector version) +RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle outline within an image +RLAPI void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color); // Draw circle outline within an image (Vector version) +RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image +RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version) +RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image +RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); // Draw rectangle lines within an image +RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); // Draw a source image within a destination image (tint applied to source) +RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) within an image (destination) +RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination) + +// Texture loading functions +// NOTE: These functions require GPU access +RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM) +RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data +RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported +RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) +RLAPI bool IsTextureReady(Texture2D texture); // Check if a texture is ready +RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) +RLAPI bool IsRenderTextureReady(RenderTexture2D target); // Check if a render texture is ready +RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) +RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data +RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data + +// Texture configuration functions +RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture +RLAPI void SetTextureFilter(Texture2D texture, int filter); // Set texture scaling filter mode +RLAPI void SetTextureWrap(Texture2D texture, int wrap); // Set texture wrapping mode + +// Texture drawing functions +RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D +RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 +RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters +RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle +RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters +RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely + +// Color/pixel related functions +RLAPI Color Fade(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI int ColorToInt(Color color); // Get hexadecimal value for a Color +RLAPI Vector4 ColorNormalize(Color color); // Get Color normalized as float [0..1] +RLAPI Color ColorFromNormalized(Vector4 normalized); // Get Color from normalized values [0..1] +RLAPI Vector3 ColorToHSV(Color color); // Get HSV values for a Color, hue [0..360], saturation/value [0..1] +RLAPI Color ColorFromHSV(float hue, float saturation, float value); // Get a Color from HSV values, hue [0..360], saturation/value [0..1] +RLAPI Color ColorTint(Color color, Color tint); // Get color multiplied with another color +RLAPI Color ColorBrightness(Color color, float factor); // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f +RLAPI Color ColorContrast(Color color, float contrast); // Get color with contrast correction, contrast values between -1.0f and 1.0f +RLAPI Color ColorAlpha(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint +RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value +RLAPI Color GetPixelColor(void *srcPtr, int format); // Get Color from a source pixel pointer of certain format +RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer +RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format + +//------------------------------------------------------------------------------------ +// Font Loading and Text Drawing Functions (Module: text) +//------------------------------------------------------------------------------------ + +// Font loading/unloading functions +RLAPI Font GetFontDefault(void); // Get the default Font +RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM) +RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int glyphCount); // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set +RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) +RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' +RLAPI bool IsFontReady(Font font); // Check if a font is ready +RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount, int type); // Load font data for further use +RLAPI Image GenImageFontAtlas(const GlyphInfo *chars, Rectangle **recs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info +RLAPI void UnloadFontData(GlyphInfo *chars, int glyphCount); // Unload font chars info data (RAM) +RLAPI void UnloadFont(Font font); // Unload font from GPU memory (VRAM) +RLAPI bool ExportFontAsCode(Font font, const char *fileName); // Export font as code file, returns true on success + +// Text drawing functions +RLAPI void DrawFPS(int posX, int posY); // Draw current FPS +RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) +RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters +RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation) +RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint) +RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int count, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint) + +// Text font info functions +RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font +RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font +RLAPI int GetGlyphIndex(Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found +RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found +RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found + +// Text codepoints management functions (unicode characters) +RLAPI char *LoadUTF8(const int *codepoints, int length); // Load UTF-8 text encoded from codepoints array +RLAPI void UnloadUTF8(char *text); // Unload UTF-8 text encoded from codepoints array +RLAPI int *LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter +RLAPI void UnloadCodepoints(int *codepoints); // Unload codepoints data from memory +RLAPI int GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string +RLAPI int GetCodepoint(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI int GetCodepointPrevious(const char *text, int *codepointSize); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) + +// Text strings management functions (no UTF-8 strings, only byte chars) +// NOTE: Some strings allocate memory internally for returned strings, just be careful! +RLAPI int TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied +RLAPI bool TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal +RLAPI unsigned int TextLength(const char *text); // Get text length, checks for '\0' ending +RLAPI const char *TextFormat(const char *text, ...); // Text formatting with variables (sprintf() style) +RLAPI const char *TextSubtext(const char *text, int position, int length); // Get a piece of a text string +RLAPI char *TextReplace(char *text, const char *replace, const char *by); // Replace text string (WARNING: memory must be freed!) +RLAPI char *TextInsert(const char *text, const char *insert, int position); // Insert text in a position (WARNING: memory must be freed!) +RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter +RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +RLAPI void TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor! +RLAPI int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string +RLAPI const char *TextToUpper(const char *text); // Get upper case version of provided string +RLAPI const char *TextToLower(const char *text); // Get lower case version of provided string +RLAPI const char *TextToPascal(const char *text); // Get Pascal case notation version of provided string +RLAPI int TextToInteger(const char *text); // Get integer value from text (negative values not supported) + +//------------------------------------------------------------------------------------ +// Basic 3d Shapes Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ + +// Basic geometric 3D shapes drawing functions +RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space +RLAPI void DrawPoint3D(Vector3 position, Color color); // Draw a point in 3D space, actually a small line +RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space +RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color); // Draw cube +RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) +RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires +RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version) +RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere +RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters +RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires +RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone +RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos +RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires +RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos +RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos +RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos +RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ +RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line +RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) + +//------------------------------------------------------------------------------------ +// Model 3d Loading and Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ + +// Model management functions +RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials) +RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material) +RLAPI bool IsModelReady(Model model); // Check if a model is ready +RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM) +RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes) + +// Model drawing functions +RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) +RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters +RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set) +RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters +RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) +RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint); // Draw a billboard texture +RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source +RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation + +// Mesh management functions +RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids +RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index +RLAPI void UnloadMesh(Mesh mesh); // Unload mesh data from CPU and GPU +RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform); // Draw a 3d mesh with material and transform +RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms +RLAPI bool ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success +RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits +RLAPI void GenMeshTangents(Mesh *mesh); // Compute mesh tangents + +// Mesh generation functions +RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh +RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) +RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh +RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) +RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) +RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh +RLAPI Mesh GenMeshCone(float radius, float height, int slices); // Generate cone/pyramid mesh +RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh +RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh +RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data +RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data + +// Material loading/unloading functions +RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file +RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) +RLAPI bool IsMaterialReady(Material material); // Check if a material is ready +RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM) +RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) +RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh + +// Model animations loading/unloading functions +RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, unsigned int *animCount); // Load model animations from file +RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose +RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data +RLAPI void UnloadModelAnimations(ModelAnimation *animations, unsigned int count); // Unload animation array data +RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match + +// Collision detection functions +RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2); // Check collision between two spheres +RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision between two bounding boxes +RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere +RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere +RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box +RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh +RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle +RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad + +//------------------------------------------------------------------------------------ +// Audio Loading and Playing Functions (Module: audio) +//------------------------------------------------------------------------------------ +typedef void (*AudioCallback)(void *bufferData, unsigned int frames); + +// Audio device management functions +RLAPI void InitAudioDevice(void); // Initialize audio device and context +RLAPI void CloseAudioDevice(void); // Close the audio device and context +RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully +RLAPI void SetMasterVolume(float volume); // Set master volume (listener) + +// Wave/Sound loading/unloading functions +RLAPI Wave LoadWave(const char *fileName); // Load wave data from file +RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' +RLAPI bool IsWaveReady(Wave wave); // Checks if wave data is ready +RLAPI Sound LoadSound(const char *fileName); // Load sound from file +RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data +RLAPI bool IsSoundReady(Sound sound); // Checks if a sound is ready +RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data +RLAPI void UnloadWave(Wave wave); // Unload wave data +RLAPI void UnloadSound(Sound sound); // Unload sound +RLAPI bool ExportWave(Wave wave, const char *fileName); // Export wave data to file, returns true on success +RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h), returns true on success + +// Wave/Sound management functions +RLAPI void PlaySound(Sound sound); // Play a sound +RLAPI void StopSound(Sound sound); // Stop playing a sound +RLAPI void PauseSound(Sound sound); // Pause a sound +RLAPI void ResumeSound(Sound sound); // Resume a paused sound +RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing +RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) +RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) +RLAPI void SetSoundPan(Sound sound, float pan); // Set pan for a sound (0.5 is center) +RLAPI Wave WaveCopy(Wave wave); // Copy a wave to a new wave +RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range +RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format +RLAPI float *LoadWaveSamples(Wave wave); // Load samples data from wave as a 32bit float data array +RLAPI void UnloadWaveSamples(float *samples); // Unload samples data loaded with LoadWaveSamples() + +// Music management functions +RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file +RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data +RLAPI bool IsMusicReady(Music music); // Checks if a music stream is ready +RLAPI void UnloadMusicStream(Music music); // Unload music stream +RLAPI void PlayMusicStream(Music music); // Start music playing +RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing +RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming +RLAPI void StopMusicStream(Music music); // Stop music playing +RLAPI void PauseMusicStream(Music music); // Pause music playing +RLAPI void ResumeMusicStream(Music music); // Resume playing paused music +RLAPI void SeekMusicStream(Music music, float position); // Seek music to a position (in seconds) +RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level) +RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level) +RLAPI void SetMusicPan(Music music, float pan); // Set pan for a music (0.5 is center) +RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds) +RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds) + +// AudioStream management functions +RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data) +RLAPI bool IsAudioStreamReady(AudioStream stream); // Checks if an audio stream is ready +RLAPI void UnloadAudioStream(AudioStream stream); // Unload audio stream and free memory +RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data +RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill +RLAPI void PlayAudioStream(AudioStream stream); // Play audio stream +RLAPI void PauseAudioStream(AudioStream stream); // Pause audio stream +RLAPI void ResumeAudioStream(AudioStream stream); // Resume audio stream +RLAPI bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing +RLAPI void StopAudioStream(AudioStream stream); // Stop audio stream +RLAPI void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level) +RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level) +RLAPI void SetAudioStreamPan(AudioStream stream, float pan); // Set pan for audio stream (0.5 is centered) +RLAPI void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams +RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data + +RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream +RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream + +RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline +RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline + +#if defined(__cplusplus) +} +#endif + +#endif // RAYLIB_H diff --git a/lib/raylib-4.5.0_win64_msvc16/include/raymath.h b/lib/raylib-4.5.0_win64_msvc16/include/raymath.h new file mode 100644 index 0000000..422a42e --- /dev/null +++ b/lib/raylib-4.5.0_win64_msvc16/include/raymath.h @@ -0,0 +1,2134 @@ +/********************************************************************************************** +* +* raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions +* +* CONFIGURATION: +* +* #define RAYMATH_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RAYMATH_STATIC_INLINE +* Define static inline functions code, so #include header suffices for use. +* This may use up lots of memory. +* +* CONVENTIONS: +* +* - Functions are always self-contained, no function use another raymath function inside, +* required code is directly re-implemented inside +* - Functions input parameters are always received by value (2 unavoidable exceptions) +* - Functions use always a "result" variable for return +* - Functions are always defined inline +* - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2015-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYMATH_H +#define RAYMATH_H + +#if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_STATIC_INLINE) + #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory" +#endif + +// Function specifiers definition +#if defined(RAYMATH_IMPLEMENTATION) + #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED) + #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll). + #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED) + #define RMAPI __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll) + #else + #define RMAPI extern inline // Provide external definition + #endif +#elif defined(RAYMATH_STATIC_INLINE) + #define RMAPI static inline // Functions may be inlined, no external out-of-line definition +#else + #if defined(__TINYC__) + #define RMAPI static inline // plain inline not supported by tinycc (See issue #435) + #else + #define RMAPI inline // Functions may be inlined or external definition used + #endif +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif + +#ifndef EPSILON + #define EPSILON 0.000001f +#endif + +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif + +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +// Get float vector for Matrix +#ifndef MatrixToFloat + #define MatrixToFloat(mat) (MatrixToFloatV(mat).v) +#endif + +// Get float vector for Vector3 +#ifndef Vector3ToFloat + #define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v) +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if !defined(RL_VECTOR2_TYPE) +// Vector2 type +typedef struct Vector2 { + float x; + float y; +} Vector2; +#define RL_VECTOR2_TYPE +#endif + +#if !defined(RL_VECTOR3_TYPE) +// Vector3 type +typedef struct Vector3 { + float x; + float y; + float z; +} Vector3; +#define RL_VECTOR3_TYPE +#endif + +#if !defined(RL_VECTOR4_TYPE) +// Vector4 type +typedef struct Vector4 { + float x; + float y; + float z; + float w; +} Vector4; +#define RL_VECTOR4_TYPE +#endif + +#if !defined(RL_QUATERNION_TYPE) +// Quaternion type +typedef Vector4 Quaternion; +#define RL_QUATERNION_TYPE +#endif + +#if !defined(RL_MATRIX_TYPE) +// Matrix type (OpenGL style 4x4 - right handed, column major) +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; +#define RL_MATRIX_TYPE +#endif + +// NOTE: Helper types to be used instead of array return types for *ToFloat functions +typedef struct float3 { + float v[3]; +} float3; + +typedef struct float16 { + float v[16]; +} float16; + +#include // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs() + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Utils math +//---------------------------------------------------------------------------------- + +// Clamp float value +RMAPI float Clamp(float value, float min, float max) +{ + float result = (value < min)? min : value; + + if (result > max) result = max; + + return result; +} + +// Calculate linear interpolation between two floats +RMAPI float Lerp(float start, float end, float amount) +{ + float result = start + amount*(end - start); + + return result; +} + +// Normalize input value within input range +RMAPI float Normalize(float value, float start, float end) +{ + float result = (value - start)/(end - start); + + return result; +} + +// Remap input value within input range to output range +RMAPI float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd) +{ + float result = (value - inputStart)/(inputEnd - inputStart)*(outputEnd - outputStart) + outputStart; + + return result; +} + +// Wrap input value from min to max +RMAPI float Wrap(float value, float min, float max) +{ + float result = value - (max - min)*floorf((value - min)/(max - min)); + + return result; +} + +// Check whether two given floats are almost equal +RMAPI int FloatEquals(float x, float y) +{ + int result = (fabsf(x - y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(x), fabsf(y)))); + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vector2 math +//---------------------------------------------------------------------------------- + +// Vector with components value 0.0f +RMAPI Vector2 Vector2Zero(void) +{ + Vector2 result = { 0.0f, 0.0f }; + + return result; +} + +// Vector with components value 1.0f +RMAPI Vector2 Vector2One(void) +{ + Vector2 result = { 1.0f, 1.0f }; + + return result; +} + +// Add two vectors (v1 + v2) +RMAPI Vector2 Vector2Add(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x + v2.x, v1.y + v2.y }; + + return result; +} + +// Add vector and float value +RMAPI Vector2 Vector2AddValue(Vector2 v, float add) +{ + Vector2 result = { v.x + add, v.y + add }; + + return result; +} + +// Subtract two vectors (v1 - v2) +RMAPI Vector2 Vector2Subtract(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x - v2.x, v1.y - v2.y }; + + return result; +} + +// Subtract vector by float value +RMAPI Vector2 Vector2SubtractValue(Vector2 v, float sub) +{ + Vector2 result = { v.x - sub, v.y - sub }; + + return result; +} + +// Calculate vector length +RMAPI float Vector2Length(Vector2 v) +{ + float result = sqrtf((v.x*v.x) + (v.y*v.y)); + + return result; +} + +// Calculate vector square length +RMAPI float Vector2LengthSqr(Vector2 v) +{ + float result = (v.x*v.x) + (v.y*v.y); + + return result; +} + +// Calculate two vectors dot product +RMAPI float Vector2DotProduct(Vector2 v1, Vector2 v2) +{ + float result = (v1.x*v2.x + v1.y*v2.y); + + return result; +} + +// Calculate distance between two vectors +RMAPI float Vector2Distance(Vector2 v1, Vector2 v2) +{ + float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); + + return result; +} + +// Calculate square distance between two vectors +RMAPI float Vector2DistanceSqr(Vector2 v1, Vector2 v2) +{ + float result = ((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); + + return result; +} + +// Calculate angle between two vectors +// NOTE: Angle is calculated from origin point (0, 0) +RMAPI float Vector2Angle(Vector2 v1, Vector2 v2) +{ + float result = atan2f(v2.y - v1.y, v2.x - v1.x); + + return result; +} + +// Calculate angle defined by a two vectors line +// NOTE: Parameters need to be normalized +// Current implementation should be aligned with glm::angle +RMAPI float Vector2LineAngle(Vector2 start, Vector2 end) +{ + float result = 0.0f; + + float dot = start.x*end.x + start.y*end.y; // Dot product + + float dotClamp = (dot < -1.0f)? -1.0f : dot; // Clamp + if (dotClamp > 1.0f) dotClamp = 1.0f; + + result = acosf(dotClamp); + + // Alternative implementation, more costly + //float v1Length = sqrtf((start.x*start.x) + (start.y*start.y)); + //float v2Length = sqrtf((end.x*end.x) + (end.y*end.y)); + //float result = -acosf((start.x*end.x + start.y*end.y)/(v1Length*v2Length)); + + return result; +} + +// Scale vector (multiply by value) +RMAPI Vector2 Vector2Scale(Vector2 v, float scale) +{ + Vector2 result = { v.x*scale, v.y*scale }; + + return result; +} + +// Multiply vector by vector +RMAPI Vector2 Vector2Multiply(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x*v2.x, v1.y*v2.y }; + + return result; +} + +// Negate vector +RMAPI Vector2 Vector2Negate(Vector2 v) +{ + Vector2 result = { -v.x, -v.y }; + + return result; +} + +// Divide vector by vector +RMAPI Vector2 Vector2Divide(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x/v2.x, v1.y/v2.y }; + + return result; +} + +// Normalize provided vector +RMAPI Vector2 Vector2Normalize(Vector2 v) +{ + Vector2 result = { 0 }; + float length = sqrtf((v.x*v.x) + (v.y*v.y)); + + if (length > 0) + { + float ilength = 1.0f/length; + result.x = v.x*ilength; + result.y = v.y*ilength; + } + + return result; +} + +// Transforms a Vector2 by a given Matrix +RMAPI Vector2 Vector2Transform(Vector2 v, Matrix mat) +{ + Vector2 result = { 0 }; + + float x = v.x; + float y = v.y; + float z = 0; + + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; + + return result; +} + +// Calculate linear interpolation between two vectors +RMAPI Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount) +{ + Vector2 result = { 0 }; + + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + + return result; +} + +// Calculate reflected vector to normal +RMAPI Vector2 Vector2Reflect(Vector2 v, Vector2 normal) +{ + Vector2 result = { 0 }; + + float dotProduct = (v.x*normal.x + v.y*normal.y); // Dot product + + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + + return result; +} + +// Rotate vector by angle +RMAPI Vector2 Vector2Rotate(Vector2 v, float angle) +{ + Vector2 result = { 0 }; + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.x = v.x*cosres - v.y*sinres; + result.y = v.x*sinres + v.y*cosres; + + return result; +} + +// Move Vector towards target +RMAPI Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance) +{ + Vector2 result = { 0 }; + + float dx = target.x - v.x; + float dy = target.y - v.y; + float value = (dx*dx) + (dy*dy); + + if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target; + + float dist = sqrtf(value); + + result.x = v.x + dx/dist*maxDistance; + result.y = v.y + dy/dist*maxDistance; + + return result; +} + +// Invert the given vector +RMAPI Vector2 Vector2Invert(Vector2 v) +{ + Vector2 result = { 1.0f/v.x, 1.0f/v.y }; + + return result; +} + +// Clamp the components of the vector between +// min and max values specified by the given vectors +RMAPI Vector2 Vector2Clamp(Vector2 v, Vector2 min, Vector2 max) +{ + Vector2 result = { 0 }; + + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + + return result; +} + +// Clamp the magnitude of the vector between two min and max values +RMAPI Vector2 Vector2ClampValue(Vector2 v, float min, float max) +{ + Vector2 result = v; + + float length = (v.x*v.x) + (v.y*v.y); + if (length > 0.0f) + { + length = sqrtf(length); + + if (length < min) + { + float scale = min/length; + result.x = v.x*scale; + result.y = v.y*scale; + } + else if (length > max) + { + float scale = max/length; + result.x = v.x*scale; + result.y = v.y*scale; + } + } + + return result; +} + +// Check whether two given vectors are almost equal +RMAPI int Vector2Equals(Vector2 p, Vector2 q) +{ + int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))); + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vector3 math +//---------------------------------------------------------------------------------- + +// Vector with components value 0.0f +RMAPI Vector3 Vector3Zero(void) +{ + Vector3 result = { 0.0f, 0.0f, 0.0f }; + + return result; +} + +// Vector with components value 1.0f +RMAPI Vector3 Vector3One(void) +{ + Vector3 result = { 1.0f, 1.0f, 1.0f }; + + return result; +} + +// Add two vectors +RMAPI Vector3 Vector3Add(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z }; + + return result; +} + +// Add vector and float value +RMAPI Vector3 Vector3AddValue(Vector3 v, float add) +{ + Vector3 result = { v.x + add, v.y + add, v.z + add }; + + return result; +} + +// Subtract two vectors +RMAPI Vector3 Vector3Subtract(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z }; + + return result; +} + +// Subtract vector by float value +RMAPI Vector3 Vector3SubtractValue(Vector3 v, float sub) +{ + Vector3 result = { v.x - sub, v.y - sub, v.z - sub }; + + return result; +} + +// Multiply vector by scalar +RMAPI Vector3 Vector3Scale(Vector3 v, float scalar) +{ + Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar }; + + return result; +} + +// Multiply vector by vector +RMAPI Vector3 Vector3Multiply(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z }; + + return result; +} + +// Calculate two vectors cross product +RMAPI Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; + + return result; +} + +// Calculate one vector perpendicular vector +RMAPI Vector3 Vector3Perpendicular(Vector3 v) +{ + Vector3 result = { 0 }; + + float min = (float) fabs(v.x); + Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f}; + + if (fabsf(v.y) < min) + { + min = (float) fabs(v.y); + Vector3 tmp = {0.0f, 1.0f, 0.0f}; + cardinalAxis = tmp; + } + + if (fabsf(v.z) < min) + { + Vector3 tmp = {0.0f, 0.0f, 1.0f}; + cardinalAxis = tmp; + } + + // Cross product between vectors + result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y; + result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z; + result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x; + + return result; +} + +// Calculate vector length +RMAPI float Vector3Length(const Vector3 v) +{ + float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + + return result; +} + +// Calculate vector square length +RMAPI float Vector3LengthSqr(const Vector3 v) +{ + float result = v.x*v.x + v.y*v.y + v.z*v.z; + + return result; +} + +// Calculate two vectors dot product +RMAPI float Vector3DotProduct(Vector3 v1, Vector3 v2) +{ + float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + + return result; +} + +// Calculate distance between two vectors +RMAPI float Vector3Distance(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + result = sqrtf(dx*dx + dy*dy + dz*dz); + + return result; +} + +// Calculate square distance between two vectors +RMAPI float Vector3DistanceSqr(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + result = dx*dx + dy*dy + dz*dz; + + return result; +} + +// Calculate angle between two vectors +RMAPI float Vector3Angle(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + Vector3 cross = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; + float len = sqrtf(cross.x*cross.x + cross.y*cross.y + cross.z*cross.z); + float dot = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + result = atan2f(len, dot); + + return result; +} + +// Negate provided vector (invert direction) +RMAPI Vector3 Vector3Negate(Vector3 v) +{ + Vector3 result = { -v.x, -v.y, -v.z }; + + return result; +} + +// Divide vector by vector +RMAPI Vector3 Vector3Divide(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z }; + + return result; +} + +// Normalize provided vector +RMAPI Vector3 Vector3Normalize(Vector3 v) +{ + Vector3 result = v; + + float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x *= ilength; + result.y *= ilength; + result.z *= ilength; + + return result; +} + +// Orthonormalize provided vectors +// Makes vectors normalized and orthogonal to each other +// Gram-Schmidt function implementation +RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2) +{ + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Normalize(*v1); + Vector3 v = *v1; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + v1->x *= ilength; + v1->y *= ilength; + v1->z *= ilength; + + // Vector3CrossProduct(*v1, *v2) + Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x }; + + // Vector3Normalize(vn1); + v = vn1; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vn1.x *= ilength; + vn1.y *= ilength; + vn1.z *= ilength; + + // Vector3CrossProduct(vn1, *v1) + Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x }; + + *v2 = vn2; +} + +// Transforms a Vector3 by a given Matrix +RMAPI Vector3 Vector3Transform(Vector3 v, Matrix mat) +{ + Vector3 result = { 0 }; + + float x = v.x; + float y = v.y; + float z = v.z; + + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; + result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14; + + return result; +} + +// Transform a vector by quaternion rotation +RMAPI Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q) +{ + Vector3 result = { 0 }; + + result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y); + result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z); + result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z); + + return result; +} + +// Rotates a vector around an axis +RMAPI Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle) +{ + // Using Euler-Rodrigues Formula + // Ref.: https://en.wikipedia.org/w/index.php?title=Euler%E2%80%93Rodrigues_formula + + Vector3 result = v; + + // Vector3Normalize(axis); + float length = sqrtf(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f / length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; + + angle /= 2.0f; + float a = sinf(angle); + float b = axis.x * a; + float c = axis.y * a; + float d = axis.z * a; + a = cosf(angle); + Vector3 w = { b, c, d }; + + // Vector3CrossProduct(w, v) + Vector3 wv = { w.y * v.z - w.z * v.y, w.z * v.x - w.x * v.z, w.x * v.y - w.y * v.x }; + + // Vector3CrossProduct(w, wv) + Vector3 wwv = { w.y * wv.z - w.z * wv.y, w.z * wv.x - w.x * wv.z, w.x * wv.y - w.y * wv.x }; + + // Vector3Scale(wv, 2 * a) + a *= 2; + wv.x *= a; + wv.y *= a; + wv.z *= a; + + // Vector3Scale(wwv, 2) + wwv.x *= 2; + wwv.y *= 2; + wwv.z *= 2; + + result.x += wv.x; + result.y += wv.y; + result.z += wv.z; + + result.x += wwv.x; + result.y += wwv.y; + result.z += wwv.z; + + return result; +} + +// Calculate linear interpolation between two vectors +RMAPI Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount) +{ + Vector3 result = { 0 }; + + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + result.z = v1.z + amount*(v2.z - v1.z); + + return result; +} + +// Calculate reflected vector to normal +RMAPI Vector3 Vector3Reflect(Vector3 v, Vector3 normal) +{ + Vector3 result = { 0 }; + + // I is the original vector + // N is the normal of the incident plane + // R = I - (2*N*(DotProduct[I, N])) + + float dotProduct = (v.x*normal.x + v.y*normal.y + v.z*normal.z); + + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + result.z = v.z - (2.0f*normal.z)*dotProduct; + + return result; +} + +// Get min value for each pair of components +RMAPI Vector3 Vector3Min(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + result.x = fminf(v1.x, v2.x); + result.y = fminf(v1.y, v2.y); + result.z = fminf(v1.z, v2.z); + + return result; +} + +// Get max value for each pair of components +RMAPI Vector3 Vector3Max(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + result.x = fmaxf(v1.x, v2.x); + result.y = fmaxf(v1.y, v2.y); + result.z = fmaxf(v1.z, v2.z); + + return result; +} + +// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) +// NOTE: Assumes P is on the plane of the triangle +RMAPI Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c) +{ + Vector3 result = { 0 }; + + Vector3 v0 = { b.x - a.x, b.y - a.y, b.z - a.z }; // Vector3Subtract(b, a) + Vector3 v1 = { c.x - a.x, c.y - a.y, c.z - a.z }; // Vector3Subtract(c, a) + Vector3 v2 = { p.x - a.x, p.y - a.y, p.z - a.z }; // Vector3Subtract(p, a) + float d00 = (v0.x*v0.x + v0.y*v0.y + v0.z*v0.z); // Vector3DotProduct(v0, v0) + float d01 = (v0.x*v1.x + v0.y*v1.y + v0.z*v1.z); // Vector3DotProduct(v0, v1) + float d11 = (v1.x*v1.x + v1.y*v1.y + v1.z*v1.z); // Vector3DotProduct(v1, v1) + float d20 = (v2.x*v0.x + v2.y*v0.y + v2.z*v0.z); // Vector3DotProduct(v2, v0) + float d21 = (v2.x*v1.x + v2.y*v1.y + v2.z*v1.z); // Vector3DotProduct(v2, v1) + + float denom = d00*d11 - d01*d01; + + result.y = (d11*d20 - d01*d21)/denom; + result.z = (d00*d21 - d01*d20)/denom; + result.x = 1.0f - (result.z + result.y); + + return result; +} + +// Projects a Vector3 from screen space into object space +// NOTE: We are avoiding calling other raymath functions despite available +RMAPI Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view) +{ + Vector3 result = { 0 }; + + // Calculate unprojected matrix (multiply view matrix by projection matrix) and invert it + Matrix matViewProj = { // MatrixMultiply(view, projection); + view.m0*projection.m0 + view.m1*projection.m4 + view.m2*projection.m8 + view.m3*projection.m12, + view.m0*projection.m1 + view.m1*projection.m5 + view.m2*projection.m9 + view.m3*projection.m13, + view.m0*projection.m2 + view.m1*projection.m6 + view.m2*projection.m10 + view.m3*projection.m14, + view.m0*projection.m3 + view.m1*projection.m7 + view.m2*projection.m11 + view.m3*projection.m15, + view.m4*projection.m0 + view.m5*projection.m4 + view.m6*projection.m8 + view.m7*projection.m12, + view.m4*projection.m1 + view.m5*projection.m5 + view.m6*projection.m9 + view.m7*projection.m13, + view.m4*projection.m2 + view.m5*projection.m6 + view.m6*projection.m10 + view.m7*projection.m14, + view.m4*projection.m3 + view.m5*projection.m7 + view.m6*projection.m11 + view.m7*projection.m15, + view.m8*projection.m0 + view.m9*projection.m4 + view.m10*projection.m8 + view.m11*projection.m12, + view.m8*projection.m1 + view.m9*projection.m5 + view.m10*projection.m9 + view.m11*projection.m13, + view.m8*projection.m2 + view.m9*projection.m6 + view.m10*projection.m10 + view.m11*projection.m14, + view.m8*projection.m3 + view.m9*projection.m7 + view.m10*projection.m11 + view.m11*projection.m15, + view.m12*projection.m0 + view.m13*projection.m4 + view.m14*projection.m8 + view.m15*projection.m12, + view.m12*projection.m1 + view.m13*projection.m5 + view.m14*projection.m9 + view.m15*projection.m13, + view.m12*projection.m2 + view.m13*projection.m6 + view.m14*projection.m10 + view.m15*projection.m14, + view.m12*projection.m3 + view.m13*projection.m7 + view.m14*projection.m11 + view.m15*projection.m15 }; + + // Calculate inverted matrix -> MatrixInvert(matViewProj); + // Cache the matrix values (speed optimization) + float a00 = matViewProj.m0, a01 = matViewProj.m1, a02 = matViewProj.m2, a03 = matViewProj.m3; + float a10 = matViewProj.m4, a11 = matViewProj.m5, a12 = matViewProj.m6, a13 = matViewProj.m7; + float a20 = matViewProj.m8, a21 = matViewProj.m9, a22 = matViewProj.m10, a23 = matViewProj.m11; + float a30 = matViewProj.m12, a31 = matViewProj.m13, a32 = matViewProj.m14, a33 = matViewProj.m15; + + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; + + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); + + Matrix matViewProjInv = { + (a11*b11 - a12*b10 + a13*b09)*invDet, + (-a01*b11 + a02*b10 - a03*b09)*invDet, + (a31*b05 - a32*b04 + a33*b03)*invDet, + (-a21*b05 + a22*b04 - a23*b03)*invDet, + (-a10*b11 + a12*b08 - a13*b07)*invDet, + (a00*b11 - a02*b08 + a03*b07)*invDet, + (-a30*b05 + a32*b02 - a33*b01)*invDet, + (a20*b05 - a22*b02 + a23*b01)*invDet, + (a10*b10 - a11*b08 + a13*b06)*invDet, + (-a00*b10 + a01*b08 - a03*b06)*invDet, + (a30*b04 - a31*b02 + a33*b00)*invDet, + (-a20*b04 + a21*b02 - a23*b00)*invDet, + (-a10*b09 + a11*b07 - a12*b06)*invDet, + (a00*b09 - a01*b07 + a02*b06)*invDet, + (-a30*b03 + a31*b01 - a32*b00)*invDet, + (a20*b03 - a21*b01 + a22*b00)*invDet }; + + // Create quaternion from source point + Quaternion quat = { source.x, source.y, source.z, 1.0f }; + + // Multiply quat point by unprojecte matrix + Quaternion qtransformed = { // QuaternionTransform(quat, matViewProjInv) + matViewProjInv.m0*quat.x + matViewProjInv.m4*quat.y + matViewProjInv.m8*quat.z + matViewProjInv.m12*quat.w, + matViewProjInv.m1*quat.x + matViewProjInv.m5*quat.y + matViewProjInv.m9*quat.z + matViewProjInv.m13*quat.w, + matViewProjInv.m2*quat.x + matViewProjInv.m6*quat.y + matViewProjInv.m10*quat.z + matViewProjInv.m14*quat.w, + matViewProjInv.m3*quat.x + matViewProjInv.m7*quat.y + matViewProjInv.m11*quat.z + matViewProjInv.m15*quat.w }; + + // Normalized world points in vectors + result.x = qtransformed.x/qtransformed.w; + result.y = qtransformed.y/qtransformed.w; + result.z = qtransformed.z/qtransformed.w; + + return result; +} + +// Get Vector3 as float array +RMAPI float3 Vector3ToFloatV(Vector3 v) +{ + float3 buffer = { 0 }; + + buffer.v[0] = v.x; + buffer.v[1] = v.y; + buffer.v[2] = v.z; + + return buffer; +} + +// Invert the given vector +RMAPI Vector3 Vector3Invert(Vector3 v) +{ + Vector3 result = { 1.0f/v.x, 1.0f/v.y, 1.0f/v.z }; + + return result; +} + +// Clamp the components of the vector between +// min and max values specified by the given vectors +RMAPI Vector3 Vector3Clamp(Vector3 v, Vector3 min, Vector3 max) +{ + Vector3 result = { 0 }; + + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + result.z = fminf(max.z, fmaxf(min.z, v.z)); + + return result; +} + +// Clamp the magnitude of the vector between two values +RMAPI Vector3 Vector3ClampValue(Vector3 v, float min, float max) +{ + Vector3 result = v; + + float length = (v.x*v.x) + (v.y*v.y) + (v.z*v.z); + if (length > 0.0f) + { + length = sqrtf(length); + + if (length < min) + { + float scale = min/length; + result.x = v.x*scale; + result.y = v.y*scale; + result.z = v.z*scale; + } + else if (length > max) + { + float scale = max/length; + result.x = v.x*scale; + result.y = v.y*scale; + result.z = v.z*scale; + } + } + + return result; +} + +// Check whether two given vectors are almost equal +RMAPI int Vector3Equals(Vector3 p, Vector3 q) +{ + int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))); + + return result; +} + +// Compute the direction of a refracted ray where v specifies the +// normalized direction of the incoming ray, n specifies the +// normalized normal vector of the interface of two optical media, +// and r specifies the ratio of the refractive index of the medium +// from where the ray comes to the refractive index of the medium +// on the other side of the surface +RMAPI Vector3 Vector3Refract(Vector3 v, Vector3 n, float r) +{ + Vector3 result = { 0 }; + + float dot = v.x*n.x + v.y*n.y + v.z*n.z; + float d = 1.0f - r*r*(1.0f - dot*dot); + + if (d >= 0.0f) + { + d = sqrtf(d); + v.x = r*v.x - (r*dot + d)*n.x; + v.y = r*v.y - (r*dot + d)*n.y; + v.z = r*v.z - (r*dot + d)*n.z; + + result = v; + } + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Matrix math +//---------------------------------------------------------------------------------- + +// Compute matrix determinant +RMAPI float MatrixDeterminant(Matrix mat) +{ + float result = 0.0f; + + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + + result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 + + a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 + + a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 + + a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 + + a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 + + a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33; + + return result; +} + +// Get the trace of the matrix (sum of the values along the diagonal) +RMAPI float MatrixTrace(Matrix mat) +{ + float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15); + + return result; +} + +// Transposes provided matrix +RMAPI Matrix MatrixTranspose(Matrix mat) +{ + Matrix result = { 0 }; + + result.m0 = mat.m0; + result.m1 = mat.m4; + result.m2 = mat.m8; + result.m3 = mat.m12; + result.m4 = mat.m1; + result.m5 = mat.m5; + result.m6 = mat.m9; + result.m7 = mat.m13; + result.m8 = mat.m2; + result.m9 = mat.m6; + result.m10 = mat.m10; + result.m11 = mat.m14; + result.m12 = mat.m3; + result.m13 = mat.m7; + result.m14 = mat.m11; + result.m15 = mat.m15; + + return result; +} + +// Invert provided matrix +RMAPI Matrix MatrixInvert(Matrix mat) +{ + Matrix result = { 0 }; + + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; + + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); + + result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet; + result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet; + result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet; + result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet; + result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet; + result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet; + result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet; + result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet; + result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet; + result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet; + result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet; + result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet; + result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet; + result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet; + result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet; + result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet; + + return result; +} + +// Get identity matrix +RMAPI Matrix MatrixIdentity(void) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Add two matrices +RMAPI Matrix MatrixAdd(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0 + right.m0; + result.m1 = left.m1 + right.m1; + result.m2 = left.m2 + right.m2; + result.m3 = left.m3 + right.m3; + result.m4 = left.m4 + right.m4; + result.m5 = left.m5 + right.m5; + result.m6 = left.m6 + right.m6; + result.m7 = left.m7 + right.m7; + result.m8 = left.m8 + right.m8; + result.m9 = left.m9 + right.m9; + result.m10 = left.m10 + right.m10; + result.m11 = left.m11 + right.m11; + result.m12 = left.m12 + right.m12; + result.m13 = left.m13 + right.m13; + result.m14 = left.m14 + right.m14; + result.m15 = left.m15 + right.m15; + + return result; +} + +// Subtract two matrices (left - right) +RMAPI Matrix MatrixSubtract(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0 - right.m0; + result.m1 = left.m1 - right.m1; + result.m2 = left.m2 - right.m2; + result.m3 = left.m3 - right.m3; + result.m4 = left.m4 - right.m4; + result.m5 = left.m5 - right.m5; + result.m6 = left.m6 - right.m6; + result.m7 = left.m7 - right.m7; + result.m8 = left.m8 - right.m8; + result.m9 = left.m9 - right.m9; + result.m10 = left.m10 - right.m10; + result.m11 = left.m11 - right.m11; + result.m12 = left.m12 - right.m12; + result.m13 = left.m13 - right.m13; + result.m14 = left.m14 - right.m14; + result.m15 = left.m15 - right.m15; + + return result; +} + +// Get two matrix multiplication +// NOTE: When multiplying matrices... the order matters! +RMAPI Matrix MatrixMultiply(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; + + return result; +} + +// Get translation matrix +RMAPI Matrix MatrixTranslate(float x, float y, float z) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Create rotation matrix from axis and angle +// NOTE: Angle should be provided in radians +RMAPI Matrix MatrixRotate(Vector3 axis, float angle) +{ + Matrix result = { 0 }; + + float x = axis.x, y = axis.y, z = axis.z; + + float lengthSquared = x*x + y*y + z*z; + + if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) + { + float ilength = 1.0f/sqrtf(lengthSquared); + x *= ilength; + y *= ilength; + z *= ilength; + } + + float sinres = sinf(angle); + float cosres = cosf(angle); + float t = 1.0f - cosres; + + result.m0 = x*x*t + cosres; + result.m1 = y*x*t + z*sinres; + result.m2 = z*x*t - y*sinres; + result.m3 = 0.0f; + + result.m4 = x*y*t - z*sinres; + result.m5 = y*y*t + cosres; + result.m6 = z*y*t + x*sinres; + result.m7 = 0.0f; + + result.m8 = x*z*t + y*sinres; + result.m9 = y*z*t - x*sinres; + result.m10 = z*z*t + cosres; + result.m11 = 0.0f; + + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = 0.0f; + result.m15 = 1.0f; + + return result; +} + +// Get x-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateX(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m5 = cosres; + result.m6 = sinres; + result.m9 = -sinres; + result.m10 = cosres; + + return result; +} + +// Get y-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateY(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m0 = cosres; + result.m2 = -sinres; + result.m8 = sinres; + result.m10 = cosres; + + return result; +} + +// Get z-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateZ(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m0 = cosres; + result.m1 = sinres; + result.m4 = -sinres; + result.m5 = cosres; + + return result; +} + + +// Get xyz-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateXYZ(Vector3 angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosz = cosf(-angle.z); + float sinz = sinf(-angle.z); + float cosy = cosf(-angle.y); + float siny = sinf(-angle.y); + float cosx = cosf(-angle.x); + float sinx = sinf(-angle.x); + + result.m0 = cosz*cosy; + result.m1 = (cosz*siny*sinx) - (sinz*cosx); + result.m2 = (cosz*siny*cosx) + (sinz*sinx); + + result.m4 = sinz*cosy; + result.m5 = (sinz*siny*sinx) + (cosz*cosx); + result.m6 = (sinz*siny*cosx) - (cosz*sinx); + + result.m8 = -siny; + result.m9 = cosy*sinx; + result.m10= cosy*cosx; + + return result; +} + +// Get zyx-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateZYX(Vector3 angle) +{ + Matrix result = { 0 }; + + float cz = cosf(angle.z); + float sz = sinf(angle.z); + float cy = cosf(angle.y); + float sy = sinf(angle.y); + float cx = cosf(angle.x); + float sx = sinf(angle.x); + + result.m0 = cz*cy; + result.m4 = cz*sy*sx - cx*sz; + result.m8 = sz*sx + cz*cx*sy; + result.m12 = 0; + + result.m1 = cy*sz; + result.m5 = cz*cx + sz*sy*sx; + result.m9 = cx*sz*sy - cz*sx; + result.m13 = 0; + + result.m2 = -sy; + result.m6 = cy*sx; + result.m10 = cy*cx; + result.m14 = 0; + + result.m3 = 0; + result.m7 = 0; + result.m11 = 0; + result.m15 = 1; + + return result; +} + +// Get scaling matrix +RMAPI Matrix MatrixScale(float x, float y, float z) +{ + Matrix result = { x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Get perspective projection matrix +RMAPI Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far) +{ + Matrix result = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(far - near); + + result.m0 = ((float)near*2.0f)/rl; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + + result.m4 = 0.0f; + result.m5 = ((float)near*2.0f)/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + + result.m8 = ((float)right + (float)left)/rl; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)far + (float)near)/fn; + result.m11 = -1.0f; + + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = -((float)far*(float)near*2.0f)/fn; + result.m15 = 0.0f; + + return result; +} + +// Get perspective projection matrix +// NOTE: Fovy angle must be provided in radians +RMAPI Matrix MatrixPerspective(double fovy, double aspect, double near, double far) +{ + Matrix result = { 0 }; + + double top = near*tan(fovy*0.5); + double bottom = -top; + double right = top*aspect; + double left = -right; + + // MatrixFrustum(-right, right, -top, top, near, far); + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(far - near); + + result.m0 = ((float)near*2.0f)/rl; + result.m5 = ((float)near*2.0f)/tb; + result.m8 = ((float)right + (float)left)/rl; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)far + (float)near)/fn; + result.m11 = -1.0f; + result.m14 = -((float)far*(float)near*2.0f)/fn; + + return result; +} + +// Get orthographic projection matrix +RMAPI Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far) +{ + Matrix result = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(far - near); + + result.m0 = 2.0f/rl; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + result.m4 = 0.0f; + result.m5 = 2.0f/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + result.m8 = 0.0f; + result.m9 = 0.0f; + result.m10 = -2.0f/fn; + result.m11 = 0.0f; + result.m12 = -((float)left + (float)right)/rl; + result.m13 = -((float)top + (float)bottom)/tb; + result.m14 = -((float)far + (float)near)/fn; + result.m15 = 1.0f; + + return result; +} + +// Get camera look-at matrix (view matrix) +RMAPI Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up) +{ + Matrix result = { 0 }; + + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Subtract(eye, target) + Vector3 vz = { eye.x - target.x, eye.y - target.y, eye.z - target.z }; + + // Vector3Normalize(vz) + Vector3 v = vz; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vz.x *= ilength; + vz.y *= ilength; + vz.z *= ilength; + + // Vector3CrossProduct(up, vz) + Vector3 vx = { up.y*vz.z - up.z*vz.y, up.z*vz.x - up.x*vz.z, up.x*vz.y - up.y*vz.x }; + + // Vector3Normalize(x) + v = vx; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vx.x *= ilength; + vx.y *= ilength; + vx.z *= ilength; + + // Vector3CrossProduct(vz, vx) + Vector3 vy = { vz.y*vx.z - vz.z*vx.y, vz.z*vx.x - vz.x*vx.z, vz.x*vx.y - vz.y*vx.x }; + + result.m0 = vx.x; + result.m1 = vy.x; + result.m2 = vz.x; + result.m3 = 0.0f; + result.m4 = vx.y; + result.m5 = vy.y; + result.m6 = vz.y; + result.m7 = 0.0f; + result.m8 = vx.z; + result.m9 = vy.z; + result.m10 = vz.z; + result.m11 = 0.0f; + result.m12 = -(vx.x*eye.x + vx.y*eye.y + vx.z*eye.z); // Vector3DotProduct(vx, eye) + result.m13 = -(vy.x*eye.x + vy.y*eye.y + vy.z*eye.z); // Vector3DotProduct(vy, eye) + result.m14 = -(vz.x*eye.x + vz.y*eye.y + vz.z*eye.z); // Vector3DotProduct(vz, eye) + result.m15 = 1.0f; + + return result; +} + +// Get float array of matrix data +RMAPI float16 MatrixToFloatV(Matrix mat) +{ + float16 result = { 0 }; + + result.v[0] = mat.m0; + result.v[1] = mat.m1; + result.v[2] = mat.m2; + result.v[3] = mat.m3; + result.v[4] = mat.m4; + result.v[5] = mat.m5; + result.v[6] = mat.m6; + result.v[7] = mat.m7; + result.v[8] = mat.m8; + result.v[9] = mat.m9; + result.v[10] = mat.m10; + result.v[11] = mat.m11; + result.v[12] = mat.m12; + result.v[13] = mat.m13; + result.v[14] = mat.m14; + result.v[15] = mat.m15; + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Quaternion math +//---------------------------------------------------------------------------------- + +// Add two quaternions +RMAPI Quaternion QuaternionAdd(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w}; + + return result; +} + +// Add quaternion and float value +RMAPI Quaternion QuaternionAddValue(Quaternion q, float add) +{ + Quaternion result = {q.x + add, q.y + add, q.z + add, q.w + add}; + + return result; +} + +// Subtract two quaternions +RMAPI Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w}; + + return result; +} + +// Subtract quaternion and float value +RMAPI Quaternion QuaternionSubtractValue(Quaternion q, float sub) +{ + Quaternion result = {q.x - sub, q.y - sub, q.z - sub, q.w - sub}; + + return result; +} + +// Get identity quaternion +RMAPI Quaternion QuaternionIdentity(void) +{ + Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Computes the length of a quaternion +RMAPI float QuaternionLength(Quaternion q) +{ + float result = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + + return result; +} + +// Normalize provided quaternion +RMAPI Quaternion QuaternionNormalize(Quaternion q) +{ + Quaternion result = { 0 }; + + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Invert provided quaternion +RMAPI Quaternion QuaternionInvert(Quaternion q) +{ + Quaternion result = q; + + float lengthSq = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w; + + if (lengthSq != 0.0f) + { + float invLength = 1.0f/lengthSq; + + result.x *= -invLength; + result.y *= -invLength; + result.z *= -invLength; + result.w *= invLength; + } + + return result; +} + +// Calculate two quaternion multiplication +RMAPI Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2) +{ + Quaternion result = { 0 }; + + float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w; + float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w; + + result.x = qax*qbw + qaw*qbx + qay*qbz - qaz*qby; + result.y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz; + result.z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx; + result.w = qaw*qbw - qax*qbx - qay*qby - qaz*qbz; + + return result; +} + +// Scale quaternion by float value +RMAPI Quaternion QuaternionScale(Quaternion q, float mul) +{ + Quaternion result = { 0 }; + + result.x = q.x*mul; + result.y = q.y*mul; + result.z = q.z*mul; + result.w = q.w*mul; + + return result; +} + +// Divide two quaternions +RMAPI Quaternion QuaternionDivide(Quaternion q1, Quaternion q2) +{ + Quaternion result = { q1.x/q2.x, q1.y/q2.y, q1.z/q2.z, q1.w/q2.w }; + + return result; +} + +// Calculate linear interpolation between two quaternions +RMAPI Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); + + return result; +} + +// Calculate slerp-optimized interpolation between two quaternions +RMAPI Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + // QuaternionLerp(q1, q2, amount) + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); + + // QuaternionNormalize(q); + Quaternion q = result; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Calculates spherical linear interpolation between two quaternions +RMAPI Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w; + + if (cosHalfTheta < 0) + { + q2.x = -q2.x; q2.y = -q2.y; q2.z = -q2.z; q2.w = -q2.w; + cosHalfTheta = -cosHalfTheta; + } + + if (fabsf(cosHalfTheta) >= 1.0f) result = q1; + else if (cosHalfTheta > 0.95f) result = QuaternionNlerp(q1, q2, amount); + else + { + float halfTheta = acosf(cosHalfTheta); + float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta); + + if (fabsf(sinHalfTheta) < 0.001f) + { + result.x = (q1.x*0.5f + q2.x*0.5f); + result.y = (q1.y*0.5f + q2.y*0.5f); + result.z = (q1.z*0.5f + q2.z*0.5f); + result.w = (q1.w*0.5f + q2.w*0.5f); + } + else + { + float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta; + float ratioB = sinf(amount*halfTheta)/sinHalfTheta; + + result.x = (q1.x*ratioA + q2.x*ratioB); + result.y = (q1.y*ratioA + q2.y*ratioB); + result.z = (q1.z*ratioA + q2.z*ratioB); + result.w = (q1.w*ratioA + q2.w*ratioB); + } + } + + return result; +} + +// Calculate quaternion based on the rotation from one vector to another +RMAPI Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to) +{ + Quaternion result = { 0 }; + + float cos2Theta = (from.x*to.x + from.y*to.y + from.z*to.z); // Vector3DotProduct(from, to) + Vector3 cross = { from.y*to.z - from.z*to.y, from.z*to.x - from.x*to.z, from.x*to.y - from.y*to.x }; // Vector3CrossProduct(from, to) + + result.x = cross.x; + result.y = cross.y; + result.z = cross.z; + result.w = 1.0f + cos2Theta; + + // QuaternionNormalize(q); + // NOTE: Normalize to essentially nlerp the original and identity to 0.5 + Quaternion q = result; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Get a quaternion for a given rotation matrix +RMAPI Quaternion QuaternionFromMatrix(Matrix mat) +{ + Quaternion result = { 0 }; + + float fourWSquaredMinus1 = mat.m0 + mat.m5 + mat.m10; + float fourXSquaredMinus1 = mat.m0 - mat.m5 - mat.m10; + float fourYSquaredMinus1 = mat.m5 - mat.m0 - mat.m10; + float fourZSquaredMinus1 = mat.m10 - mat.m0 - mat.m5; + + int biggestIndex = 0; + float fourBiggestSquaredMinus1 = fourWSquaredMinus1; + if (fourXSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourXSquaredMinus1; + biggestIndex = 1; + } + + if (fourYSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourYSquaredMinus1; + biggestIndex = 2; + } + + if (fourZSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourZSquaredMinus1; + biggestIndex = 3; + } + + float biggestVal = sqrtf(fourBiggestSquaredMinus1 + 1.0f) * 0.5f; + float mult = 0.25f / biggestVal; + + switch (biggestIndex) + { + case 0: + result.w = biggestVal; + result.x = (mat.m6 - mat.m9) * mult; + result.y = (mat.m8 - mat.m2) * mult; + result.z = (mat.m1 - mat.m4) * mult; + break; + case 1: + result.x = biggestVal; + result.w = (mat.m6 - mat.m9) * mult; + result.y = (mat.m1 + mat.m4) * mult; + result.z = (mat.m8 + mat.m2) * mult; + break; + case 2: + result.y = biggestVal; + result.w = (mat.m8 - mat.m2) * mult; + result.x = (mat.m1 + mat.m4) * mult; + result.z = (mat.m6 + mat.m9) * mult; + break; + case 3: + result.z = biggestVal; + result.w = (mat.m1 - mat.m4) * mult; + result.x = (mat.m8 + mat.m2) * mult; + result.y = (mat.m6 + mat.m9) * mult; + break; + } + + return result; +} + +// Get a matrix for a given quaternion +RMAPI Matrix QuaternionToMatrix(Quaternion q) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float a2 = q.x*q.x; + float b2 = q.y*q.y; + float c2 = q.z*q.z; + float ac = q.x*q.z; + float ab = q.x*q.y; + float bc = q.y*q.z; + float ad = q.w*q.x; + float bd = q.w*q.y; + float cd = q.w*q.z; + + result.m0 = 1 - 2*(b2 + c2); + result.m1 = 2*(ab + cd); + result.m2 = 2*(ac - bd); + + result.m4 = 2*(ab - cd); + result.m5 = 1 - 2*(a2 + c2); + result.m6 = 2*(bc + ad); + + result.m8 = 2*(ac + bd); + result.m9 = 2*(bc - ad); + result.m10 = 1 - 2*(a2 + b2); + + return result; +} + +// Get rotation quaternion for an angle and axis +// NOTE: Angle must be provided in radians +RMAPI Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle) +{ + Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + + float axisLength = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); + + if (axisLength != 0.0f) + { + angle *= 0.5f; + + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Normalize(axis) + Vector3 v = axis; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; + + float sinres = sinf(angle); + float cosres = cosf(angle); + + result.x = axis.x*sinres; + result.y = axis.y*sinres; + result.z = axis.z*sinres; + result.w = cosres; + + // QuaternionNormalize(q); + Quaternion q = result; + length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + } + + return result; +} + +// Get the rotation angle and axis for a given quaternion +RMAPI void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle) +{ + if (fabsf(q.w) > 1.0f) + { + // QuaternionNormalize(q); + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + q.x = q.x*ilength; + q.y = q.y*ilength; + q.z = q.z*ilength; + q.w = q.w*ilength; + } + + Vector3 resAxis = { 0.0f, 0.0f, 0.0f }; + float resAngle = 2.0f*acosf(q.w); + float den = sqrtf(1.0f - q.w*q.w); + + if (den > 0.0001f) + { + resAxis.x = q.x/den; + resAxis.y = q.y/den; + resAxis.z = q.z/den; + } + else + { + // This occurs when the angle is zero. + // Not a problem: just set an arbitrary normalized axis. + resAxis.x = 1.0f; + } + + *outAxis = resAxis; + *outAngle = resAngle; +} + +// Get the quaternion equivalent to Euler angles +// NOTE: Rotation order is ZYX +RMAPI Quaternion QuaternionFromEuler(float pitch, float yaw, float roll) +{ + Quaternion result = { 0 }; + + float x0 = cosf(pitch*0.5f); + float x1 = sinf(pitch*0.5f); + float y0 = cosf(yaw*0.5f); + float y1 = sinf(yaw*0.5f); + float z0 = cosf(roll*0.5f); + float z1 = sinf(roll*0.5f); + + result.x = x1*y0*z0 - x0*y1*z1; + result.y = x0*y1*z0 + x1*y0*z1; + result.z = x0*y0*z1 - x1*y1*z0; + result.w = x0*y0*z0 + x1*y1*z1; + + return result; +} + +// Get the Euler angles equivalent to quaternion (roll, pitch, yaw) +// NOTE: Angles are returned in a Vector3 struct in radians +RMAPI Vector3 QuaternionToEuler(Quaternion q) +{ + Vector3 result = { 0 }; + + // Roll (x-axis rotation) + float x0 = 2.0f*(q.w*q.x + q.y*q.z); + float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y); + result.x = atan2f(x0, x1); + + // Pitch (y-axis rotation) + float y0 = 2.0f*(q.w*q.y - q.z*q.x); + y0 = y0 > 1.0f ? 1.0f : y0; + y0 = y0 < -1.0f ? -1.0f : y0; + result.y = asinf(y0); + + // Yaw (z-axis rotation) + float z0 = 2.0f*(q.w*q.z + q.x*q.y); + float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z); + result.z = atan2f(z0, z1); + + return result; +} + +// Transform a quaternion given a transformation matrix +RMAPI Quaternion QuaternionTransform(Quaternion q, Matrix mat) +{ + Quaternion result = { 0 }; + + result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w; + result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w; + result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w; + result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w; + + return result; +} + +// Check whether two given quaternions are almost equal +RMAPI int QuaternionEquals(Quaternion p, Quaternion q) +{ + int result = (((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && + ((fabsf(p.w - q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))) || + (((fabsf(p.x + q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y + q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z + q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && + ((fabsf(p.w + q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))); + + return result; +} + +#endif // RAYMATH_H diff --git a/lib/raylib-4.5.0_win64_msvc16/include/rlgl.h b/lib/raylib-4.5.0_win64_msvc16/include/rlgl.h new file mode 100644 index 0000000..86208de --- /dev/null +++ b/lib/raylib-4.5.0_win64_msvc16/include/rlgl.h @@ -0,0 +1,4740 @@ +/********************************************************************************************** +* +* rlgl v4.5 - A multi-OpenGL abstraction layer with an immediate-mode style API +* +* An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0) +* that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...) +* +* When choosing an OpenGL backend different than OpenGL 1.1, some internal buffer are +* initialized on rlglInit() to accumulate vertex data. +* +* When an internal state change is required all the stored vertex data is renderer in batch, +* additionally, rlDrawRenderBatchActive() could be called to force flushing of the batch. +* +* Some additional resources are also loaded for convenience, here the complete list: +* - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data +* - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8 +* - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs) +* +* Internal buffer (and additional resources) must be manually unloaded calling rlglClose(). +* +* +* CONFIGURATION: +* +* #define GRAPHICS_API_OPENGL_11 +* #define GRAPHICS_API_OPENGL_21 +* #define GRAPHICS_API_OPENGL_33 +* #define GRAPHICS_API_OPENGL_43 +* #define GRAPHICS_API_OPENGL_ES2 +* Use selected OpenGL graphics backend, should be supported by platform +* Those preprocessor defines are only used on rlgl module, if OpenGL version is +* required by any other module, use rlGetVersion() to check it +* +* #define RLGL_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RLGL_RENDER_TEXTURES_HINT +* Enable framebuffer objects (fbo) support (enabled by default) +* Some GPUs could not support them despite the OpenGL version +* +* #define RLGL_SHOW_GL_DETAILS_INFO +* Show OpenGL extensions and capabilities detailed logs on init +* +* #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT +* Enable debug context (only available on OpenGL 4.3) +* +* rlgl capabilities could be customized just defining some internal +* values before library inclusion (default values listed): +* +* #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 // Default internal render batch elements limits +* #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) +* #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) +* #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) +* +* #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of internal Matrix stack +* #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported +* #define RL_CULL_DISTANCE_NEAR 0.01 // Default projection matrix near cull distance +* #define RL_CULL_DISTANCE_FAR 1000.0 // Default projection matrix far cull distance +* +* When loading a shader, the following vertex attribute and uniform +* location names are tried to be set automatically: +* +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) +* +* DEPENDENCIES: +* +* - OpenGL libraries (depending on platform and OpenGL version selected) +* - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RLGL_H +#define RLGL_H + +#define RLGL_VERSION "4.5" + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +// Function specifiers definition +#ifndef RLAPI + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +// Support TRACELOG macros +#ifndef TRACELOG + #define TRACELOG(level, ...) (void)0 + #define TRACELOGD(...) (void)0 +#endif + +// Allow custom memory allocators +#ifndef RL_MALLOC + #define RL_MALLOC(sz) malloc(sz) +#endif +#ifndef RL_CALLOC + #define RL_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RL_REALLOC + #define RL_REALLOC(n,sz) realloc(n,sz) +#endif +#ifndef RL_FREE + #define RL_FREE(p) free(p) +#endif + +// Security check in case no GRAPHICS_API_OPENGL_* defined +#if !defined(GRAPHICS_API_OPENGL_11) && \ + !defined(GRAPHICS_API_OPENGL_21) && \ + !defined(GRAPHICS_API_OPENGL_33) && \ + !defined(GRAPHICS_API_OPENGL_43) && \ + !defined(GRAPHICS_API_OPENGL_ES2) + #define GRAPHICS_API_OPENGL_33 +#endif + +// Security check in case multiple GRAPHICS_API_OPENGL_* defined +#if defined(GRAPHICS_API_OPENGL_11) + #if defined(GRAPHICS_API_OPENGL_21) + #undef GRAPHICS_API_OPENGL_21 + #endif + #if defined(GRAPHICS_API_OPENGL_33) + #undef GRAPHICS_API_OPENGL_33 + #endif + #if defined(GRAPHICS_API_OPENGL_43) + #undef GRAPHICS_API_OPENGL_43 + #endif + #if defined(GRAPHICS_API_OPENGL_ES2) + #undef GRAPHICS_API_OPENGL_ES2 + #endif +#endif + +// OpenGL 2.1 uses most of OpenGL 3.3 Core functionality +// WARNING: Specific parts are checked with #if defines +#if defined(GRAPHICS_API_OPENGL_21) + #define GRAPHICS_API_OPENGL_33 +#endif + +// OpenGL 4.3 uses OpenGL 3.3 Core functionality +#if defined(GRAPHICS_API_OPENGL_43) + #define GRAPHICS_API_OPENGL_33 +#endif + +// Support framebuffer objects by default +// NOTE: Some driver implementation do not support it, despite they should +#define RLGL_RENDER_TEXTURES_HINT + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- + +// Default internal render batch elements limits +#ifndef RL_DEFAULT_BATCH_BUFFER_ELEMENTS + #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // This is the maximum amount of elements (quads) per batch + // NOTE: Be careful with text, every letter maps to a quad + #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 + #endif + #if defined(GRAPHICS_API_OPENGL_ES2) + // We reduce memory sizes for embedded systems (RPI and HTML5) + // NOTE: On HTML5 (emscripten) this is allocated on heap, + // by default it's only 16MB!...just take care... + #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 2048 + #endif +#endif +#ifndef RL_DEFAULT_BATCH_BUFFERS + #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) +#endif +#ifndef RL_DEFAULT_BATCH_DRAWCALLS + #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) +#endif +#ifndef RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS + #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) +#endif + +// Internal Matrix stack +#ifndef RL_MAX_MATRIX_STACK_SIZE + #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of Matrix stack +#endif + +// Shader limits +#ifndef RL_MAX_SHADER_LOCATIONS + #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported +#endif + +// Projection matrix culling +#ifndef RL_CULL_DISTANCE_NEAR + #define RL_CULL_DISTANCE_NEAR 0.01 // Default near cull distance +#endif +#ifndef RL_CULL_DISTANCE_FAR + #define RL_CULL_DISTANCE_FAR 1000.0 // Default far cull distance +#endif + +// Texture parameters (equivalent to OpenGL defines) +#define RL_TEXTURE_WRAP_S 0x2802 // GL_TEXTURE_WRAP_S +#define RL_TEXTURE_WRAP_T 0x2803 // GL_TEXTURE_WRAP_T +#define RL_TEXTURE_MAG_FILTER 0x2800 // GL_TEXTURE_MAG_FILTER +#define RL_TEXTURE_MIN_FILTER 0x2801 // GL_TEXTURE_MIN_FILTER + +#define RL_TEXTURE_FILTER_NEAREST 0x2600 // GL_NEAREST +#define RL_TEXTURE_FILTER_LINEAR 0x2601 // GL_LINEAR +#define RL_TEXTURE_FILTER_MIP_NEAREST 0x2700 // GL_NEAREST_MIPMAP_NEAREST +#define RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR 0x2702 // GL_NEAREST_MIPMAP_LINEAR +#define RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST 0x2701 // GL_LINEAR_MIPMAP_NEAREST +#define RL_TEXTURE_FILTER_MIP_LINEAR 0x2703 // GL_LINEAR_MIPMAP_LINEAR +#define RL_TEXTURE_FILTER_ANISOTROPIC 0x3000 // Anisotropic filter (custom identifier) +#define RL_TEXTURE_MIPMAP_BIAS_RATIO 0x4000 // Texture mipmap bias, percentage ratio (custom identifier) + +#define RL_TEXTURE_WRAP_REPEAT 0x2901 // GL_REPEAT +#define RL_TEXTURE_WRAP_CLAMP 0x812F // GL_CLAMP_TO_EDGE +#define RL_TEXTURE_WRAP_MIRROR_REPEAT 0x8370 // GL_MIRRORED_REPEAT +#define RL_TEXTURE_WRAP_MIRROR_CLAMP 0x8742 // GL_MIRROR_CLAMP_EXT + +// Matrix modes (equivalent to OpenGL) +#define RL_MODELVIEW 0x1700 // GL_MODELVIEW +#define RL_PROJECTION 0x1701 // GL_PROJECTION +#define RL_TEXTURE 0x1702 // GL_TEXTURE + +// Primitive assembly draw modes +#define RL_LINES 0x0001 // GL_LINES +#define RL_TRIANGLES 0x0004 // GL_TRIANGLES +#define RL_QUADS 0x0007 // GL_QUADS + +// GL equivalent data types +#define RL_UNSIGNED_BYTE 0x1401 // GL_UNSIGNED_BYTE +#define RL_FLOAT 0x1406 // GL_FLOAT + +// GL buffer usage hint +#define RL_STREAM_DRAW 0x88E0 // GL_STREAM_DRAW +#define RL_STREAM_READ 0x88E1 // GL_STREAM_READ +#define RL_STREAM_COPY 0x88E2 // GL_STREAM_COPY +#define RL_STATIC_DRAW 0x88E4 // GL_STATIC_DRAW +#define RL_STATIC_READ 0x88E5 // GL_STATIC_READ +#define RL_STATIC_COPY 0x88E6 // GL_STATIC_COPY +#define RL_DYNAMIC_DRAW 0x88E8 // GL_DYNAMIC_DRAW +#define RL_DYNAMIC_READ 0x88E9 // GL_DYNAMIC_READ +#define RL_DYNAMIC_COPY 0x88EA // GL_DYNAMIC_COPY + +// GL Shader type +#define RL_FRAGMENT_SHADER 0x8B30 // GL_FRAGMENT_SHADER +#define RL_VERTEX_SHADER 0x8B31 // GL_VERTEX_SHADER +#define RL_COMPUTE_SHADER 0x91B9 // GL_COMPUTE_SHADER + +// GL blending factors +#define RL_ZERO 0 // GL_ZERO +#define RL_ONE 1 // GL_ONE +#define RL_SRC_COLOR 0x0300 // GL_SRC_COLOR +#define RL_ONE_MINUS_SRC_COLOR 0x0301 // GL_ONE_MINUS_SRC_COLOR +#define RL_SRC_ALPHA 0x0302 // GL_SRC_ALPHA +#define RL_ONE_MINUS_SRC_ALPHA 0x0303 // GL_ONE_MINUS_SRC_ALPHA +#define RL_DST_ALPHA 0x0304 // GL_DST_ALPHA +#define RL_ONE_MINUS_DST_ALPHA 0x0305 // GL_ONE_MINUS_DST_ALPHA +#define RL_DST_COLOR 0x0306 // GL_DST_COLOR +#define RL_ONE_MINUS_DST_COLOR 0x0307 // GL_ONE_MINUS_DST_COLOR +#define RL_SRC_ALPHA_SATURATE 0x0308 // GL_SRC_ALPHA_SATURATE +#define RL_CONSTANT_COLOR 0x8001 // GL_CONSTANT_COLOR +#define RL_ONE_MINUS_CONSTANT_COLOR 0x8002 // GL_ONE_MINUS_CONSTANT_COLOR +#define RL_CONSTANT_ALPHA 0x8003 // GL_CONSTANT_ALPHA +#define RL_ONE_MINUS_CONSTANT_ALPHA 0x8004 // GL_ONE_MINUS_CONSTANT_ALPHA + +// GL blending functions/equations +#define RL_FUNC_ADD 0x8006 // GL_FUNC_ADD +#define RL_MIN 0x8007 // GL_MIN +#define RL_MAX 0x8008 // GL_MAX +#define RL_FUNC_SUBTRACT 0x800A // GL_FUNC_SUBTRACT +#define RL_FUNC_REVERSE_SUBTRACT 0x800B // GL_FUNC_REVERSE_SUBTRACT +#define RL_BLEND_EQUATION 0x8009 // GL_BLEND_EQUATION +#define RL_BLEND_EQUATION_RGB 0x8009 // GL_BLEND_EQUATION_RGB // (Same as BLEND_EQUATION) +#define RL_BLEND_EQUATION_ALPHA 0x883D // GL_BLEND_EQUATION_ALPHA +#define RL_BLEND_DST_RGB 0x80C8 // GL_BLEND_DST_RGB +#define RL_BLEND_SRC_RGB 0x80C9 // GL_BLEND_SRC_RGB +#define RL_BLEND_DST_ALPHA 0x80CA // GL_BLEND_DST_ALPHA +#define RL_BLEND_SRC_ALPHA 0x80CB // GL_BLEND_SRC_ALPHA +#define RL_BLEND_COLOR 0x8005 // GL_BLEND_COLOR + + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE) + // Boolean type +typedef enum bool { false = 0, true = !false } bool; +#endif + +#if !defined(RL_MATRIX_TYPE) +// Matrix, 4x4 components, column major, OpenGL style, right handed +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; +#define RL_MATRIX_TYPE +#endif + +// Dynamic vertex buffers (position + texcoords + colors + indices arrays) +typedef struct rlVertexBuffer { + int elementCount; // Number of elements in the buffer (QUADS) + + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + unsigned int *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + unsigned short *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) +#endif + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int vboId[4]; // OpenGL Vertex Buffer Objects id (4 types of vertex data) +} rlVertexBuffer; + +// Draw call type +// NOTE: Only texture changes register a new draw, other state-change-related elements are not +// used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any +// of those state-change happens (this is done in core module) +typedef struct rlDrawCall { + int mode; // Drawing mode: LINES, TRIANGLES, QUADS + int vertexCount; // Number of vertex of the draw + int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES) + //unsigned int vaoId; // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId + //unsigned int shaderId; // Shader id to be used on the draw -> Using RLGL.currentShaderId + unsigned int textureId; // Texture id to be used on the draw -> Use to create new draw call if changes + + //Matrix projection; // Projection matrix for this draw -> Using RLGL.projection by default + //Matrix modelview; // Modelview matrix for this draw -> Using RLGL.modelview by default +} rlDrawCall; + +// rlRenderBatch type +typedef struct rlRenderBatch { + int bufferCount; // Number of vertex buffers (multi-buffering support) + int currentBuffer; // Current buffer tracking in case of multi-buffering + rlVertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data + + rlDrawCall *draws; // Draw calls array, depends on textureId + int drawCounter; // Draw calls counter + float currentDepth; // Current depth value for next draw +} rlRenderBatch; + +// OpenGL version +typedef enum { + RL_OPENGL_11 = 1, // OpenGL 1.1 + RL_OPENGL_21, // OpenGL 2.1 (GLSL 120) + RL_OPENGL_33, // OpenGL 3.3 (GLSL 330) + RL_OPENGL_43, // OpenGL 4.3 (using GLSL 330) + RL_OPENGL_ES_20 // OpenGL ES 2.0 (GLSL 100) +} rlGlVersion; + +// Trace log level +// NOTE: Organized by priority level +typedef enum { + RL_LOG_ALL = 0, // Display all logs + RL_LOG_TRACE, // Trace logging, intended for internal use only + RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds + RL_LOG_INFO, // Info logging, used for program execution info + RL_LOG_WARNING, // Warning logging, used on recoverable failures + RL_LOG_ERROR, // Error logging, used on unrecoverable failures + RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) + RL_LOG_NONE // Disable logging +} rlTraceLogLevel; + +// Texture pixel formats +// NOTE: Support depends on OpenGL version +typedef enum { + RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} rlPixelFormat; + +// Texture parameters: filter mode +// NOTE 1: Filtering considers mipmaps if available in the texture +// NOTE 2: Filter is accordingly set for minification and magnification +typedef enum { + RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation + RL_TEXTURE_FILTER_BILINEAR, // Linear filtering + RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} rlTextureFilter; + +// Color blending modes (pre-defined) +typedef enum { + RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default) + RL_BLEND_ADDITIVE, // Blend textures adding colors + RL_BLEND_MULTIPLIED, // Blend textures multiplying colors + RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative) + RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) + RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha + RL_BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) + RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom src/dst factors (use rlSetBlendFactorsSeparate()) +} rlBlendMode; + +// Shader location point type +typedef enum { + RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position + RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 + RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 + RL_SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal + RL_SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent + RL_SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color + RL_SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection + RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) + RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection + RL_SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) + RL_SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal + RL_SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view + RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color + RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color + RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color + RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE) + RL_SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR) + RL_SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal + RL_SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness + RL_SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion + RL_SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission + RL_SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height + RL_SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap + RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance + RL_SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter + RL_SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf +} rlShaderLocationIndex; + +#define RL_SHADER_LOC_MAP_DIFFUSE RL_SHADER_LOC_MAP_ALBEDO +#define RL_SHADER_LOC_MAP_SPECULAR RL_SHADER_LOC_MAP_METALNESS + +// Shader uniform data type +typedef enum { + RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float + RL_SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) + RL_SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) + RL_SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) + RL_SHADER_UNIFORM_INT, // Shader uniform type: int + RL_SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) + RL_SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) + RL_SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) + RL_SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d +} rlShaderUniformDataType; + +// Shader attribute data types +typedef enum { + RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float + RL_SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) + RL_SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) + RL_SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) +} rlShaderAttributeDataType; + +// Framebuffer attachment type +// NOTE: By default up to 8 color channels defined, but it can be more +typedef enum { + RL_ATTACHMENT_COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0 + RL_ATTACHMENT_COLOR_CHANNEL1, // Framebuffer attachment type: color 1 + RL_ATTACHMENT_COLOR_CHANNEL2, // Framebuffer attachment type: color 2 + RL_ATTACHMENT_COLOR_CHANNEL3, // Framebuffer attachment type: color 3 + RL_ATTACHMENT_COLOR_CHANNEL4, // Framebuffer attachment type: color 4 + RL_ATTACHMENT_COLOR_CHANNEL5, // Framebuffer attachment type: color 5 + RL_ATTACHMENT_COLOR_CHANNEL6, // Framebuffer attachment type: color 6 + RL_ATTACHMENT_COLOR_CHANNEL7, // Framebuffer attachment type: color 7 + RL_ATTACHMENT_DEPTH = 100, // Framebuffer attachment type: depth + RL_ATTACHMENT_STENCIL = 200, // Framebuffer attachment type: stencil +} rlFramebufferAttachType; + +// Framebuffer texture attachment type +typedef enum { + RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0, // Framebuffer texture attachment type: cubemap, +X side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_X, // Framebuffer texture attachment type: cubemap, -X side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Y, // Framebuffer texture attachment type: cubemap, +Y side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y, // Framebuffer texture attachment type: cubemap, -Y side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Z, // Framebuffer texture attachment type: cubemap, +Z side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z, // Framebuffer texture attachment type: cubemap, -Z side + RL_ATTACHMENT_TEXTURE2D = 100, // Framebuffer texture attachment type: texture2d + RL_ATTACHMENT_RENDERBUFFER = 200, // Framebuffer texture attachment type: renderbuffer +} rlFramebufferAttachTextureType; + +// Face culling mode +typedef enum { + RL_CULL_FACE_FRONT = 0, + RL_CULL_FACE_BACK +} rlCullMode; + +//------------------------------------------------------------------------------------ +// Functions Declaration - Matrix operations +//------------------------------------------------------------------------------------ + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +RLAPI void rlMatrixMode(int mode); // Choose the current matrix to be transformed +RLAPI void rlPushMatrix(void); // Push the current matrix to stack +RLAPI void rlPopMatrix(void); // Pop latest inserted matrix from stack +RLAPI void rlLoadIdentity(void); // Reset current matrix to identity matrix +RLAPI void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix +RLAPI void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix +RLAPI void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix +RLAPI void rlMultMatrixf(const float *matf); // Multiply the current matrix by another matrix +RLAPI void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar); +RLAPI void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar); +RLAPI void rlViewport(int x, int y, int width, int height); // Set the viewport area + +//------------------------------------------------------------------------------------ +// Functions Declaration - Vertex level operations +//------------------------------------------------------------------------------------ +RLAPI void rlBegin(int mode); // Initialize drawing mode (how to organize vertex) +RLAPI void rlEnd(void); // Finish vertex providing +RLAPI void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int +RLAPI void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float +RLAPI void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float +RLAPI void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float +RLAPI void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float +RLAPI void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Define one vertex (color) - 4 byte +RLAPI void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float +RLAPI void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float + +//------------------------------------------------------------------------------------ +// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2) +// NOTE: This functions are used to completely abstract raylib code from OpenGL layer, +// some of them are direct wrappers over OpenGL calls, some others are custom +//------------------------------------------------------------------------------------ + +// Vertex buffers state +RLAPI bool rlEnableVertexArray(unsigned int vaoId); // Enable vertex array (VAO, if supported) +RLAPI void rlDisableVertexArray(void); // Disable vertex array (VAO, if supported) +RLAPI void rlEnableVertexBuffer(unsigned int id); // Enable vertex buffer (VBO) +RLAPI void rlDisableVertexBuffer(void); // Disable vertex buffer (VBO) +RLAPI void rlEnableVertexBufferElement(unsigned int id);// Enable vertex buffer element (VBO element) +RLAPI void rlDisableVertexBufferElement(void); // Disable vertex buffer element (VBO element) +RLAPI void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index +RLAPI void rlDisableVertexAttribute(unsigned int index);// Disable vertex attribute index +#if defined(GRAPHICS_API_OPENGL_11) +RLAPI void rlEnableStatePointer(int vertexAttribType, void *buffer); // Enable attribute state pointer +RLAPI void rlDisableStatePointer(int vertexAttribType); // Disable attribute state pointer +#endif + +// Textures state +RLAPI void rlActiveTextureSlot(int slot); // Select and active a texture slot +RLAPI void rlEnableTexture(unsigned int id); // Enable texture +RLAPI void rlDisableTexture(void); // Disable texture +RLAPI void rlEnableTextureCubemap(unsigned int id); // Enable texture cubemap +RLAPI void rlDisableTextureCubemap(void); // Disable texture cubemap +RLAPI void rlTextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap) +RLAPI void rlCubemapParameters(unsigned int id, int param, int value); // Set cubemap parameters (filter, wrap) + +// Shader state +RLAPI void rlEnableShader(unsigned int id); // Enable shader program +RLAPI void rlDisableShader(void); // Disable shader program + +// Framebuffer state +RLAPI void rlEnableFramebuffer(unsigned int id); // Enable render texture (fbo) +RLAPI void rlDisableFramebuffer(void); // Disable render texture (fbo), return to default framebuffer +RLAPI void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers + +// General render state +RLAPI void rlEnableColorBlend(void); // Enable color blending +RLAPI void rlDisableColorBlend(void); // Disable color blending +RLAPI void rlEnableDepthTest(void); // Enable depth test +RLAPI void rlDisableDepthTest(void); // Disable depth test +RLAPI void rlEnableDepthMask(void); // Enable depth write +RLAPI void rlDisableDepthMask(void); // Disable depth write +RLAPI void rlEnableBackfaceCulling(void); // Enable backface culling +RLAPI void rlDisableBackfaceCulling(void); // Disable backface culling +RLAPI void rlSetCullFace(int mode); // Set face culling mode +RLAPI void rlEnableScissorTest(void); // Enable scissor test +RLAPI void rlDisableScissorTest(void); // Disable scissor test +RLAPI void rlScissor(int x, int y, int width, int height); // Scissor test +RLAPI void rlEnableWireMode(void); // Enable wire mode +RLAPI void rlDisableWireMode(void); // Disable wire mode +RLAPI void rlSetLineWidth(float width); // Set the line drawing width +RLAPI float rlGetLineWidth(void); // Get the line drawing width +RLAPI void rlEnableSmoothLines(void); // Enable line aliasing +RLAPI void rlDisableSmoothLines(void); // Disable line aliasing +RLAPI void rlEnableStereoRender(void); // Enable stereo rendering +RLAPI void rlDisableStereoRender(void); // Disable stereo rendering +RLAPI bool rlIsStereoRenderEnabled(void); // Check if stereo render is enabled + +RLAPI void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color +RLAPI void rlClearScreenBuffers(void); // Clear used screen buffers (color and depth) +RLAPI void rlCheckErrors(void); // Check and log OpenGL error codes +RLAPI void rlSetBlendMode(int mode); // Set blending mode +RLAPI void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors) +RLAPI void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha); // Set blending mode factors and equations separately (using OpenGL factors) + +//------------------------------------------------------------------------------------ +// Functions Declaration - rlgl functionality +//------------------------------------------------------------------------------------ +// rlgl initialization functions +RLAPI void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states) +RLAPI void rlglClose(void); // De-initialize rlgl (buffers, shaders, textures) +RLAPI void rlLoadExtensions(void *loader); // Load OpenGL extensions (loader function required) +RLAPI int rlGetVersion(void); // Get current OpenGL version +RLAPI void rlSetFramebufferWidth(int width); // Set current framebuffer width +RLAPI int rlGetFramebufferWidth(void); // Get default framebuffer width +RLAPI void rlSetFramebufferHeight(int height); // Set current framebuffer height +RLAPI int rlGetFramebufferHeight(void); // Get default framebuffer height + +RLAPI unsigned int rlGetTextureIdDefault(void); // Get default texture id +RLAPI unsigned int rlGetShaderIdDefault(void); // Get default shader id +RLAPI int *rlGetShaderLocsDefault(void); // Get default shader locations + +// Render batch management +// NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode +// but this render batch API is exposed in case of custom batches are required +RLAPI rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system +RLAPI void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system +RLAPI void rlDrawRenderBatch(rlRenderBatch *batch); // Draw render batch data (Update->Draw->Reset) +RLAPI void rlSetRenderBatchActive(rlRenderBatch *batch); // Set the active render batch for rlgl (NULL for default internal) +RLAPI void rlDrawRenderBatchActive(void); // Update and draw internal render batch +RLAPI bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex + +RLAPI void rlSetTexture(unsigned int id); // Set current texture for render batch and check buffers limits + +//------------------------------------------------------------------------------------------------------------------------ + +// Vertex buffers management +RLAPI unsigned int rlLoadVertexArray(void); // Load vertex array (vao) if supported +RLAPI unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic); // Load a vertex buffer attribute +RLAPI unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic); // Load a new attributes element buffer +RLAPI void rlUpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset); // Update GPU buffer with new data +RLAPI void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset); // Update vertex buffer elements with new data +RLAPI void rlUnloadVertexArray(unsigned int vaoId); +RLAPI void rlUnloadVertexBuffer(unsigned int vboId); +RLAPI void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer); +RLAPI void rlSetVertexAttributeDivisor(unsigned int index, int divisor); +RLAPI void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value +RLAPI void rlDrawVertexArray(int offset, int count); +RLAPI void rlDrawVertexArrayElements(int offset, int count, const void *buffer); +RLAPI void rlDrawVertexArrayInstanced(int offset, int count, int instances); +RLAPI void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances); + +// Textures management +RLAPI unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount); // Load texture in GPU +RLAPI unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo) +RLAPI unsigned int rlLoadTextureCubemap(const void *data, int size, int format); // Load texture cubemap +RLAPI void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data); // Update GPU texture with new data +RLAPI void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); // Get OpenGL internal formats +RLAPI const char *rlGetPixelFormatName(unsigned int format); // Get name string for pixel format +RLAPI void rlUnloadTexture(unsigned int id); // Unload texture from GPU memory +RLAPI void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture +RLAPI void *rlReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data +RLAPI unsigned char *rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer) + +// Framebuffer management (fbo) +RLAPI unsigned int rlLoadFramebuffer(int width, int height); // Load an empty framebuffer +RLAPI void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer +RLAPI bool rlFramebufferComplete(unsigned int id); // Verify framebuffer is complete +RLAPI void rlUnloadFramebuffer(unsigned int id); // Delete framebuffer from GPU + +// Shaders management +RLAPI unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings +RLAPI unsigned int rlCompileShader(const char *shaderCode, int type); // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER) +RLAPI unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program +RLAPI void rlUnloadShaderProgram(unsigned int id); // Unload shader program +RLAPI int rlGetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform +RLAPI int rlGetLocationAttrib(unsigned int shaderId, const char *attribName); // Get shader location attribute +RLAPI void rlSetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform +RLAPI void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix +RLAPI void rlSetUniformSampler(int locIndex, unsigned int textureId); // Set shader value sampler +RLAPI void rlSetShader(unsigned int id, int *locs); // Set shader currently active (id and locations) + +// Compute shader management +RLAPI unsigned int rlLoadComputeShaderProgram(unsigned int shaderId); // Load compute shader program +RLAPI void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pipeline) + +// Shader buffer storage object management (ssbo) +RLAPI unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint); // Load shader storage buffer object (SSBO) +RLAPI void rlUnloadShaderBuffer(unsigned int ssboId); // Unload shader storage buffer object (SSBO) +RLAPI void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset); // Update SSBO buffer data +RLAPI void rlBindShaderBuffer(unsigned int id, unsigned int index); // Bind SSBO buffer +RLAPI void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset); // Read SSBO buffer data (GPU->CPU) +RLAPI void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count); // Copy SSBO data between buffers +RLAPI unsigned int rlGetShaderBufferSize(unsigned int id); // Get SSBO buffer size + +// Buffer management +RLAPI void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly); // Bind image texture + +// Matrix state management +RLAPI Matrix rlGetMatrixModelview(void); // Get internal modelview matrix +RLAPI Matrix rlGetMatrixProjection(void); // Get internal projection matrix +RLAPI Matrix rlGetMatrixTransform(void); // Get internal accumulated transform matrix +RLAPI Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye) +RLAPI void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix) +RLAPI void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix) +RLAPI void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering +RLAPI void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering + +// Quick and dirty cube/quad buffers load->draw->unload +RLAPI void rlLoadDrawCube(void); // Load and draw a cube +RLAPI void rlLoadDrawQuad(void); // Load and draw a quad + +#if defined(__cplusplus) +} +#endif + +#endif // RLGL_H + +/*********************************************************************************** +* +* RLGL IMPLEMENTATION +* +************************************************************************************/ + +#if defined(RLGL_IMPLEMENTATION) + +#if defined(GRAPHICS_API_OPENGL_11) + #if defined(__APPLE__) + #include // OpenGL 1.1 library for OSX + #include // OpenGL extensions library + #else + // APIENTRY for OpenGL function pointer declarations is required + #if !defined(APIENTRY) + #if defined(_WIN32) + #define APIENTRY __stdcall + #else + #define APIENTRY + #endif + #endif + // WINGDIAPI definition. Some Windows OpenGL headers need it + #if !defined(WINGDIAPI) && defined(_WIN32) + #define WINGDIAPI __declspec(dllimport) + #endif + + #include // OpenGL 1.1 library + #endif +#endif + +#if defined(GRAPHICS_API_OPENGL_33) + #define GLAD_MALLOC RL_MALLOC + #define GLAD_FREE RL_FREE + + #define GLAD_GL_IMPLEMENTATION + #include "external/glad.h" // GLAD extensions loading library, includes OpenGL headers +#endif + +#if defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: OpenGL ES 2.0 can be enabled on PLATFORM_DESKTOP, + // in that case, functions are loaded from a custom glad for OpenGL ES 2.0 + #if defined(PLATFORM_DESKTOP) + #define GLAD_GLES2_IMPLEMENTATION + #include "external/glad_gles2.h" + #else + #define GL_GLEXT_PROTOTYPES + //#include // EGL library -> not required, platform layer + #include // OpenGL ES 2.0 library + #include // OpenGL ES 2.0 extensions library + #endif + + // It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi + // provided headers (despite being defined in official Khronos GLES2 headers) + #if defined(PLATFORM_RPI) || defined(PLATFORM_DRM) + typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); + typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount); + typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor); + #endif +#endif + +#include // Required for: malloc(), free() +#include // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading] +#include // Required for: sqrtf(), sinf(), cosf(), floor(), log() + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +#ifndef GL_SHADING_LANGUAGE_VERSION + #define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#endif + +#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT + #define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 +#endif +#ifndef GL_ETC1_RGB8_OES + #define GL_ETC1_RGB8_OES 0x8D64 +#endif +#ifndef GL_COMPRESSED_RGB8_ETC2 + #define GL_COMPRESSED_RGB8_ETC2 0x9274 +#endif +#ifndef GL_COMPRESSED_RGBA8_ETC2_EAC + #define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 +#endif +#ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG + #define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00 +#endif +#ifndef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG + #define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02 +#endif +#ifndef GL_COMPRESSED_RGBA_ASTC_4x4_KHR + #define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93b0 +#endif +#ifndef GL_COMPRESSED_RGBA_ASTC_8x8_KHR + #define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93b7 +#endif + +#ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF +#endif +#ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE +#endif + +#if defined(GRAPHICS_API_OPENGL_11) + #define GL_UNSIGNED_SHORT_5_6_5 0x8363 + #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 + #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#endif + +#if defined(GRAPHICS_API_OPENGL_21) + #define GL_LUMINANCE 0x1909 + #define GL_LUMINANCE_ALPHA 0x190A +#endif + +#if defined(GRAPHICS_API_OPENGL_ES2) + #define glClearDepth glClearDepthf + #define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER + #define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER +#endif + +// Default shader vertex attribute names to set location points +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION + #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL + #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR + #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 +#endif + +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP + #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW + #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION + #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL + #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL + #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR + #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +typedef struct rlglData { + rlRenderBatch *currentBatch; // Current render batch + rlRenderBatch defaultBatch; // Default internal render batch + + struct { + int vertexCounter; // Current active render batch vertex counter (generic, used for all batches) + float texcoordx, texcoordy; // Current active texture coordinate (added on glVertex*()) + float normalx, normaly, normalz; // Current active normal (added on glVertex*()) + unsigned char colorr, colorg, colorb, colora; // Current active color (added on glVertex*()) + + int currentMatrixMode; // Current matrix mode + Matrix *currentMatrix; // Current matrix pointer + Matrix modelview; // Default modelview matrix + Matrix projection; // Default projection matrix + Matrix transform; // Transform matrix to be used with rlTranslate, rlRotate, rlScale + bool transformRequired; // Require transform matrix application to current draw-call vertex (if required) + Matrix stack[RL_MAX_MATRIX_STACK_SIZE];// Matrix stack for push/pop + int stackCounter; // Matrix stack counter + + unsigned int defaultTextureId; // Default texture used on shapes/poly drawing (required by shader) + unsigned int activeTextureId[RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS]; // Active texture ids to be enabled on batch drawing (0 active by default) + unsigned int defaultVShaderId; // Default vertex shader id (used by default shader program) + unsigned int defaultFShaderId; // Default fragment shader id (used by default shader program) + unsigned int defaultShaderId; // Default shader program id, supports vertex color and diffuse texture + int *defaultShaderLocs; // Default shader locations pointer to be used on rendering + unsigned int currentShaderId; // Current shader id to be used on rendering (by default, defaultShaderId) + int *currentShaderLocs; // Current shader locations pointer to be used on rendering (by default, defaultShaderLocs) + + bool stereoRender; // Stereo rendering flag + Matrix projectionStereo[2]; // VR stereo rendering eyes projection matrices + Matrix viewOffsetStereo[2]; // VR stereo rendering eyes view offset matrices + + // Blending variables + int currentBlendMode; // Blending mode active + int glBlendSrcFactor; // Blending source factor + int glBlendDstFactor; // Blending destination factor + int glBlendEquation; // Blending equation + int glBlendSrcFactorRGB; // Blending source RGB factor + int glBlendDestFactorRGB; // Blending destination RGB factor + int glBlendSrcFactorAlpha; // Blending source alpha factor + int glBlendDestFactorAlpha; // Blending destination alpha factor + int glBlendEquationRGB; // Blending equation for RGB + int glBlendEquationAlpha; // Blending equation for alpha + bool glCustomBlendModeModified; // Custom blending factor and equation modification status + + int framebufferWidth; // Current framebuffer width + int framebufferHeight; // Current framebuffer height + + } State; // Renderer state + struct { + bool vao; // VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object) + bool instancing; // Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays) + bool texNPOT; // NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot) + bool texDepth; // Depth textures supported (GL_ARB_depth_texture, GL_OES_depth_texture) + bool texDepthWebGL; // Depth textures supported WebGL specific (GL_WEBGL_depth_texture) + bool texFloat32; // float textures support (32 bit per channel) (GL_OES_texture_float) + bool texCompDXT; // DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc) + bool texCompETC1; // ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1) + bool texCompETC2; // ETC2/EAC texture compression support (GL_ARB_ES3_compatibility) + bool texCompPVRT; // PVR texture compression support (GL_IMG_texture_compression_pvrtc) + bool texCompASTC; // ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr) + bool texMirrorClamp; // Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp) + bool texAnisoFilter; // Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic) + bool computeShader; // Compute shaders support (GL_ARB_compute_shader) + bool ssbo; // Shader storage buffer object support (GL_ARB_shader_storage_buffer_object) + + float maxAnisotropyLevel; // Maximum anisotropy level supported (minimum is 2.0f) + int maxDepthBits; // Maximum bits for depth component + + } ExtSupported; // Extensions supported flags +} rlglData; + +typedef void *(*rlglLoadProc)(const char *name); // OpenGL extension functions loader signature (same as GLADloadproc) + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +static rlglData RLGL = { 0 }; +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +#if defined(GRAPHICS_API_OPENGL_ES2) +// NOTE: VAO functionality is exposed through extensions (OES) +static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays = NULL; +static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL; +static PFNGLDELETEVERTEXARRAYSOESPROC glDeleteVertexArrays = NULL; + +// NOTE: Instancing functionality could also be available through extension +static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL; +static PFNGLDRAWELEMENTSINSTANCEDEXTPROC glDrawElementsInstanced = NULL; +static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL; +#endif + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +static void rlLoadShaderDefault(void); // Load default shader +static void rlUnloadShaderDefault(void); // Unload default shader +#if defined(RLGL_SHOW_GL_DETAILS_INFO) +static char *rlGetCompressedFormatName(int format); // Get compressed format official GL identifier name +#endif // RLGL_SHOW_GL_DETAILS_INFO +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +static int rlGetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes (image or texture) + +// Auxiliar matrix math functions +static Matrix rlMatrixIdentity(void); // Get identity matrix +static Matrix rlMatrixMultiply(Matrix left, Matrix right); // Multiply two matrices + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Matrix operations +//---------------------------------------------------------------------------------- + +#if defined(GRAPHICS_API_OPENGL_11) +// Fallback to OpenGL 1.1 function calls +//--------------------------------------- +void rlMatrixMode(int mode) +{ + switch (mode) + { + case RL_PROJECTION: glMatrixMode(GL_PROJECTION); break; + case RL_MODELVIEW: glMatrixMode(GL_MODELVIEW); break; + case RL_TEXTURE: glMatrixMode(GL_TEXTURE); break; + default: break; + } +} + +void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar) +{ + glFrustum(left, right, bottom, top, znear, zfar); +} + +void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar) +{ + glOrtho(left, right, bottom, top, znear, zfar); +} + +void rlPushMatrix(void) { glPushMatrix(); } +void rlPopMatrix(void) { glPopMatrix(); } +void rlLoadIdentity(void) { glLoadIdentity(); } +void rlTranslatef(float x, float y, float z) { glTranslatef(x, y, z); } +void rlRotatef(float angle, float x, float y, float z) { glRotatef(angle, x, y, z); } +void rlScalef(float x, float y, float z) { glScalef(x, y, z); } +void rlMultMatrixf(const float *matf) { glMultMatrixf(matf); } +#endif +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Choose the current matrix to be transformed +void rlMatrixMode(int mode) +{ + if (mode == RL_PROJECTION) RLGL.State.currentMatrix = &RLGL.State.projection; + else if (mode == RL_MODELVIEW) RLGL.State.currentMatrix = &RLGL.State.modelview; + //else if (mode == RL_TEXTURE) // Not supported + + RLGL.State.currentMatrixMode = mode; +} + +// Push the current matrix into RLGL.State.stack +void rlPushMatrix(void) +{ + if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE) TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)"); + + if (RLGL.State.currentMatrixMode == RL_MODELVIEW) + { + RLGL.State.transformRequired = true; + RLGL.State.currentMatrix = &RLGL.State.transform; + } + + RLGL.State.stack[RLGL.State.stackCounter] = *RLGL.State.currentMatrix; + RLGL.State.stackCounter++; +} + +// Pop lattest inserted matrix from RLGL.State.stack +void rlPopMatrix(void) +{ + if (RLGL.State.stackCounter > 0) + { + Matrix mat = RLGL.State.stack[RLGL.State.stackCounter - 1]; + *RLGL.State.currentMatrix = mat; + RLGL.State.stackCounter--; + } + + if ((RLGL.State.stackCounter == 0) && (RLGL.State.currentMatrixMode == RL_MODELVIEW)) + { + RLGL.State.currentMatrix = &RLGL.State.modelview; + RLGL.State.transformRequired = false; + } +} + +// Reset current matrix to identity matrix +void rlLoadIdentity(void) +{ + *RLGL.State.currentMatrix = rlMatrixIdentity(); +} + +// Multiply the current matrix by a translation matrix +void rlTranslatef(float x, float y, float z) +{ + Matrix matTranslation = { + 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matTranslation, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by a rotation matrix +// NOTE: The provided angle must be in degrees +void rlRotatef(float angle, float x, float y, float z) +{ + Matrix matRotation = rlMatrixIdentity(); + + // Axis vector (x, y, z) normalization + float lengthSquared = x*x + y*y + z*z; + if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) + { + float inverseLength = 1.0f/sqrtf(lengthSquared); + x *= inverseLength; + y *= inverseLength; + z *= inverseLength; + } + + // Rotation matrix generation + float sinres = sinf(DEG2RAD*angle); + float cosres = cosf(DEG2RAD*angle); + float t = 1.0f - cosres; + + matRotation.m0 = x*x*t + cosres; + matRotation.m1 = y*x*t + z*sinres; + matRotation.m2 = z*x*t - y*sinres; + matRotation.m3 = 0.0f; + + matRotation.m4 = x*y*t - z*sinres; + matRotation.m5 = y*y*t + cosres; + matRotation.m6 = z*y*t + x*sinres; + matRotation.m7 = 0.0f; + + matRotation.m8 = x*z*t + y*sinres; + matRotation.m9 = y*z*t - x*sinres; + matRotation.m10 = z*z*t + cosres; + matRotation.m11 = 0.0f; + + matRotation.m12 = 0.0f; + matRotation.m13 = 0.0f; + matRotation.m14 = 0.0f; + matRotation.m15 = 1.0f; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matRotation, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by a scaling matrix +void rlScalef(float x, float y, float z) +{ + Matrix matScale = { + x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matScale, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by another matrix +void rlMultMatrixf(const float *matf) +{ + // Matrix creation from array + Matrix mat = { matf[0], matf[4], matf[8], matf[12], + matf[1], matf[5], matf[9], matf[13], + matf[2], matf[6], matf[10], matf[14], + matf[3], matf[7], matf[11], matf[15] }; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, mat); +} + +// Multiply the current matrix by a perspective matrix generated by parameters +void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar) +{ + Matrix matFrustum = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(zfar - znear); + + matFrustum.m0 = ((float) znear*2.0f)/rl; + matFrustum.m1 = 0.0f; + matFrustum.m2 = 0.0f; + matFrustum.m3 = 0.0f; + + matFrustum.m4 = 0.0f; + matFrustum.m5 = ((float) znear*2.0f)/tb; + matFrustum.m6 = 0.0f; + matFrustum.m7 = 0.0f; + + matFrustum.m8 = ((float)right + (float)left)/rl; + matFrustum.m9 = ((float)top + (float)bottom)/tb; + matFrustum.m10 = -((float)zfar + (float)znear)/fn; + matFrustum.m11 = -1.0f; + + matFrustum.m12 = 0.0f; + matFrustum.m13 = 0.0f; + matFrustum.m14 = -((float)zfar*(float)znear*2.0f)/fn; + matFrustum.m15 = 0.0f; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matFrustum); +} + +// Multiply the current matrix by an orthographic matrix generated by parameters +void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar) +{ + // NOTE: If left-right and top-botton values are equal it could create a division by zero, + // response to it is platform/compiler dependant + Matrix matOrtho = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(zfar - znear); + + matOrtho.m0 = 2.0f/rl; + matOrtho.m1 = 0.0f; + matOrtho.m2 = 0.0f; + matOrtho.m3 = 0.0f; + matOrtho.m4 = 0.0f; + matOrtho.m5 = 2.0f/tb; + matOrtho.m6 = 0.0f; + matOrtho.m7 = 0.0f; + matOrtho.m8 = 0.0f; + matOrtho.m9 = 0.0f; + matOrtho.m10 = -2.0f/fn; + matOrtho.m11 = 0.0f; + matOrtho.m12 = -((float)left + (float)right)/rl; + matOrtho.m13 = -((float)top + (float)bottom)/tb; + matOrtho.m14 = -((float)zfar + (float)znear)/fn; + matOrtho.m15 = 1.0f; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matOrtho); +} +#endif + +// Set the viewport area (transformation from normalized device coordinates to window coordinates) +// NOTE: We store current viewport dimensions +void rlViewport(int x, int y, int width, int height) +{ + glViewport(x, y, width, height); +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vertex level operations +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_11) +// Fallback to OpenGL 1.1 function calls +//--------------------------------------- +void rlBegin(int mode) +{ + switch (mode) + { + case RL_LINES: glBegin(GL_LINES); break; + case RL_TRIANGLES: glBegin(GL_TRIANGLES); break; + case RL_QUADS: glBegin(GL_QUADS); break; + default: break; + } +} + +void rlEnd() { glEnd(); } +void rlVertex2i(int x, int y) { glVertex2i(x, y); } +void rlVertex2f(float x, float y) { glVertex2f(x, y); } +void rlVertex3f(float x, float y, float z) { glVertex3f(x, y, z); } +void rlTexCoord2f(float x, float y) { glTexCoord2f(x, y); } +void rlNormal3f(float x, float y, float z) { glNormal3f(x, y, z); } +void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a) { glColor4ub(r, g, b, a); } +void rlColor3f(float x, float y, float z) { glColor3f(x, y, z); } +void rlColor4f(float x, float y, float z, float w) { glColor4f(x, y, z, w); } +#endif +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Initialize drawing mode (how to organize vertex) +void rlBegin(int mode) +{ + // Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS + // NOTE: In all three cases, vertex are accumulated over default internal vertex buffer + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode != mode) + { + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0) + { + // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4, + // that way, following QUADS drawing will keep aligned with index processing + // It implies adding some extra alignment vertex at the end of the draw, + // those vertex are not processed but they are considered as an additional offset + // for the next set of vertex to be drawn + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4); + else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4))); + else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0; + + if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment)) + { + RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment; + RLGL.currentBatch->drawCounter++; + } + } + + if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch); + + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = mode; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.defaultTextureId; + } +} + +// Finish vertex providing +void rlEnd(void) +{ + // NOTE: Depth increment is dependant on rlOrtho(): z-near and z-far values, + // as well as depth buffer bit-depth (16bit or 24bit or 32bit) + // Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits) + RLGL.currentBatch->currentDepth += (1.0f/20000.0f); +} + +// Define one vertex (position) +// NOTE: Vertex position data is the basic information required for drawing +void rlVertex3f(float x, float y, float z) +{ + float tx = x; + float ty = y; + float tz = z; + + // Transform provided vector if required + if (RLGL.State.transformRequired) + { + tx = RLGL.State.transform.m0*x + RLGL.State.transform.m4*y + RLGL.State.transform.m8*z + RLGL.State.transform.m12; + ty = RLGL.State.transform.m1*x + RLGL.State.transform.m5*y + RLGL.State.transform.m9*z + RLGL.State.transform.m13; + tz = RLGL.State.transform.m2*x + RLGL.State.transform.m6*y + RLGL.State.transform.m10*z + RLGL.State.transform.m14; + } + + // WARNING: We can't break primitives when launching a new batch. + // RL_LINES comes in pairs, RL_TRIANGLES come in groups of 3 vertices and RL_QUADS come in groups of 4 vertices. + // We must check current draw.mode when a new vertex is required and finish the batch only if the draw.mode draw.vertexCount is %2, %3 or %4 + if (RLGL.State.vertexCounter > (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4 - 4)) + { + if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%2 == 0)) + { + // Reached the maximum number of vertices for RL_LINES drawing + // Launch a draw call but keep current state for next vertices comming + // NOTE: We add +1 vertex to the check for security + rlCheckRenderBatchLimit(2 + 1); + } + else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%3 == 0)) + { + rlCheckRenderBatchLimit(3 + 1); + } + else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_QUADS) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4 == 0)) + { + rlCheckRenderBatchLimit(4 + 1); + } + } + + // Add vertices + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter] = tx; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 1] = ty; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 2] = tz; + + // Add current texcoord + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter] = RLGL.State.texcoordx; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter + 1] = RLGL.State.texcoordy; + + // TODO: Add current normal + // By default rlVertexBuffer type does not store normals + + // Add current color + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter] = RLGL.State.colorr; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 1] = RLGL.State.colorg; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 2] = RLGL.State.colorb; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 3] = RLGL.State.colora; + + RLGL.State.vertexCounter++; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount++; +} + +// Define one vertex (position) +void rlVertex2f(float x, float y) +{ + rlVertex3f(x, y, RLGL.currentBatch->currentDepth); +} + +// Define one vertex (position) +void rlVertex2i(int x, int y) +{ + rlVertex3f((float)x, (float)y, RLGL.currentBatch->currentDepth); +} + +// Define one vertex (texture coordinate) +// NOTE: Texture coordinates are limited to QUADS only +void rlTexCoord2f(float x, float y) +{ + RLGL.State.texcoordx = x; + RLGL.State.texcoordy = y; +} + +// Define one vertex (normal) +// NOTE: Normals limited to TRIANGLES only? +void rlNormal3f(float x, float y, float z) +{ + RLGL.State.normalx = x; + RLGL.State.normaly = y; + RLGL.State.normalz = z; +} + +// Define one vertex (color) +void rlColor4ub(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +{ + RLGL.State.colorr = x; + RLGL.State.colorg = y; + RLGL.State.colorb = z; + RLGL.State.colora = w; +} + +// Define one vertex (color) +void rlColor4f(float r, float g, float b, float a) +{ + rlColor4ub((unsigned char)(r*255), (unsigned char)(g*255), (unsigned char)(b*255), (unsigned char)(a*255)); +} + +// Define one vertex (color) +void rlColor3f(float x, float y, float z) +{ + rlColor4ub((unsigned char)(x*255), (unsigned char)(y*255), (unsigned char)(z*255), 255); +} + +#endif + +//-------------------------------------------------------------------------------------- +// Module Functions Definition - OpenGL style functions (common to 1.1, 3.3+, ES2) +//-------------------------------------------------------------------------------------- + +// Set current texture to use +void rlSetTexture(unsigned int id) +{ + if (id == 0) + { +#if defined(GRAPHICS_API_OPENGL_11) + rlDisableTexture(); +#else + // NOTE: If quads batch limit is reached, we force a draw call and next batch starts + if (RLGL.State.vertexCounter >= + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4) + { + rlDrawRenderBatch(RLGL.currentBatch); + } +#endif + } + else + { +#if defined(GRAPHICS_API_OPENGL_11) + rlEnableTexture(id); +#else + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId != id) + { + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0) + { + // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4, + // that way, following QUADS drawing will keep aligned with index processing + // It implies adding some extra alignment vertex at the end of the draw, + // those vertex are not processed but they are considered as an additional offset + // for the next set of vertex to be drawn + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4); + else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4))); + else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0; + + if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment)) + { + RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment; + + RLGL.currentBatch->drawCounter++; + } + } + + if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch); + + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = id; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0; + } +#endif + } +} + +// Select and active a texture slot +void rlActiveTextureSlot(int slot) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glActiveTexture(GL_TEXTURE0 + slot); +#endif +} + +// Enable texture +void rlEnableTexture(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_11) + glEnable(GL_TEXTURE_2D); +#endif + glBindTexture(GL_TEXTURE_2D, id); +} + +// Disable texture +void rlDisableTexture(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) + glDisable(GL_TEXTURE_2D); +#endif + glBindTexture(GL_TEXTURE_2D, 0); +} + +// Enable texture cubemap +void rlEnableTextureCubemap(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_CUBE_MAP, id); +#endif +} + +// Disable texture cubemap +void rlDisableTextureCubemap(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif +} + +// Set texture parameters (wrap mode/filter mode) +void rlTextureParameters(unsigned int id, int param, int value) +{ + glBindTexture(GL_TEXTURE_2D, id); + +#if !defined(GRAPHICS_API_OPENGL_11) + // Reset anisotropy filter, in case it was set + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); +#endif + + switch (param) + { + case RL_TEXTURE_WRAP_S: + case RL_TEXTURE_WRAP_T: + { + if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) + { +#if !defined(GRAPHICS_API_OPENGL_11) + if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_2D, param, value); + else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)"); +#endif + } + else glTexParameteri(GL_TEXTURE_2D, param, value); + + } break; + case RL_TEXTURE_MAG_FILTER: + case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_2D, param, value); break; + case RL_TEXTURE_FILTER_ANISOTROPIC: + { +#if !defined(GRAPHICS_API_OPENGL_11) + if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f) + { + TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + } + else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported"); +#endif + } break; +#if defined(GRAPHICS_API_OPENGL_33) + case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, value/100.0f); +#endif + default: break; + } + + glBindTexture(GL_TEXTURE_2D, 0); +} + +// Set cubemap parameters (wrap mode/filter mode) +void rlCubemapParameters(unsigned int id, int param, int value) +{ +#if !defined(GRAPHICS_API_OPENGL_11) + glBindTexture(GL_TEXTURE_CUBE_MAP, id); + + // Reset anisotropy filter, in case it was set + glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); + + switch (param) + { + case RL_TEXTURE_WRAP_S: + case RL_TEXTURE_WRAP_T: + { + if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) + { + if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); + else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)"); + } + else glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); + + } break; + case RL_TEXTURE_MAG_FILTER: + case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); break; + case RL_TEXTURE_FILTER_ANISOTROPIC: + { + if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f) + { + TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel); + glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + } + else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported"); + } break; +#if defined(GRAPHICS_API_OPENGL_33) + case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_LOD_BIAS, value/100.0f); +#endif + default: break; + } + + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif +} + +// Enable shader program +void rlEnableShader(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + glUseProgram(id); +#endif +} + +// Disable shader program +void rlDisableShader(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + glUseProgram(0); +#endif +} + +// Enable rendering to texture (fbo) +void rlEnableFramebuffer(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, id); +#endif +} + +// Disable rendering to texture +void rlDisableFramebuffer(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, 0); +#endif +} + +// Activate multiple draw color buffers +// NOTE: One color buffer is always active by default +void rlActiveDrawBuffers(int count) +{ +#if (defined(GRAPHICS_API_OPENGL_33) && defined(RLGL_RENDER_TEXTURES_HINT)) + // NOTE: Maximum number of draw buffers supported is implementation dependant, + // it can be queried with glGet*() but it must be at least 8 + //GLint maxDrawBuffers = 0; + //glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); + + if (count > 0) + { + if (count > 8) TRACELOG(LOG_WARNING, "GL: Max color buffers limited to 8"); + else + { + unsigned int buffers[8] = { + GL_COLOR_ATTACHMENT0, + GL_COLOR_ATTACHMENT1, + GL_COLOR_ATTACHMENT2, + GL_COLOR_ATTACHMENT3, + GL_COLOR_ATTACHMENT4, + GL_COLOR_ATTACHMENT5, + GL_COLOR_ATTACHMENT6, + GL_COLOR_ATTACHMENT7, + }; + + glDrawBuffers(count, buffers); + } + } + else TRACELOG(LOG_WARNING, "GL: One color buffer active by default"); +#endif +} + +//---------------------------------------------------------------------------------- +// General render state configuration +//---------------------------------------------------------------------------------- + +// Enable color blending +void rlEnableColorBlend(void) { glEnable(GL_BLEND); } + +// Disable color blending +void rlDisableColorBlend(void) { glDisable(GL_BLEND); } + +// Enable depth test +void rlEnableDepthTest(void) { glEnable(GL_DEPTH_TEST); } + +// Disable depth test +void rlDisableDepthTest(void) { glDisable(GL_DEPTH_TEST); } + +// Enable depth write +void rlEnableDepthMask(void) { glDepthMask(GL_TRUE); } + +// Disable depth write +void rlDisableDepthMask(void) { glDepthMask(GL_FALSE); } + +// Enable backface culling +void rlEnableBackfaceCulling(void) { glEnable(GL_CULL_FACE); } + +// Disable backface culling +void rlDisableBackfaceCulling(void) { glDisable(GL_CULL_FACE); } + +// Set face culling mode +void rlSetCullFace(int mode) +{ + switch (mode) + { + case RL_CULL_FACE_BACK: glCullFace(GL_BACK); break; + case RL_CULL_FACE_FRONT: glCullFace(GL_FRONT); break; + default: break; + } +} + +// Enable scissor test +void rlEnableScissorTest(void) { glEnable(GL_SCISSOR_TEST); } + +// Disable scissor test +void rlDisableScissorTest(void) { glDisable(GL_SCISSOR_TEST); } + +// Scissor test +void rlScissor(int x, int y, int width, int height) { glScissor(x, y, width, height); } + +// Enable wire mode +void rlEnableWireMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); +#endif +} + +// Disable wire mode +void rlDisableWireMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); +#endif +} + +// Set the line drawing width +void rlSetLineWidth(float width) { glLineWidth(width); } + +// Get the line drawing width +float rlGetLineWidth(void) +{ + float width = 0; + glGetFloatv(GL_LINE_WIDTH, &width); + return width; +} + +// Enable line aliasing +void rlEnableSmoothLines(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11) + glEnable(GL_LINE_SMOOTH); +#endif +} + +// Disable line aliasing +void rlDisableSmoothLines(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11) + glDisable(GL_LINE_SMOOTH); +#endif +} + +// Enable stereo rendering +void rlEnableStereoRender(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + RLGL.State.stereoRender = true; +#endif +} + +// Disable stereo rendering +void rlDisableStereoRender(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + RLGL.State.stereoRender = false; +#endif +} + +// Check if stereo render is enabled +bool rlIsStereoRenderEnabled(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + return RLGL.State.stereoRender; +#else + return false; +#endif +} + +// Clear color buffer with color +void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a) +{ + // Color values clamp to 0.0f(0) and 1.0f(255) + float cr = (float)r/255; + float cg = (float)g/255; + float cb = (float)b/255; + float ca = (float)a/255; + + glClearColor(cr, cg, cb, ca); +} + +// Clear used screen buffers (color and depth) +void rlClearScreenBuffers(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear used buffers: Color and Depth (Depth is used for 3D) + //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // Stencil buffer not used... +} + +// Check and log OpenGL error codes +void rlCheckErrors() +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + int check = 1; + while (check) + { + const GLenum err = glGetError(); + switch (err) + { + case GL_NO_ERROR: check = 0; break; + case 0x0500: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_ENUM"); break; + case 0x0501: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_VALUE"); break; + case 0x0502: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_OPERATION"); break; + case 0x0503: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_OVERFLOW"); break; + case 0x0504: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_UNDERFLOW"); break; + case 0x0505: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_OUT_OF_MEMORY"); break; + case 0x0506: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_FRAMEBUFFER_OPERATION"); break; + default: TRACELOG(RL_LOG_WARNING, "GL: Error detected: Unknown error code: %x", err); break; + } + } +#endif +} + +// Set blend mode +void rlSetBlendMode(int mode) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.currentBlendMode != mode) || ((mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE) && RLGL.State.glCustomBlendModeModified)) + { + rlDrawRenderBatch(RLGL.currentBatch); + + switch (mode) + { + case RL_BLEND_ALPHA: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_ADDITIVE: glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_MULTIPLIED: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_ADD_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_SUBTRACT_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_SUBTRACT); break; + case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_CUSTOM: + { + // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors() + glBlendFunc(RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor); glBlendEquation(RLGL.State.glBlendEquation); + + } break; + case RL_BLEND_CUSTOM_SEPARATE: + { + // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactorsSeparate() + glBlendFuncSeparate(RLGL.State.glBlendSrcFactorRGB, RLGL.State.glBlendDestFactorRGB, RLGL.State.glBlendSrcFactorAlpha, RLGL.State.glBlendDestFactorAlpha); + glBlendEquationSeparate(RLGL.State.glBlendEquationRGB, RLGL.State.glBlendEquationAlpha); + + } break; + default: break; + } + + RLGL.State.currentBlendMode = mode; + RLGL.State.glCustomBlendModeModified = false; + } +#endif +} + +// Set blending mode factor and equation +void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.glBlendSrcFactor != glSrcFactor) || + (RLGL.State.glBlendDstFactor != glDstFactor) || + (RLGL.State.glBlendEquation != glEquation)) + { + RLGL.State.glBlendSrcFactor = glSrcFactor; + RLGL.State.glBlendDstFactor = glDstFactor; + RLGL.State.glBlendEquation = glEquation; + + RLGL.State.glCustomBlendModeModified = true; + } +#endif +} + +// Set blending mode factor and equation separately for RGB and alpha +void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.glBlendSrcFactorRGB != glSrcRGB) || + (RLGL.State.glBlendDestFactorRGB != glDstRGB) || + (RLGL.State.glBlendSrcFactorAlpha != glSrcAlpha) || + (RLGL.State.glBlendDestFactorAlpha != glDstAlpha) || + (RLGL.State.glBlendEquationRGB != glEqRGB) || + (RLGL.State.glBlendEquationAlpha != glEqAlpha)) + { + RLGL.State.glBlendSrcFactorRGB = glSrcRGB; + RLGL.State.glBlendDestFactorRGB = glDstRGB; + RLGL.State.glBlendSrcFactorAlpha = glSrcAlpha; + RLGL.State.glBlendDestFactorAlpha = glDstAlpha; + RLGL.State.glBlendEquationRGB = glEqRGB; + RLGL.State.glBlendEquationAlpha = glEqAlpha; + + RLGL.State.glCustomBlendModeModified = true; + } +#endif +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - OpenGL Debug +//---------------------------------------------------------------------------------- +#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43) +static void GLAPIENTRY rlDebugMessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) +{ + // Ignore non-significant error/warning codes (NVidia drivers) + // NOTE: Here there are the details with a sample output: + // - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low) + // - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4) + // will use VIDEO memory as the source for buffer object operations. (severity: low) + // - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium) + // - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have + // a defined base level and cannot be used for texture mapping. (severity: low) + if ((id == 131169) || (id == 131185) || (id == 131218) || (id == 131204)) return; + + const char *msgSource = NULL; + switch (source) + { + case GL_DEBUG_SOURCE_API: msgSource = "API"; break; + case GL_DEBUG_SOURCE_WINDOW_SYSTEM: msgSource = "WINDOW_SYSTEM"; break; + case GL_DEBUG_SOURCE_SHADER_COMPILER: msgSource = "SHADER_COMPILER"; break; + case GL_DEBUG_SOURCE_THIRD_PARTY: msgSource = "THIRD_PARTY"; break; + case GL_DEBUG_SOURCE_APPLICATION: msgSource = "APPLICATION"; break; + case GL_DEBUG_SOURCE_OTHER: msgSource = "OTHER"; break; + default: break; + } + + const char *msgType = NULL; + switch (type) + { + case GL_DEBUG_TYPE_ERROR: msgType = "ERROR"; break; + case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: msgType = "DEPRECATED_BEHAVIOR"; break; + case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: msgType = "UNDEFINED_BEHAVIOR"; break; + case GL_DEBUG_TYPE_PORTABILITY: msgType = "PORTABILITY"; break; + case GL_DEBUG_TYPE_PERFORMANCE: msgType = "PERFORMANCE"; break; + case GL_DEBUG_TYPE_MARKER: msgType = "MARKER"; break; + case GL_DEBUG_TYPE_PUSH_GROUP: msgType = "PUSH_GROUP"; break; + case GL_DEBUG_TYPE_POP_GROUP: msgType = "POP_GROUP"; break; + case GL_DEBUG_TYPE_OTHER: msgType = "OTHER"; break; + default: break; + } + + const char *msgSeverity = "DEFAULT"; + switch (severity) + { + case GL_DEBUG_SEVERITY_LOW: msgSeverity = "LOW"; break; + case GL_DEBUG_SEVERITY_MEDIUM: msgSeverity = "MEDIUM"; break; + case GL_DEBUG_SEVERITY_HIGH: msgSeverity = "HIGH"; break; + case GL_DEBUG_SEVERITY_NOTIFICATION: msgSeverity = "NOTIFICATION"; break; + default: break; + } + + TRACELOG(LOG_WARNING, "GL: OpenGL debug message: %s", message); + TRACELOG(LOG_WARNING, " > Type: %s", msgType); + TRACELOG(LOG_WARNING, " > Source = %s", msgSource); + TRACELOG(LOG_WARNING, " > Severity = %s", msgSeverity); +} +#endif + +//---------------------------------------------------------------------------------- +// Module Functions Definition - rlgl functionality +//---------------------------------------------------------------------------------- + +// Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states +void rlglInit(int width, int height) +{ + // Enable OpenGL debug context if required +#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43) + if ((glDebugMessageCallback != NULL) && (glDebugMessageControl != NULL)) + { + glDebugMessageCallback(rlDebugMessageCallback, 0); + // glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE); // TODO: Filter message + + // Debug context options: + // - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints + // - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a breakpoint can be placed on the callback in order to get a stacktrace for the GL error + glEnable(GL_DEBUG_OUTPUT); + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + } +#endif + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Init default white texture + unsigned char pixels[4] = { 255, 255, 255, 255 }; // 1 pixel RGBA (4 bytes) + RLGL.State.defaultTextureId = rlLoadTexture(pixels, 1, 1, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1); + + if (RLGL.State.defaultTextureId != 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL.State.defaultTextureId); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load default texture"); + + // Init default Shader (customized for GL 3.3 and ES2) + // Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs + rlLoadShaderDefault(); + RLGL.State.currentShaderId = RLGL.State.defaultShaderId; + RLGL.State.currentShaderLocs = RLGL.State.defaultShaderLocs; + + // Init default vertex arrays buffers + RLGL.defaultBatch = rlLoadRenderBatch(RL_DEFAULT_BATCH_BUFFERS, RL_DEFAULT_BATCH_BUFFER_ELEMENTS); + RLGL.currentBatch = &RLGL.defaultBatch; + + // Init stack matrices (emulating OpenGL 1.1) + for (int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++) RLGL.State.stack[i] = rlMatrixIdentity(); + + // Init internal matrices + RLGL.State.transform = rlMatrixIdentity(); + RLGL.State.projection = rlMatrixIdentity(); + RLGL.State.modelview = rlMatrixIdentity(); + RLGL.State.currentMatrix = &RLGL.State.modelview; +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + + // Initialize OpenGL default states + //---------------------------------------------------------- + // Init state: Depth test + glDepthFunc(GL_LEQUAL); // Type of depth testing to apply + glDisable(GL_DEPTH_TEST); // Disable depth testing for 2D (only used for 3D) + + // Init state: Blending mode + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Color blending function (how colors are mixed) + glEnable(GL_BLEND); // Enable color blending (required to work with transparencies) + + // Init state: Culling + // NOTE: All shapes/models triangles are drawn CCW + glCullFace(GL_BACK); // Cull the back face (default) + glFrontFace(GL_CCW); // Front face are defined counter clockwise (default) + glEnable(GL_CULL_FACE); // Enable backface culling + + // Init state: Cubemap seamless +#if defined(GRAPHICS_API_OPENGL_33) + glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); // Seamless cubemaps (not supported on OpenGL ES 2.0) +#endif + +#if defined(GRAPHICS_API_OPENGL_11) + // Init state: Color hints (deprecated in OpenGL 3.0+) + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Improve quality of color and texture coordinate interpolation + glShadeModel(GL_SMOOTH); // Smooth shading between vertex (vertex colors interpolation) +#endif + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Store screen size into global variables + RLGL.State.framebufferWidth = width; + RLGL.State.framebufferHeight = height; + + TRACELOG(RL_LOG_INFO, "RLGL: Default OpenGL state initialized successfully"); + //---------------------------------------------------------- +#endif + + // Init state: Color/Depth buffers clear + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Set clear color (black) + glClearDepth(1.0f); // Set clear depth value (default) + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear color and depth buffers (depth buffer required for 3D) +} + +// Vertex Buffer Object deinitialization (memory free) +void rlglClose(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlUnloadRenderBatch(RLGL.defaultBatch); + + rlUnloadShaderDefault(); // Unload default shader + + glDeleteTextures(1, &RLGL.State.defaultTextureId); // Unload default texture + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL.State.defaultTextureId); +#endif +} + +// Load OpenGL extensions +// NOTE: External loader function must be provided +void rlLoadExtensions(void *loader) +{ +#if defined(GRAPHICS_API_OPENGL_33) // Also defined for GRAPHICS_API_OPENGL_21 + // NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions) + if (gladLoadGL((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions"); + else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully"); + + // Get number of supported extensions + GLint numExt = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &numExt); + TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + // Get supported extensions list + // WARNING: glGetStringi() not available on OpenGL 2.1 + TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:"); + for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, " %s", glGetStringi(GL_EXTENSIONS, i)); +#endif + +#if defined(GRAPHICS_API_OPENGL_21) + // Register supported extensions flags + // Optional OpenGL 2.1 extensions + RLGL.ExtSupported.vao = GLAD_GL_ARB_vertex_array_object; + RLGL.ExtSupported.instancing = (GLAD_GL_EXT_draw_instanced && GLAD_GL_ARB_instanced_arrays); + RLGL.ExtSupported.texNPOT = GLAD_GL_ARB_texture_non_power_of_two; + RLGL.ExtSupported.texFloat32 = GLAD_GL_ARB_texture_float; + RLGL.ExtSupported.texDepth = GLAD_GL_ARB_depth_texture; + RLGL.ExtSupported.maxDepthBits = 32; + RLGL.ExtSupported.texAnisoFilter = GLAD_GL_EXT_texture_filter_anisotropic; + RLGL.ExtSupported.texMirrorClamp = GLAD_GL_EXT_texture_mirror_clamp; +#else + // Register supported extensions flags + // OpenGL 3.3 extensions supported by default (core) + RLGL.ExtSupported.vao = true; + RLGL.ExtSupported.instancing = true; + RLGL.ExtSupported.texNPOT = true; + RLGL.ExtSupported.texFloat32 = true; + RLGL.ExtSupported.texDepth = true; + RLGL.ExtSupported.maxDepthBits = 32; + RLGL.ExtSupported.texAnisoFilter = true; + RLGL.ExtSupported.texMirrorClamp = true; +#endif + + // Optional OpenGL 3.3 extensions + RLGL.ExtSupported.texCompASTC = GLAD_GL_KHR_texture_compression_astc_hdr && GLAD_GL_KHR_texture_compression_astc_ldr; + RLGL.ExtSupported.texCompDXT = GLAD_GL_EXT_texture_compression_s3tc; // Texture compression: DXT + RLGL.ExtSupported.texCompETC2 = GLAD_GL_ARB_ES3_compatibility; // Texture compression: ETC2/EAC + #if defined(GRAPHICS_API_OPENGL_43) + RLGL.ExtSupported.computeShader = GLAD_GL_ARB_compute_shader; + RLGL.ExtSupported.ssbo = GLAD_GL_ARB_shader_storage_buffer_object; + #endif + +#endif // GRAPHICS_API_OPENGL_33 + +#if defined(GRAPHICS_API_OPENGL_ES2) + + #if defined(PLATFORM_DESKTOP) + if (gladLoadGLES2((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions"); + else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES2.0 loaded successfully"); + #endif + + // Get supported extensions list + GLint numExt = 0; + const char **extList = RL_MALLOC(512*sizeof(const char *)); // Allocate 512 strings pointers (2 KB) + const char *extensions = (const char *)glGetString(GL_EXTENSIONS); // One big const string + + // NOTE: We have to duplicate string because glGetString() returns a const string + int size = strlen(extensions) + 1; // Get extensions string size in bytes + char *extensionsDup = (char *)RL_CALLOC(size, sizeof(char)); + strcpy(extensionsDup, extensions); + extList[numExt] = extensionsDup; + + for (int i = 0; i < size; i++) + { + if (extensionsDup[i] == ' ') + { + extensionsDup[i] = '\0'; + numExt++; + extList[numExt] = &extensionsDup[i + 1]; + } + } + + TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:"); + for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, " %s", extList[i]); +#endif + + // Check required extensions + for (int i = 0; i < numExt; i++) + { + // Check VAO support + // NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature + if (strcmp(extList[i], (const char *)"GL_OES_vertex_array_object") == 0) + { + // The extension is supported by our hardware and driver, try to get related functions pointers + // NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance... + glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glGenVertexArraysOES"); + glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)((rlglLoadProc)loader)("glBindVertexArrayOES"); + glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glDeleteVertexArraysOES"); + //glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES"); // NOTE: Fails in WebGL, omitted + + if ((glGenVertexArrays != NULL) && (glBindVertexArray != NULL) && (glDeleteVertexArrays != NULL)) RLGL.ExtSupported.vao = true; + } + + // Check instanced rendering support + if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") == 0) // Web ANGLE + { + glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedANGLE"); + glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedANGLE"); + glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorANGLE"); + + if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true; + } + else + { + if ((strcmp(extList[i], (const char *)"GL_EXT_draw_instanced") == 0) && // Standard EXT + (strcmp(extList[i], (const char *)"GL_EXT_instanced_arrays") == 0)) + { + glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedEXT"); + glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedEXT"); + glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorEXT"); + + if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true; + } + } + + // Check NPOT textures support + // NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature + if (strcmp(extList[i], (const char *)"GL_OES_texture_npot") == 0) RLGL.ExtSupported.texNPOT = true; + + // Check texture float support + if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) RLGL.ExtSupported.texFloat32 = true; + + // Check depth texture support + if (strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) RLGL.ExtSupported.texDepth = true; + if (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0) RLGL.ExtSupported.texDepthWebGL = true; // WebGL requires unsized internal format + if (RLGL.ExtSupported.texDepthWebGL) RLGL.ExtSupported.texDepth = true; + + if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) RLGL.ExtSupported.maxDepthBits = 24; // Not available on WebGL + if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) RLGL.ExtSupported.maxDepthBits = 32; // Not available on WebGL + + // Check texture compression support: DXT + if ((strcmp(extList[i], (const char *)"GL_EXT_texture_compression_s3tc") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_s3tc") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBKIT_WEBGL_compressed_texture_s3tc") == 0)) RLGL.ExtSupported.texCompDXT = true; + + // Check texture compression support: ETC1 + if ((strcmp(extList[i], (const char *)"GL_OES_compressed_ETC1_RGB8_texture") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_etc1") == 0)) RLGL.ExtSupported.texCompETC1 = true; + + // Check texture compression support: ETC2/EAC + if (strcmp(extList[i], (const char *)"GL_ARB_ES3_compatibility") == 0) RLGL.ExtSupported.texCompETC2 = true; + + // Check texture compression support: PVR + if (strcmp(extList[i], (const char *)"GL_IMG_texture_compression_pvrtc") == 0) RLGL.ExtSupported.texCompPVRT = true; + + // Check texture compression support: ASTC + if (strcmp(extList[i], (const char *)"GL_KHR_texture_compression_astc_hdr") == 0) RLGL.ExtSupported.texCompASTC = true; + + // Check anisotropic texture filter support + if (strcmp(extList[i], (const char *)"GL_EXT_texture_filter_anisotropic") == 0) RLGL.ExtSupported.texAnisoFilter = true; + + // Check clamp mirror wrap mode support + if (strcmp(extList[i], (const char *)"GL_EXT_texture_mirror_clamp") == 0) RLGL.ExtSupported.texMirrorClamp = true; + } + + // Free extensions pointers + RL_FREE(extList); + RL_FREE(extensionsDup); // Duplicated string must be deallocated +#endif // GRAPHICS_API_OPENGL_ES2 + + // Check OpenGL information and capabilities + //------------------------------------------------------------------------------ + // Show current OpenGL and GLSL version + TRACELOG(RL_LOG_INFO, "GL: OpenGL device information:"); + TRACELOG(RL_LOG_INFO, " > Vendor: %s", glGetString(GL_VENDOR)); + TRACELOG(RL_LOG_INFO, " > Renderer: %s", glGetString(GL_RENDERER)); + TRACELOG(RL_LOG_INFO, " > Version: %s", glGetString(GL_VERSION)); + TRACELOG(RL_LOG_INFO, " > GLSL: %s", glGetString(GL_SHADING_LANGUAGE_VERSION)); + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: Anisotropy levels capability is an extension + #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF + #endif + glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &RLGL.ExtSupported.maxAnisotropyLevel); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + // Show some OpenGL GPU capabilities + TRACELOG(RL_LOG_INFO, "GL: OpenGL capabilities:"); + GLint capability = 0; + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_SIZE: %i", capability); + glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_CUBE_MAP_TEXTURE_SIZE: %i", capability); + glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_IMAGE_UNITS: %i", capability); + glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIBS: %i", capability); + #if !defined(GRAPHICS_API_OPENGL_ES2) + glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_BLOCK_SIZE: %i", capability); + glGetIntegerv(GL_MAX_DRAW_BUFFERS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_DRAW_BUFFERS: %i", capability); + if (RLGL.ExtSupported.texAnisoFilter) TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_MAX_ANISOTROPY: %.0f", RLGL.ExtSupported.maxAnisotropyLevel); + #endif + glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &capability); + TRACELOG(RL_LOG_INFO, " GL_NUM_COMPRESSED_TEXTURE_FORMATS: %i", capability); + GLint *compFormats = (GLint *)RL_CALLOC(capability, sizeof(GLint)); + glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compFormats); + for (int i = 0; i < capability; i++) TRACELOG(RL_LOG_INFO, " %s", rlGetCompressedFormatName(compFormats[i])); + RL_FREE(compFormats); + +#if defined(GRAPHICS_API_OPENGL_43) + glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability); + glGetIntegerv(GL_MAX_UNIFORM_LOCATIONS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_LOCATIONS: %i", capability); +#endif // GRAPHICS_API_OPENGL_43 +#else // RLGL_SHOW_GL_DETAILS_INFO + + // Show some basic info about GL supported features + if (RLGL.ExtSupported.vao) TRACELOG(RL_LOG_INFO, "GL: VAO extension detected, VAO functions loaded successfully"); + else TRACELOG(RL_LOG_WARNING, "GL: VAO extension not found, VAO not supported"); + if (RLGL.ExtSupported.texNPOT) TRACELOG(RL_LOG_INFO, "GL: NPOT textures extension detected, full NPOT textures supported"); + else TRACELOG(RL_LOG_WARNING, "GL: NPOT textures extension not found, limited NPOT support (no-mipmaps, no-repeat)"); + if (RLGL.ExtSupported.texCompDXT) TRACELOG(RL_LOG_INFO, "GL: DXT compressed textures supported"); + if (RLGL.ExtSupported.texCompETC1) TRACELOG(RL_LOG_INFO, "GL: ETC1 compressed textures supported"); + if (RLGL.ExtSupported.texCompETC2) TRACELOG(RL_LOG_INFO, "GL: ETC2/EAC compressed textures supported"); + if (RLGL.ExtSupported.texCompPVRT) TRACELOG(RL_LOG_INFO, "GL: PVRT compressed textures supported"); + if (RLGL.ExtSupported.texCompASTC) TRACELOG(RL_LOG_INFO, "GL: ASTC compressed textures supported"); + if (RLGL.ExtSupported.computeShader) TRACELOG(RL_LOG_INFO, "GL: Compute shaders supported"); + if (RLGL.ExtSupported.ssbo) TRACELOG(RL_LOG_INFO, "GL: Shader storage buffer objects supported"); +#endif // RLGL_SHOW_GL_DETAILS_INFO + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 +} + +// Get current OpenGL version +int rlGetVersion(void) +{ + int glVersion = 0; +#if defined(GRAPHICS_API_OPENGL_11) + glVersion = RL_OPENGL_11; +#endif +#if defined(GRAPHICS_API_OPENGL_21) + glVersion = RL_OPENGL_21; +#elif defined(GRAPHICS_API_OPENGL_33) + glVersion = RL_OPENGL_33; +#endif +#if defined(GRAPHICS_API_OPENGL_43) + glVersion = RL_OPENGL_43; +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + glVersion = RL_OPENGL_ES_20; +#endif + return glVersion; +} + +// Set current framebuffer width +void rlSetFramebufferWidth(int width) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.framebufferWidth = width; +#endif +} + +// Set current framebuffer height +void rlSetFramebufferHeight(int height) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.framebufferHeight = height; +#endif +} + +// Get default framebuffer width +int rlGetFramebufferWidth(void) +{ + int width = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + width = RLGL.State.framebufferWidth; +#endif + return width; +} + +// Get default framebuffer height +int rlGetFramebufferHeight(void) +{ + int height = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + height = RLGL.State.framebufferHeight; +#endif + return height; +} + +// Get default internal texture (white texture) +// NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8 +unsigned int rlGetTextureIdDefault(void) +{ + unsigned int id = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + id = RLGL.State.defaultTextureId; +#endif + return id; +} + +// Get default shader id +unsigned int rlGetShaderIdDefault(void) +{ + unsigned int id = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + id = RLGL.State.defaultShaderId; +#endif + return id; +} + +// Get default shader locs +int *rlGetShaderLocsDefault(void) +{ + int *locs = NULL; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + locs = RLGL.State.defaultShaderLocs; +#endif + return locs; +} + +// Render batch management +//------------------------------------------------------------------------------------------------ +// Load render batch +rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements) +{ + rlRenderBatch batch = { 0 }; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes) + //-------------------------------------------------------------------------------------------- + batch.vertexBuffer = (rlVertexBuffer *)RL_MALLOC(numBuffers*sizeof(rlVertexBuffer)); + + for (int i = 0; i < numBuffers; i++) + { + batch.vertexBuffer[i].elementCount = bufferElements; + + batch.vertexBuffer[i].vertices = (float *)RL_MALLOC(bufferElements*3*4*sizeof(float)); // 3 float by vertex, 4 vertex by quad + batch.vertexBuffer[i].texcoords = (float *)RL_MALLOC(bufferElements*2*4*sizeof(float)); // 2 float by texcoord, 4 texcoord by quad + batch.vertexBuffer[i].colors = (unsigned char *)RL_MALLOC(bufferElements*4*4*sizeof(unsigned char)); // 4 float by color, 4 colors by quad +#if defined(GRAPHICS_API_OPENGL_33) + batch.vertexBuffer[i].indices = (unsigned int *)RL_MALLOC(bufferElements*6*sizeof(unsigned int)); // 6 int by quad (indices) +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + batch.vertexBuffer[i].indices = (unsigned short *)RL_MALLOC(bufferElements*6*sizeof(unsigned short)); // 6 int by quad (indices) +#endif + + for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].vertices[j] = 0.0f; + for (int j = 0; j < (2*4*bufferElements); j++) batch.vertexBuffer[i].texcoords[j] = 0.0f; + for (int j = 0; j < (4*4*bufferElements); j++) batch.vertexBuffer[i].colors[j] = 0; + + int k = 0; + + // Indices can be initialized right now + for (int j = 0; j < (6*bufferElements); j += 6) + { + batch.vertexBuffer[i].indices[j] = 4*k; + batch.vertexBuffer[i].indices[j + 1] = 4*k + 1; + batch.vertexBuffer[i].indices[j + 2] = 4*k + 2; + batch.vertexBuffer[i].indices[j + 3] = 4*k; + batch.vertexBuffer[i].indices[j + 4] = 4*k + 2; + batch.vertexBuffer[i].indices[j + 5] = 4*k + 3; + + k++; + } + + RLGL.State.vertexCounter = 0; + } + + TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in RAM (CPU)"); + //-------------------------------------------------------------------------------------------- + + // Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs + //-------------------------------------------------------------------------------------------- + for (int i = 0; i < numBuffers; i++) + { + if (RLGL.ExtSupported.vao) + { + // Initialize Quads VAO + glGenVertexArrays(1, &batch.vertexBuffer[i].vaoId); + glBindVertexArray(batch.vertexBuffer[i].vaoId); + } + + // Quads - Vertex buffers binding and attributes enable + // Vertex position buffer (shader-location = 0) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[0]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[0]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*3*4*sizeof(float), batch.vertexBuffer[i].vertices, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0); + + // Vertex texcoord buffer (shader-location = 1) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[1]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[1]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*2*4*sizeof(float), batch.vertexBuffer[i].texcoords, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0); + + // Vertex color buffer (shader-location = 3) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[2]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[2]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*4*4*sizeof(unsigned char), batch.vertexBuffer[i].colors, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); + + // Fill index buffer + glGenBuffers(1, &batch.vertexBuffer[i].vboId[3]); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[3]); +#if defined(GRAPHICS_API_OPENGL_33) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(int), batch.vertexBuffer[i].indices, GL_STATIC_DRAW); +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(short), batch.vertexBuffer[i].indices, GL_STATIC_DRAW); +#endif + } + + TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in VRAM (GPU)"); + + // Unbind the current VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(0); + //-------------------------------------------------------------------------------------------- + + // Init draw calls tracking system + //-------------------------------------------------------------------------------------------- + batch.draws = (rlDrawCall *)RL_MALLOC(RL_DEFAULT_BATCH_DRAWCALLS*sizeof(rlDrawCall)); + + for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) + { + batch.draws[i].mode = RL_QUADS; + batch.draws[i].vertexCount = 0; + batch.draws[i].vertexAlignment = 0; + //batch.draws[i].vaoId = 0; + //batch.draws[i].shaderId = 0; + batch.draws[i].textureId = RLGL.State.defaultTextureId; + //batch.draws[i].RLGL.State.projection = rlMatrixIdentity(); + //batch.draws[i].RLGL.State.modelview = rlMatrixIdentity(); + } + + batch.bufferCount = numBuffers; // Record buffer count + batch.drawCounter = 1; // Reset draws counter + batch.currentDepth = -1.0f; // Reset depth value + //-------------------------------------------------------------------------------------------- +#endif + + return batch; +} + +// Unload default internal buffers vertex data from CPU and GPU +void rlUnloadRenderBatch(rlRenderBatch batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Unbind everything + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + + // Unload all vertex buffers data + for (int i = 0; i < batch.bufferCount; i++) + { + // Unbind VAO attribs data + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(batch.vertexBuffer[i].vaoId); + glDisableVertexAttribArray(0); + glDisableVertexAttribArray(1); + glDisableVertexAttribArray(2); + glDisableVertexAttribArray(3); + glBindVertexArray(0); + } + + // Delete VBOs from GPU (VRAM) + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[0]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[1]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[2]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[3]); + + // Delete VAOs from GPU (VRAM) + if (RLGL.ExtSupported.vao) glDeleteVertexArrays(1, &batch.vertexBuffer[i].vaoId); + + // Free vertex arrays memory from CPU (RAM) + RL_FREE(batch.vertexBuffer[i].vertices); + RL_FREE(batch.vertexBuffer[i].texcoords); + RL_FREE(batch.vertexBuffer[i].colors); + RL_FREE(batch.vertexBuffer[i].indices); + } + + // Unload arrays + RL_FREE(batch.vertexBuffer); + RL_FREE(batch.draws); +#endif +} + +// Draw render batch +// NOTE: We require a pointer to reset batch and increase current buffer (multi-buffer) +void rlDrawRenderBatch(rlRenderBatch *batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Update batch vertex buffers + //------------------------------------------------------------------------------------------------------------ + // NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0) + // TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (change flag required) + if (RLGL.State.vertexCounter > 0) + { + // Activate elements VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId); + + // Vertex positions buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*3*sizeof(float), batch->vertexBuffer[batch->currentBuffer].vertices); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW); // Update all buffer + + // Texture coordinates buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*2*sizeof(float), batch->vertexBuffer[batch->currentBuffer].texcoords); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer + + // Colors buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*4*sizeof(unsigned char), batch->vertexBuffer[batch->currentBuffer].colors); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW); // Update all buffer + + // NOTE: glMapBuffer() causes sync issue. + // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job. + // To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer(). + // If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new + // allocated pointer immediately even if GPU is still working with the previous data. + + // Another option: map the buffer object into client's memory + // Probably this code could be moved somewhere else... + // batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE); + // if (batch->vertexBuffer[batch->currentBuffer].vertices) + // { + // Update vertex data + // } + // glUnmapBuffer(GL_ARRAY_BUFFER); + + // Unbind the current VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(0); + } + //------------------------------------------------------------------------------------------------------------ + + // Draw batch vertex buffers (considering VR stereo if required) + //------------------------------------------------------------------------------------------------------------ + Matrix matProjection = RLGL.State.projection; + Matrix matModelView = RLGL.State.modelview; + + int eyeCount = 1; + if (RLGL.State.stereoRender) eyeCount = 2; + + for (int eye = 0; eye < eyeCount; eye++) + { + if (eyeCount == 2) + { + // Setup current eye viewport (half screen width) + rlViewport(eye*RLGL.State.framebufferWidth/2, 0, RLGL.State.framebufferWidth/2, RLGL.State.framebufferHeight); + + // Set current eye view offset to modelview matrix + rlSetMatrixModelview(rlMatrixMultiply(matModelView, RLGL.State.viewOffsetStereo[eye])); + // Set current eye projection matrix + rlSetMatrixProjection(RLGL.State.projectionStereo[eye]); + } + + // Draw buffers + if (RLGL.State.vertexCounter > 0) + { + // Set current shader and upload current MVP matrix + glUseProgram(RLGL.State.currentShaderId); + + // Create modelview-projection matrix and upload to shader + Matrix matMVP = rlMatrixMultiply(RLGL.State.modelview, RLGL.State.projection); + float matMVPfloat[16] = { + matMVP.m0, matMVP.m1, matMVP.m2, matMVP.m3, + matMVP.m4, matMVP.m5, matMVP.m6, matMVP.m7, + matMVP.m8, matMVP.m9, matMVP.m10, matMVP.m11, + matMVP.m12, matMVP.m13, matMVP.m14, matMVP.m15 + }; + glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MVP], 1, false, matMVPfloat); + + if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId); + else + { + // Bind vertex attrib: position (shader-location = 0) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]); + + // Bind vertex attrib: texcoord (shader-location = 1) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]); + + // Bind vertex attrib: color (shader-location = 3) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[3]); + } + + // Setup some default shader values + glUniform4f(RLGL.State.currentShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE], 1.0f, 1.0f, 1.0f, 1.0f); + glUniform1i(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE], 0); // Active default sampler2D: texture0 + + // Activate additional sampler textures + // Those additional textures will be common for all draw calls of the batch + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) + { + if (RLGL.State.activeTextureId[i] > 0) + { + glActiveTexture(GL_TEXTURE0 + 1 + i); + glBindTexture(GL_TEXTURE_2D, RLGL.State.activeTextureId[i]); + } + } + + // Activate default sampler2D texture0 (one texture is always active for default batch shader) + // NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls + glActiveTexture(GL_TEXTURE0); + + for (int i = 0, vertexOffset = 0; i < batch->drawCounter; i++) + { + // Bind current draw call texture, activated as GL_TEXTURE0 and Bound to sampler2D texture0 by default + glBindTexture(GL_TEXTURE_2D, batch->draws[i].textureId); + + if ((batch->draws[i].mode == RL_LINES) || (batch->draws[i].mode == RL_TRIANGLES)) glDrawArrays(batch->draws[i].mode, vertexOffset, batch->draws[i].vertexCount); + else + { +#if defined(GRAPHICS_API_OPENGL_33) + // We need to define the number of indices to be processed: elementCount*6 + // NOTE: The final parameter tells the GPU the offset in bytes from the + // start of the index buffer to the location of the first index to process + glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(vertexOffset/4*6*sizeof(GLuint))); +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_SHORT, (GLvoid *)(vertexOffset/4*6*sizeof(GLushort))); +#endif + } + + vertexOffset += (batch->draws[i].vertexCount + batch->draws[i].vertexAlignment); + } + + if (!RLGL.ExtSupported.vao) + { + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } + + glBindTexture(GL_TEXTURE_2D, 0); // Unbind textures + } + + if (RLGL.ExtSupported.vao) glBindVertexArray(0); // Unbind VAO + + glUseProgram(0); // Unbind shader program + } + + // Restore viewport to default measures + if (eyeCount == 2) rlViewport(0, 0, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight); + //------------------------------------------------------------------------------------------------------------ + + // Reset batch buffers + //------------------------------------------------------------------------------------------------------------ + // Reset vertex counter for next frame + RLGL.State.vertexCounter = 0; + + // Reset depth for next draw + batch->currentDepth = -1.0f; + + // Restore projection/modelview matrices + RLGL.State.projection = matProjection; + RLGL.State.modelview = matModelView; + + // Reset RLGL.currentBatch->draws array + for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) + { + batch->draws[i].mode = RL_QUADS; + batch->draws[i].vertexCount = 0; + batch->draws[i].textureId = RLGL.State.defaultTextureId; + } + + // Reset active texture units for next batch + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) RLGL.State.activeTextureId[i] = 0; + + // Reset draws counter to one draw for the batch + batch->drawCounter = 1; + //------------------------------------------------------------------------------------------------------------ + + // Change to next buffer in the list (in case of multi-buffering) + batch->currentBuffer++; + if (batch->currentBuffer >= batch->bufferCount) batch->currentBuffer = 0; +#endif +} + +// Set the active render batch for rlgl +void rlSetRenderBatchActive(rlRenderBatch *batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlDrawRenderBatch(RLGL.currentBatch); + + if (batch != NULL) RLGL.currentBatch = batch; + else RLGL.currentBatch = &RLGL.defaultBatch; +#endif +} + +// Update and draw internal render batch +void rlDrawRenderBatchActive(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlDrawRenderBatch(RLGL.currentBatch); // NOTE: Stereo rendering is checked inside +#endif +} + +// Check internal buffer overflow for a given number of vertex +// and force a rlRenderBatch draw call if required +bool rlCheckRenderBatchLimit(int vCount) +{ + bool overflow = false; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.vertexCounter + vCount) >= + (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4)) + { + overflow = true; + + // Store current primitive drawing mode and texture id + int currentMode = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode; + int currentTexture = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId; + + rlDrawRenderBatch(RLGL.currentBatch); // NOTE: Stereo rendering is checked inside + + // Restore state of last batch so we can continue adding vertices + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = currentMode; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = currentTexture; + } +#endif + + return overflow; +} + +// Textures data management +//----------------------------------------------------------------------------------------- +// Convert image data to OpenGL texture (returns OpenGL valid Id) +unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount) +{ + unsigned int id = 0; + + glBindTexture(GL_TEXTURE_2D, 0); // Free any old binding + + // Check texture format support by OpenGL 1.1 (compressed textures not supported) +#if defined(GRAPHICS_API_OPENGL_11) + if (format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) + { + TRACELOG(RL_LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats"); + return id; + } +#else + if ((!RLGL.ExtSupported.texCompDXT) && ((format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA) || + (format == RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: DXT compressed texture format not supported"); + return id; + } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((!RLGL.ExtSupported.texCompETC1) && (format == RL_PIXELFORMAT_COMPRESSED_ETC1_RGB)) + { + TRACELOG(RL_LOG_WARNING, "GL: ETC1 compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompETC2) && ((format == RL_PIXELFORMAT_COMPRESSED_ETC2_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: ETC2 compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompPVRT) && ((format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: PVRT compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompASTC) && ((format == RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: ASTC compressed texture format not supported"); + return id; + } +#endif +#endif // GRAPHICS_API_OPENGL_11 + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + glGenTextures(1, &id); // Generate texture id + + glBindTexture(GL_TEXTURE_2D, id); + + int mipWidth = width; + int mipHeight = height; + int mipOffset = 0; // Mipmap data offset + + // Load the different mipmap levels + for (int i = 0; i < mipmapCount; i++) + { + unsigned int mipSize = rlGetPixelDataSize(mipWidth, mipHeight, format); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + TRACELOGD("TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset); + + if (glInternalFormat != -1) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, (unsigned char *)data + mipOffset); +#if !defined(GRAPHICS_API_OPENGL_11) + else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, (unsigned char *)data + mipOffset); +#endif + +#if defined(GRAPHICS_API_OPENGL_33) + if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) + { + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } + else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) + { +#if defined(GRAPHICS_API_OPENGL_21) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; +#elif defined(GRAPHICS_API_OPENGL_33) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; +#endif + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } +#endif + } + + mipWidth /= 2; + mipHeight /= 2; + mipOffset += mipSize; + + // Security check for NPOT textures + if (mipWidth < 1) mipWidth = 1; + if (mipHeight < 1) mipHeight = 1; + } + + // Texture parameters configuration + // NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used +#if defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used + if (RLGL.ExtSupported.texNPOT) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis + } + else + { + // NOTE: If using negative texture coordinates (LoadOBJ()), it does not work! + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // Set texture to clamp on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // Set texture to clamp on y-axis + } +#else + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis +#endif + + // Magnification and minification filters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Alternative: GL_LINEAR + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Alternative: GL_LINEAR + +#if defined(GRAPHICS_API_OPENGL_33) + if (mipmapCount > 1) + { + // Activate Trilinear filtering if mipmaps are available + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + } +#endif + + // At this point we have the texture loaded in GPU and texture parameters configured + + // NOTE: If mipmaps were not in data, they are not generated automatically + + // Unbind current texture + glBindTexture(GL_TEXTURE_2D, 0); + + if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Texture loaded successfully (%ix%i | %s | %i mipmaps)", id, width, height, rlGetPixelFormatName(format), mipmapCount); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load texture"); + + return id; +} + +// Load depth texture/renderbuffer (to be attached to fbo) +// WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture and WebGL requires WEBGL_depth_texture extensions +unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // In case depth textures not supported, we force renderbuffer usage + if (!RLGL.ExtSupported.texDepth) useRenderBuffer = true; + + // NOTE: We let the implementation to choose the best bit-depth + // Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F + unsigned int glInternalFormat = GL_DEPTH_COMPONENT; + +#if defined(GRAPHICS_API_OPENGL_ES2) + // WARNING: WebGL platform requires unsized internal format definition (GL_DEPTH_COMPONENT) + // while other platforms using OpenGL ES 2.0 require/support sized internal formats depending on the GPU capabilities + if (!RLGL.ExtSupported.texDepthWebGL || useRenderBuffer) + { + if (RLGL.ExtSupported.maxDepthBits == 32) glInternalFormat = GL_DEPTH_COMPONENT32_OES; + else if (RLGL.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES; + else glInternalFormat = GL_DEPTH_COMPONENT16; + } +#endif + + if (!useRenderBuffer && RLGL.ExtSupported.texDepth) + { + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_2D, id); + glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + glBindTexture(GL_TEXTURE_2D, 0); + + TRACELOG(RL_LOG_INFO, "TEXTURE: Depth texture loaded successfully"); + } + else + { + // Create the renderbuffer that will serve as the depth attachment for the framebuffer + // NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices + glGenRenderbuffers(1, &id); + glBindRenderbuffer(GL_RENDERBUFFER, id); + glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height); + + glBindRenderbuffer(GL_RENDERBUFFER, 0); + + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Depth renderbuffer loaded successfully (%i bits)", id, (RLGL.ExtSupported.maxDepthBits >= 24)? RLGL.ExtSupported.maxDepthBits : 16); + } +#endif + + return id; +} + +// Load texture cubemap +// NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other), +// expected the following convention: +X, -X, +Y, -Y, +Z, -Z +unsigned int rlLoadTextureCubemap(const void *data, int size, int format) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int dataSize = rlGetPixelDataSize(size, size, format); + + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_CUBE_MAP, id); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + if (glInternalFormat != -1) + { + // Load cubemap faces + for (unsigned int i = 0; i < 6; i++) + { + if (data == NULL) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) + { + if (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32) + { + // Instead of using a sized internal texture format (GL_RGB16F, GL_RGB32F), we let the driver to choose the better format for us (GL_RGB) + if (RLGL.ExtSupported.texFloat32) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, size, size, 0, GL_RGB, GL_FLOAT, NULL); + else TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported"); + } + else if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32)) TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported"); + else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, NULL); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format"); + } + else + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, (unsigned char *)data + i*dataSize); + else glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, dataSize, (unsigned char *)data + i*dataSize); + } + +#if defined(GRAPHICS_API_OPENGL_33) + if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) + { + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } + else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) + { +#if defined(GRAPHICS_API_OPENGL_21) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; +#elif defined(GRAPHICS_API_OPENGL_33) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; +#endif + glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } +#endif + } + } + + // Set cubemap texture sampling parameters + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); +#if defined(GRAPHICS_API_OPENGL_33) + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // Flag not supported on OpenGL ES 2.0 +#endif + + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif + + if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id, size, size); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture"); + + return id; +} + +// Update already loaded texture in GPU with new data +// NOTE: We don't know safely if internal texture format is the expected one... +void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data) +{ + glBindTexture(GL_TEXTURE_2D, id); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + if ((glInternalFormat != -1) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) + { + glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat, glType, data); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to update for current texture format (%i)", id, format); +} + +// Get OpenGL internal formats and data type from raylib PixelFormat +void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType) +{ + *glInternalFormat = 0; + *glFormat = 0; + *glType = 0; + + switch (format) + { + #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_LUMINANCE_ALPHA; *glFormat = GL_LUMINANCE_ALPHA; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break; + #if !defined(GRAPHICS_API_OPENGL_11) + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + #endif + #elif defined(GRAPHICS_API_OPENGL_33) + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_R8; *glFormat = GL_RED; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_RG8; *glFormat = GL_RG; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB565; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB8; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGB5_A1; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA4; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA8; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F; *glFormat = GL_RED; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F; *glFormat = GL_RGB; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; + #endif + #if !defined(GRAPHICS_API_OPENGL_11) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: if (RLGL.ExtSupported.texCompETC1) *glInternalFormat = GL_ETC1_RGB8_OES; break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGB8_ETC2; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 + #endif + default: TRACELOG(RL_LOG_WARNING, "TEXTURE: Current format not supported (%i)", format); break; + } +} + +// Unload texture from GPU memory +void rlUnloadTexture(unsigned int id) +{ + glDeleteTextures(1, &id); +} + +// Generate mipmap data for selected texture +// NOTE: Only supports GPU mipmap generation +void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_2D, id); + + // Check if texture is power-of-two (POT) + bool texIsPOT = false; + + if (((width > 0) && ((width & (width - 1)) == 0)) && + ((height > 0) && ((height & (height - 1)) == 0))) texIsPOT = true; + + if ((texIsPOT) || (RLGL.ExtSupported.texNPOT)) + { + //glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE); // Hint for mipmaps generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE + glGenerateMipmap(GL_TEXTURE_2D); // Generate mipmaps automatically + + #define MIN(a,b) (((a)<(b))? (a):(b)) + #define MAX(a,b) (((a)>(b))? (a):(b)) + + *mipmaps = 1 + (int)floor(log(MAX(width, height))/log(2)); + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Mipmaps generated automatically, total: %i", id, *mipmaps); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps", id); + + glBindTexture(GL_TEXTURE_2D, 0); +#else + TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] GPU mipmap generation not supported", id); +#endif +} + + +// Read texture pixel data +void *rlReadTexturePixels(unsigned int id, int width, int height, int format) +{ + void *pixels = NULL; + +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + glBindTexture(GL_TEXTURE_2D, id); + + // NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0) + // Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE + //int width, height, format; + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height); + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format); + + // NOTE: Each row written to or read from by OpenGL pixel operations like glGetTexImage are aligned to a 4 byte boundary by default, which may add some padding. + // Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting. + // GL_PACK_ALIGNMENT affects operations that read from OpenGL memory (glReadPixels, glGetTexImage, etc.) + // GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.) + glPixelStorei(GL_PACK_ALIGNMENT, 1); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + unsigned int size = rlGetPixelDataSize(width, height, format); + + if ((glInternalFormat != -1) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) + { + pixels = RL_MALLOC(size); + glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Data retrieval not suported for pixel format (%i)", id, format); + + glBindTexture(GL_TEXTURE_2D, 0); +#endif + +#if defined(GRAPHICS_API_OPENGL_ES2) + // glGetTexImage() is not available on OpenGL ES 2.0 + // Texture width and height are required on OpenGL ES 2.0. There is no way to get it from texture id. + // Two possible Options: + // 1 - Bind texture to color fbo attachment and glReadPixels() + // 2 - Create an fbo, activate it, render quad with texture, glReadPixels() + // We are using Option 1, just need to care for texture format on retrieval + // NOTE: This behaviour could be conditioned by graphic driver... + unsigned int fboId = rlLoadFramebuffer(width, height); + + glBindFramebuffer(GL_FRAMEBUFFER, fboId); + glBindTexture(GL_TEXTURE_2D, 0); + + // Attach our texture to FBO + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0); + + // We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format + pixels = (unsigned char *)RL_MALLOC(rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)); + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + + // Clean up temporal fbo + rlUnloadFramebuffer(fboId); +#endif + + return pixels; +} + +// Read screen pixel data (color buffer) +unsigned char *rlReadScreenPixels(int width, int height) +{ + unsigned char *screenData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char)); + + // NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer + // NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly! + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData); + + // Flip image vertically! + unsigned char *imgData = (unsigned char *)RL_MALLOC(width*height*4*sizeof(unsigned char)); + + for (int y = height - 1; y >= 0; y--) + { + for (int x = 0; x < (width*4); x++) + { + imgData[((height - 1) - y)*width*4 + x] = screenData[(y*width*4) + x]; // Flip line + + // Set alpha component value to 255 (no trasparent image retrieval) + // NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it! + if (((x + 1)%4) == 0) imgData[((height - 1) - y)*width*4 + x] = 255; + } + } + + RL_FREE(screenData); + + return imgData; // NOTE: image data should be freed +} + +// Framebuffer management (fbo) +//----------------------------------------------------------------------------------------- +// Load a framebuffer to be used for rendering +// NOTE: No textures attached +unsigned int rlLoadFramebuffer(int width, int height) +{ + unsigned int fboId = 0; + +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glGenFramebuffers(1, &fboId); // Create the framebuffer object + glBindFramebuffer(GL_FRAMEBUFFER, 0); // Unbind any framebuffer +#endif + + return fboId; +} + +// Attach color buffer texture to an fbo (unloads previous attachment) +// NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture +void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, fboId); + + switch (attachType) + { + case RL_ATTACHMENT_COLOR_CHANNEL0: + case RL_ATTACHMENT_COLOR_CHANNEL1: + case RL_ATTACHMENT_COLOR_CHANNEL2: + case RL_ATTACHMENT_COLOR_CHANNEL3: + case RL_ATTACHMENT_COLOR_CHANNEL4: + case RL_ATTACHMENT_COLOR_CHANNEL5: + case RL_ATTACHMENT_COLOR_CHANNEL6: + case RL_ATTACHMENT_COLOR_CHANNEL7: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_RENDERBUFFER, texId); + else if (texType >= RL_ATTACHMENT_CUBEMAP_POSITIVE_X) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_CUBE_MAP_POSITIVE_X + texType, texId, mipLevel); + + } break; + case RL_ATTACHMENT_DEPTH: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, texId); + + } break; + case RL_ATTACHMENT_STENCIL: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, texId); + + } break; + default: break; + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); +#endif +} + +// Verify render texture is complete +bool rlFramebufferComplete(unsigned int id) +{ + bool result = false; + +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, id); + + GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); + + if (status != GL_FRAMEBUFFER_COMPLETE) + { + switch (status) + { + case GL_FRAMEBUFFER_UNSUPPORTED: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id); break; + case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id); break; +#if defined(GRAPHICS_API_OPENGL_ES2) + case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id); break; +#endif + case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id); break; + default: break; + } + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + + result = (status == GL_FRAMEBUFFER_COMPLETE); +#endif + + return result; +} + +// Unload framebuffer from GPU memory +// NOTE: All attached textures/cubemaps/renderbuffers are also deleted +void rlUnloadFramebuffer(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + + // Query depth attachment to automatically delete texture/renderbuffer + int depthType = 0, depthId = 0; + glBindFramebuffer(GL_FRAMEBUFFER, id); // Bind framebuffer to query depth texture type + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &depthType); + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthId); + + unsigned int depthIdU = (unsigned int)depthId; + if (depthType == GL_RENDERBUFFER) glDeleteRenderbuffers(1, &depthIdU); + else if (depthType == GL_TEXTURE) glDeleteTextures(1, &depthIdU); + + // NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer, + // the texture image is automatically detached from the currently bound framebuffer. + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glDeleteFramebuffers(1, &id); + + TRACELOG(RL_LOG_INFO, "FBO: [ID %i] Unloaded framebuffer from VRAM (GPU)", id); +#endif +} + +// Vertex data management +//----------------------------------------------------------------------------------------- +// Load a new attributes buffer +unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glGenBuffers(1, &id); + glBindBuffer(GL_ARRAY_BUFFER, id); + glBufferData(GL_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); +#endif + + return id; +} + +// Load a new attributes element buffer +unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glGenBuffers(1, &id); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); +#endif + + return id; +} + +// Enable vertex buffer (VBO) +void rlEnableVertexBuffer(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, id); +#endif +} + +// Disable vertex buffer (VBO) +void rlDisableVertexBuffer(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, 0); +#endif +} + +// Enable vertex buffer element (VBO element) +void rlEnableVertexBufferElement(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); +#endif +} + +// Disable vertex buffer element (VBO element) +void rlDisableVertexBufferElement(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); +#endif +} + +// Update vertex buffer with new data +// NOTE: dataSize and offset must be provided in bytes +void rlUpdateVertexBuffer(unsigned int id, const void *data, int dataSize, int offset) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, id); + glBufferSubData(GL_ARRAY_BUFFER, offset, dataSize, data); +#endif +} + +// Update vertex buffer elements with new data +// NOTE: dataSize and offset must be provided in bytes +void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); + glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, dataSize, data); +#endif +} + +// Enable vertex array object (VAO) +bool rlEnableVertexArray(unsigned int vaoId) +{ + bool result = false; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(vaoId); + result = true; + } +#endif + return result; +} + +// Disable vertex array object (VAO) +void rlDisableVertexArray(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) glBindVertexArray(0); +#endif +} + +// Enable vertex attribute index +void rlEnableVertexAttribute(unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glEnableVertexAttribArray(index); +#endif +} + +// Disable vertex attribute index +void rlDisableVertexAttribute(unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDisableVertexAttribArray(index); +#endif +} + +// Draw vertex array +void rlDrawVertexArray(int offset, int count) +{ + glDrawArrays(GL_TRIANGLES, offset, count); +} + +// Draw vertex array elements +void rlDrawVertexArrayElements(int offset, int count, const void *buffer) +{ + glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)buffer + offset); +} + +// Draw vertex array instanced +void rlDrawVertexArrayInstanced(int offset, int count, int instances) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDrawArraysInstanced(GL_TRIANGLES, 0, count, instances); +#endif +} + +// Draw vertex array elements instanced +void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)buffer + offset, instances); +#endif +} + +#if defined(GRAPHICS_API_OPENGL_11) +// Enable vertex state pointer +void rlEnableStatePointer(int vertexAttribType, void *buffer) +{ + if (buffer != NULL) glEnableClientState(vertexAttribType); + switch (vertexAttribType) + { + case GL_VERTEX_ARRAY: glVertexPointer(3, GL_FLOAT, 0, buffer); break; + case GL_TEXTURE_COORD_ARRAY: glTexCoordPointer(2, GL_FLOAT, 0, buffer); break; + case GL_NORMAL_ARRAY: if (buffer != NULL) glNormalPointer(GL_FLOAT, 0, buffer); break; + case GL_COLOR_ARRAY: if (buffer != NULL) glColorPointer(4, GL_UNSIGNED_BYTE, 0, buffer); break; + //case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors + default: break; + } +} + +// Disable vertex state pointer +void rlDisableStatePointer(int vertexAttribType) +{ + glDisableClientState(vertexAttribType); +} +#endif + +// Load vertex array object (VAO) +unsigned int rlLoadVertexArray(void) +{ + unsigned int vaoId = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glGenVertexArrays(1, &vaoId); + } +#endif + return vaoId; +} + +// Set vertex attribute +void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glVertexAttribPointer(index, compSize, type, normalized, stride, pointer); +#endif +} + +// Set vertex attribute divisor +void rlSetVertexAttributeDivisor(unsigned int index, int divisor) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glVertexAttribDivisor(index, divisor); +#endif +} + +// Unload vertex array object (VAO) +void rlUnloadVertexArray(unsigned int vaoId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(0); + glDeleteVertexArrays(1, &vaoId); + TRACELOG(RL_LOG_INFO, "VAO: [ID %i] Unloaded vertex array data from VRAM (GPU)", vaoId); + } +#endif +} + +// Unload vertex buffer (VBO) +void rlUnloadVertexBuffer(unsigned int vboId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDeleteBuffers(1, &vboId); + //TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)"); +#endif +} + +// Shaders management +//----------------------------------------------------------------------------------------------- +// Load shader from code strings +// NOTE: If shader string is NULL, using default vertex/fragment shaders +unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int vertexShaderId = 0; + unsigned int fragmentShaderId = 0; + + // Compile vertex shader (if provided) + if (vsCode != NULL) vertexShaderId = rlCompileShader(vsCode, GL_VERTEX_SHADER); + // In case no vertex shader was provided or compilation failed, we use default vertex shader + if (vertexShaderId == 0) vertexShaderId = RLGL.State.defaultVShaderId; + + // Compile fragment shader (if provided) + if (fsCode != NULL) fragmentShaderId = rlCompileShader(fsCode, GL_FRAGMENT_SHADER); + // In case no fragment shader was provided or compilation failed, we use default fragment shader + if (fragmentShaderId == 0) fragmentShaderId = RLGL.State.defaultFShaderId; + + // In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id + if ((vertexShaderId == RLGL.State.defaultVShaderId) && (fragmentShaderId == RLGL.State.defaultFShaderId)) id = RLGL.State.defaultShaderId; + else + { + // One of or both shader are new, we need to compile a new shader program + id = rlLoadShaderProgram(vertexShaderId, fragmentShaderId); + + // We can detach and delete vertex/fragment shaders (if not default ones) + // NOTE: We detach shader before deletion to make sure memory is freed + if (vertexShaderId != RLGL.State.defaultVShaderId) + { + // WARNING: Shader program linkage could fail and returned id is 0 + if (id > 0) glDetachShader(id, vertexShaderId); + glDeleteShader(vertexShaderId); + } + if (fragmentShaderId != RLGL.State.defaultFShaderId) + { + // WARNING: Shader program linkage could fail and returned id is 0 + if (id > 0) glDetachShader(id, fragmentShaderId); + glDeleteShader(fragmentShaderId); + } + + // In case shader program loading failed, we assign default shader + if (id == 0) + { + // In case shader loading fails, we return the default shader + TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader"); + id = RLGL.State.defaultShaderId; + } + /* + else + { + // Get available shader uniforms + // NOTE: This information is useful for debug... + int uniformCount = -1; + glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount); + + for (int i = 0; i < uniformCount; i++) + { + int namelen = -1; + int num = -1; + char name[256] = { 0 }; // Assume no variable names longer than 256 + GLenum type = GL_ZERO; + + // Get the name of the uniforms + glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name); + + name[namelen] = 0; + TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name)); + } + } + */ + } +#endif + + return id; +} + +// Compile custom shader and return shader id +unsigned int rlCompileShader(const char *shaderCode, int type) +{ + unsigned int shader = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + shader = glCreateShader(type); + glShaderSource(shader, 1, &shaderCode, NULL); + + GLint success = 0; + glCompileShader(shader); + glGetShaderiv(shader, GL_COMPILE_STATUS, &success); + + if (success == GL_FALSE) + { + switch (type) + { + case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break; + case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break; + //case GL_GEOMETRY_SHADER: + #if defined(GRAPHICS_API_OPENGL_43) + case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break; + #endif + default: break; + } + + int maxLength = 0; + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetShaderInfoLog(shader, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log); + RL_FREE(log); + } + } + else + { + switch (type) + { + case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break; + case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break; + //case GL_GEOMETRY_SHADER: + #if defined(GRAPHICS_API_OPENGL_43) + case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break; + #endif + default: break; + } + } +#endif + + return shader; +} + +// Load custom shader strings and return program id +unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId) +{ + unsigned int program = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + GLint success = 0; + program = glCreateProgram(); + + glAttachShader(program, vShaderId); + glAttachShader(program, fShaderId); + + // NOTE: Default attribute shader locations must be Bound before linking + glBindAttribLocation(program, 0, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION); + glBindAttribLocation(program, 1, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD); + glBindAttribLocation(program, 2, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL); + glBindAttribLocation(program, 3, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR); + glBindAttribLocation(program, 4, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT); + glBindAttribLocation(program, 5, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2); + + // NOTE: If some attrib name is no found on the shader, it locations becomes -1 + + glLinkProgram(program); + + // NOTE: All uniform variables are intitialised to 0 when a program links + + glGetProgramiv(program, GL_LINK_STATUS, &success); + + if (success == GL_FALSE) + { + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", program); + + int maxLength = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetProgramInfoLog(program, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log); + RL_FREE(log); + } + + glDeleteProgram(program); + + program = 0; + } + else + { + // Get the size of compiled shader program (not available on OpenGL ES 2.0) + // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. + //GLint binarySize = 0; + //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", program); + } +#endif + return program; +} + +// Unload shader program +void rlUnloadShaderProgram(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDeleteProgram(id); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader program data from VRAM (GPU)", id); +#endif +} + +// Get shader location uniform +int rlGetLocationUniform(unsigned int shaderId, const char *uniformName) +{ + int location = -1; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + location = glGetUniformLocation(shaderId, uniformName); + + if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName); + else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location); +#endif + return location; +} + +// Get shader location attribute +int rlGetLocationAttrib(unsigned int shaderId, const char *attribName) +{ + int location = -1; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + location = glGetAttribLocation(shaderId, attribName); + + if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader attribute: %s", shaderId, attribName); + else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader attribute (%s) set at location: %i", shaderId, attribName, location); +#endif + return location; +} + +// Set shader value uniform +void rlSetUniform(int locIndex, const void *value, int uniformType, int count) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + switch (uniformType) + { + case RL_SHADER_UNIFORM_FLOAT: glUniform1fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC2: glUniform2fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC3: glUniform3fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC4: glUniform4fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_INT: glUniform1iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC2: glUniform2iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC3: glUniform3iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC4: glUniform4iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_SAMPLER2D: glUniform1iv(locIndex, count, (int *)value); break; + default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set uniform value, data type not recognized"); + } +#endif +} + +// Set shader value attribute +void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + switch (attribType) + { + case RL_SHADER_ATTRIB_FLOAT: if (count == 1) glVertexAttrib1fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC2: if (count == 2) glVertexAttrib2fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC3: if (count == 3) glVertexAttrib3fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC4: if (count == 4) glVertexAttrib4fv(locIndex, (float *)value); break; + default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set attrib default value, data type not recognized"); + } +#endif +} + +// Set shader value uniform matrix +void rlSetUniformMatrix(int locIndex, Matrix mat) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + float matfloat[16] = { + mat.m0, mat.m1, mat.m2, mat.m3, + mat.m4, mat.m5, mat.m6, mat.m7, + mat.m8, mat.m9, mat.m10, mat.m11, + mat.m12, mat.m13, mat.m14, mat.m15 + }; + glUniformMatrix4fv(locIndex, 1, false, matfloat); +#endif +} + +// Set shader value uniform sampler +void rlSetUniformSampler(int locIndex, unsigned int textureId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Check if texture is already active + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) if (RLGL.State.activeTextureId[i] == textureId) return; + + // Register a new active texture for the internal batch system + // NOTE: Default texture is always activated as GL_TEXTURE0 + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) + { + if (RLGL.State.activeTextureId[i] == 0) + { + glUniform1i(locIndex, 1 + i); // Activate new texture unit + RLGL.State.activeTextureId[i] = textureId; // Save texture id for binding on drawing + break; + } + } +#endif +} + +// Set shader currently active (id and locations) +void rlSetShader(unsigned int id, int *locs) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.State.currentShaderId != id) + { + rlDrawRenderBatch(RLGL.currentBatch); + RLGL.State.currentShaderId = id; + RLGL.State.currentShaderLocs = locs; + } +#endif +} + +// Load compute shader program +unsigned int rlLoadComputeShaderProgram(unsigned int shaderId) +{ + unsigned int program = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + GLint success = 0; + program = glCreateProgram(); + glAttachShader(program, shaderId); + glLinkProgram(program); + + // NOTE: All uniform variables are intitialised to 0 when a program links + + glGetProgramiv(program, GL_LINK_STATUS, &success); + + if (success == GL_FALSE) + { + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", program); + + int maxLength = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetProgramInfoLog(program, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log); + RL_FREE(log); + } + + glDeleteProgram(program); + + program = 0; + } + else + { + // Get the size of compiled shader program (not available on OpenGL ES 2.0) + // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. + //GLint binarySize = 0; + //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", program); + } +#endif + + return program; +} + +// Dispatch compute shader (equivalent to *draw* for graphics pilepine) +void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glDispatchCompute(groupX, groupY, groupZ); +#endif +} + +// Load shader storage buffer object (SSBO) +unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint) +{ + unsigned int ssbo = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + glGenBuffers(1, &ssbo); + glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo); + glBufferData(GL_SHADER_STORAGE_BUFFER, size, data, usageHint? usageHint : RL_STREAM_COPY); + glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, 0); + glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); +#endif + + return ssbo; +} + +// Unload shader storage buffer object (SSBO) +void rlUnloadShaderBuffer(unsigned int ssboId) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glDeleteBuffers(1, &ssboId); +#endif +} + +// Update SSBO buffer data +void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, dataSize, data); +#endif +} + +// Get SSBO buffer size +unsigned int rlGetShaderBufferSize(unsigned int id) +{ + long long size = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glGetInteger64v(GL_SHADER_STORAGE_BUFFER_SIZE, &size); +#endif + + return (size > 0)? (unsigned int)size : 0; +} + +// Read SSBO buffer data (GPU->CPU) +void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, count, dest); +#endif +} + +// Bind SSBO buffer +void rlBindShaderBuffer(unsigned int id, unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, id); +#endif +} + +// Copy SSBO buffer data +void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_COPY_READ_BUFFER, srcId); + glBindBuffer(GL_COPY_WRITE_BUFFER, destId); + glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset, destOffset, count); +#endif +} + +// Bind image texture +void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly) +{ +#if defined(GRAPHICS_API_OPENGL_43) + unsigned int glInternalFormat = 0, glFormat = 0, glType = 0; + + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + glBindImageTexture(index, id, 0, 0, 0, readonly ? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat); +#endif +} + +// Matrix state management +//----------------------------------------------------------------------------------------- +// Get internal modelview matrix +Matrix rlGetMatrixModelview(void) +{ + Matrix matrix = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_11) + float mat[16]; + glGetFloatv(GL_MODELVIEW_MATRIX, mat); + matrix.m0 = mat[0]; + matrix.m1 = mat[1]; + matrix.m2 = mat[2]; + matrix.m3 = mat[3]; + matrix.m4 = mat[4]; + matrix.m5 = mat[5]; + matrix.m6 = mat[6]; + matrix.m7 = mat[7]; + matrix.m8 = mat[8]; + matrix.m9 = mat[9]; + matrix.m10 = mat[10]; + matrix.m11 = mat[11]; + matrix.m12 = mat[12]; + matrix.m13 = mat[13]; + matrix.m14 = mat[14]; + matrix.m15 = mat[15]; +#else + matrix = RLGL.State.modelview; +#endif + return matrix; +} + +// Get internal projection matrix +Matrix rlGetMatrixProjection(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) + float mat[16]; + glGetFloatv(GL_PROJECTION_MATRIX,mat); + Matrix m; + m.m0 = mat[0]; + m.m1 = mat[1]; + m.m2 = mat[2]; + m.m3 = mat[3]; + m.m4 = mat[4]; + m.m5 = mat[5]; + m.m6 = mat[6]; + m.m7 = mat[7]; + m.m8 = mat[8]; + m.m9 = mat[9]; + m.m10 = mat[10]; + m.m11 = mat[11]; + m.m12 = mat[12]; + m.m13 = mat[13]; + m.m14 = mat[14]; + m.m15 = mat[15]; + return m; +#else + return RLGL.State.projection; +#endif +} + +// Get internal accumulated transform matrix +Matrix rlGetMatrixTransform(void) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // TODO: Consider possible transform matrices in the RLGL.State.stack + // Is this the right order? or should we start with the first stored matrix instead of the last one? + //Matrix matStackTransform = rlMatrixIdentity(); + //for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform); + mat = RLGL.State.transform; +#endif + return mat; +} + +// Get internal projection matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixProjectionStereo(int eye) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mat = RLGL.State.projectionStereo[eye]; +#endif + return mat; +} + +// Get internal view offset matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mat = RLGL.State.viewOffsetStereo[eye]; +#endif + return mat; +} + +// Set a custom modelview matrix (replaces internal modelview matrix) +void rlSetMatrixModelview(Matrix view) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.modelview = view; +#endif +} + +// Set a custom projection matrix (replaces internal projection matrix) +void rlSetMatrixProjection(Matrix projection) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.projection = projection; +#endif +} + +// Set eyes projection matrices for stereo rendering +void rlSetMatrixProjectionStereo(Matrix right, Matrix left) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.projectionStereo[0] = right; + RLGL.State.projectionStereo[1] = left; +#endif +} + +// Set eyes view offsets matrices for stereo rendering +void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.viewOffsetStereo[0] = right; + RLGL.State.viewOffsetStereo[1] = left; +#endif +} + +// Load and draw a quad in NDC +void rlLoadDrawQuad(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int quadVAO = 0; + unsigned int quadVBO = 0; + + float vertices[] = { + // Positions Texcoords + -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, + }; + + // Gen VAO to contain VBO + glGenVertexArrays(1, &quadVAO); + glBindVertexArray(quadVAO); + + // Gen and fill vertex buffer (VBO) + glGenBuffers(1, &quadVBO); + glBindBuffer(GL_ARRAY_BUFFER, quadVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW); + + // Bind vertex attributes (position, texcoords) + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)0); // Positions + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)(3*sizeof(float))); // Texcoords + + // Draw quad + glBindVertexArray(quadVAO); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + glBindVertexArray(0); + + // Delete buffers (VBO and VAO) + glDeleteBuffers(1, &quadVBO); + glDeleteVertexArrays(1, &quadVAO); +#endif +} + +// Load and draw a cube in NDC +void rlLoadDrawCube(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int cubeVAO = 0; + unsigned int cubeVBO = 0; + + float vertices[] = { + // Positions Normals Texcoords + -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f + }; + + // Gen VAO to contain VBO + glGenVertexArrays(1, &cubeVAO); + glBindVertexArray(cubeVAO); + + // Gen and fill vertex buffer (VBO) + glGenBuffers(1, &cubeVBO); + glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + // Bind vertex attributes (position, normals, texcoords) + glBindVertexArray(cubeVAO); + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)0); // Positions + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(3*sizeof(float))); // Normals + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(6*sizeof(float))); // Texcoords + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); + + // Draw cube + glBindVertexArray(cubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); + glBindVertexArray(0); + + // Delete VBO and VAO + glDeleteBuffers(1, &cubeVBO); + glDeleteVertexArrays(1, &cubeVAO); +#endif +} + +// Get name string for pixel format +const char *rlGetPixelFormatName(unsigned int format) +{ + switch (format) + { + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: return "GRAYSCALE"; break; // 8 bit per pixel (no alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: return "GRAY_ALPHA"; break; // 8*2 bpp (2 channels) + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: return "R5G6B5"; break; // 16 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: return "R8G8B8"; break; // 24 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: return "R5G5B5A1"; break; // 16 bpp (1 bit alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: return "R4G4B4A4"; break; // 16 bpp (4 bit alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: return "R8G8B8A8"; break; // 32 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R32: return "R32"; break; // 32 bpp (1 channel - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: return "R32G32B32"; break; // 32*3 bpp (3 channels - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: return "R32G32B32A32"; break; // 32*4 bpp (4 channels - float) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: return "DXT1_RGB"; break; // 4 bpp (no alpha) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: return "DXT1_RGBA"; break; // 4 bpp (1 bit alpha) + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: return "DXT3_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: return "DXT5_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: return "ETC1_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: return "ETC2_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: return "ETC2_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: return "PVRT_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: return "PVRT_RGBA"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: return "ASTC_4x4_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: return "ASTC_8x8_RGBA"; break; // 2 bpp + default: return "UNKNOWN"; break; + } +} + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Load default shader (just vertex positioning and texture coloring) +// NOTE: This shader program is used for internal buffers +// NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs +static void rlLoadShaderDefault(void) +{ + RLGL.State.defaultShaderLocs = (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int)); + + // NOTE: All locations must be reseted to -1 (no location) + for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++) RLGL.State.defaultShaderLocs[i] = -1; + + // Vertex shader directly defined, no external file required + const char *defaultVShaderCode = +#if defined(GRAPHICS_API_OPENGL_21) + "#version 120 \n" + "attribute vec3 vertexPosition; \n" + "attribute vec2 vertexTexCoord; \n" + "attribute vec4 vertexColor; \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" +#elif defined(GRAPHICS_API_OPENGL_33) + "#version 330 \n" + "in vec3 vertexPosition; \n" + "in vec2 vertexTexCoord; \n" + "in vec4 vertexColor; \n" + "out vec2 fragTexCoord; \n" + "out vec4 fragColor; \n" +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + "#version 100 \n" + "attribute vec3 vertexPosition; \n" + "attribute vec2 vertexTexCoord; \n" + "attribute vec4 vertexColor; \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" +#endif + "uniform mat4 mvp; \n" + "void main() \n" + "{ \n" + " fragTexCoord = vertexTexCoord; \n" + " fragColor = vertexColor; \n" + " gl_Position = mvp*vec4(vertexPosition, 1.0); \n" + "} \n"; + + // Fragment shader directly defined, no external file required + const char *defaultFShaderCode = +#if defined(GRAPHICS_API_OPENGL_21) + "#version 120 \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" + " gl_FragColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#elif defined(GRAPHICS_API_OPENGL_33) + "#version 330 \n" + "in vec2 fragTexCoord; \n" + "in vec4 fragColor; \n" + "out vec4 finalColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture(texture0, fragTexCoord); \n" + " finalColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + "#version 100 \n" + "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" + " gl_FragColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#endif + + // NOTE: Compiled vertex/fragment shaders are not deleted, + // they are kept for re-use as default shaders in case some shader loading fails + RLGL.State.defaultVShaderId = rlCompileShader(defaultVShaderCode, GL_VERTEX_SHADER); // Compile default vertex shader + RLGL.State.defaultFShaderId = rlCompileShader(defaultFShaderCode, GL_FRAGMENT_SHADER); // Compile default fragment shader + + RLGL.State.defaultShaderId = rlLoadShaderProgram(RLGL.State.defaultVShaderId, RLGL.State.defaultFShaderId); + + if (RLGL.State.defaultShaderId > 0) + { + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", RLGL.State.defaultShaderId); + + // Set default shader locations: attributes locations + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_POSITION] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexPosition"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexTexCoord"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_COLOR] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexColor"); + + // Set default shader locations: uniform locations + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MATRIX_MVP] = glGetUniformLocation(RLGL.State.defaultShaderId, "mvp"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, "colDiffuse"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, "texture0"); + } + else TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to load default shader", RLGL.State.defaultShaderId); +} + +// Unload default shader +// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs +static void rlUnloadShaderDefault(void) +{ + glUseProgram(0); + + glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultVShaderId); + glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultFShaderId); + glDeleteShader(RLGL.State.defaultVShaderId); + glDeleteShader(RLGL.State.defaultFShaderId); + + glDeleteProgram(RLGL.State.defaultShaderId); + + RL_FREE(RLGL.State.defaultShaderLocs); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader unloaded successfully", RLGL.State.defaultShaderId); +} + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) +// Get compressed format official GL identifier name +static char *rlGetCompressedFormatName(int format) +{ + switch (format) + { + // GL_EXT_texture_compression_s3tc + case 0x83F0: return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; break; + case 0x83F1: return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; break; + case 0x83F2: return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; break; + case 0x83F3: return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; break; + // GL_3DFX_texture_compression_FXT1 + case 0x86B0: return "GL_COMPRESSED_RGB_FXT1_3DFX"; break; + case 0x86B1: return "GL_COMPRESSED_RGBA_FXT1_3DFX"; break; + // GL_IMG_texture_compression_pvrtc + case 0x8C00: return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; break; + case 0x8C01: return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; break; + case 0x8C02: return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; break; + case 0x8C03: return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; break; + // GL_OES_compressed_ETC1_RGB8_texture + case 0x8D64: return "GL_ETC1_RGB8_OES"; break; + // GL_ARB_texture_compression_rgtc + case 0x8DBB: return "GL_COMPRESSED_RED_RGTC1"; break; + case 0x8DBC: return "GL_COMPRESSED_SIGNED_RED_RGTC1"; break; + case 0x8DBD: return "GL_COMPRESSED_RG_RGTC2"; break; + case 0x8DBE: return "GL_COMPRESSED_SIGNED_RG_RGTC2"; break; + // GL_ARB_texture_compression_bptc + case 0x8E8C: return "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB"; break; + case 0x8E8D: return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"; break; + case 0x8E8E: return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"; break; + case 0x8E8F: return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"; break; + // GL_ARB_ES3_compatibility + case 0x9274: return "GL_COMPRESSED_RGB8_ETC2"; break; + case 0x9275: return "GL_COMPRESSED_SRGB8_ETC2"; break; + case 0x9276: return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break; + case 0x9277: return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break; + case 0x9278: return "GL_COMPRESSED_RGBA8_ETC2_EAC"; break; + case 0x9279: return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; break; + case 0x9270: return "GL_COMPRESSED_R11_EAC"; break; + case 0x9271: return "GL_COMPRESSED_SIGNED_R11_EAC"; break; + case 0x9272: return "GL_COMPRESSED_RG11_EAC"; break; + case 0x9273: return "GL_COMPRESSED_SIGNED_RG11_EAC"; break; + // GL_KHR_texture_compression_astc_hdr + case 0x93B0: return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; break; + case 0x93B1: return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; break; + case 0x93B2: return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; break; + case 0x93B3: return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; break; + case 0x93B4: return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; break; + case 0x93B5: return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; break; + case 0x93B6: return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; break; + case 0x93B7: return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; break; + case 0x93B8: return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; break; + case 0x93B9: return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; break; + case 0x93BA: return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; break; + case 0x93BB: return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; break; + case 0x93BC: return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; break; + case 0x93BD: return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; break; + case 0x93D0: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; break; + case 0x93D1: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; break; + case 0x93D2: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; break; + case 0x93D3: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; break; + case 0x93D4: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; break; + case 0x93D5: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; break; + case 0x93D6: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; break; + case 0x93D7: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; break; + case 0x93D8: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; break; + case 0x93D9: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; break; + case 0x93DA: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; break; + case 0x93DB: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; break; + case 0x93DC: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; break; + case 0x93DD: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; break; + default: return "GL_COMPRESSED_UNKNOWN"; break; + } +} +#endif // RLGL_SHOW_GL_DETAILS_INFO + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +// Get pixel data size in bytes (image or texture) +// NOTE: Size depends on pixel format +static int rlGetPixelDataSize(int width, int height, int format) +{ + int dataSize = 0; // Size in bytes + int bpp = 0; // Bits per pixel + + switch (format) + { + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break; + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break; + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break; + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break; + default: break; + } + + dataSize = width*height*bpp/8; // Total data size in bytes + + // Most compressed formats works on 4x4 blocks, + // if texture is smaller, minimum dataSize is 8 or 16 + if ((width < 4) && (height < 4)) + { + if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8; + else if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16; + } + + return dataSize; +} + +// Auxiliar math functions + +// Get identity matrix +static Matrix rlMatrixIdentity(void) +{ + Matrix result = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + return result; +} + +// Get two matrix multiplication +// NOTE: When multiplying matrices... the order matters! +static Matrix rlMatrixMultiply(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; + + return result; +} + +#endif // RLGL_IMPLEMENTATION diff --git a/lib/raylib-4.5.0_win64_msvc16/lib/raylib.dll b/lib/raylib-4.5.0_win64_msvc16/lib/raylib.dll new file mode 100644 index 0000000000000000000000000000000000000000..df58566c09adb96233c2b78219b1fe624196cda6 GIT binary patch literal 1697792 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%0DjU|0qbhbh<*=ZxqRj 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

Ca* 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

oW{^GFGO$P`;yX*xM6VpntflJJc3JbSBVP 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

LB&C@HNpArw)Qp)d7an);I-xd?XURk7lZ0)p zJ)ZNU_#Fv-kLOI&_a%pd*806L5?HZcJzgMuz{m6G^z?^}_a|nsa6hdsEc(=bGg|mp zq@{(RMeeUN+1Fw7_zdi-?$%XotS#Z?pKI1@Uw3BHL5BNvIJI4edyF9;9MtMANK5WX zbY0aquU~4PLy!Qh@vFYJa$w8upk)Hnu=V1w#59^=IN7T_ry7{?GqlIRr?tUFOK-gK zZtf?4@m6qvmc*r`UF9ARy$_A1W_O!r!%$+LQaF67*#I60%$FMcYU1X;27jr&{mx%! zJQpk(*y<+&|MhsT+VOuM&nL(Bjc2J?yrobe|6Zwv92at063Dbxh^wMgs61?c8#4S@ zHF9M(r*PH7Zq~!n>(sHSm}tQbF&bKV5ZI1}79ljWCM1?$2DRI(p{3EA3gjeyE3IDb zbLfO++P4^Wkvz8335Kvq*ve(!mX}y*(y0OUn@f9nxH@fSIc=snH12q~>J)3Or#%&4 z-Jau@o~1pz5*Mc0Gq9eXZN%Vzr9}rz#;lx`m9}(>24SlGImpcl28bcDJwN1wp{?K% z3^qK1!A5q_GY$_^FJKg3R^T5KAZ_h-b$==(oS!$_6Y9y|HwY`$R6FZ>z9g2S*h}~l zrD7yzb^ZepJ#<)F6NyJa zOP|SKMN(;V)bT6ZR!+PU6nfPRPTE><5U}d0A$z1^*!#Kkm6P&o{x<6|csTIp1K7hi z`6xRWus;&wT^_Q(z+&<;(^U9^$3pfi{w^!NoEif5!*2iQORosn+4k--JK`7f3tPl9(#M? z?x1TgWw<(3X%MFRFLZK;Ws|FM5DGR`yxtp`{?cH{g8X1jR>1#e#46hzu*%*{=0geX zC!wn);BQ za(V4%6lSgXgSru)gF}Np_(zy_bD;2aN%67^;17oFq;`h6;dnU>>LX9-dr!!bdX@uQZj(Z>ErL}nu?H6Dvauh#J*dewotus0Yh2*wt= z;f1Z`3%C=mbGS4u8v8cgz}@5(U;dI>fqz3<1!fd=Pl}KAhU}Bb#28Hb)sichd{2Xt z%lOzc-Tt?hjt$xwHrv1*-a@7xu=_k{pAXoD{H;s80SEAk0)-L>BnzYV6iRCg6*e2# z++H{olF0$QHm(P2vUeA5M=C=(?XKfN{~NXcsQwpg!_AFdogA!5E{^fO0PZSd4P*$* zC=iPHU(ko7n=0QW#WjOreI;Caij>}qDw5S?Sc5D z45N|;vQ+x9we&6i&{{jQJy73*9QX{HLB*G%X?7n06xZ~{iT!xrJnQ9`=UMyicoMDp z*Srd$v}O|beM26c`iAgmf9-0k;KqD$HGGk(gJ{o3{QH-bLjMHfccx2*6cx$e=#99V zLazM=o$G^t?5g6W=r$jA3y}py4tGT)HhI^e3z7Jg0+~0t8p~qUOT07#oRAoDgV} zv2a>xS?qz*6xP&pAegQDPPs@EYE%p{Andj?7@wOix!{G-_>`Rf^aonG@KJK%*83Z4 zKY|Sxjb}ZLhbwm8z{XrEk#D2RzayjspW+YDOr3xW!}0II;6Mlz#`GD+0;}yqF&O3s z?FT++a}=>uY1{_ z^hgfjjkY1Wjh&0cKew##eXC(4pR~s2Gg$wAf}6MEp@HBJeKsBqq=BoY_hun-e3qOa2q=2hmE_GU0R?E4OLgn3ax~qqm~f0IP;++ zktuncsyKg{{hm|~1Zbae`1OWUJ>l-<^ z>5$ijs^>QAQCucKJO;-Pp{(&wLf| zHN#qgv6;$uTMhqAV@Wb{aQuPc5^j$i6nH_3T7)Y{di5BJfcrFmuhWIs=i#P6$%hcw zKQFN7L%j@}XTr&lf2Z}>FsE@Nv((W{(=W^m315B=`Y)rbi*5bLAVBF0dG=^Pm)`lE%1k=;ipALHIV>|-ZZE!I

6pyIP#;<-E{y^ z(?Wug{8S^as490xgU4SqRaZ!t+@J^CfcjMFB3Fk;9zk2eJy&m zrv_H3MDIGjl0G&~clj~MsxXX2IqGj=Ah^&KtRCYI)HeVi@?Lr1M(1UwSj%+Ozo5*~ zL=~^#9}HCCo*O@%x2q4p5~b>bkaRec=W6r-sCBLdWVcQxEbuph=rjbp=%ky%jZ( zIMne_FyNC}xtAv>QoUk)M!-%JLfNUg)ak zni>#uJy5f~rD1%F`Za>k@iKv5o*ShhqxRo;+=NXc`iv)2)r5y2fG;Y6Z#`Y#;>Hka;`5X&&x>B?O|z$~_F_sSfHsCrY$;ck14*m59?V5&^{aO+>QcHu zgUjs&@RMqI?aX$_@3~0WTGiZS5I9x;pr-~`P1otL>+I11B{jcMF)p|&xJ7U+^c%)Y z;b~kb2%k%r=mj3DOohTiNFrq_DxMbE6p61aEM$A?d7=2@D7PWd2>ujFlWIhtsd&KFUyX^7MmMoq3O7~!JZX4a2me7xJ?r=i zqIZqW!5WtvbE*uZ+tbs`x0+Vg>~>?4({l7053NX1w4eo6mWn1{A6Q-Rk~#W97gimC z29LD(t&9lE;Ma5Xx&ZF;tM}9gK+up#trDo7HDIPeSuo98>AcQ z8|qpb`EOY(sx4<^eP|8AZkns1fj9&{cgWVsYS>yv@KUP`T)X8#RRkh707wLPe9TsF zUjT--tI@A!K64syA~E&9nXX21@u8_yZ#(&Q#Q~rdvzmSL0ZM0Hy{d&{Pj!$?98hhM zA^>~}F7#q>dHsqJluM>^AVa;&-y-{jPp*W0O)Xf7fF<()2LSZy76DGqRtr3~w8K~p zg&(n^Pehw?z_arqC2Fqw0)E`TtcR@Q6agq0B0I!EX0 zbun7S01*5xpvc$7vT2TW-K?2YkI$K|n=8B7L?|ceg`8s0S0xjVFE8}dlAsw)1GKRf z$x94LPveS!5=>7UTkSJ=%rZ|CY&R3h%`Yj=!O})j#ysA0CfN=kbMKeuK9RqyrRz$AXTVpC2{OxQQa-GbxSRN%dR88-S!H_`@pP#b<7G+} zPPc_8R-{&>@HZ-60ZWBbWqPq~k6Puq8eDu8h=GF28t==R__wPU*1HzMk_l2|uQ0+xnMCJOLgSj5?f7KFFA_d~<;{jhF=slfd7yqp_*0}>gkNLgu z{h$#%1^lN4Frx&7&EP9y%gv|9YqwS}5j^J~>w z0KYU1K(LPkK|$@MhD{gngMed|0`$SWRTB)<>ody>$7CUK7t&+I8L5*RC+SH-Orhm# z#afwG0%+uDC!(BkqM#g6X|Ofw`OPlhEU(9q11kQg#^VVH;Rd1vByk083 zU3v$2+47l;gh?P42EAaFIi(=T2Z`Gxc}zXjO#pvPzYu7XFyORij2T76L*Pp*y9M5A z52iK99gK#Dq!V0Py}%|N#DsrN^%u53>s?^p>l?&UqMk18#r%<$k!ee3R$umOX;E&D zUgd4VDB=l2zAMw!yBgASzf>YYDC4lMmPxYL5P=O2PgMyYwE;*mG?!1T+!Pat$TqdNc zU=@sdDlXGc?I&*E+t^6tDBN<$6o2sV>!K}dBpz8z2Plws@kGrd;tt=p{D_r`W2e`%%{+h}H3Z5yFp(wdm#e7ljK%;XdM z0Qs2D6Vw#K$@+;NK;q(}3Z5mjKRNj1D$D2(lim=W69ZbW#yBHH16QozWu_B!PNsC* zCx3i7on15)yDpN- zHFy_6Sw&!oZi=jo6&woZ>CHwP+Xd6Z)PAGnO;`)QE1%Y^*GmTtMFne);9_k@GBwg#8M2D zQe^ZlkU7x~z9CW%L72A@e4kpE%J((2SuHjoDjLD$$?6b%`G!ffc-m+Y095-Y9KQT} z_V*QX+fT&PMvNog)0k$ap*pB~JJN;h>qJQB4^)U%y=n(ZTdey!>b;v*ZjF$J%k`-$ zk0VosoP4bH5!e*6QG|S9r2_eR92FOG@+is)o35lVpC@d@VB%s9D>jGbBYcmP6saYi zLwGB;Nx2jfybzI?8Db|_4hxIej)Y38`F60AgvhaV&)X}DlAYV7qEs(Ci?o)9tv-W< zb5U3LT2)w(##x-85BWk^XwYW4t*$@-zLIZh8JpP(Zk^DRHm8hH|T0%5O5@oT=jqc-{j`jkr6poi;&Ud08Rf8=FqozXxRZ>Sf4;MF)LI+>H z^U9cNA$HW_?J9uM0GBU@N|>$eu14vwq@jhki|;&ORy09|2_(=Qq%lhAY7F6*wkE+K@ZlxQ4y8V*DSYHRh(@@l-brjk+Q;y9g_JIT~}$kr@&Vnnfo zT8bS|l4VHSsV$HflE4tZ!P-Ga456!(3MI=qRm=~3Kf=2R5&$F>T0*AenoCzLEfDa? zmlEPGz(Wa>QFjvbLd0b$O~F?#xHWsg6V%9xT_be5()Hq4p>l|p=jhWxUl({V69Yiyw98;5H+l`5r;zwyZJ-bV$7jeI zF=)M#tB9|Xyjqke`08$!XUsN24hELghfO5Df5-(s;A*jc!N` z=#YmK=9CnZ@t-lRw2_*cFtcBBi-znZIO`CX3Ga>yx3 zmO^sAtr~*d3+o_lAYOoPnn}eAf;rRyQ3X@rssg-TQ>CsTQ767@z|-@t@(BKw4>-Yk z@zlJ}m$5=x4s(AUaQ? zPv}n?%28^)fb^UXReA;$RnV$Jn?l|%N=>DvhP=l{mk+2d!NB8lrWZ{us4z;z)|h09 zW&UvS6_`bkE@J+Q>U91M`hM8_3;4cfbzwIMa3r`%v5>?UgWKovqQ6uUTfdnJ zQ4cGhSqpvr^`?DO{CH zvykPR(I4j2Y)4I5ob*o3PEUV6N7LGJwQbu9>E$;5e7QvW+hXu84lWk1CtQNV#Us3r zeAgTPO1N@lS_OX&{JHRF!#^4RT=~}aEHMSf*T4q z4DN8aBj5(Z>2O2fhQkeu86J}qb7ag>F(YC|#*B&?8#68@B_=f{Ehar?d`w2npYI%X zEZUc&Y4_)9{28BT{ysm?Eg3Y@8=~ksu*&4u`dYXOT^(NV_w`(@Oq=fsat5}jWJVdi z&nqm{$%ld--#{yzF}-{e?)$EBK`;ZRg2o-!xWQoO>z|rtAC#jSW1D z(%M9*iVBqxR}=QC?d4d$3!OvKE1?3RECY5MAO!5j?V?8>J3;ySE_lX`vy@*5B*}r! z0yh0Ti}>+?puQk=Y>GYxR08uNehlu4hlmlG*uD?cyL(8AR>^%3rodRj_q))*M|PS;Ca*bUdqT>d6kJ;W9+eMGiw z!^lYGs`s|?$L#b+x0PQ$BYy@6K52B(vYdK?1iGa4NgaYE9CU`U8WpQ{qoeuwrqfCa zma6jbZRK+$Avpw3I2Mm3<@WsyEuYUKf#4*47nMJ?IIm!OS-~zSf7cL*K5_ta;EO(^ zp-Ef!G`VBg3Zf?ZS}_Ghr8y^#&Y4;=C1;2vbi>3k89i^tw35<-va*8wiu|1NoQksI zlL{(`m{ue;f+(xc5k0b$&Pg|p`w)32St94Mal|ygpm1tVdBMm&lz#e*a=>*4h7inp z_@wBEXK5t0RU9D$p@#5+Dp!`5Gqpg`CaNO#(V?vknHs6+N`lS_e?Gp6y3LJN@l*6; z^)qzdQqo^eTa?^~@R44~F#m0a^~Fcama29d^q%AoZfxpfO(z;GYANdn-U$jXq}aw& z@ERi2NHt9I@_LB$^!+pRB#_sdWSghUpuRYnQmTrmdWgwd%wz;R1tSB#kd=ruV@1bv z0Ase~^I#tZM^Vorn)yl7i`SEfoHdp8^rBW4cZQy#FXk0g^`c3g>svMZxp0lv5>z({ z7mh1ak%oQ%7$X+IPRYnVXQ=9H^c|k4hH#d;3tv#3fO06FqQ=ttyo^p>9*Y_sZOhN& zdE@i=ISFeDBR`MF`Db2Rk%9`Lc(f%C`bwA_cqL?$#3y9Dz~MX-#d%5#qz#l$)}i?- zB@a*!gCtlC3&PhCBlQ{yC)EHdpU!?zd6a~jNJH*eJ%u-t;_b*kiudfX&Z1QT$ebK? zG$-pvsT_AS4<$+x#KVq<ow` z+H%1!7D79Ze{F>L8r48NRPIbab%8yee{Ckjs0NYYV1Q_!t10swAP>9>LS0=9WLeJ~ zsNvN5#R#E+EX0zWDdFW*bG1@mi>ihu^UcmFonAb>Xp&w|=R>JMg4l7XAc+Dd;e$YWyUVNXC;8ebv3yRKz0s(?Wk1daIl2=tmu|0gnvS z)L?UxCoz96a#b%NJuAGHAB?8aRrveFsR=(! zJ|=PK;`hH>jQCZbrcr#t&>o5L1&Lb6Ew`p6Ab-3F>-zVbPECl_mc~wAJb3fsL{LQf zeydS|ZvI%)PiyPf{@ss@&w8xl(={d9%?SzlpN<>Y=iJz(B~w-+JmRC`5hDinSr)rA zd&M)XFaC%o=l%6nFT%c{q8=o@yM=E$>I4R42ehh7#+&V^dQ`^ z_=E4x{qpz|)_nQnnlFz&AzmxU8F=o9g{5TA(n zWinptb9pS!Kkm3!?)>z}HSK2%j-g`X6SApr9e?<2^qujQmC&Z9hmwe7^_tmc>odwbqquVs(J=BE9sf*wK3Y(92`D9IbWqx-{$fk76h3 zv4bu;B4O0O`^UHU&D|V(_VAd2@dH17IR2F$tq(r=NuNmJWW<+f7lK56F`>EL0 zd~N75{nJ>j1Qp3{jn(uX+NF~*+7jd2J5bC8Z)3(H+e2O1xq6TV2>CxAYC$?9s z_Qc952SbXrY)J1bVsnp-j~Q};rY&Kyxv_~OwV?ysfX+Xk)q54t`XB#@8_+KwqwU<> z-b=If#KitF3GpJlM26$fepaMk`tm1V_wOH*b_dX((ytQfvmX@U78)ifPhUA$)CiP< zo(7$Jk^hW{O*m(0j24@a7aOC+#GE-Wep!BurpGUfZ%trlYs>ifi#v-(S)U=Awv3Or zi%Kbc`l>JEZaj{DmGba$gA-zx@n1vf?dIbVzpRSKQ#k(gRU=~0!etc+_#tI8Mbx2?W>?x+;zPt^F+V zwwS$v5C{;05|Jf15^*G~0x{sfW8qUgIeJfy-cef0L+R8z6(7l`^yH{4%1=IhPkoDi zM{?@>&iaK*ugW7|{Z{Fy?(|NzD_Y&Dj;bwGZ^{!by-I7%r`{=_+F^x(f}?`X?(|h1 z$tM_5UFbK}nZl|MRGsM^{Z{YEC#T>Y(0t*H?L4Q3g2$D;>Xwzzu~P28Wm)G5p~H^G{4{Tzrq7 zy%Ku&>AOT=bxd4bYE){uhUMP- z_yMJ_bPP|g3ZC7&&w&RWe8{0mM;uy9e!>E|pv_q_8jxbUJYuDt5%Ypz}K`|EDL<<{H&_@~?Nxbv^~-T%Pf z{{G-Y4?pqbQ%^th?Aqu4`RZ%0uYY61n{U0nanpw%ef+OaKK=J+U;X#%&EI_c-Iniv zP)&*x&BR~zhWnOwiubWGvGMV7@x7>>F|i9};%#qh`@~_I?;qD+;|m{E2=e!j?=d8` z=YX6Odbv*9e`wm$gn_x2ue$f~-ow&MI}WG{zS8Hw;o~0oxJb_+*4+YcLQ9c=XA9DJGA*mq`3)hCEO~wo8fMOyA|#>xJb_#1UJBwhKuxkkG@-n_*dXwg?kO|b-49#Z@_JUdlN3w^8@m~h4{DO-hq1;?mf8o;XZ(C zhua7j>Dhw5--P%N;XZ=<817$ipTKsXGIpXkkZa{SXccmlX+9rtQXN6JsMhiDazVHyYF z#y*YhNDt8uqFd3%K8@{2577_8!DwTj#&)EK=qAyRXk(wocBF^s58+_6u}@<=(nGX2 z+PGI^J5qk4z0tHQ~jp;PW2!4AV5lh}WNme8wr&pti+#_toiZ|r_@ zbNIrN=|%hYIkbKb0s9efNM`#wodElnNQMwAaD!2x? zYB);ghNHSs9q2pb;OL#zQQQG=)b3nI9Hpat6qgkyj^e4zaQUp?*qy(>j?c(`Y~UH$ z73cV}Q{E}hrtsSn_sc%u%O}|rPZzO$K{fV;md?IfE8O{Tzk|C9?mDOoVuI&dm0xkz`E?hI*WpKB{JrPr@y$jbbwpPo7TL5<_+~m^s??LWw6W*y^k}%VEaKcp$kM>&G_)&sIc+M(~I09KMpxcZ8+$4(HRApVhlDn@OS)(JI?Z}BCYv& zS~}R{32Hdm&W{#CkI?HzPEjwR)JSL3DcpdADNtABMUe4fA5MJJSf__{4n6)rb8Vea zq*m?o%6mhgdxyg*nx?{Bl@9s1ofa5r(Tk_#mm*Bxp`SVcLgl88OB*+ST-LbM%rUUW z$8S5J*P?!8+?I#T`ofMe?7vs@c=1j3MkJ*2xh*FjOrThzQpSkmKD8)uYN7p3K>!9;|HxRTD3@!xLZ6pRLN!QRoyu?=KisNwBTn== z;JGlwN99m>7%R=mFV2~sC$;7gF3QDk^F2?4ca&P-4`D#zjM8a2<;SL{QFm7aeV&S7 zZ52wij3a2KauaFVm=kr|d#*7n4eXAdqw{iAzg0uwnJY{}GnaHm3BNGlG&NKVh1%k2 zIYl@Yke^?slfI}>t0g=Tb`QqZdTXfQv31pe670T-}dfn&sSZ| zhlctLdRVrHBbzOcrTlzK7eVI}#`|>~P-~<=URd^Pz|lQAKF1&V9rM5#6(Y}ISkOx= z$Km3crD*tEZaDoEy@VS8;~-T=#O&&(qWqA2=9g49%gG9yfpmT+OnQqlwHTC^ipur~ z)D*E27|i`>SEBC8UuXq6+qSx2d#tf+)aP3P@|ntFr- zYu5U5m>M6CdTz~j-bj?eb6d_z5d(=wotH^!te9P#Up__0gX1yQ_frari>8!^z86D| zzo%T{L3`wZH%=|h12O{I#<`oY=U`9?I;^8knCPe<&b8o_ivzBrMbQ<-sd0Gh`sGf2 zao!&`h4B!)cf+hW=~%0iFd(q}oFH8SgApmJ0?O!ZXofKYI)uh=*5S59gibaom&@S= z>ajr3*)aKRW1j{$h^uirK!C4N(T#k|_=h6DnJ}5#JEx+c$&b@9LN(l=H*{V>Xu0F$ zVhbz;xj~{`WIa_rW&YeaB~EptN2bd&A;|}V{Ja%d)i}C|(}7gD z<&pVkn(P=D9ZE=tgsK`E8tL3D{E@J(PPa6rW+FgD1b3-njwc($xTwKoKhlqPwLlDxS|-W-1N zR}?7A3#H!Tv57)q*J72HKR;;o5};#f<18gXVgD3?V(+1R%5A*voYkI@7hqrmZ6 zZc&47HUolT!V+dO6dWuaY^@1y?gIQR6&KlnXZ)C#_1-0sO-v2wQ#u?pQg@7Y;1fSn zR1Gu9gaDlnb$fbCMbJM03#t<`#Cels`}sIW<0&I&BnV!7DwfATRQqLmbH?F`+|5-U z%@2AjezC z{4Nen5e1b;^2N9%Gw8EQbEe_m#*&#}RzmVk2cIg5i9rlFq{~Z-rxs5y$SE~S6nsAV zkpr>ypu3(vio_NZ2aTO}^pJ$Jk4YF3f9${hl634}id+z_v>tom1s5E$&V`^h&K9LTn9Tf&a*b3Unvt-SNjx7mv?e4*6EU<)EHThny7Hn?^;EvNLs={YD1 zZaLiTaP2S+@g@8%a3p$2glm916Rx!g?omig+E6@PJKWkQkj{9>t^@_*;bQq)Ri5(c zWe1fl{Uv$Ot~cGbB}JOW6;CfjheI}_4vO)7&Uus=Tv&Lgn;=2+1b-66@uoH{G2&I$`YJi>Q{@p;RK?dk08rNpp& z#y=gJt`V1}gpLPQPw+=HrX#R>bPE#4^RBUZis{11Maj+)Kj}Q*pO&^0&-dHf%c)az zHq4gZq&kux=53V)Xj%}{nk_x&R;W`VAQ6CSOK+CX@rWpgLXrsSI39H&oxGgDEYMb- zS$grwUmJE{&o1Q6-{L44? zx51-a#uI&`r&5NE^7k3Q(-Umzsgv=77Q)_=BitavD*bSoU!`wyq+jF+x5}{UpGzF^ z+Aa3_EO*3TIkF!s{IQUw4GxbcEk^gxekAj~wAo9pNuzSi!5q5#H=bzr_*$$r09q z4*Yk7bs0ABQ-&43WXbSA*?%RD_(~ZbAmbOw@E{ppA;YvcL(hYb_%|K#TO9ERH;VcX z6WO(F8KylEdMagD=OInIK!yj)@a-~uqztcf5AjGrUJ zs{BPVtjqY7GCWj<*UIn+8Qvnpqhxr*0`WcC52j~|3@iFPM}}$Ni=GAMp&<)t;i;9XGNT{vh1z7e3g6a**^{GHbg$Gw; ziGon>LT^n|1?^kXqrzz-XoS;^a6?ltb3ER|b_{IWtEGBH1q_4xxXl-yQpHlkbiaAu z67H3tTLQGn*la!K7_o0Y1gnp^r-%=LVS%|~VGMN)(u@XTju``oXu?q%mt!W6;`^9{ z!ze;K2Kj04b~5}CBQ>1o(6m$G&V)M>8P3EHvg$S(ZVcQwxFopA$Z!lYABo>*!kr3N zxuAv%?~g)WdMX!GIl=_dqqIueV+qu#WLhN|g!AcA>{r{2+i-YXB>~A_Yo=Sk#buD1 zGzFWfgJevl=q>>sT6#NDR4U5{+#-y~iXDsqOdNZth)Ti*m}cPM4VPb*Z_SSTs5q>7 ze&hS9Vz7&1MgtBUope$CNTm?Gyul{iu_Y~xy7`^$5VSR@c6#b?&oecg#3kXs#o=zI zGa+HAQl%LmwMvz4SOc?t$^tZkTXQv;e<4f7yqhWurf8L=<>kdx2|Ti24Xm(-!xv2W zuJBoOh(`sr%0RszvK`LOKoTRv+Ntz?XZ+k#Y$+-snuVRa>dt`bOcxfY z^gR=gSAfU8)?lI|PoMly4jF(qy_h>@`Kl^r1s_6mN#zfeII0kxMV}sC361OB4*WlAHL> zH})1)!}VN}vggt5e3qR@*q_(M)M1U!A!C0sqs%hJi?JMZ*R@zO^AuQ3i@SUE8RF8~ zsdOQ(L6)>i7w*t(p__}j)PdiSq3T5S1-a$?GyS$c2EWteN;TD5qj&l5b~(@Li^P0e zDSa0-ZoHUH>Y+z6M&4yO1{yX2+?D9Tn;OJc;a8By`=HM=MmkaD&hj@x+sBXc>X1+5 zPQ$MhqrLNa*?#=>LH9__vZOO+t(QnnYnVb`V-8(XY!rYW@_k{@_Udi#unc)#BIl~}(I+#-B+<&tNS8wPSo z142A{N%-`%FKmaofb_zSkq-$J>XM1dVdw(tB1lX5mwNobkvWk_dMEI=u-Lc zkM32(&8S{=m#QiOzF@TJFBK>L(2-DzA?3sP_#X66GycW(Al{z7C7xK=1BpvObb{84 zR3YPf(b>`-y^x|8rJ$2$c+Y<$n9x(}Nsj-c_+AOU$nk$Xok&aRVf6?9=#gcMFBoO< zs2%$=0@&HiVT6&3XM`X2WyMcfaCZ5R-2RaWrn;*Rb=|)XoRNAeZQ;g-xUm-nC4!nCbZ&XYrbrEmNut%pU%aBm9*ktojGJ!d9R% zVtUcf>mBjyjPP~8r{_5%Y{v^(%Pp6+srvq`=zw~`{nbW(fvyT)HSJ&JRN@0h{Oiv= zjPG4&gl{_Gt6sy3tBi2Rwo}%QZ#~8cqxkmRvHvo{$FyVs<@^#KLh;`^9!LgBbdHFj zAV)&a89~R>o+n?>@{68U{@1`Og-;64jIdEJ)o$S{d{B62_)A2&3PCy^6Jf1&y!@f? zZL7q)4E3HDtjd-6s_;$~C(>@Ar1+_PdfQ5W@U-&3@yoMq{@UejJgj`9-TW>7sP?Mx z7TFGr4_m#uG+v_ir~E>;`jYS!9Z+vO8xLmuj^h7S!;7yNUi<`8U*>+N8D6vm%b+bjvr-t(r=Ug zO6f0`euMNYrJpVR6zS{I*QDR^gDhA2ZPH&U{pHecm42o4OQfGIeO>yA($}QlPWBe@ ztdoA5^jAuMx%6A5-yr=G>1RtnMf$q*HR*S35#_f_f1UJKOMj*GmrK7@`VG>rlzz7K zQ>3p;KT-Oc^gF(j-;@42>93alO6f0`eyj8wq+coh66t44KSlbw^b@78Nx$P;`CaL+ zlYX1@S4)4T^p{J&Rr(Fmuatg?^s}X(B7I%@iPG1k-|>z7zVz2gzfJn9rN2`8%cbAy z@Ec^fQu-y*&z63Q^mXYcN?&vM9h+r+q`yx3ZPH&Y{gn=XxeT{Tzd`zy4!=Z(v!$OR zecj;1tuox;@GE7w#NlVlaEim%WjN8{Ycj0-4#^+3JN$Jr+~)9C z%dqlS%J6cB-zvk(Z;;_ihhHMY%FmYJ6o;?Nu<{dSSoxX^cgXo&`Ry{S{B<&{{5Ba@ z{%RRs>F}4!u<~1FSosYyto%wDR(^>LD?eL?m7gNR%GYIB`H3>Dd`*T8pU)EfkKR5Q z|F%u;==D>~lD5I@&OxgNul#2!)3+=gyk#k4fBf@%Jw4}6VU27dRz)EYME+0*d<7`CkM zm51Iu(#5jczdAqehyc63q4nX9UO$Pow=Iq9wV#iz9-VpU!~JHlYyPwEi2Y~JWB>l* zd;OYk%Gj`*n$H>eUoSiPcR#uBT2#(v9aww+8E?*GmkfOH$4f7s&EjszT<49eXHzB| zRylgeDeSFQUv{S6m%UO{@K^UWRqWKfmVH0Y$Y*hn=p(nSt7QkyZ#!Uq+e}ve{f2%O zll(01jAvhOd*8*zKHca13)6~N+}q<(i`;;?JWgGWNNLqMNAzOa`kUL*5_Q7T| zJ#O~$PjN?QK2pw>&e-qTn46MW(%dhfIcR~G{j=@0yT5n2SkD#r`L-TX#_l_`V9+G* zIJW7IA#uZRoX5`jIyGzXIc_%Sr+1(Fy!b@6&x&VSz57gIaZOvF)@}%}qOwmm91--g z!CCvqeX-Qd%8q>eFHc-Mmp%O9aj{?DSi%lI&xQY4to5jUI+n%wS?R-zJ>QJ=vXt!N z9&uMyGjX4JCF^-`Wot~&Ic!PH&pkFDRKni-bkVC9jmlx0do0eWSa%S6!X_28f9QMic-FAA@5$}4MeNGIYxtkX?)9CS ze*Xf-R`)w^P+ip|Dd)&!&%S(1>YdBSv&r!zCmir%Ive|Q-{0NdIG!C;xAeferI{@A zrqd3r{CXlgaQV0aw>>kNy?n^bw@03t%c_U;J#lSrA?w@GbJkN29LJ9NxqsgWUz@@1 zoc{1LD_<;SJrA5yxwOYDcK(-tzjfX66ItMf+1VfZPhsBUo__26mn+%SzvxHKPIR-I zhkkR}B`qFyck2VOZ}h2Sf%4xMZF+JZD}4LjSl6xftg^?Pm|3j{uwmET*YoMuCbP4E9>Gl2Qv3D=JaM%+C zes(}f4E|@Zp|4kecHkLP*~X6tKJtgNXEXiUIS(#Azmk3S?y1M`cbbQ-eSGk=e=MHI z;vP8bw(PqDEc=8$tLOim$L_d3=lM%NDQCB8m&fM!sbo)nGvegSp75~aUTFJk-5=(& zrFmaJv~|%))~DoeM<4j|boS8awHIH#aV|Uhx_4*0rdP8M_GNb-|H3?W#_&e;6KrzCyi$zfj}xZ#e%n%V4vmu7!A zWwe|1yrZ=6uaD1T1CPFU|D*3sXUi_sKi{~#ocW*GnldM=ik)>>{}=vPfcUJX`)4gp zX9<5lD5)qgla0D;zehef%+2yUW=?(#^}VC_GjreiB%6J5$h6k`{&gaI!rgMu-`09q z?B=6ifBPXnoABegb51yP28;D=cSmWQ?#*PitvmR%DJ#W*AC$QM^;n@YT)oggj zw|TLF0PC@0_K=u=&1C)VUHbCDm)5WWdJO)jvB8foj{mOz$?Vh>4ciud>Sc%A{N&GX zwG^>lEmxoX(q}HVabj%2+Gcj)1Mwjp1~|Jm$}*-PKq z{~#|bxqj)tCp~){`*!N`>FJf#QZAXwI=1G-Z~0FJ+d8EE=OOKwx6Zrfh0p#zn>{jk z;)@$T^Rnf6t-WU*Qo_~yzPl_w@H-cKzxc_|Z^<0WE_tQwKUBD#`B9Z#$(2=D$(2=D$XjkR@{91(Mp&dXWzY_p_GvGu!Vh=RusK^KKm%{r`5N&UB;SkE6ls~ zr7PKC_pa}C*hAN{6_?+0RNGD0GcA45e%GIU6Kj2I*oAMcUd1XO-TKh^H{Qb5f3)_V zxfk8WetI|U+c`~tVxNDwcE58@zJon>+99XCm-}Z{+V`D{<{x!8`(suAwv;~iu+u(T zk+GtAHQRXlE&s{%+{+Fc*k|0gWq)O_ymHtz8*=Vr9ff~f^X}OD89TTq>vh-z?5UCo zcg*SeH#T+t#}~cY@i+G3fHUeBy#04J&`rDLmRs*w|3dNMUS(Uwd2;0`upST`IGt_5;*b+Htd_hTS~8fg1xrnqk}iZ zJ;|CbJ3{~Iv?tl9XTDhd#0O8ZBNjjJ8$InQ_VLW?zRrC3DVBBrst-Rt@@aOSzT&N{ zE1zbsU-_qolxkc1Id;yEi^pdE<2mMjVAJ47hW(QrGVX$( zzPR|G?CZx`r$6`gKiRDhTz2CLbDw8#Tr#HVyeFP#j~{%=%({^;u%Xvo_w09Qm5)6BqJ+;&tn#EgOJgs2iDjPn?(=tdyu>D)ar~@4 zGhb$-C!bn>@Ix=N!%OZi@a?yb<*d8^s-*07Y~K@Kta$LWb?n3CjhlwwvW^}9_v>cQ ze|;TWf81ZbzqrRMZ1wF|#-5+~3fu3GfBy5ywXd+iu-C`zyW$o0(`Ny1*ud+!CK1i%Q@l|%qdGGIk(uJ?Gq#GWbl=9H4EcNh>4{!SPRd#Mp z`E#co{2H6Nc*S+^6}`shzWG?ykqcjApA~p#PW|I+Eb+U?Z=13HHTKb;&O0w9{&hC+ z)A&(eroGOdICany7rS0(uk_At?YaDQwrbJBt1H&L&gR8drd|8R>uk)HG3VcX=z8XU z_3kHcp0b|#PAWKP;ez#S)61JzkGgd|`)BVtk3IUzdfAWb+11ZJ^xw0S-(X*FjB9-0 z#5dSI1Ft_~?Rjso$ya3z{l|T8u#Z-azVp)dH(2Hsi#Fx%yMgsu_m6KkOx(a;erMu< z=`|bJ%|-83+;+tV)^^W?KJTyDz@EJ4?4!4Qwt-#q`pUyMANVFa=;9;ZekJ!!wz6;f zb(j0!WOH*LKQH~dH`&Ga&sqETr{84HR%M=l#8+>!$+s7LUOVV5_Tzy=23=M37MpXz z{yDb<-(nZHAGGx98{T5>gm+`-uYHS6UGdl#!@hotUH#Dd>bAq*W_|wg@$&2`Z?n(d znt#o$!ME9Q3D;fs#UI{gAFZDA#KF(L&E_vEN*npr+idPnkM4KGVec^aWiOoZUH&`l z)US`Z;Q{|U?8n3_ubH#r9oFaWeJ^f*{2g}YVSl<|+UM`EqdE@w>ZXD3vT1j}_@@oW zzRR`*wtcv{=3R+@@3McMKCP+!!FSo`U!U9eo{jIa>LY@Garb$Tt^Zs*YirtjY}qrL zu3IwqJvMpVMMQ4_NSkZ}k~(e85(0o}DoE=MUIL z+mi16p?^Euw(hpuN|V~z(e9VNyfLety?W#wH+*n>JNrYyk&h0nXlL0U3_5vo5EhyW zj=$jKbKBXFjM*~+E0AvBOKTSVxt*OeD(R!(ns)Z!8xOtUex;pV^1>_U7Jt;v78hSX zX!v*S?AobgZv49UMz-aJ^ACD(&_?#imsehW+PICZ;Mn0wdhSN{+4{||K3Tp|j-!oi z)$iZ@$7d}YSF2*>BMUrNd;h;~+{kXadGQ0~_ikiK$DB6!!6!GexQ5!TiEnIV z>#`e8t@v~!o7(&Q<8S$4BlG|HidWv<{-Zx+S6`U+@Xg13$X?s{hZ{yr|B$WpzxIE(R(#0*R#f!BL8pDlmbA>-+Isef z?9frOUTeSdL-xa?XHA}P+lTD`$@>nlD3*539s~&nP*f1pfS{m&m|#d-#1;2=skD;fA8+|+}&quXx@G+r>^O# zu6n!g&*qVf&wV6qhtxFRx$}`UOq@AGCg&rWIw<7tp`Skzn~0~2JsLiePq|{p+3gF- z@hFGVwY>_-HSveAWWz!d__(fM7b%46VCdLwu7z}bC?v-Y4<#{Ch2+EX&rioKDkSnh z_beK)p^#i+)27w#DU( zLJ|@rc&MsaL>z`)%-Gkxh#blE=w~pXh|Jr5LGGAY5!td~YoPY1BJ!x+nel&n6p^hJ zr(f2E6p?jh#ubz17LgSRkIo+ZtBA}mt=DNtE+PiIhC5pwD^5gy@+&Q@$^marXrHFd_?7tj>ROqtcS7j89jnjZ zVjQxP^><0voqJbZIC5>@)SG2`zP+SD{mwQHle_h7S-|?buI8b3Ty!cqN&Xx3ZG2t} z?6tP3_3Q7l3+%0AHp*XLF;Tnc!TQX=u)EQ@VaL8iNq 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%0A>{^| zXp{O$q0H1)eB18KkfT7e=BaBbXhJ+~w9pF7iKpFZxB=|PT;%vt?)G`*7{p91-{ z({3+qP7TSawBIQ{OWO#mG$c%T6OwJl%n<1DYXLOP%F$y@Z-5NRBFV6Ld& z8n~0zH(_#@yUzeJ~!V4TIIlFt7OjbVdyU&$^5WZO4Io! z!LS?OOIy2c_|E+1O8O~`+^^g@8^rJE{5DsPYv5U*<+o0s zC(tgRH2RTGa(EYxJd6E>hYqbTlEZe+lLNNTXMekZF||-;cSVp#bGFom&3emX>?_X| z_?o71ePovD%DH}-yL*mI8<{I*V=a~QL-&%LxaO=wevoVI%*a+-)V>|7+Px7RQ~EarQzMb@(y^7AG5lwOK1^)hs+uRxc2 zWBi`K{IM_B48C8RX2;$C>3IYt>g^yVgtlYrt>m>F5Ct zxpmd&UfP?+%+5q6K)$RiC9Esi>Q_$Z$JP0=nl-47HE0QI&^*?lX{wf)rA@ZVc&nWJ&Yyz5WxBNVWy&e+XO2ZKbOigJgV@(BXAIW1&VoOg zDU(?T3fZ&xhr;xGB{JX{(!}9a2e?kl(DecaQ0XI%;@sLTH-T2(Wvm>TbcHNG+9yYW zkKK65v^Q@nw_z>{pevg`m>Q|{Be!d1?nW+=+E^^zt9|k(P&-6D)aPdpvc)cB6v(W7 z$gEQb^6m3ah;xv};Vi41Ij^wIu|LxABMxUy&}V!Di8L>pd^G>@^u+O&X*O}+bw{e4 z(Z>F}g>&E95-Cj5`!`FoWhvvnl5szo@jSWqYTPNOcJ7mM|B9t(u?C%d}JJ?}8q;j6@oKnzIM>U6hcPzVp&X&lZ@|a$8ty_-Yoj&zR++FIEk3jHErw_cewY`t`o3}rXMLu?%Pu93;`n|L#UicuN+yLV7ytFw! zAjh+=*0Zh_nwic%sXy)ojPLNgd^wN#v6*%GIM(I0tjhf z@?TCLxpnc_!+T5W&^{7F4&tlgoBJJYFGVMbx!upa zp2}RV;mbf+pIwuKoHQRu9P6>g}&NV zHm|v(K522w*Sx)SLV4~w+4MJ`Tn^&*%6e(r-YqGkm3ogWd*2e;nalc{)yR1j{8~Th zehY$cIqmh*W)|`!&IZc)2JAV?-hSD;1K(%xd)3PCdF6Exbc>l2&Rxnx{%LYtPB7J?mI|8d!VQu=X6vI<+_J)NIzNO4gyt ztV6|(VPqi{=;^~}$5gYLHB;~Oga`5WyJKDFk+CHbInyU+f-kkq6DG?EyYuAek$gFP zXMr5Jy-@bWzvg26YtHQ|kt%#-PQ^!N2p^e6!%HPFw2Zw=olW0H9{#tTe$xCVXr058 z%3-{E%Qe>)$hEZXO4@cjZ99~=N{@h`hEaYp?M>tOk(-m^@nXbjxhr$aqfh7fIQKwv1OJ=__~-Nu%}$9v zo+T@vK%VL5@1;Wv)o0PH6!z%j5VQU;Lqw8ER9x1{&k)Sr?mEnrOZQkfp>g!&=ZuzSFl8m{ADDBaR0o}MXF{@|3G z5J$fW@>U(gggmt`2~P||KI|#i6vAVnqhtNuc=fHAi$_;y%9_K`Y1cCCcw{|?z7O=c z^+=|@X$-uJ)nVLdZ{Jo66Gu;M44Z}aO!?zCC?lTtK#rxy2uuB=(?)&nr4!ODReVN;xg&_OEcwuFk;j2ZkP`f!t|RWEXWvZ0^WED zVQ#$6woG{sc;k7)jNW0{nl0t%6_qz~W?IYlTw|>>`>kyX;p4U`svAcfwN0sKA8{MF zC8qCzekNSL7S1^G#?!t;jv4F5w(-GCN3YJxsTr5a;dT!HdboifJ!lO3baad}H##1% z>^p)NkdiFf0K)G%W5Y{3cmD>Zydlx@)be39j)j=@p*)5SlKu8*W1rSBQ=&FM<|Ce2 z8yw!X_nAH4Xk<;V&6eUC{JIV1SeqAT>@e?5XMc*1s3+ZeCDOcO&WgNYj?PLBIxFa{ z(5@*B6H>2nUwRu8ZC@R~AMn);i6abwrR*KIZdJ358>~8V^Ul6 zEchXNdgQSnf=?($$Fh}kCG2yHvCl28#Xcs+`42WCSvyz*Vjlmax}O@z#(o7mGx$GW zBfeuNWy+7inm@U7*ie?G-z2O_!}vb+xtC5zBa92uSep*=74ns&d_&XG-!s$V9u%xD zx2}_e@o&Ew+w?D)XaDV!om%E$$avdw;7joNPS_kUrs0-{skC(9EA~IbT0fn`D-+|9 zuQxySz3(@*;tha}fS=wD6$f5p?erj>oc!YnxeSbGPZYdF7Bn&xX zJ947&xp_MG4`#{n;5tpCd<=3QA95ZIyB=)SaQl8{S^8bVdffc=xtC5zqrAqzEZRGh z_Re4~Oe#yyt~&zq(ZyMkc}bRxX`a{S%e9P;%NZYM@5cYe2c{k-fyVb024v zod;#guffjCw0y>CQkYSB=5VG=V@@rA$539ZpvKwphvumO8E zfXlD)$=UvHKFoy6&^?}lt;dJR(hHSe;Y@@)dy9n+cTdACV% zLt6u~wfS38)p{?s)Az8)*)nlPQSX%3&ho1BM?U8tmTw=le%tMNwyg_pt4ms`2Yy=W zeVH-{N=KY}B+_I=JV}b@=q7TmIg&1|$T3erj@ih%cR2FSI^>=EBJZq3-Z>e0r|Q9l zrl_njpR)}0%_Q2Rmc)ws84GJe-2adwt41ct%AMSmxZOEltm#1~wu>{&4%J2a z`uSMpKAgjKp!ifh8~E?vl7n-lN*s8rkd4)o-a z17;xyOdG~O_cycTbnxYWJMY;`o8zX)aqQKPVy}KUd-a3atMAWVeQ);Ui@GM{5M}Jm zOH7%gs}Rj@%Btr)%<9KX=;PZxN1MJM?lQk6OFjhce{st6(nf7VTeR-XHSmJtc0H;$ zPJ8Fl-g4S&b&9HyPZ3r{SW!I8`l02lycXTe2F}3r%z$#sD0f_+lKYfq(Lbt#RYqSF z(-&4R>*6B(BH$~Tww^*;*VEP`XzNPax*xKMX~-ceXlwk8z(laEru-7h&vwfXEea4v z{dk7y6Zq>r_|@!Wtc9vMKQrG`+rEBl6Y74WVTNWU`X&`)Ka`T8AMhteeR{bX{_H~WVGWptSWCD=G<;*I`WVi()kiP1_ONan%Bls*|c|={qyA z!N@{)l{uh?I|aG|$gr3<+j2Sg3rcXTiuG@fO&fR_S+83c&C5%B^EV;Am+(ZvH*&v~ zL)v-tI0?3@zt9u7)7B^705Q!=*Vv(ToMWuFVSl`YeVB&Z^{`r${sj2{N|^1JIhLMw z8Q*$5tZlX^z4CJ8yBfwjOr{g^(R~MHN^+T`(|V290oq$vN0;d!XMP@+gt+s!zRNo1 z(vc8nqLZa;dzs|-O_9tV&g-A^N!<%R>C?Kc&XUz#<;c@2=;JWoMkQ;@TKoJt;_P(m zpO8j*Px2M=74jAGm85(f-tQsd-pOc6lT)V{&2;=(_R#O&lgO}7{skKUMm<<7rw?~a z+0cWGk4J5I!JqNbsLyOaA1O+ge}K$Z!|01dn#@Trq}M#h(-O~Hj@55Lx6OLFiL&F4 zAj>`;o64bilGnpIA$RXZ???9e0Ow#@&W3#1u-lKU8owvobJ5`lNG*DEbGy(D=qNxh z6FusdA{+m!$Kk0yaq6b&y|gz^%PYW_2Vx!{eA>pLDrx@>XK;hur>*&%SuAJ5XPr8N z9uRz1!}d)4cA=G_Wz36pd|=(ta=X`ZnkLZaOb*^?A6fx3qZRL`+C$nB9__aanKzX?+W6R!^OWQJOo1Em6r%s0d|I}$m0&QguYFm_n z|M6^j?C$Id+aeEbZ5WU-r>RoODTJzKim@)Bv* z`=mHlkBjxKi1kf%?Hw5gw(wVGODTCd_L-V4Da@6jv|q!Whrq_uF!nV{zW~C!oHi%Z z-ZYM#<@Y3oja_KKIfIX><-HjnpRQWo@EY zI{tmfWtpw;WH)5XS>PSbd!3K{rr!I__lvAklArUQ6XLu3y!z{?o1#zKPQNjx62ep` zpT7KBxYm`p+Rxtj*8aw<5|xcReN|;`h_$c8@L&0)Mm_g%?3xZ6;tgoAJ18heI3C zmug)uRn05dL+r;MVu@n|t$QWvuXXO$Jbw|8U$lNG&o+M`Q)@>!Ta5|Q&X~Pr$&EKk z7lo#xR}N1S=NB}6g!FbSG_u#(mwnpuZ0tUrHhSq0_DO+<>|G=YzMOS`5MrO=+ven| zc~Yb!qd_i|wb9YBiD+06XZ<@;tj>+bv1k7Dnfm(~JcRLmXttz&=9KNFZ8~(;HSapj zXKIS%AXlHD^^U*-L8oRgUVde@U#iEDOCckk%9(mDI+*Ie$od8PDob7lC)%>;7~-ic zS$N)^@Qg8}&%PGUI3zqVF1it(v<|H8Z$8?yCKpDSbZ z5Bs<7{gE%M#J`+dhL?86ZsGXYZKn+9PO5x#yb7d>Gq_UD`+}VJp<^%I+%K|adbSM2 z^YYO49EZL9_Cc-W%V2Lb#m| zz8>z#6xhQy2H4x+|9=bm-pB`XScTEps*8ep}X`&209@bENx=EcrQzY5SB19imy4!i?HRhyO#^lFW^h-F9Ex*a(Z21fF(X|}8LK^Qy!~O}TXgGC9roHK$cQ=c7hrX8Q-Hnn?&t}x` zpq3lewj7khnL|*Pper>OU8ykqSW$B^ItWF~6NS?IahCiJT<4bSrS14-&L1DYtZSoF z=!dDbMtW%W!qTY3dy?KXeDG5+?_-Za)$ zc$D$qpHg30hX3DIe5@k-3t<0|HpJK*!dD>J?&jsCL-ggxV@2{Vw$%P@_J*UTxJ>{% zGuB?_O6MM)!MHrn_9Jui=o?wG{!RQo{mU5xUfNurA=lT^CoA#KYHt>#y}FJMt6Ug; zl14xGiQ^A{2XnqnPlxbK<@w(5(1vu`K-fvl1M%@$r{l)nW6QTR>OBp2zI{6Io>F4-=1a=P7y2Br3H99s98vZ&c{L*QA zBF%W9EeYu)lF#iOS(Yxv%=zY`Fc6`=^fZ z$_Dnlt?)===t~T9Zia4DQ$4yTpxu_E?~`}NGa+8$Gsc-GuAS@I^Jv}?EmP0w_%7o- z;4%%{lrEd#$KpDV8kg7Nw6T`8@uh6JdLVn;_mY=(`A3_7i{>?5&)zD&cJ|h*`OWZQ zi>*GD0#Y=9t~z_*rdP6M7ij#-=|3;++!-^E`(Uc}C?mAr`5ff$t&60zF~WX#A^TnA z88K%})$4a+$Ik*8eIZ-^^i%jAw;V6+`0<&zn@HPl`(-hE_twM6_i*w(NE}a@PToO= zi^CVLmgxD}a>s@6%AB|9TIi)6-GiHreYd)Qz;?Y9y)*I}mt5(yUaji|sdB;40q~m3 zB*vKf+i}^_s(IRP6#M3W#u{+;tE>rL+MQ1Z2`ge=iu)__(&nrTISYM;GR_n1O$fZ? zO0~)0yr5(NU)rtko5;gE8?xmKFlyVQV+}rw=fd;EXUy07EIHiP1%0C*Wy|_)+2cN` zytILriOZbPEkMT-KA-^~+WT@|f&63^a^)&y5mS*dlp89n!vEAN($|rG z8R;XWpG*3gq^~6X6w;TFzJT<(wa382)LXqfE#FCBO8N@Yhe=;a`YNgJnk!g(4X}jV# z*A_<2LHYO_;I3HG#PvqiM!JkNCCrT_=#7@_;;!~1L)6EyonPFOid|G1GIZptZP;YA zFwWs6r@%{2ftQ>DFR6EW6){)D)7AA&LiWxbNdLd-_Qhrxd7s+dRWnX27^gXmQ}sty z$$Htyc&%V8hZx5}&cf6VX>`6{Rxa>MT`GOO6rZ6Z+#5MO8F?MPfY4LbXWv+e+*O}5 zmn75P^v0I2c7L4l^iY16mXD8T=3l4$fK1ztj#~$O7`7NbYzQOVS9}fV*ZlXw-kh_X zIV1S+8lD25&EBE0%0Az`*e~z6b#qT>x&EJV#dM# zjGd*7oe1M#4&z`-EAOHYdEn|$9 zw5Tl${)HmU1A2EMHgKibzZGErmcu$?XK0@3x8BaXu=6lBa)SkaSzU;IOFH#FxmZr# zohiqRWT6v~jgGJ%JHY_oWe&2AS?tNGrIdYP5P7Vxajs2wC21p?mOM2dFYV1cG+W0w z{xr<~f?kc~{esLJl?P_Yf#}6A=_$dEsT7+WN4LH=?3bg_0qWMgV?l|H?JcjPyZ_w4 zzVc&aRu4DtCl%>*R=`^q(i^y?%!gm+lS zJ5)b4wY(0)5*tXKGuG2|bwr-!!w$CC42Uub>cH2#0&Eveks0zP*0 z_R?lmfOG6rS;6?9&G@fm{1-FkbI_sA&^D~i=d61YeoUNuG8QpURP$Yg^}A5S>1Qu(RL{E&UotK3x$Z)>4@LDCo%_rdSLc2q zkTjX3vHsRljs306<_x0C*z@zzKd_JeBWt~usrDYENh6Jh?FDwbbxEeZ>C7GZatHIs zik<0vYkd36M>Cj3jXIO$PVooyI%ReKq}5$DH{qFs$XO zoVqm~xq{DzjS>E_TOW<%rM>B#ea&R}iBk9pXMX5q+#Bq|3mOZV>o_0V;jDO$Uxn|b z%rN(-?CG4lAC)XCb8R~UJ?*uobCX~G+3M$Ncc)*xbZ92L5VoYHlsj?jiBo=`malgh za>mDgJ8IAORNtPxknWM{&-BZSU{Ld2%voATKK2^SmF%MmhuKG=|E15H&hkslEjyX^ z=3&-xcF-7m43*o+nkwgK$@~`lrH(oKmK8S?BW~Ww zbV3^X*qd)??_9p)5V|htxYX96-?C(nHk$3q>#5C4AM)>xTy!LY`2E2bnwgnqO;%9%T}(5K0kgL?w-AUQG{J*JA*`S3WrpV~Q6f1qDJ0q6Rie)Q7TE|GOGz}T}s zW0q#YkD>R&H!+`YVz&DYnn-|pa1KP9OVKmRN6#n+o8GwXt34CliH-VpY=V2R@#y0G zfqLY&PUAa4Z}I@YTm;74I(TV&CfbD#$@?mcWn7mq2efgYK?|}I_6gbe7f$8-=)J-( zAA$M+?a=dB>YUz@YQyTTWDIIJeXVi4v^Smet+6lQOvvi6#p1f)KIy;AFJFM?-F&>X zO{Y3<-ZN+&XG83zuVvi>V{SSxZPX?TIaIP=J3B_<^#;G;m!;QWbC=`P-AkKXd|8}^ zq^jSe=iZ9Ev(qm-K#QhP+jq`g0>jvW4&~bL-}9`^%}?Wb>4da;*GQW%pW_GpHoxo! z%dd0x(_Y%Po%yZ++qZ&7?$;c3{Tm|Fh~3J!Lb_46JTGnV30V%WjONy0L4RH}7~$P& zeaF}{x@S1OoBcBLX2y4}(|#{K;gg0nsg^lvv~V!L-`($EUlHBnmv7%mKe%bVw6)KN zXU~UckNc&z`)>I6{>S|CSMac#&Py9~e&%)g;r(+s%jRAS6L$EyChCqZYNR6|v*6Dv zhLOpm2kNVxF74kUKk$y5pO8Hj zwlcfj+_l|s$=KZYqLHg_nbbm&;mtiM*^XTj5qpO>VuC6{`@}OU$8izcR zX>T4@R-GUBnVl-VKl96e{ml7p+5}qHLqvl0FZ$)qmw5M_4>{*M$zh4Kb2g*-aM2!aewB-rOclTnLn$UKd08t=UjDq(mfZHVRa6iyQ5;iWG(<>=Q`hmm$vt4 z#(ASs<~nTVll^>$Zmy7<+vdqByQkyJV}=~Lb0+q9v(WLY#_n!5zWwH4!!;M52J=}1 z&SVWZagS?21bLAuVb8(XDPb&^Fn&rHKS9P%Wexh6@FpSnxit8>$WA}HgxDf%)H)*% zAY2F+;v_zUPja6nhEv$r@$y9nX(A-ny7v^gUOqP9}8?xp#}A7vV?Vul6_5&-`*V@D)1w zd+8AN%(}ki>~e1va{X4VqYOJw4U|aqE%qdDv(MG^y4G-pru4m_DIUi9sPwNut6NSo zosfq7z4@A}i{xtdA7`-tIF9{C1AC3bx-!`-p>y2=KZcwqVGpkLU>`F2FTecqOW>C2 zrOksOd2n~STsD#+7i`azGy1adcbUytVa{UytYdE7o4Ivr^EAH2D!xVRY;~OIUUDb; z8K3**KfBrM6*>LprA-BTqCLv5A{)}xco5$!P44d*Eo|FuqEPq@Pr zpaX;EO24nk*=w+^Ms}tA<tyLRhd+Un1)#P37DYGqK4@)?|^>HWrf$6o(~0r?Vab@TVqp_wXMU!*>)oU=;z ztR>3SX?;^;$Ko4UCf&CO`-74YG$qPHW{Yb(&W9%gysxFC!AX2mTop zmeM}_8CJ1>^09x?unqSHq*}xIHk0Xubn1I#*s+c2ejp&f2BTK*g}Ie*y|*ecoPCEU zo?`=7056p%#aqy3jyX1PA@+L#vry9UOQJF>TX)rSrH-?yW0-wlfc->jBMX07KxTkJ zt*?%w<^`6npBj*1w+;H-OMBB;p7xsTSmvPn&CXUibBct=;4cRjw7@IlYfr&mzbpcNp7;R?did=c85VolXl#yPMuin`N9Ivqq`xv&7&Z zZIGL|(8hH1s#DRcPLtDE<4$CaJA(C1eSGc9`nH($ZSL4qnKq1Hrhy91gu~K3Js=G; z0@Cl6ghbE=&k<9ml&CtE+tmyU2|$3CrjJ7X^ zi88)}$r9TXkY$XuceGBr7j@gIVK;#hx30-_LOPugnfHbKh5Uv5h5RKsf4lZ0`@J0~Gj-E`XwI?p(}Xoob=s@XCur6wWJd|q)(cml!4qd09QA9qDQdTkovV`O@DWkk7!na>~*>3R>|u$Jv!|R*~?G zHhO8JI%(S+X`l6@fId$Vc0YN@xKf$_!`JgYf`>Ien*V!5uek8O#glpAqLk zP^j^A&q6#Qo)9PDnXWZM1#4fw=Pbfp%hVEK1 z>uPSZ!#l(_vQK0Fil6l-&{nohJkFE*FXSAMxbb)iw7uIAyB;^s!5ag}h9}}C&^Axj zb@-Fc8v^ooVDq%!Gkzzbr<0yRWZRcad(${RS~(lonC09_!I0XR)T}I$OUwAlHH+H}3>`8h-2GHH!JBRNg$g z3j52$0^|BFUfTU0qwE%)GcDdp@Q8pM25PHlx7y&1`LOTKk|K0we8|Z4*=A6u&v~!O zbV7QoXNFy#`#xk#K&n9e-Fa!tKW!PmgE!*bMXU2eCgtWyQ+GhV2m0M|y|kI7XYR-i zw{b^t6#YgW!^|g53j*>4_)^oTFSaq-G0ge#05Yq_eEaMVJois?+M;p2bV7Q42dxu6 z9wPMXalrb9({*pm@vov`cY`K3&t%%0&TxNRK`k=0jds^qZ|6kTo?_OXyjF*29NfSd zJR=}ay7_r&GY$La(~>zI_yz8~sX$N7sN-gTk- z+A{dNl4j168@aa)9gGtCL*-M}774p8c>R9WUvYF)=Scf{zE@B^gSzN^+&J6P|3%m` z4J$y#JXU4*M;bQegn+Ek@cpx7{~qL;*f@r;aSUSP=)=ZQpVxpUjidT_geQiHB;>=l zq~(v72kots^ z*3lQkyH#6o_)#A^-?4`S^5J)x|7L34@jsV9vknqZb;A?Fb!{J;&w4md-uoVF0cf%5 zX*=PGVUkE&8K>G+VN3G_d?T=Wsve#C#Bk)eo_I#>QW@JhjBVAwws$?gPao)6MXmZ8 zK!(A)uWaHjC(c|O*-IV7UTO(@Db+Wb$DXT_J=GNUR3+@G3R?8;0nV@s0_Zit2h7rb zfF~xcJX~CW!zH$LJ3DbtKry0QCD|2M0 zjS3i*a_QU?_EF|EKk|qSQ##}`_*^x?<}BlH%r>dDe$ziUNB#-g+;Y6M>Xn-aktX7$a9dcc}SQBI0$>$gN57#o3zl7gVnY)HH zfh%m;=(!}&S{KF<>4mu7Jglt=^SV2Z$G?qU=4AVAplcJGmm_z~&q3YWd2fj{ZAp$} z`P+19Uzj7)Imh?|mjT34GO{!^?~UjKw%x0;SSWw8CH{t&mp8S4f}uoVq2I7g`aJ`K|Y+%x}IYWq$3qQs$d2DdVHP z-kF=)SqhBG_ZnFUAH#h(R8vK}-pWKLQt@+A64KY`C(KwIXr{~hDL-eK1Hfdw}FB%ZC&XS@rI z=cT=AL$g_1YZoyWR_{^&Jwmyrl>Pb+Jnh4=2J3UVs~vgWFz0MT$mlqGl4Uuv77W<( zv_JTUJz=g-wo#R~S8|qB1+PDuKCyn;__o52Qf2_R|Ev9Ai4$zxj$b3DO`MQ|-I(JCtKztO#%Z}Ew9vqb;&ucptbN@nL z3hVbI2{O;CUw?geA{cbrnMf=D2Jb?C3HewaAtNaa*_fv+6Qm6KC3BSey*OE3>`IsC z;j^El%t!Exb1;0wLimW;9T`#y4?Yz?)y2pWbCDxvw`$#|O83>+2Y}{?^A5bUxq7l( zJ(4CD??kt9dxjhjFLV^V&~o^zMetX%;f1Eb3ss;KJh8V4Mx1$Ls`MV6BQ3`;J~VHg zOB%~9Jwn)*Zh89LOMBDUJL>VLkZ{tkvV1Ema_$S6-NiWSU~d60uD)MoeU99E0(O3j zoc4HWqieu6s}mKiT;!KU?CU0vp+C)B?}s;rzeAW0d~*%bUp56%vK(fBZrKjKe3bVczX^!W-j&!+!@oA zhh9d$^j?@Fr*6Uq&MiNI);WDBO**&c$eg=!1ZYLaF&9?yFaq~`~wSCOv zgYd)e0V{{;_enqRDi>Zht5x~fZ2Rm3o-bRh^<&NEnGi>KuIVP8@qM|^62nn7@RVUT zWyz*t?q{tc{%m>JL3wFgXYM$?i~aN6?9(% zJzu3}Ho6W$dw!<#tFzawmbz^@auo>D@A@tiY1+jZOG22IH^%*-PvpoAz}m-Y7;~!9 zPlFTPypm~e8s|)JuE2ZSI)$}Ps-vKKO9R!+5!f*|E|Sj2a^#2LVa-$b-9xij`{&rO zxsT^apIes3@zM$Dw0_7M+JBHEZvcBH>Gqq_89$``dpYe-roCxQCOXMFN9!JyeU93i z(Phpa6IX;Z!SU&UY%&)c)!h8-XrB7rLf^uBH+RR59GzjM@Yx)>7S!Lv9-4n2@b{-4 z+RFTDQtI<;dF*HLX{BiyRWkRv99a#{bkm0U`!vw*(&zB^#h&L%U*dV5seZz1bM1Y; zh0%g0%~$LH1aa^W$KJjX{r_5Q zMK=bcnWe0wI|?K5HlFiVj@%5|?#;8m);4(~JS&`dNcXylK4EP-W(4_Qj5MF+$Se2d z+28L&KLGs>wElaWzhfRc6l6`-%rQ_v=U9<_5kyd||UjKK_!`-~BFI2`_ z(tTgC%up6GX3l|_yF#`6?fOd9wrRfK_*0HNHSF}$D8Fw4{nh@`-%LA(RsK40zkIx3 zX8xIV0BGE8`fJO=hifzUkHL3_YAJV1QOvO!ov}xo(IAQKUDLINGI?8~Z&ouy@9&!? zGuZni`&P8Fot323@wlg7l{s@(pUZgBJDIG0yV)%4H3n1qo%fHZ3Rxz03uD(~lYay2 z(2cA^9jrq)$>=}1Kk8pOQo6S@H+bn#u5*{jb$`H4^-|78`FF9&m9O}xx)$ZMJ8w%? zy*}^YxrVpDiA^E@9usU1`Io7BXALRiW9;~^a%39_eLGM7&2OHSr_hF)>}b5drxHFB zd=-D^dVa#%Q^fc!V(b=e%!`I>yC?k0bg{PU`#CKw7x#y`atQhBKdW1f+`-=Cy)C=m z%0rux`!kmZ8~o8cmE-Zv>)-M6PfgF2^TCDjJpAYYY)q@)Q(ag3a^(qdlN&cLA3qPZ zLCN3d=u*b>jA@+ATzNPiZx8K$k>|ew<9XRQw6VeI8y&~p{#v6@qUI(LX$o#rwE4 zkMn#G@1M}ZY;?%-Q>J1NuqQi-x*+eN9N);SC$7(IN5;;sCsc?&D&K4&Wx(@A<7G%; zuFMAGWq96GJWdDC@AkxT-gTbS|2ufsc0N_#&CI2Y)dc_0W%x|oQMkutX?DlYoIDr1O7oCc_7{oI&yq&}*g3`R z@5b@>=FBOad51WA2udHzU{mYzf2no>EFUF$h{Y5b4HDy)Moso*5WhOY!!Q- zo4X!#G9Q>K{7STD5{G?bBWDQ6qN{4kVPy(4E#<~6L&6#Y<=>{r~*gT9D8 zM`eu-ZuBD$Wxi`=zN=-9WqwtDL-l8MF4lkgYxM%P?a0xyqtN;;SMsZKCGyUE##uh! zYiJfcWMe&Z{E_fetDSe-!vMU|FM5fUn3+`aFl zZBcq5_N)V^(5EM353$Y}AMW?iOWuy3n`4nlsEzo9kD{nPo33}<97jEmMSkC4+o0vN z>oe;E=vex6a0Z&_WuJM#?&G*yVP#MrJ1{tYmr?@l#%W&_l+}k##PQOmfcwqk{bI+l-ht$d zr>=%K{t!9C5L{Y^pnCCI+tMew{u z*spozH~r*ks&bGo;=35RKp|(jtZ4~ehK=fz&_Aq)^~U;4;yYk2En_Y%t0}C{wDZJ- zuekUcz48Y1IlwgfS$~bb=T;-m-qZ1&7LVI-OHh6bj&$Eip7OCZ6MXDGw+H1Y&=P-V zI_8l1?a4<$$W0sXzvoH!A&BQav4*pL(=J`Zjn9bhA7L^Jisyg&KjIX11?6DyzvXi)dED#C$J+6(q%D?rn(%oY z@9T5!56XAIz47*F+ZnHWs$jTXfU2J`xJ z$M^p?JsOl(z)#%rlwX>G4MYf8@3@~w^)U~Sv9>+@ITZdW`_S&QNKBPwWt$Z(~8w+E4hLUM{VZ9TD zF;QdZjQ)6E&Uz~-5uo3`{#uz&eoDm7%T=EBD$cL!Jf!!V>iqp8e=GmEB{gF0xRJ>h zB42SlYB~4$>Y8llE}JGDzfh#fK@P(iiSi*<-wTZuT z<6F-1F8{+GPWwHDdTkxW&hS&dRd-w*%-`!hbm;#`f9ck2@c2F?RJG^t zcAU4dJlEl@sjK0+R*myq5jw!(tz4VME$s8`TF6*v#J99F9!6Dz+3tl~za|qJ9}~Yx z%afm_=Z(+djvSLU6JEcl7Cx*YZ+zc;U}~Oh2J!j+f2+Upn~uLR)(l>#(+_3zLx_GT zwYqBY{g~yC?Ru35U(31I4rDm<1IJV_Hp&K~`z=$viiS^~^T+DDehR@(-imn5x^ z&R(-ctc8baeKk$^Csp1*G=sZs8?is3JaoOsZBR7dWz^k~t&HE(HNGc*V|t!UpFz3@ zTs{RqelwbnX6|f2cC}WpF^(2eKZmy*V_g3o-g0!Dw~TTO=ZqVNe~*8g7f#KSAnGJv z#^*UJi%WP9vE=plvb~Vqf`x8f^0Y6|n<$}8B^$@>JgiJdznQa^=1KXoJUQ5ne;7n;Do_|XIzXS2{Og0W5r(;lU;JA;mqLufFu5tzEl&XWM?KiWqPsUf_EOe@7!H3R5 zt~c%xN&Cmjy7Be1C4IbaXD!c@wcw0+-zv|*TJD^m`}q#IL$ASEWgMT%6Ys|v|BU@c z=E7R|L1+IOb@-Ze$*OT=>N?hLTAe5Nf`c#d`%dVK+y-a&Xy2RTdvp8?oOqY`R*An$+cx|kHKK3Cw>)Lr zMB8kh!^lKh_3X*nQF-Mkp;_6-gpMvm1MutokG8*^_nm3STH+Wu@0<7~2ElIUmuU81 z=ckVBHhN@fJZSt^zo8Dod-w3HGsL|L{8PS2e{E_vFQw!E`t}g-#684|$B*YXcz&tf zYZNkfDSY*%vhKuE>1ipI?&Tt3Tx0g0ktY2hb|$}PA$vO)n;H-~j}6HAX)*}HQT!EL z2sRSFiRTyd_a($fm!baq8B+InhV<^lPVp^#nc(9l_6~PpzKeey{Om;D!>1dFzKb3g1fC4k%yU6>T~m?wc$Y&p^hOAkmpP(8&?AGUkMk6p=KLRV9- z71SSu+c|dz!EccF6O{1-{O&)MA>B{oKd=uBWJo{dM+W(T{)As#15H`b+4$*I8>&=v&hUX0gYL}4_78;perX3W z{mns-KS;Uw-%>wW>SwAQS)=+yQ=eqrejoAhPtDm-{|bC2>`!`pm8hST&O_)|`Yf1< zuBih3(pU-oSxSE{!OsZ$WkJude{a(5LwV3)`mh`Hg7CGxXV88<{d)ubej{U|gLe+P zfu5sw9!h%hQ#;8)_{h5bITvCc)Au<@9Jz`3<-EH}%EYcw{otrQquLs(U8LIN_0L1^ zZ9ZY8$o0^digE9D-4g!Zmo^&Pce@iNowNZ2kEOlq(2+f!`U3TBq~ocbXPtL2rnk_(JBhcI_@Ezz?;?-&^yl4- zD^LeIK{x0JgCGV*LHL`*Q4qfy3<9+a2rj|~g7CWIsqYCs>E-W1rO{L91Tj$eE%F1w zd#FF?1*0JR0DT9VKs$&W%J%}I%$M~`=`X^f-8?&uyt!{VaxQlJ+#jv?9}f~91EWA5 zB=3jF4@5v6s0U4;U4PyDWBfe|>b^tR!_*Iqg2C@n&ZC4a;~g%iP1vldy_wpQshxt_ zil}W#Q0-HI+IFZNi`qJ>&79iwsE)eY45;3J{prx47j$l5On}jINOvyd0I2SM{RNB* z&>rRYLdGq&JZgW~eI>wtN$thdUP|q{)W$|_cH}1V1Zp!_w~8^?OS{)FKY%*W1msD= zKo~?o6L#dmpU`H|31T4f6#W9iw^0_q{a{q-r-|3f_yfJ54mt|@L9mZB@v`{4Ueofc zW%q&@bd2AA!UjPMi~@Ovv>*&3p#C}PaU}a^_IpkI9eW=71)iZhq51|*8~C>IS=GCd z@r&QAdUTzF*mA3Vx7x|5&2{|)&_Hcp)K-r<8pL{d6Yv{SI|~n7)0K^p{bOm*}Un_^v_ZeERcM>a(3XzfQVe(r(cCThb2^ zZzq4hMVo$4-QR(Jmv;Vve)=Q7Ao?ET8}z?V9)BVY=mx=I^1Fg|ffza$;j1Z+-+IE^ zKOj#KyO@4-G0Jc765{Y1`H*^iMp>X8bc4~)$^V~}_b>tCR4n*K%`_Y~4);a_I9fcNT=XF=J)_{I6s(-gL z=J5HXex732_^t1#&g%%jo^f~s?+(=8NI3S`o%pM+qx}9W885uc&T`5I`nN)Tim4B? z_8(GLH!MnjjDqfu`NsanSOue`?<7tgcb^II`rY`!ed$9tU4-9Go)2Qv*8U0KCa7dl3ipg76ZagFz6) z7h*3M)Ze|;rzBzfQpR%fUO{z(@$4tha97z7#~<9Bp_(j7pW z11a|)et|x#TTQ$p$>S*MaSU`5;27~&00(qXo-%aEJdQYQ1r;|U>zKu2W_XhH8 zAx|(0B4?2X#LgzpIXnXqPzR!*8_2no2|B?b2%k@UFn9rFB1C8c{a_G`g8Gfb*~H&K z%dNkN`h#vT3haBnm^?t_5}tu>&<}!_6X$8ZUHt{WXRq-Y2wuRx9?S#Fz(L>`umM~Q zI>0^PG4KL-4ZI2710R8Zfr4nM%mVv^W58M9T5vD;F?bDp0KNdZ7nVv9m;si6L&4GD zbZ|bn3fu0EKY+QIdVq2; z3+xTnfaAdF-~w+Dh>iK|Wv_SOE3`hl3NqS>SSTD|i?@1zrQc1AhVk04bN2Nfi2)c@Fds{-UVYI^9sHt5CJQ|;ouZ-9=IIb1|9<2z)N5U_y|n8 zvQ&z}Jg^+B1}A_s!KL69a5v}%KL)RWA@FDLPmp;PayJkG2Z8lqBe(|K0UiWTf|tM> z;IH5_;Jcdd0L%u9!G7Qfa0<8(To3LBkAmmHtKfIw1MnHhZl{kx4LB662j_#U!5yF* zJO-Ww{opn5HuwajeS0mKf2^zo#a3#1CJOX|KUIuT0kHF_3{Tk*RPyrT!{lQvr zA~*wV1XqGvK^OQw=m)<8e*s^BtZQjIs0Ov*P;dg+2sVTJzz@K4;AOA_#J~vH4RWqy zjDh)JC0GYqz(rs)xC=Z6`oODT2>c0r0=@$I*Q1vM7K4Mq(cpA&A-EXa0PX@k;05q& z@Ov-c7=-pp763&BdT9z?-4;4bhe_#t=!{06)S{tEsHGHyX83zmYlpb4~so4`Hb zQSc;q6}%00fvj86e+BcwN^lft0vCd-!Oh@Xpa(n!2EaRD3{1L>aSIlJ72rs40yqn_ zf$PED;Je@%@EX_&J_Nf#=IxXX=7D{{VPG9N9c%*Ef?L7;;0e$Nehz*E-UfdLpMrma zv`*$pPzGj!y}$urEm#lE0j=N$@J;YI_!;;$co&R-&%vZS;0ZuASPE8xwcvDcDYzLt z03HW@;1%#&@B#P~Oxi+vPz7qhfnXgt8(a*o19yRL@O|(c*bd$RAA-+8)}8b#m;;u9 zLqH?g04@aAfV;qV!H>ZJ_zn02_!xWvGPknsfrVgSa0oaSoDMDm*MO~{2lRp0!CT-X z@CC@Yi*|sSpa$#*R)KZk3~&j!26TZZ!1LgBFbw_!vhU_yfC#7qM}gD8`QQ@J4sHTl z!S}%T!L#7k;C=8H@NW?OChY)Az=2>LI1QW&E&(@!2f#M)3iu=VJ4o+>Cj$$>f#7J+ z0>Lg$AR;}wO|YQ9(WE6f)7B-eSFVgF<1po2AjZU&<&mdFM}BP z1pEi&ew%p^M8HaL3^)T^20FmEK`(d_ya7G|UxKXrdEa0vm<^VI!@!9k3N8cJf?L4@ z;2E$Tyb1maCOyD>2WEl&!13TBa0}=H-v!&i%it~WH;~oM_yUW;p`a18fGfZq;1TdN zcpb#RXCUoC-V;~~R)QnII&eC;99$1LVUiR<-%YrKUGTRg=ov{i67ztdu`fYEXH3v> zk|M!thcHrvo3CYxOqFuserqh2s$`l>ml-lsW}zcETjt1InJ4pQfh^=+s6|pEi=|ff zk|nZKmdW0-kL)YUWj|RV`y(GZKvv3ua*!M>hsdF_N)D6Na=5IKBV?@{$z4%LNrN0M zjdF|}E62$?IbPPw338&GBqz%$=oy|Wr^)HkEF0tuITN=EXUW-ej+`s!$@y{tx|SEp zM%lz&M;FP(a*4FbrE-~EE?3BvautG(cKL=}BiG7xa=qLjH%f=xB%9@CxkYZ3+vIla z@b8c9rgX`-UnA zHiwu)%_?)4S#1tCYs?X5tvS-vo1;vFIodRuW6ZJUIJ3?iZ`PX=%!%eCbFw+bG?`P) zY36j(Y&MuP%$cUeoMp~7=a_TNdFFg`0b0)&nvG_YX*Cy_i_Imb&0K0OGnbny%$4RU zbG2zV-!RvhYt41$dUJ!h(R7%b@JM>Ixy9USZZo%=PIHIZV(v6s&0Xeh^G(xbzGdz) z_nQ06x6S?L0n=?BG!L2Yn1{`G&G*bBrpG*L9y8xJkDDjV56lluulbSLW`1m*G(Ry< znWs&kdB*%d_TB`(iR#_|pG?xy1u!520zyPURF+E1+BQjP*|$K;DoR5eXdrDu+5*Lj zK?bB{&>)zAt(CyTf>E73UpxdR}t@}{-k?v#N9^GEuC%R8{ z`*fe_KG*HnmFvFH9ngKLJE;3g_qFaD-67p!-4WeU-7(#_y6<$yb$;FVx)ZvSx>LFz zbfdxqX(*3OaMR!*BtL``5@45=zIo)~PAG!;=KXrfU{?=X8UD93FUC~wQuIj3E z)!6xUs;cT$gBqrWt98@}HByaIqt&`K*Ex>RoCFwWHce?X1SAcdK30ST#=Vs&-Sm zt3A}7YA-cjO;8h6vuaVTYLePpO;%IXK5AdJpW0s?pbk_Ase{!a>QHrLhitnx#6`De6?!rDm%+s$2D_ z(^RjTtLCZs>U4F6I#VrBXQ}tAh3W(9Z1q9ar_NCyQs=5g>O6J6`mnk{eMEg!eN0`b zKCV8YKB*R~PpOO4#p=`Q5_PG%OkJ)%qdu!Xr>;<+S6@(HR7=#C)RpSX>MC`$x<-9P zU8}yTzNWseu2bJo-&EgHOV#!2+v)~&qq<4mtiGdeQQuX!s@v4<>U-)Ab*EaUzOR0u z?oxNFAF3azAFF%Rz3M0Gr|LfSGxc+Izgn(-p&n4bR1d0Osb8z#sE5?U>Jjy*dQAOR z{Z2iu`ql5%6Y5Fzl=_2uTK!QyqyD7+tp1{&Rex1~Q-4=0)N|^2^$+!e`ltGr`nP&f zy`)}Nuc(#kRkcd3#?Y_Rt9rfOpbyiB>+9$v^pW}~eYC!=zMj6m{sz5K-$36`f1}=O zFK{_0cFJ_Ql%%{odq!4Lex}ns#5vQEY4f@>9J#q}Z>Uddp4VZ|4tn)=Om^nciW=?HPBIcDbNdmX_5qr9nk4zI&4 zEXnq4hu1#DJ>AjQ?VVxwW-39;2Lc8!1x{wH zeTI^pWzU)HNO5`{8F_AR0o;y^smTcA%yqhRdb?+)da{t8f7%_nwQR{wZ-&b;!jW-J zd+pGJojLzV!RB`6g#o9_fH)abPRQSv+XYD zEC=#M0RnDzreVWUa|hz3xd#Yqw#SRjq}cQ9N{S-``6RWsJ=f7KP8e$VUvKY8aRhv7 z?>&Le)n}$NH!oL7apu}5x*W;*UfS)XtIu>tPTpv{GmrKu+P8W;U9O34>hm>R*ePoo zsFg(sY7|69mlf`0yC*jvtxSGWAB|p)&67d&)esdsY|!4%YtM8dJ0T|SuE8LwVs{A% zz=qnvMsbMzi83Ehf~Jt{z%E?U6QflQh6#==9erf6q%$OPs6~eAgZ&qhEAhLWQ_m6uhS9d-m;fsR`u7o-Hnwtrf(ph*Ygeq~qWh zhy^_)6kJ1Xb~H?;!&&`(}g}W zJ#KFvjowMQ)FuiW`r^=0!!RJ*K3Ve=dJSK(gL2H#_UT$UQf08dn8GN1oh~$%7|;8< z-1fXa)AH@ET&15QN2HkSaJlkbc5l!?^9pp*Kma;Q1zaMFc`kb}f#A-h#n3DxFgV*? zfvB2!RKQ|$cwNq%p>8JzKrJ#=Tfi|o%bDj0_)~dtbQNKRPNOyAN!^)|ZTAG++Q=;Z z`#b0;9TK3wBikwWAsJ*)j$3S*lH*ZHdWgYD>NTUJ(UdF)M@s3N=Jw_bht~K`4>n1b zyd;mu<;<|>VXhW9%#xiac-pKnU>IW0^Ezh+1F#z%Fc1Pe*c1$CNUwHSo^S>NVsaVK zM>!ocLV{=6y*8Rsh~~~q#-T_Y$YmRZ3>TCD`l*-~C1b#%iV9kWa+?JWNOZc>Evf=W zIYp%*K*Zwyl!s}B7nL`}o#VuWmb?NLgV7|540He_h%TJx$f238W*F?qnJh!W8@pMW zGn=}D2t5?@@lbuVGcU`XkD*OuoH}ueW0F1J#ZE6mYq9%5_t-O&u*U=n8e*dEhE zD|(OEGKaM}b8v=KD*<5)Nx@a%$x5O>Kpgb{VG}JJs7~49yh~E5(x6qCblS2Ca90rv0qsJff24oZ0*o0QgG0mH`pvAgga2FsTp2}BPZz1 z?lkvkx7U@)BN&^4F~qs{U^fqsv);PC(c!s5VzOu32_dw=S~fAqFZER5OaEPUM=GEcIA8f+4FOA zapugH+9$&znCNIBC$2$b;OsSM!g0GGm&z{_r1`*roaqj4UWj3Y!{f5!Ogb1%oXJY3 zM`kZMP?{7B$QWRRKh3g&nmpqR_^_L&eb+LMsvR}NK(T_}i5INTnrV)-@8aYDrWP8qZ%-TXMLx)P2n=XnZCy%b-l&)ZgLo=J^whc>D24GkZ zy^2C^-d&Udxgj1S9QI6f05-{M4jA}oVqMe7SNJd>)-Y?)`7#9dnoI}!b}l=I<;Z<* zKrYP^QqaLXB7vH72Kb_0wUo5u`E|t;VrD#XW&QPKS5`mQ2M(rkOCg8V0l9F5qzacv3$r!{PJvun8N`7$DaVQKfI}V*0=Psl zAXiv}L2xwU*@@haI6l>!uTY#ou#oMBSb6(&%nGDTj@m6rlQyb#WP^_g)MGI5(IWAf z9&pjTfsTLN4N}Re`PGU@XEd4@_piS04CI*#EZzAoSFSkh1WbW`!Xbv(XF9XRRW~ip z5GN|HhNb2g;-WJ7YF7ks z$erYzEFuIFCZ$$B$dro9+ti&&5ccbf6Vbf>{cN<_95&gNiLT=gOt9Q!xAwjut|;4j|;N5fpA25@*i?ay&S7rOWQQ3TEtR>KqLD)cQ4Cd?FAur8uW!h8Yq@ zUik@zpdLmix_k;*)7}S{!0MQ`Mb5;X(zsb*}NTPh)O0^KecLrxrn26b|3k?!%j9?heXTl5bJwn+G&lFWkj#rtI01h#NrNToqRJ3MF((T`Idj;W!sQgOX0czo)e zKWUP~OQ(|Bh+ES?8C`rLZkH)F%{H7u)Ut@XlQnIl+%6P?0@l2ILx`N=aN4z zLeljEQsvBQh~4AC;a~X5xl%4)rp=^KG)QXY4b7uwr=o}2adL!xBbXsHhnO=M1}tXGXloDQWhp4mRXw;o34)5-tPdYKc&j-8d~KTVD(Zd_hjQ_!N&++;pR} zY@z0g(Oc*Pad%oMa_l63?fjecR9tE1STxGPAOee<$d1Wq9txA@9_*eG&~0`)!IvH* zkwpY@PsaVUzQKvL)?CWS92a)X&?;d|$PAbbwdTOm$Y*G@U+2oCw0%6pNmq5XgpsyV-88}D;6A?_;d zL8Zi0MEZz{A$!!C8nRJL4uh&T7aZxywCB}0im-)mEZ~VN@@5C!lVi8Iaw`rCnxV!# zTQi1Ct2v&`y+|{V`%o8M0U7C`4kE5M@|>Ux%~gUbk6W5sT)vhLUcV9Qs1X(`5X4Pr zEiKKRI?Wq2iAj%4BE?O&Ff;Qpfs__G2a+y18<8%#JJoQ7BrQ(;G*4Vg;#re4&_&@i zH?921)ixEFxyT?x9h1=#ns0E@BE5&DJX^p88fu8VuhndY+UQh&8=Dcv08&^Noek1 zEh9)s1IGTN0b^@4U~G*BjIGgt(iM_)NCU>=q(I9Ajwu0EJN=PGtkGn#wVNz9*krNd zOz9s1aLz=-y)#4HVU>y2Y~5J8ML}mcny+Z=-UY!qXDyH5gjI_Y+9P5E6I&TgbJu8_ zz7+wIOnjnU$pU`%A# z;pQ3*T7xYj<4S{eF(eS3u4X%CCV9~rg0ZDh+~h$W*7gWAtxTJPv$cmMc}Lr)jOsrqD(X zvB;KVOU))`Tg?`hHgTH`<(1AF?JI3Ho0pBj)~(?VHZGe(iX7O6w1qTnXxKo@{?iz2 zSoRBP*FKm(dtD)g=9R)VZL~k)@+0*F?NXT6g;g4|EZWTyvf-L(U>A{hEo+Pi8|Sh?7w+fw=1~B7}}p;v6Z&Iv`WKb`WAjF>`B}W!2OQj7}hj`~kU~ z3EnNaWvMagjK0PQio#Dut4J@}lc~3bIB^uzBKDanSB6kqh-(AE_LP>ug(wbCb5x)x zp+%Q**d$hGaV$2}%vo^Ppj4zQxMPGE#f~hKuDPdBAhrbdhuWs#-Vp3CNQ-8eY@nkP z&pyNyT{fJm@-;i?`QoYvtt#@0yGVS*6Fq@yj_!Wcss=L2G6jQ)`3Y@LOgmT+ zYv;-2$P>d?UrcED09?zGinTRZ#zHNr`N+{4PCDu#ru4klUWq^=P~bQMGuI#&FW5QY5!~&AjzHT4O?+18oYkIm+dudG?Isp-52VFj=0DO`eQquujNT~z1TAhX?*WOv! z8mtj^*W3|8ZGl}uo_C5vS1n^mYT^{M)=tDRLyaMaaW;$Ukg5{}VpZ%y)atZI6V?eX z?4c7fGjk_Q!UgjQ*?cq2>za&dB;8;jjqZKpDaV;BgYS&I@H(E;EN!5e)&y;v*W)?j zjrgWxNVrvR!yn<+t__AOhpl9D1LflCpsnSGrb@*Ie&;MURpS>&Y2a61Qk6W9?a}YF z$D`XrZ1wv-f!;osY@a=JSt_euIC|B?)UP3B9owPY8`zLIH@lO(50 zE|gp;xkd7zY9EnB-=}NlT48uDmhVdrsRCdrIM>8-wmsx5?2HX_mZGvP7$A$yt*3Nv24~Nw$-0 zCK)byS?>GCBtMsYR@Q%6$k;&nu9ExXS;-@kb!EON4E@w~T+T+4Q{;YMB>95m7|Gs} z4d3E;G1A>a(jfU;Df=Ik+%8!n`KV-$WV+;F$zGD}C0j_=mo!NJCG&Ag@_=NSWU1sT z$)_b}OXf)4CplQsEZIe}on$k~Lb?6QH@Tc=B=<>fm0TzJtmG4tKFJ)(iIO(S1j+W2 zjU~e+FTcUtJuP`ea*yQOk}D(^O3s$_NRE(@36ogo)Vn~g z)l`-nXm(28iZU_`b01R0icp6a_wtoN;iJ8Hct8YrnxFWSQ6Hdm2jgC$xJrcguNsEu zJG=$BRwp)thn&QkQe5bq_75K{3z(Mg$jK;BT>AbFyNA~crDX-#YzM`B(8FB-zBXEhuWT|woI1BfQ>2;HI%?&4Nskj{EatxbDr-XQJ zpX*5^lSD5;O?5dO9z1K$_CNxo6+C#$wzMo%bf%&#rtP!C=5=DhA?}rZsH5Btc24x- zBCqn9mShZW84X>Bt^m1wBkI3-Bx-|hqF}9d&SXvt zkB{SeyJCa?IJY|+3kZ}IDy>2atiQnfOvH&v(4e%Ztp?m;eWB8g@>k1tM(LC7$twt0 z6(ycxiuINXzGQ$He6}kKJ%ub-)WJRY4LzQjMvm$F>jNrQcZ_m+^YFA80-)_oA`f|}X`L z<#`cmtV$z4Z)r5%F(daYu}0%w;V16MAY_i*3&{(M8N_P}6uhTLdu>53o)0KMM(MHf zT(RG(80Yh|XgNGmt3TyP-F@iT#Xu>dBDaPK3gA6}|&sC^A zPGyv44pkMJru4~GHdD9}_8DU7o!DL8sbLYX4WI;YG&~;|lL8Thcdqj8KjRF>@TrVU z?K46fzi&njxp5UC)nOw4m*(-dpaH5aEw)Uho$k7-8>q8gh^SeA3%4^`86kfF)zmA5PI$a z(UjPKrh(_2x`$YKQU{|FrN{Por=SCQl6W*i9MT^RnRlg9U&N#|Qz^lAQ*e`TGFAs^ z+dD@oV_3%k?%_Q}Pj$kTfnn|mq=cf=gvXKD*M*DAB0VLOY9eHIJwIfNwPt8Zcw`#u z|M&^6)1h-rvA6fZI6#LIIjL73HjJ?2N#Q`<<4Y^lezpwU%|>%mNzfE(Fqg_q9j!Uk zs&^2TD8-BQ%V`B3bf_uhrkLbZk_|K)qDgC}%?bDWVZjQ-A$L|P);`l@2Xi{ROVnkN zPDDlpWAqk>CSk^2NDI37(%=%I_jP)6#g;_5)(9ItGfVMDEBPWHxb{sCP{>(xU#i7E zIn$k9cMi=PM%nS~2c`w1m3Z=zeJQZOiuMjlecH({$(!)Gk*+-*v66J0)r7^6}5Yms5HQ7d8pJ#HY zlx*z%bf+OnIVXIB7L3axpTQR6%Az^zZgF-M(wG6Sixh`l+$EJ*+HOYj8%alG(i=j$$hi3Ir_x2nZA`k1OIN+R$hgf&mvLJ_kCky- zk}l(#poji^+Y}{b9W40HMA^NH(s~p=Uoi%?G()Et*W>G5zp083-rb?=%qMDGmB9kZ#Hs{hpR?ZeIo8!s77MuJl_c-BbqpZINzjJNoUGZhTch z{Psw9gmfR2?nvoACf(G=^gAWp_$rq8RY*6ryZCM4{NSrK;#XI?sV~s4k#u8fE6SNJ z>5(j!)apf}r^B`D3oWygQ>OpEopTIbg_{VmkX5sh{%?f0goL;Jed?th6k7M4cPDi8 z6xNCS^C9gT+ZNl>eBmeD50u}y6JjBfA8mv3BW=PS5=O+4VaP8aA?b>A*j;1$|6>=G z@_(jI%Dc$@HkMf$$HYr!ML#Z)ESId1G?57jBS=GF)kjh^(ghS=D`e%G=G{6pgWTlxF9{Is-)KFh8@*NXgTB5@Ll3Q4@WTa25v z>%%DRCP`y^4(F3Bm8=~v<}MCrm9$A3J4?G{?RYk6H^#{A$o$1fckS?++oOe-^FZIf z6JCqwm*Fb3@OSfejgsY(#qxNg#jEJS;qW?hQEx^`TQ7DOOO{J&^GCmQYw0M`1K)tE zQU5yF$;(vBu7xkFW!F`6iq?dGrb9mI*RlJqW2aLUEzcC6@Fu_Xy@Qc9*fty0sP2g`0)Axb3A0FH$ z+o54O;CQStKpDb$a2X0kl!FC6k-%)5#%7G1?t!Z z*#&8X!ao5~aUwJqVnju}4jF}lHbg=FkX=s zf~KLM$C@k3>Xx`NbSuh_f_~B-_aHmqp6=aPVbBeq`^0zF-cG_fXMaVRjqiL;!}Xrd z=~!3fRFsKW5Lo>n%Io${bmD#${d_M$ z-w)P5%l@=pD7#?&yXHhXB^#<^DVH!vD?q zh`vfF<$+@3$OX#k5~SGy0&Ud)q<+! zRcER$R_&=eRMoz!M^!{s)2ghhnN|I(##F7X-cr4wdU^Gk>WkHTst;ASukKMDf!>x? zJ+r!h^_c3C%l^xz%juU(uK2H*uB2Znx#+)Wx|n{kf3 zD~qy5l|@^l%Ob21Ws%m%vijEgWj9!FD64C&TUO6n4bwBREUvG_nlcctqXy!n47-rnC7Um)m# zuLvB%oA58TxBFbm`Q7JJ{@DFT%7xt*QvTfiXUbo@|4R9L_unZOS6w`HvCXB-ORFxO zy42=!=H*qFPhD_OysCv&E2`F2ZLiu_b*$=aRb^G(>K4@!ZwAi3r&?RD{rZ6QQ5q*S>?@@O)HyJHmvQg!Y zl?^K!prhT8aKrZc3H7(vOQ^TKZbIGd(FxJpqY|RFM z-Xi>1*ov_6VJ*Ur8CDp^8(J8S=~w7o`oa1Rcq{!`ycvHT-p=pB7XmuqD+OoqrG$0( zT0+U#Pd}5sE z;Q?{Cm5hqpvM4idWOi=cf*0q+RYpG=x7e^a&beqsT$i0|;w($n$1QI4Ufe0?-nch> zU&nQub}DYofIs3EEYx)^`#Z90`0ow7PQSlJ*RnP3x^}<+?yg7liCym-JfLg5eN@+X zhh=uHY@6Hl(SkW$=bwC}YvJKVUFT)4=sMzwHC$|o+v%TxFPJ6q4p7eFsq)w;0 zj#mHZ`s5^Cw_*DuyZyPVVYlT&T68;;->zGies_1v+n3Poz6JxjIa-hE_IcgRZd<wKr zcPx6Od*0kd-A_lX=)R-Fn(qBBm3A*E*xtQr%bxE2c7N4<(b|*UFXo=_Ue-+4WAW_B z9+$Ek_6R@UyvM{w?Rtzl9@FE{y$L-QJ=ed-`Bfu(#6FzS1F!My@nxMkJ*G~1q{l;J z7WKIE=yN?HD_8f(`mnS|eDCc&?wGx&N6EaedK`9~>~W^U`5r%APJg( zcQ^03>15lU556ALb7i}Po*$<7@0mJjWY4)N89lQiy*+g&d_CLrex&E~9T)Yy|BdH* zW_-H3=QB^0_N*7Zz2~IlJw2oQebuweZ6|yF`op=Nx9nGXg>{PT71Oj~uUD5g?{(9L zw!Pk&5!0*i_xN5>?fUon`1X;#PU|vy&HP|mulVi0UO(OZNUx97MZJzb_*}0~pIzPS z(7mO-e*bb?uMH7zAZ~vuV{E(m0;_ux#F@DAU)8Zdo>WklcZbAH|Z=Q~rE1_LTNZ z_~Es*gfoQ`6As2rOW5!6B`n>$AfeYAPbHMKc`o6@o~sk){qa|u`ORT3ZB6p?s*S%XBie)Gh~Z*80S?y=5^*#qMft<(D@KIKYFoY!k& zV(Z^LiFXe2B|iAlg2V+6J(bx1?`IRoM6OOe|G`^{7dvfB)Q|l*F?-0t#PK(uNc`fH zio|<*;1iaQN0?)?8<>mz&CIu-Yh&*8YG?DqH^!SkiSK6~(kac{{i5Am^oqy)WLuv( zw_t(!#OSBY$M!yJzI14nIs3`C%*`)uH7{xTu{rjJgXSjRd~Z%HsxW`lP_cL&5thZh z8(8kz(9H6ASsTmx{LYrQkM*)Rbp0&1RHRz2Y_eOfq#uk z)nopG31l4tKAQnR2gH94qD7!GRUh30?SkAi7J>4>yIOqBw0pehtki%aoo{-_Dm zke^Oj+y>Y5F>hLr#OfiTqu6+N$RUJU0m+AqgY<*+gmi}74lzL}pEMVx?Oz2cKUYA? zB{?X9{@XnvtXYO`(PA)BQlf)`*PUF!u|^E*|0B${Uc2Jwy|-VwAzyFaR{uVUV+ zKU-bB1^)fvZ$!Kb#IvEoN`J4ePRCrfY#x`y$;jsxE=GKdeC8Nvtm&wa(@(7BLy-xFar{8^eqo&u1-oZptR-DvOQM*wGu%GKN2Ix$X7>E^;u3Yzrq(pfsPg=gHj9Qtr zvS`N^%B$99TDxg&r?nr3DsfE$*%4);a%sOuY(x9ii)t2yjfPR0O7%!lX3B@V;oM$L z-uZ$?o@@Mkmd@X1(&0eq{Ou|8@nMgfZ#y~`wo_)~n4UW;UI`D?cZP%!I>K0Fm>r0_ zL&n{KGIffh2aGTd>{+|X_%q9;#$(7X2NkrCIXB`i$>so6c`OF zeLFE6u_%llj6f_s{K7y{8St$GdmZ@bA(61t7Z<}I;i82&7vnOUi#ljEZ;++oT&ub7 z<{K@fkITHWW8fxMiMqqAVgVZIj|qc+zEfN(25>-(olq)CAQr z)fLrcT~S|DpY=qYQJvNo?O_mKspPt+uT|DX=xDGZLPo$vU$3l>(DlF@L`~O+)(|0# zV)Wtq4*tj7?;rQ*$VR`=dzsgBU#s7c4LgG95!4g(&~+g7CtPED@imctZq_up9Yy)6 z-MJm)m;Qsz5~A;$?zuFjg)`+)9h`oV{d;Qdxu(fnH;V{U?zl=_qmR}?{)0`u4C_i9s7Xm*au$6KIl63!Pl`5 zxsHA4b?n1x*~{hrRdJBV3C~x|;;)&d-!RJ$F)I!;jYpZ*V@%Jt%$V;ak2BN#Oyl=V z>j|dqB-3|_S^5Lhf0}7L!>o`j|B2mYKQl{yVS3IoO}{d&zcG!!GfO4?71DlQhWmpV zbAf64lj)cA{l)H*znNthnH85LFH2rwnyxZ!RZL$svsAg!N8_r30Ad1DO?rn8qQ@n4wJDFs8>QIh^Sm!7NE-mZve5 zQOuap%=9r#-&m$+9JAyerfob^xmWT&rfCAxn$9ehEVr|}Vj|O+Dd}LwOk&z5Gd)>M zpOaZSg;_S0>32zHGZi<}6ynYna?bHnCV}@tawE7QD)3Srsr{H@e|ViB-2(b`4rQ$ zNV*qGKFu^PVU|hym$F+~&a^(mEPhtHpJS%4VA`IS_7|8jFEULfk}olBE18~`nZ>J^ zrK_3cYnTru&L%$RSPw(q3@>Fm8n!SjY=bNd^PEqHkIkoGm8z((lBOuI8%vW z#zZpHqnN&EW=UOUc|B%DeWuYU?UH2;q<=%EsS(q5lVoG2rwKE?spQQ}YcuI?&h)il z#@xa*wUq8wOsh%SZ0oBX5Tg_FVl3NpUCuOFiSI;eh0H`60>}=v}ZAmQ>0z8cq+SN zTuf88441=H+>#zj#k6D_}ESWAjLvkjwynu;C$6`N?DP*QUz$~84 zEPIey;bZ#eFpYDW)*_~F9#4KJc-A^-1mN3hfGX2Y##%Cm-Wm=z;T*34_&rE+ox?g1aN|>cDG5sr<6)!W( zS4sD3rtuY~vR3*_R=mn?|7$YbI;Qmvrsqwj?JcISlv%o->3^H4Y-Gl4V%jz{eeW@m^->C(QCs znHBq(rq7wi{Y+~))ANPo0cP=+%(8<_|5r@q8>ZsS#+Nxt3Ri>h6R%kS^yCjTR z9?mSS!z_+qrbjYOQB1$2FItAH%PgtKEUnM1xPfVEz_d1Grr*f)HDZ?B#4Kyf^fzHD zH#1|JF|Ey+rWVrw7N%dayd}GfTQO}Wrtwy0nPf$4cAMJBaBZ2McFf}2nPu&n6?ZUA zcQI`pn7)qEUoyQDyUQi5o!MO~X^LUD^=@W*7p5BqG7XL<%Oiw8>oK}_Rd=^nzg4P|8N3K=|uay2TGt*ZweXE(CHPZfyQyLo+HfSqs-D{%<^xU%5kR2&$NEew4Gr3PBM#6G5tRHwHfw))1I7vhs7LnsVHErl~pf z^;i6KSaQR6is>#S-9x9l?)7jtw*l_#Ho+Q_R#;|!7uJr%W8Fw9){Nw0y~xX0D{>O+ zMD$vbC@HM7&|&3oaP2RaxQLsw!Mo9QkbXU+d^6T++>Lb_cC68OAMxfOA`&y`!m(t% zuFi<1>n2@{&Zz#~u&{8fpoxfxjEstkj;>p`o?IxgG^Wms4)*%LZ5pXd3il^)9jGta!lKDcH1xM?z+H$O*Wdm;bC6@%SE7PW*jF=ipOG>0f!LODJLY~6pu>i4$1utjYju^?>1+lT9Z)aIw?^$!=iJ2x1dHRknO z?C&RboV2+(>Dct}X-9S2O$V0WY5eN&%S1q}=et z+Q_9%m)HM(TfHd{c1+BUSmw%nN;f{^^o8M5r{Xn#Ee^#v<_%RQp8s`8xaF6=y0jS_R~8Jf8Mg=vBCxKRvy3Q+ld1@9=Yj{!Y>y(1|PgK#{Tw@&xdd7 zm8Wcf`9#dNgGsB85Bz4yp~URnU#z-v;p;D_{NzloJe(8PcfsU0%D1E+$?a%J`Qa9Q z?1aHluk9_Y_ie(oFxzWM>g`5j^p5$ax_jGh${M|4p4$|8aMHUkp0a;l|I&B&E#G_i zj@HY|OE<3l=Hn)b8^+G5x3N?F`1jsXxyw(g0|`ezTU&+FOmtDoPR zap3uz+8s5_ZG0@ZVRXjHqWH|G%~P`LtsOUIR`mY*r=G8lTzvbRO4Rxn>O7FL_=buD zFGoC_bzax9>Vt6Sy`v}o{pnxgmRz;7qJkH35A z((gN-NZ#>IldqmAO+WMU*I&3<*YD}aM;@QN_V*`p?k?Ej?7MJ-{nKW1Cv7h|;BMRPMAnEU zGwSZs_lw^4Zez7|=XPNucf@b~uzmDHb8qL~r;?29(-`}J8 z=DN>4abQus9bf(M&hN(xZ#{lA`rv^t=l4Ew@Z7}>-)7~^J<{s4#yjTR)9&5BzMoO* zp3(1}rl-e6EbvUZq56~f@JZvNbq%Uta6IXJbK=D>tEbxg>~}Suc_OOhw*&RQNtYLkN{qTit-#xhh z?S4O1Z;EMg{=N4e{b1`SF^e~(u6cQ5o3L)>TNj6a^VuDvzf0RW`S5L>W=-0#WuSex z+C1ytr|)v#*?mX!#+RO`yQ}%}uyK$7u67h-5B||Q4jO%FJ%skt1}GYcv{AXq124r* z&hOjyZ^x&v7S8T)|MK6S>iD|%YE;<*!}FI~-q!yu%aC!KjOp%qS%X&I+oN|yM3=N5 z?mqCw?~m(7H&j1*vgh|Dy$-Ma{Lg(KhYv_-bo$Gm?%Ojaa^Q2f-f;Ax6Q87>y>s2_ zBi+C2Gt}P{Yi|)h|yk8e4x?i=m#u zmpeDTve314$EnxedF=M>7yc@WnNhs)(fRL>*gUgf)Uhx0_nccY^0TGW4zW7Ybv zpZT#}zjxoX@4aP0o$=kOc1~~o?cC^>GkzX^a`B4N22b>O_R=!t_y*QA&hC z7pB&Us1qF-g;h9MlO7$eGhmf!6qb5o31_6Pj;e-7hlLr!BWY1#o$$yALzG^J5Rp;Q zVbRfQc$D6t8X}|gYPcTDIQ538XcZfYMgoRt#Sl$Bvrc%FL5Ibs2pNghh**Rej!i0t z@Tdq?9~~WmmADb;#Zlon;$gWcRxCzGhJ{69TlxrH1Q;EKMWtbgi}hScKO6z-)KPVH zumn!0!x|zS7qR?SiHgvN)zL*Gn^;X3hAipBBI_W-;V8)e+vOMYBe6b98zpEh8qK-1 zpO}Baru~F}s9T2B;%IBx0&dM;#tHb>N<#}z+xcJ1L(Ie%d*0NlRj-caIlXRb^-Ix@hpm6c|LD~x>`Skk@X?x^5)P)cO1Q&vN5Z0~ViS5>%?UjQ z4MRgZz9W^)Mt2ZA>_;X%yg6;8T3ChPWB(&_hCSm56ZzNdP zY)Tma`g;l0r$0=%nD%+XeSd$QFtGf1!s>6&B+S3{e8RzJt|Zu3tBEb1sgu}jZQaCs z4m3zS+q6mIzWZAwUcG#4;sZ->PaHC|V`9N=v59{+>Y4c2ZI(oxtxw`p&kRbORy{oN zaxTW;VTm7m`V~S4qTOZb?(~4)X&x>{?u-LV!x+0B~FOmnz&`jj>O?HyAszQ{W$UP zvVDn3nO`LSZ2daX-|1-L^Bw((&n5hjczXQLiL;;hJ#lpTg+zUu%Zbw$R3|onP&H5J z9cF&KeuUY6GRoZY{d#80D@OCcr8k-_Pc$~)^5o6tmCIY08@%4iyzZmc=HGs9YrePX z9p+6#JDB62=xl!N>n`TL?Yo)l&+Tb8{Fq>Fmu5BRf0ArIH=v*S*#iU3Z)XlQ$15Yu z6{|*?Z%Q3&el6-=v+L7z^Y=?K%^x|l%+33`%(r#&n4fEzXP(=1rumi@g=SppHFq;T zWG;>=GVkg$-&{Unf%%=;kD6z!Txjm{=@aHN7mLj^?pkbCGnSYqy|~Q$qyHIm@7q_H z-}Sy=zH3*Bd3n>9%}VZS^SlGEnA>%K&Ah8*oq601Z<%A}t~a-?++a4&+H8)$y2U(q z-Zt}@hC9qtR+pLYNZe(<{m6&r-i3S21-E@_zM=dx^R7AN=C6BvX%7GMEAx`ghs+rd z95uTKd}n^Q+4ts*b0^KN&rX{+zWI~+o+W3^6X*PH-s?SY&T;-}UgEfDZa(>nS(j5~ zj(bnBg!fe~uYaMpR80u8sOQ2h9~VVf#y5|$tlSuFS#GOmnecmk%iqODi=}Hr%h+Q# zT5g+vlVyLGCYJaUO)XhZH?zzb(8AJB*V1xmTPw@Jf?F+5_Pouqs z`E1mkmY!`pSQh-%(X#B5&X(mb-EDE*A8WaFOjpah-Md>_H|uGcUERyF{l^5$z5`~< z{xYj&_xj$J$5y9U`mE?{IlrX8WzM337Q>>!*xpb}`7<_4vy~$(W8O%!EZ8>6^7_6p zmIMBAmZN`m&UFQ`s$9JAr@4ZM}ihFK@t1{&&Lv-{MWzasI6z zUE>M;(X-z4)5=%7Pfh&uKUTk5djC3&*ZpxCrtALx^=6mE80%hEI~=>3Qk>D^IO#ru?w-%*uPNpZ@HZM2z9MI5qspeMd~n zgdYb=tKiv_B9ha-gB&+ zhAe#XK+>QSw?eX@6JNgtXMNC#Wi9cZWaz|Yt?*3- z=){dAWCstM@csqpe$b9V@ep*plUZrmnsvPYO<6&LdL!Q47UhCYjE9s%$GhN^M137z;bWH)r;yO4v> ziRU4wpyS=U$}&hC@__g6Djz{wc(L8?C|IfTks0^VZgIyZp>A^Tt_E`=O~PJ9(|26`!&VB!8?1s{Rz zMtcz-Ou}|uCFwe$y?gMvWR&1mG0QQ}P{SmqiOqh)Q5$RjOu}D7Iyr^5`pBRRhHI$PM)`y&hZUmo%jE7GA z43Y<(IDb0&A#`F1WEFJc5y(d9#u<2jA%yld8@LKmhdv`K+;h^#f5mmKg5Q(#J?b8 zpcA)0fVPBQ27V8rJXe5KvlXQX>BKyU_X|N1&^L&4ApM~ezk!U0PQ1y7GD0Wzf)qn1 z_J))|w}JU&N1DVB=3)PWPCNtI2fYGZG#_<{Jd}W)9_Fzt2D}$igt8E~L7s+AJPKJ0 z-4C{Z1n;hgPTUDO2%UHoat3+@IQ22~;g^~SIv3)-jnIj+A4flg?gPJm8hL>32ahj7 zo=cht{sp}RI`PM)2m_s13E2ak7`Y5>2c7sLqyl;gcoJejn#4z!WB-CqjC=<9hHeC> zL1scH=01z_B`7;|VkzVhbYe9mZ*>#F4XcqR zbmD%(24nwa_GdowdhySi3O00(20*iBG#Z^fsHmGf5@8&d<0Uu65|!P z15yT^*m5(%Kqq#9T!2nYdkSM^IM?ZvziPil;Ua z{QM}66WA{Cmt*Kl&?~@~zQcG6y%fCv4EhOlANU5OJ<=iO{fsdUI&lGHJoI94A7nSe z6Px{td_pI7hFpXm15SYqe!Yp{2hcO26El9p{so;l53(FO@mt7R=)@+!qm7^wPeS%V zS1K^hK0AvEVn{~Pbux(GMg*8_IGgnbiw z3>bTv#~&+byn?k$2A$}HWI-nuRbu>sPJ9Zo96GTSvKG3v8vRbuiQ_xnW9|UC zi2M*AhSWt_h_69R&`ZHlcwrBfD;?Zw&?zynmw~s0>G)U=&V%$v`o-WT$SSlu(N<5V zY=KT34ylW6rGu-DI%PZbQt-LPI;92l67W^Xc<97>O>{~Ybm9ca0_em7$O`Dh{g8Fg z{Wt5B)K)sBDe_QZ(kabvMSkp9Uj~kV_?9;j91DFp^mK4jN1ft&24w-Qow$sG&}n{B z3O4ABbP$Hv5;7jT37iF?I`PEll=tt}DLtOWcEMlcbV?d@;+U>FB@;T)2`Pl`0Y8MS zMIMO1K+2#KW4fb0p%WYT)F~IB6Q@EVuw9}b(gr%Q64C>@(o3g|#LL<0B78ddNFufi zy%;P>LU`!JiWHOuI?>Sw^-uW+8~0`11m;32kR~y96w*YVi3=g^p%;U%Lj0KT5!;T| zDH{=<*aNZ;I@|+V5bwALGpbe(dL(g)i?PC<_WzlP9u1)--? z`rtb=bxIy|;%-PWbmA|N66h7+M+GPY;u3Ev)F~e5L@VTJ=)`Ks_~&rk1SdU!G@%oV zAPb-qAD)f<5jyc{$VTYI7a+T#6SqMQLN5b-4nO!DU7qw8-cGvtk8-3 zA!DEue}!a0FJ6rFm+<&px)kHaG9F_+VEi)}a}dV#oKATbLi-?b#hyh{B zz%DOvTq{@v*)kL9gWF%^v8xOmP=b0cLY~3p5ISa+fURF*Jq8>F8ISoJaTz2FI&u6; z?03+KGo|hW^IyjPOLHeMWtC1bK_^ax#6kCfKSF5y^u3}}F29QMV(x^4jxrF^2J<3f z@*CLipc7Lenb56oA^lRFat8A{;suC;JP^NIk8MFGezO7Fg6;>G?n1vs+!FB2ZuFrk z=>K4w4^h|a(Z|4+AEEC-C;s>;+6X$a-aeEQI`IvN3p#NV#0R|$JOGJ9S%`0chHaEK z5!?#BE`Be`xG95!QEUN7f0-2u4rF8Z!dF&i)F-* zi_X7k2Nx?3@><*vH+L`(v?B((C7Bp5zD{zf6M~0HfPEp#hE0Ai${o|9g~-2P9P3k97^(VaZEvyapB?= z;={$U{rI=!aQ^8{Q#`=xg9k28xEYvac9Zzmwr>c)dF@S8&V-%RSIN(sHpJ2 z;bKoxkBk2$%1u#{Sxt1`3q#i>N%8j)@e@yyDZP_&c-K{o6ZgS4#wEqiUpJ%@Ff z$ynf}^XT6U%Hb3eeT?%3zb1QdaR)KfkHPvUlH#A?hhd*;UQ4+PUOYd^xTnz$%v_LU z#{1dx@U#H0siF>i;%U}}@&LShA#=rReehkPb1MEwLi9)coiyMvc>JOy(};_AkSH!b zLE3R~331SV5Z?9-_oI8e$GH_>j*A^6jGJeZ%(my)8}vckSHryp7Yl-%ZCpI#W#$bR zeWVT-JH5hQWxNjfQ7!Asb;I!OS6Ms88-AUATSqy46R&tH$yDRw2PBAx;n)?dJFoS^ z$H`b;D=vA5*W%(9QiY2%-=#menEpQf!5y&M2T3M}zB%FZAF{6)quA{u&OR;{easr+ zVksGmiw~1BTpaf)=MEQdA}aU7<36*_X%LQBLtE?(@#HY~D_k72mOX@v6G$~KP9sZk z@tp?N0vA6g>+lF{|ITXPtf$To^m#UC6L$KMbIn|dUyuS^?6iscxC8!5^u8R0?L>P? z|2WM@q>%Q*@b;e=dpT>$9z7wf!F>?KXLIL;=;u*Nf91_r?#@MxW|h1yEren_$671 zN1$ytXAl>A?B#tN7mLXr+ykHbi}_r@b>V`2++*ugJe!QAzF14jaq&1_O5S1cima50@NfB+l!UB_%^A* z#cxO*E`F8L+0^4=gf!t|8NV_S|BMA*%b|Tk% zkU4}O5hpI%dvrD~+yg%(i*T`5&(3B!E}l=qxOfMN;NnZYI-3?;Tu%(+6*m*rkHVDR z{B2vx#e9;7i&qgBE~YzK3tU`Cytw!hslbEqQ=<77C!9=u+84v56c^7rg|)-QtB4;L z%M$K`n@P!3p4;K@KAlZDF770LTztMSdkhzsE4Y|{8hZ&BZzAh)FZ_$Nuph)@#855{ z@6SHK#f!)QT)c@4(`#Xf=pHEEHjw$R|(gE5K&NhL0pk^nBYkUCtvdzFI%#04)WwTxX1ka}GFpi${s!*~Yxp*$gG?>9hFR3dV?wFTP71 z+7~}0Ik*@h`M9|IJ+4K6VleG}Yu}2el3M0X98T(SvByfTg*#yh(cbpJ*AgCr7k|j! zqkRvouV*ja!oGq(6P*k37-^v$@uZJCn+{xzksRh$?DmOO-w7v^_~&)-)K#=e`{G5! zkBeK#B3%51EXT$C&sbC31^-#Y{fE70!nC)RJ<0wQKO;{1ARZtExY+3n>f_?x2G$xE z*M7-b9d&NC6%QC0Ms#do&2aJDjm#k~UQeoU@nNzE_rqPJ zp66Tf`w0EO#TEsR!G1sRT0Ykm$NtD`aq%`%hx_11o0zv}I3v*B#9ZOxa8ixCVc#v* zdw~nSx0N~MvxqS4w~c$+&5W_RvpJazdz`Nk;ElwCiyv<1c?lOQe&K$Fi@%elxOjGy zvEbsJVqapP$7^BP5njV*p+4A1mQyaibBuMt#YWPGN8v>#*(CE> zhu9@0**I~rKPkao@HLW0eerNwvMI#HlhTvTSlkJpC1tp{H8a^%;-bk)HcN5w$?RlP zOrHa=R?glNM>&#BJ7-y(LG0`YKYW+W!Nc$vapIymjy~XGFESn%o5@66+?gnk!OOcP zTYC(40lxR~!uHY;)Q0@8rHq4#9koZUUn#eMj1Ts)6|oV5xUA0#1MT+%n$gmJNfs9fAZ z_Tb_br!h8MypE{c3*RRC`czCiJ=xUpOemK1OE#-;@m>;}a0gkAi-rB^ z1MY@PNdy~7Y~kOu5dBs z8uokzU(3M0BoBANn(>tLULel9j&fZ5aROt+qj1tq)Zw#4@#xKr7Z+c-opXVUn}`n= zU%5Zo`0)_jPV}=n;*JNn9xe{5V195H98L6Dr8to^;G%huGlh#?$R1q0opj(n_&M?4 z#k#;YQiF?sO=hlevDZV%W*sh$e3&+IaTD2ti~C3iZXQWC^T|ZUF1|ID_Hl6?S%iz* zNi8n6B+6qdn?^f#GIn^LpR-S!ZaCsG%RTVSszf=QPIPv}lv&B9l=|W(;=`kG)ExE- z?t#nZaSy@8{3i%54k3lO8|Kcp`rw2+iM~dQ!5ONTQ67e+&v31$ z`Pu|depYRDk8{j(><8QfCoN`AF63J9KeC5%vF&;GC*`8;1@7Uv1I~Sk^F^I#Fxfou zGJT+2{FapA;%{UME{?9{y#N=-5|w*lm)B^YemdY|A_B@!+z$qV&Cs*9~YOAVq83KJ@bi+qln7I_1|+Jz{Ouk z6CT-=Z2lolj8`1nNI!9L*H6sP!#vZ%yv>XYcftoq{Ob#t(M11Qcd-|7Pe$*WhAo7xi(m>u&mhizks5 z-0Vpq)%U^yF3Vl;y0d6A$UMU( zL~RD)dQ$%)X8~S0xQl7P#VQiT#l@rp7Y~x0m)OH_;gBw-02fa|9rzL-KI(UE;#Su-m!J3H6m~vdaek9|>#Ro|ZE-oQ;co?>gVZ6+(xq`nUM6~YWNyJsl z=MS)&6yxHHq!brFAwFE3?%`UvIFr=iVky7qSci+At5^$MT&Lh-Gik!3@DKiB*;YIT zORr6`c2IqKLUpxS7Z|`D)co;_SU@hh{7WmnnUCfjZ zDTnFhyaso`KZx3o!87i$_Ph(Wlco35hkLu2{bb#jeEkatOk$33@eC5f#b=25s(YM0 ze5@nxgd>SwD^`+1%EcL^1Q-7xrMP(4eXJwygLmHF#rWm$^ar|_eB1@EA$7R8i!|Wk zVbX$&BOYW7xVV($e$71`cAv}`aB(jghR5J7578go2S1(C#RPb57@CI@a{`|wdKL=8 z5tY`S_rNcR<~ah_O=BHDX3pUOQt}C(Q$g=^f{RV00vC6YIk-4w2749v!(M*omUf(Q zDAD;6?6mq8{#tRkN*m2*Ae26MGMuIaWL3MMU>i4_uNckHAAj zV>EL)o5U8T4m^Gyuh%@lePj-M$vnZei03254rk0~|KNW3=mM_GItHNoNv=hG@eo;x z`vdF|vhD*u8;6sgqOZ6(nY7|!6=}x<@Z6_4U(B=kJ!!_p-6V#`;HHJtp$}2$SY(Yw z96NFW~_gO}KdG;zS+zLBhk(_IzSo@WF(~VDFc@7$;*7!rOvY z|9$ZLgqxSUn5<>&dFsUA;8(1^x#5Ib-gnqPUO1mcx?pU^9J*P z``~jVejcIoO~QJKot9JnEuRTP+X~JdE}ljzaPg@SdkGioNev!`|Gdv@XveiuWDhZ) z?t0#riPp&daTjv~srZg(Jed6n_b6Pvi!8#$;!n9p;o>M#k9*-_l21G0i=+@2U8}fP z;No=R#l;_q50AoGt2vuhJR`xupC#TGU^&ryrFiuh>zEjHldZqkgqQc}$HRNCTNe)yg(#jM1`@Z|IqW5ZqWw2Tzf zhOKrt zlS*9NM5^&9?32SB(vAyWC#PKegw*2V52PMGq@i4k{yX9PggeejF|QHrfe2i2 zF72v)=sS-+fQ$C?SwGrwz$wF+N8Ase9?pKEP7t2y<}Bc5M2dNttW!HMr6k3aQ{M?6 zAsUMxE+KCAvpDH;_8ua=+yl3hf_2Unu=)5@)5`N$6y}|f8h;iNhmxh#5sOF&_dsuVLVfW|vK$w?+VydaaMbm@!aj_@Sz7j|EOf~J_@YxicKytaiiT9C0+z;0go&5;(=W(r1IcxB< zldN{au%Vab5t!cFsxM9;w$-!=ZzE3J?@TqTPG;<%aTee!r_e5Kibu#wTs)x<*T!A> zsiu?^ui{w|9@m#S!NuYIQ%wynjwAKB=or9jad8G|$0P6v(LF6PFxBiM8kcWSs=3)^ z^}z?*iT1NOGu3Q7E7c634-q(UuvJHVlH}8WaXBf(T|-mNc%nAFa3j&UBJjdNUo|kI=x{&s@|6$pPRO7~daN9-Jd`97MMOK?pSU5V>w9%#;7L%o1R~%ZB zYU*%tIa!5=;KxMc75^T?|D%2J>noTaoi*sa((0Rd`&C?nH4^>AqxFI>j7>EYaq*0C z{6Ad0j0A8Gyo&^Jv5Bn2#mZ|_O(QOzJU-RLaPf9x=%){Mx;{1jJHHNiG0_})U;~MN z{tSz5usi^tzlm$m{~%oJr5)xZ21B>dXWVsbs`-SdoiOZI#yGi_xQ0~V;&xJvN8zWp zQ6CS(ZWGzJwBv-$MC}Lf#P71!#aqs}iO!Mu9nqeNz!UDZ%A@f6N%WI8Bk*6+ii`bx ztRpU-Pi%}uyoBW8F}UqMYhA>__j5h^AbLnGE_Qps>YEepATH)M2JJ7O5cj}`i2Cn`FA%*p2wM^!gPD`9atHjCIOuZ}p8k-v7B2X3!ox6WYN{#MyuntY zXMh-7J%j(IJPfB*rSkJ2To;Dt(he@JpO+f{9ft_K;0f-tl#6xMoDE$3d48&yf=A)q zPxAk8A9OvPYUbc#zeW7F9Ik(ceZ{>r0xx`yeW?2|yuF5N<370cHReif!n0rJ9x{bG z@ES5K#^)-~{TBVf#Sx?$_rPIW=LX@vM(!Q!xi9^cYR(~=TQ~gfXU-Vq5t!O! zl{?^-q-=wJPmMjYh5dtzDWnb;-CLP|T#S+kE(W&o-?(^VGkwFoa33-BQ*8K+YvJOb zqy&$_v41cpxECHEi*Rx3Zte-V_!5cYLAaR&7_Yc#5BCsU{EIZ;F?iQr?#n!%_~5ss zm3b3?JU}0Qg*X~e~AyK`M!oRVuZwoUx(C48FX;z78ZI5zY38vLy%ugAr# zJewJYJK(01ZKl1E{y^I)^zCOpe}IL=iHkS&;lFXQW)Ne+#naEQ89y$To@p}yT%13| z#_uukJ!{zQY^z*6Ybf(fxf@oKML+S`IDD1V;o_)5n`ywsN6w`_E^ax`W?FHv)A`Ju z`VUKn@mgG*J%YKy#nq$(55s?nK64Pej1_)`d9?!r#ddT>P69;o{|&aV=bQmC!ye{zHPe`0M316T-y< zqyaZ$Z02H;Lx02zJ**2ZP9TN27tSG7th;#mmCQLV4!fE;#KkMg9$b8S9P@*VdDqZB z*Al}d9~b*xYmHs(eVxsWXT0KY;=|qW6H-7s;$PQu_Hfa41M`WCw-7I9Q;e2Uj*CZ0 zHEwRSnGYwhSNHLAckr@X=r=A-Cu4CxJmU_|o$lfA4$^^(Q;2;l`yU>@oB6>-d%4Y& z;bK=(fr}@TIk*enbC1o$a38FmL|e2e-r{3@ad81zjtAhz`zWWrm{h?U;o|uuibrAJ z2iXrXJ`08W$sSy^PiEgT76*KkMECGJJMh=9eoC5f@vqO>OSqW*1=pp|VhM5K;_O6u0G`;uo@5@x%rBX1Tuk1`oa5qE zB#es>kO=OFS4LPP#wb2Us&H}s7S;$CUnPyWn6;I$;12loHty9MnICv|GxrVFPCW2C zW5mVNTNoGag8z`Q^k3}u2Wx|iy>@b4T)g>D+QG%iWF;={BMrFdXtkMUTA&v#V%xk)*Ze~3Ro9$3mJloyGaQigIRl6Q=V7F{-oiD?r{e3CR}`vBuDtUMEDiS z#l=l~xfU+A5H~Jf{TF))_rj?}e_KpkLiTW7aTPI~>sn4iMTkWo#z%@^po|tIF~fz0l0}&GcNJNf0%Pz?AF1Y<4&0KFJu3m z-^+mgNELx#>MR?rHvjEfVA4;Sww zRk#n%Co6yDo&zJK0T&ODCfrO(GjoW(P7lBxq?K}U)WeiVS$B8^DaAeTMWQ-l(j#f6 z9T#oHP8|pI64enKh?8>hTQUTXzyVX4L&htvC#!JrR}#U+zeyC2!P?3+Gle$Aq0`b# z02jwi=l|(ia26@1zPO2u#l<0h<_H(hCv)&1{Pj`x5_2WCk!0Et!&RIGT>O#@z{M?O z7%u)ci#>shUFW2kGTaF_E#O+e@tgn`K9gn&@gO{HG3|5KT=3Z!(##%}!)TE4sy^)c za$5ZJcJWNo%v^~#lNc_}AhsRcf8g+1+T^uvc;f5q2g;pr@f%io5LUfy^&tSi_`vcA zEUCBZcwi;*@mjI($NV=go=<9UH{3;h^dSb{SY^F71edQ#I86OA&D7H$2ORe!>yCS2 z>SoIwu;pi~4>35c*(&$L(|1t*Jo5t`yVHzE?ZDvP#8{v!X1Q2($f^^7UR%1!V{XO8 z8R_vk3Buu7=_aW8ft3!c+z%VOS>;h!a)MRvfeT1AV-&w4OL6fJvJw}MkoCCfo^Ea< zPUc5^j|{=ZFG(>TfuTI=&3E#@M`VfK{r*bV`D^`>BxcCZ* z;^LbmhKuhe%ENF)-$XmmRbaVzb3e<&a8iHzb{F>tIFHzx`5A23N*uWO&VY0?02j9s zH!enr2NzcjV!X_G7^a+&9{)_$0Y?!1%~J6i7uWiO&v4+-v(il|F5XQla6cS7INglr zeN9|FG~M`cF?@5nslmm4B#euhx1^g0F1}JhpK$RL;-pQ{_MlbA39lnnl#8>-B3#@~ z>TvO^$+VA)n@J-s?j|j`nD$V*X~V_cB!~AAvH#R`Q-F)ZNGUFEB;~lcja1^|U!(^2 zRHmEnh@M?N)0ngA>HHo%4!1G*;P$vZMnaR1Jjt_30&3fTc`1lj)W(ppF3#-|q^dSiUBz|5ip7Ufnf1i@S-2`tX zb+`}O7P24y$JvAfNGUdy;==(L|$4fa!l#Abx2rlj?QQW+cZf;tZZi;Bf z3s;g5ds~c=^|)AFOMP5?pS0s*r#Bf3?;~;I`M3>ckwV-7XAnIDi#thV8{ZFt_rJwD z;-a6li|dNte#UEXao`&6W4H@$Ai2C&d?w7=;NlCU2p8wA zWq;!0(9bz*xae<4H*;`t2dTluQQunS;^QPlxww>s@gRI^1ATZ8hbw-d{sGnn7XHY! z{^9c_n7xT>;bI-B#zU}!=vm7&rkhj9x}*G^dD!$5XAl>ECvA8PUcZ@n=CxwNfp->=l#Wf2^Tv^ zSpE5%H6ro;!1qb~`zf$T%qn-ntBA_QIbn6NJwlp%1hZglkEZ z`eOH^?0H-q)WMmjj#x|zaM4E!aj}^c<6`fBt@6NstnV?aZ$bDaDW#v{LH^ZlA1G~M?S%akg2!cM#J{iSgd4LmjE(gY zkCHrG3^_9Ro4C}6ACO{P+(5?T5je72hFPS21wSKN7n8&5NI83698UbWIFBsC#anYT zOdT%HBK3FxR-Z^8SVu>X408g>r(8TeFT)JL#S2I=F4mAzJO+$-%{JCvCFs4!Dxo=tCGjbuzDIj6t}Im_z)0DO`LCuf@eRqyQH)`ec}4 zxHyJ*aB(j2;^IrhhX>))`5C4G7XzoVUbr}@FV|v^x#01qu^#LnaZW*oS%-@|`em3_ zJO)2KgL%+7g}csXjI6b5Xok6qIA}+FmE_@K?{iouTpXToaTF<{+yn0`wDyl5en~Vx z5qOZq?|bL+|If=XOX))tPCB3V?`O}$Zo@K675x$4Crfd0>;;Sk_rkwO3H#Oz&oJka z`1hpXa~Cp)Rm=}e8_E7*PU5_Xc5pv@o~*=!@YW*E!!)i7?H4o8x3G?I_$Bm{Yq{Y! zWEj_qKO004hTuj=T zlOS9;hQ852addw{^4RJsmI0a zt1?U@?tn8%3m$++NX+EMnRyLk@04rA!6Y9S?B2j>zOuN60wVYnD29$ftE+6+@c zo8qcc_AVZVFWzYNISkL7kP&~bcEj7etP8L8!P{=N=F*+)tn77DsCmfaV2z>Kdt6ZE_!+xM0aT%$^ zL$G*pV&35I3HLtFy@;rvQP^!sqJ7wNDP!lgPIxs@9WPv%@DSYbqSenB9QTsdz85Ye zsvm@#5*~%!f>ybCnfnY;oe=yz;W5}}nN=QmCBu9{;_cM3Mnv=GdX+OmgMEve6|51_wOsHy{Wtdwv56GoVh8cy=55|KO(9hhSe*%AJI+#_W6kZ z^K38nTg6$%#Y;#NE{-OxxOjb{+zV$CwJE+#DybtLBmvy4&M@=#T;^%94@4&@hNIM>d{lZrJE;yIyT#K)fI_^v2$7B^Afyb}4>Wk--^^}X_Nfh_O zdx_RU{Ep<%Px0>0c`wGrN>YrAZDc$y&iI1)#Qm^|sGTUB(ZF-U2YlTMe91QF!fk?q9Uyg?oPCd{HL`PxzJhYs$s5NjoksiSjH*9kKTg_AM@+ zMhbC1^!>&)s2_&Mh~8h!?-}On7T&Krvo0`iC+mef;oW3qQf{18f3hyPIQ@T|0bC4_ z9O{eZySbO)J~;d@o(*s}yq)M;KDhgD#zlDyPT0phCo@L)8`1Mp40b=re&Z}S;gNRk z;atlcVO=^nU$__U`)BK55W_Tah7zxV9eM}B`yx@WH*7- z+&I7QY&W&IxQ{gBCfROAkUh8k{K0v{x8xOmD%%zI{ToR{Ek+ynn6<NFJV96;!Ls%55THR z?Pk3kMy}wsxH!U~sq_;UdsVXDxD&ojbPo@~-NZw==$=L& zaPhn8tP?JtGJ~^?i-lx49)>$f{J8@9{hYyV+(Y2ZN3D5_z;hmB>{-kS{Dc(Y;!k8e zZf4R3X`@YXOcnD_xj2*L;Q@HxEUQgFykxfJAvo%B%RTTY(LLPEv75yt{&hNBP4vAO z@jKGUT8LXnD=ucuWk2C!PvT%tiWdt zh7qEl&k=jfv-3AobK|@guhJfXeV^cLX6MGaWF%xlF(OBn+$zEAQT%pu(T zBG<#kp)WIsxH$Sv`izTHNeCC;BVjxY_mWz*52wGySa5M6S&s+dQz7nOU2*vKyX;|J z8+ecV$@^UEIL-*HUc*?Z6M`3nSy$?a50EBYY$SW|C>-%Q_a*9k;KDChKkirJD$+q6 z@epxPN9^BVxp-Z|#YYk@K1%YbAAom##Tle;J~)S{eKGZG?w`~V$B{X>7akx3xbKPf z@0d?qJcE?uF8C0MKO4ZV>)8{u?}S^4{!OJQJVNyMYQ(QLFm~D(`+U#-#9gpsBYT_g z&zcD5g>=x4Sg@Hh)h##9)A1tQ1-B4=wh)B_o9LU`ftL|ISBRNg7z^!)Hf=-R;;aq&jdf{W8hJMM@3Tet@2!u-Kr-p^XofAQvnw8lx0*+lpJ z09=!BN2g44Pg16tSU`W^pw5}bgS%isa;7Pj!@4e+eD9n(shMU!(ccOaC)qNMjdJlZ zl81+(JuNf-KIMR$Nk?DK5j;lfPRot+`)-+LB`*F<+VLptl#^+4aB=zxnf$$E&N%$K zdnUgV$y&fBQlt9tp;?~h@)uSce-&t?95W|~t;1Q$IgWttXTtRuD)bK^|v zMgMVeBpHBv;Pt(!)06iLIQryFex8ea6s#t0JOEorL66)xFF1vAT%1J4;y(B{(cf{6 z!6AJzji2_#^88E_z{TfC2oJ)mPR%r7T(lQ3W?a04%yWDzdLNG&e*7)77?x<)*I zG<%P^6-SVK+yiHl#*=wwfT<;%Yh27E?YI+;CK{vI>GDjooN_UhG~f<6iVUGmaUOBw z;w@uX4_us0DsXWDslo%WfmG6tc)Tam%)vz`S&EDI5)WrY9Camo5f}H6N<0ShuA3G7K+JohHr!Nto+ z2p6v=VO+eKL~tK`lGyWe@g31xbi;sGaiP0?zi5*#2@9Xi`Yck@F*PqfK^9q zBFiZkePP$F)r35%7bvpboLDG z1mP;8`-b=(sq3w;#WKxSvI-ZU_p{cxxQxVb@l9grr}zPJ;9+=>jOX4Wh970EadF0D z>@i%NOBUe)*neiGNv2KlB9eoP6RKEaT)dTx$HjG|0vD5Kah7qhE2+Vq@On~9`{L&$ zgo}e_GZtK|BrUi&o3!Bpc!22HL(G4iK5%~!myu#z{DPF?;y0umkHEomtk;S$l1#aH zh&XXGH`BaI^lTr31Lia5tc45SLi9VH;vK}t+KGEe6)tvNz}dvbJhB}3z)eJ-{W_k^ zG*1)#yX`^vWq|SWwVv4bDcZutVV$ z8yC~g;M_QE&$9=HaMqxU8H5jWyXt(Yselv3_Hjo#xCB!jJ<)2eiFvTmtWz( zng0-MtYtszIS~H&Dr3jRy4M&BF76=Xad9`9h>Mrh(GD(tNNR9#2U)KA@c1{Z*E-?b zM1M0a1b-k?crF!ttzg}8v6$529(afToAnh}DYPjbC5^av#oLyPQxh)MkUi81!Ux{5 z<~#sDOn4aXPq+!OKZ)*jE_heMeemD+xn~Yy|E$b386WVzjEgst5?oyP5oaG48;Bnl zetn0uVp_E$c^)-FQ|`4Vb=!sUVqL4Joq*1 zg^L5$5nL=M#kkl=O7SS{`VIdN7rmqs7eD%rzTx7xqz)Iu8+bm)#WCNrj`TtNlr-St z1wU{f$Hj|D8!k>D$pg8M!MjNgE6TGJ?es-5>m_N_SbU)BH@%SbCOe*Pcto4B}# zs5}P0IL3W|?>R=`VABI0WvaIie!za3Nt(|=R3s3BmWr~?|C+w4-6~9l4 zWu%HdCf1S~JOt;&mhk7yXHHG2fLH|G7KyK2ks(aS0iQ`_Ihc`w+|<=Up5_8rXZ{ z@KIbB7blM9y0{NUNb_0DGmMt7UbvWXIqma)#|HaE`Chr;Nm_K#Le|tX8sLXrieDh3HLHK zTnzZwC%E|9ef0lD-fQ5^4=}fsi;c-3!VBiJ7PvTL5q-wRxnvz4fc>7yGD{coy?!|D`7AS@K8V$% z91lS6GUoRszV3!6y+S`2yEyz++QG#N(v16I&(}E@^w|j)kz`zKeS>wu#oRZuj7xRk z6GWc}2H-oSmS-EW|MDzTkBf^*6E5x|F<0s3-QxcvJFG#o>dJ-= zk{mn&e;~QI{b$Z2QT+k%VWKuG;WLTy8hCA!wI9aAmq@&Q_<6z`VEPv8wRU(>!i(TD zq=;+Pz@tRxr~~%hYSk}*)kOPE9KVe*^L3o~Y_m0oHE_vx&K2z}g`0``*#!IlVvT(O z98T0XH@qt0V_`W_eX%OxV*0P_Kg|QYKFaxhp5HTtFB8?Tg}V~I2cEUVDjx!85zYA= z_&*XqFR`nQ2%@UnlnF6CnMKh_Hu|082@bBuK(>u|BN$u@O(GW>@4 z@%8XOqHCE>+2&-TeUc9sk}}nSg`Km_9<>9nP0o(bZ8`j!=(SO}xJ$M%=W(vZl7!1_&QPl>)_cr*=C*U!&gWQuZ3;LTVofm=uSJ7d*F|`*`^vFaALOk zim06koY=#1@pV!>jP_yQp4su|`2vx+DHne_iFv@A;KRMLO%7fOZ||MW-<{;S5$-4D zcpE&^nQbaB;Cn8xnP?8hC;Mc_e>XM&7oN)eQhyPA?ljA5;F8lVxA)679}?aFm-o*$ zr2{OFiUXNX+MhTm+Z-hNcemT&g0rmG2B2f8<>GVaSo2>4d!K8$6JC2kwrQmgj{c-~di;k9mf_BEU@JO+D~QXhB1ckgH4;$b-ZQO1i0 z;L+LHCW@QKv(2ITj1g~#YZtI*@D8}_N%p{n>>oHfV0j5V{2X&lc{_Y%F?(8dVDeJd z6c?uvt&1NXNq7gm`$cPR%i-vtENzMz@3R)T9nSk9 z+sx6mVBwF<+he?!!RH$}r<99xH)k6cE;f@Qe9_O0t0{3^_}Uih{MNw}wpyMGzbAUX zi@k!LUkMwD?pAZInXT+k z+zB81ANv!pf~V}_-pl8ZF4(@8{!=b`|Dr#51Qz~nx%dWA`^({}`>Zot04w*?C+ds& zZR|fc_i*?HapDc|*g;9tb-39W9*by!k3BKtc9*l4*m@g_A_)OIgAGvmvnZ- z+g}PlNOr`3CZryopW-mdBlx*ixF*%|Fg(-dh>v9mOiOdb*VGPoB)kQ>G90E!*Mdv! z4zmXrAIWsY-$N_mjaim^VGCJD9Wf)@5kDh#I5^=$;CP3_xap7BqpKsnfAXN`IQl@j zSefH6rMP(e2@W$6p9pX2;V>1r7v9v{VQTPZIMwNh-*W=+FbPs_PIj30`#MY=9)>jq z4pWbd_R}5l??H=i65XSg!?A-Lrhz)*b7wGi)rVDQ(mu~Ni_UVGy9VQwSHPQxGN1e` zO&R>}0>(R%>kfCAZEmZ)8CH*Q#NW%r;Ug_~!zj@n7T>&xYjEEdKPqyVLfR2Sm(WjK z>~X2JUU~3iqR-)1!OCK*9X}jB%4$cvb~JOyYei3q!}xIVuQ9w9kHMF(u=-OA$9XIt z4>PW`+zwYKy!a~S`D(_)Yb)V9V=WKCtwj5?8K#W0JOXRSvli43!PiO|4_*iVonXzs z?IwpALiAeEn{aWum-^gW{IH4C^IGwro0)$b?=SGuGHcz7;asA>d0q`Sk@)j4yz_Qz zZn7xz}NGDfhtiN$e#)x3t5)L}M&~BNJW(XC&MYKTY^5c#Op8kIm;W7m;GxEP`eC zIpXi{;_GApu%uBd<9nl!eU~R(1V?_PQd4Ro7;(ddK2^a54xDWahF1|_1 zx$bh9QDL=jhqn;56M$VFw90L;h!nrpJ zu0pVUjEY$N(z`lXIEQo7Q$Vm zgz`Ob(0r@h1y5Sw;BQLtJ_`$;wC?BPt;F~L_Pzx!#`Nv~=|CkkNe8qVLOG=nWmBW5 ztXAWkb0HP!pfFA~C1i=5Lus1nFx52ANL7{V7lg ziUpqsYymOAw*eO2u?nUI7K@Hm;oZX@PRKt#OAMnMW>YO zihwH;mF=s5qmq>E1e;X+E8x)6O1&(BKd5*Q;3ZH#))E6hfCS*%fIE^=Bf-Z24LO(} zya_Na75n0fGY{}k8sZK75uh+#$>#y-eB@HJ6D$A`TM?|x#CvG320jtMZ@^1|ZaK&y zs9Em7?sM4nBwea^U0w_!)QxaPiMH$^m_r0JmI1{RO`b$hxe| zfdmH?Dr0aIumq&I?*p#6qU6JYYp>F%BN!V9l!1ty37#ub+A|;60V3^qD3~e*k$n*Z zyIn)=##rlO)L9VevkG`Z#U}#qsCWsm+YMzOZD6t(zK5|KVB$^0A%0##aQkh{k9Ib2 zUYRm>yns1(lzBA|sD2l+qK_u9zXUeHdDs-Fb`L&^?_JRZ=KqHL?~a@R995;X3BkJ{ zVh8-9iV6S`nZtp-AHw(0p9W-u7~l!+u7Ur6j|X0Vj5-Zo0xYb>ISIT7I8lmq!G{Bl zo+@jf2{1*)OMw2*;Q#1D@D3=1%me(XPHE?Tz;pH3KeXoq8=otAdIMwuk^D)}Tg4On z03vg?0Zkf}eF)}*639Hj1{v}Kco}eBld|0#`06F>jCO(pUMXY56c`I4KQkd1|C)x+ z%|mzKgl6Tw+W|d5Bv%k*yurHD;gi6dAd>gWfUD%nnoe->Ti6-%ECFr>5nW<{*FbEH zEe7`a9b>@v1qOeB%-}HA23W)svE*0oNSI$Y$e6T*gUl4tO zhll7>G2o8?J%;L2OTZHpfQUa36svfGJ1sF6`osc1gUEL}(T3|&wjk2q4(K`pYvF#x z9as+{_pJmStYCk{H9?MzQWt_d$HER|PT;0-`ik>jEbzPW%CU5y1BlG;4y*wY8xkCB ztJG^0aE*!&1oA*~%$W*&1!8)@XMp`DKsV%n2jF=-eTs&5hCSW~vB1Xz$4$~#ocGFr z1HM&*u(jQ23g75u^JOebEqEE@tZUTG&Y6o8fY<0$1@NK{mF4#N7 z%P8OgH|z!4`M`nGmHN5^BSEBw@`21Blrj*!3L1j7M8Kgll)7627l4R;ynrh_FeV>) z8z=#hc?hcisO+x^>^T$dn1`UYr_!DTk2CctFSI8BTR~*bHsJTOl)mHud@>ulppO(d zU=HF6yeaS%i0n1N_PP3sb2!1D{IK8XGu2<88Wx~WiNLdg=hwiuz>iw1Pi+N}wYC8R z12HGgT`|Czb?|%iAt(ot+)l6|1ai+r%mO{uV{P;ysIftxvP8Qk@CJzV7XyFZi22d( zut}d<3nFU;0#B*UpUMX>0;X)o*gc3T;6OI?LOUJEkJ88U zyx2$J`DlGbzA6CP?NIs*!7ZQ=^w|a!fSBORfZj3C6LJ#V1R}DrfM-;EKCoWJ6BO^n zHO3P3-UWTh`3?Afx4xoo{tmpeN1y7u1N#mf{F8F;h5#8LGC#pi5cv!XwHNP$h^+{+ zK%`y}6sy`Lz^w<7GqG+0aNZ$(MSb@IK01n6_Jp4UeUB;a;}3iTBKzolTpwph$VvJD zwGxzT(SQd)Bo8M5>p&#$(N98VPy&88#{jy5IN+H;Kad!|V8`0XBd_KpMD~0Qn#$$f%?@r3X?2y}!|$dJd`pT>)i+ zj)GiEds9vz8<0835TpirjWG{EH$Yr5em@P014V*DK`TM?KyDy=5P1#0)ted!8VTwL znhTl=vH%%^wt)OVA)tjICWrwt2kC>dZ{s-{P!i}E=m2OZXe%fbfH1WG%in6Bg^#?#U{>R-Hl>o$@ z7L})H0`v8SzpVjYjCOUP6iCLm0r8jaDViFEzurqxmO%V9L42PTKDH0^0^(cMsSqIG z>x;~ViP*9K(2id?E7sxsMLSuy;4j*BAb^BS_@|c|McSo*(=Pv;c8VxcJIGw4?#QUU4QcE)z=qOZ2;v#jIMfdvkXhzl1)^-SOxC@^Qb_3F{T2O4`#cb__&_yQqqGUq*-lMT5Fo9*UI z<&>Mgz=fvYlpm+yk+TE3?LNf$bVA%0hEY`SUkIs{2J=^;v48k9ukbm+tHU?>toOy| z69R(5t!7S}OW!!o%GS!p#_hfHM07WsK6T1m*0R@+D%RIr%87Ye-?4mC?&qY?&iR3* zx7ghoq5Mv(@*L;sntKD+2+|VGvOnMKdU*O+ZEdB6Oyf{p%ec>4PSnK4ZZ(hIeST@- zv0pE5=`F2QVNax2Hg`;D>{b3&Lt^#3*M%7$b^MR7r^2=|4i&ODragb(Xd!)47_o7< zllS^ zOCIY;-+JmwQE|TB_Vk4vY*vJQ<$Lq=4efmr>pni;SAHPjL(1K20|G}5QjCL?8V z2DbMJJbn_R#s~c#Bk}9+loHlF!D+=Jzn0_DO5s3JWn7M#&1;wB9TThPJ9~VVSiA~y zx>o5>WJ8v@)n+`TRIA>6#lzi>_uAO?HS0QJ1HLQLY;4m>8aK&_G;3kP!ie*+0cM|K zHtz`AxYc=+dAe4l&V?Cwo-AL{|KcYs^HJxD(TYW-W3Jgd((QSWdAlr3-n~)aSX8-v znPL{7C*G&_Kz`4DX7N{4182yaw2I%~&OB{qBdj|vO{~-?xKzKIDip3nWnrrn#AU8I@Ysr&33+a#X*)IPs;Gn9a|_Ux^Ti9TkZ z5_Xn3(u>EJFOLqx7BpcCCUy2nJhz2fF!53Zu|w}C-ivjJmGUlkXfAlKvAUMUDgDxcoo`x__jQmE;q z2A^;wJ3KCKA}hG^rJKjgwxM>VT0{K86*8H&$CSTS%bZ5Gq-;Rp#mW!IG4Q}b@hc6o zO@95mbPk7IB%(si@7ea*cZ2&X_tDPpBDE}ztdcO%uJom9!C?85)o;ew#JzXg{p3;8 z%LS9+1Er9;*+`U4OnGK-=gw^9YMvs~yTLulWMd=L8`{|0rYaURi%-1#9Zj{5B6}W0 z{w!(qt$D4(+C)^nZpu*XA(2t5CssNxz4G|Aae~4g<&V|9)`csKDG)cQZL?L3D7-eo z;HxFu*ss=o=}S~pZ_M3JeJx5}e6&R%@* zc?PUpDwx`$HVB~(4~e{9uZs2CUfXvFjmSP(Ygv~TeX++E5jz_t8`GK)5sD0F6{Tq)pY!R%GncC{QR@ zM|Aol%CVx-iU%L7+dXPjgu6k5#n-?&Q8|&dL9wD8NkdfQAEGMFU)WPi{?$iL*P4(W z^ljHHd#m;_HlgGr7Sm#lR&Mk*Mgs}Jzse>yx+k`?_rP~N&V4eFsKh(>X-1w#0#b;p zQm@|9Dbf6QIu z;*uryn@*{QonBrpgQu8%D%@8&v09b#46I9u_4PWxBzBUwzNQ{*pvr{EAQz4*1ysBF zwq3Q7MfiR_u^XxZ$^Z83wZyAXK$aJ%Hv0Y8_L!^2#A-e$X2J`Ka&zmC*t8Kuu-|-O z|2xBw<@Ce~yRRN}PS2X`d;pS}!snAJmq&jmx}vN(W+R_z%-;L&B&za-9aQaWH5a7D z86o8_HRX+Nb3H>2G7YnwH}oJPYB{NGnzCqTla5uNEa!RrnN#4C7G-K>CoV>$&f}k! za+94R3p6SYiCeIO-)fb;5e>wk!6_r~ z*6}Pew$e?OH5%{7h+rS>lux6-WIe$^(S`;$EPc^BhD<@StwzGQV6tw6u8Vf%aHN>u zJ=-&6b5^%dIXOWc?%B)^qg^bo&Y`Tn+tc3~OtNq+s*RdV8fjU}vrq>WHMvavtdpV1 zEPm&^&qaqVthrFurp7$@ywgiJq7e~pr1c6DV%1-oJVlW{aU;>G7i$XxgL+h&H0u*f z{JCS^Q9bRoOQQ65u8F#AmX#D4#oHQXEm%20vDTkN-?^q| zt9GTe!Vl{_MVklewl@dQC4JiprAHL+&Vwo74OIuS3M)G~L}J^0WFJn9gtnvR=9UCP zo}(!(bpsU}s_>DPr=bjfN&D5;3`O6&h#6GO(!LPkx}FHKpHxbFjIv)2Ef0uEf?OYZ5}1ROwESoX92e0lU}zaebA|Ka3z1_@k`y5;eS zt?$j-oLd$t&XKR$hq89z6#Jw{aGmg~>I|ef=RN7MuRxjGFLw*MaQCGf3-Xt*QS5id zK4k6di=*_n{&8^E6Tc$UkU@&WV!Q4{W0HAxBuoDOZ1l$gJVK}ZZL;+@Cw|t~8->;j z4;7~aQfQ$?B8vGp_cMQW^tQ&GfvOy-4l5Hs^$FZKGTV%1CcQGcs0epQ?>mFa2PD=} z!*C~JDjG7zd;k65un6^sM+=K^%SFAOO=^?-A>)uR$7`#*q#9=@z6r)v@RQm*o5_J3 zcWx8T{n*j=HZrEZPx$2tJx1e(lA1nk=F}W#@92NNU!~Z1o2|HC^;q&D5f}fW`_=B3 zRrjmMD^~C(_3ZYjtLyRQH^ygIPB^3Q7~@huyTSMPqO#C#2=0s ze_!+?XUYB1!(NI;1T>0AByJeAuu(iIc$v?^+uCK5+)tY5|6H_KIw@$(hxhxfLRf2} zBGo(VY6mvk9i8>rCA*Wmde5wn`JyYoZK!zI=dt$Y%b|PwO_R=&WVtL82OF@$o${OF zkC(`dFJ5%YFX6j*`Q}f|YZz6b@86>LG`l#naIvv)bQ5i0hbX9K!}EznjAib}OblCf z!^Za(PO5(}&2LZWIWn@wrEQ7ix{d|kI@&1OWs<%Ztm;0qzEn3VSFerG?4E*hwjFOwd5mANl0^M1m zt(%nVblX2Hy+QDvYuj+Km(QjpdikGr=biH0Yrpprk^iF9=-;_HT;|;XOQGK1X(J>#=DmjA6{3V0VeJDYAkXVoaRpo=p2}t3@l%?#laV zG3Wantwryz>KquD@h*sTzG!{PWMXrtPPR3@SfQG{#Inf6BkwzFBHq&wUTW2hUDGyOIG!IT0u1H zaB|XJ7|gjPGhWiFG^2*!jm%XooAjQpl3bEpp}n&*x84d5!T^Ep{Lq%&^Sfx}eUj!a zNK^QcQH@r4pM*-YMV||HhZrs7^6c`hYFzB3f=dcx1f8AQ%6Qr4VmET;^T(I`*X;?4 zDSW(YPiS4Uo^U(*&G_AaLj^WUuKu_qX`V6J+Na5bC#ehT^n46kBZ8Vb$u>Gy?JSt) zS2=C1*#_U#U?61&+=fAhwu=Dpwd z*RMbh^uAGPMcTdx5W)=|6zM??f}Wd(#bK&DWwCan#Cq})_y2m zWLOlb9c-|93Y_lP@|Np0(vnllS;gfWHa}VQ@QuFHF9)h(W_~`Ce&bx8QDLtN-5X}a zlLcothW=hKg70?OY-@nCh1bfK=h0?Po1=DSOg!lq@ZM0;WOjY)Gnq~EdadtkWja;) zETbp2g&(4c!*DkYOJ7rrp-L7MkYGW4a&bPo;oNjLzDOp+b+#qZzcVeiXPx)RtN?Py%kuv5z+xcTn&)(yMlJtvneolhH`e4_DqTV%(X zsy$jp`BI&#PGQwDi6Z~am)Y34+%{db>uL9?POpo4RjhqG%45b`+LK+f?jP?g*eySe zBzGY6xZ%`R`X}3nx@WPS1G@T`USE{$&>CCF*^shzQ2oLa1GbqaG>&fAQI;|}y`yuO zhnzR>^i+c@Mn#2Q4yD&Bx*1$yT4@SxTH@mGbFO|wG_#y~J{2#$sI{oW#p}lQL7(d+ zwO3O!n8+r_WUk`HA$#pLG+XIg2DIAOE0S!wOk2|_){$os`=qqOm_`!ko`^<~cJq|q z{VY3DY+Yf?H`+DNGD=e_onk6Ux*)#%@Q`hcoAGN!d+1`xWit_limJZv!Hy%qIz-6v@!^ph{PEbrM^s6O(j!iuAD;CoYm0Tm^8VM;oc*H9{o=4{PDx$mcCJrht2M9SbD$Z zc>9#gqgdDuV;@r>B9FgvBsmu*(|<9e)7p23 z{tzYLkk|0vZyo+G{GEXw428cB)os{=i~qd8{~!InL*p#* zcz>7Iho`JxY}3=__2=amAM7@4^NADb&H2fAVf~%)zV5W>(a)!x{urs|wup8vC-I}K zYDQp{`gMV(ssH+n zn+5nN{644kC1oc{!pDZb*U=w0yS#Yn{l*nB!s@YuSEq(o)%IV#M1HB;X6NrdWprO` zzA_;+vNL9`%f9Nq#e3bVbs~D(4xThZc)zrncd|Y+lAB?R%L_v-$43 zgZp;{ew=D^eLjEI&w7(q+z32)(XrpAK~{qrjfZJ{bmuT^T@&}5@)U;{x$Ev&!yR{h z=8HX{zs;GkHl$%?kLZ~tOQi-)CI>H%Q$Lp`J2rgmnPtvpbAK#ze<9e^bB0;!(k?1` zw7E-Z#!42H=~1#}SN{|GFZ|sbwT=2M7&B;f)&!HdPyDu5u`(!L68f@joY|aFt7>)@ zXzr_RzRNEW4ESZg-d>NIZO%#2f$Pp#^M_3`e|6-vNvYZCAHq}17ol%A$3f3u&7Bi} zZq~3Mupak@$C}0E8MK=Y&t#hK&_5n!^yKu>P{Vyc=XQJHFFuy;QqtlX8$PLr?cx>F zwsTEanBnu1YEq|wcW*xyQ{tVvBAR;vHf74BX0ZhGCbX%y6fKXpY)Pm z7yU7;zMWgg?{9c&!-{SB;({$YHoRE>-GOl)eyy?lvg-@EVY@15m9kHZf7z$Y(w$Y` z{!BQFV}9>NTX^w_YNr%obYMX2M)%>a4{f){ANr}hpR3DU!Q$ZUV{@Y4R`vVN#)en= ze$O-epV~54Y#iIXO^3fC-G1M}Yi&omtv84mxW+x))oZ#L|Kt%@-B;n;j;-jt#S=C9 z?B*N}RlDbAlYVjSP}3WmF3|1>tmIc*Z6@?-&+_zFn-jmMrO%4hXAjLjmpJ9ls9n1j zs-0Z2e7x6zhCsXP^UHQeZSGYQ&@j$@ys@)^Q<#JFe3_#}60-Ef=Ev7N493DN5> zI?^^TnRf9vi@Hx1#n-LZ9`iCeYJaQoTCAnqAc^Wf_WJz#!WB=nUdj56;{HtI39Q;; zypHVcdTlkvG94g&MtJa^k+}?VZ>7A4M7gpSt^{x!B znipnKUcg9>|JD9z;2s^fq`?LwZFsVYheMAhc5NBkY!=!6mgR6&?bv4{;njl%O~?x0 zW|6snP z`g=z?hh2HaGpktF#-;2~#_*A9-g0=);VsLlzDGl=nIK``ij%rGN1QNva}mN zQ_X?jXSloedTrj5-x`Le?$DIa)mWkCIPL7PlW|@)-LU%A;p`u5emJBRaCFZrjmnhJ z-!#{pJu7jnW(I%;}(Z6hu?wc@kr21=^4>nbx!B19T&_`Tpd1SsNS}m8>Tk~EZ?zO@bKlrF~die zO1;MLqDPLlb&k4!adbD&y}vCwY9ITdV{ueUg_|4U*4Ew1TBl~xrWHk@2bUNq~e)gS9JuOMlPO~qLjQB41{=^l1Wgl#p zJjGKB{}7&kb*`nO6I~IX?Iy2zxcC>XGdG#Y>l7y02wbb;YhS>dh3P+q>`E&dhsSn44k$K(FR? zlHX|IN6RBkYW?n0SG8=-G{jq&0xfZ7#H7o;Xq61LZF+^xY8QeTp}vzta@GpZ*NuGV zdN=Q+_R zvs=)!t+QU*4h!gL&`F(KIayR{_Mm0v+PEz*ljUpHy}10Hw5-8)l0D@e7yjy|btAs7 zYjkt!j=rDE7RIeL+1GdV2Th*SuaXx|-8uF@@q2|&l=z1Cj}KU4e!pb-LC5v|IG0Pe zd`}IK_0`j8&y9B7VV%Bz9NsVbL_MzAt?}uxxg9;sOXM%Ba9BH0gDP7mI<`Z+d*_;_ zIq^ZGJ`B4Nv&n7tmLbCFYnBgH{?lcDzeOwTxjJ*n?T#vJ{nupv7w19pD3*!BPl64z za{qOHLNyaVvGYtiH04kaZu8L z9L<`;5pTD>wqHAzerpX+i{(7+?YA(Yt-bXL-Wfpt()J22#G7P2ZJyX>!$z}J%!YuXFe!HViCkJQc zA05#)SSasN`*IG2;W^;*;6wQtz(c-!%3`UbjfIN%%VyYuSC->=s<8J2x^2wQhR zRPjc=CI77MtBvdO9$sWNsU1mN&lrB{eQaS?bdmi@>F4-;9lwmfqL%%g+`{f{W^FFY`%_b+ss#*40^M>XTDM~)f%LdY|;UAB04d>ou@ZEW$gRL4s{G;(c^Kuy|Z(iJAXa+i{B_&tFG0d?z)pS%hf|7jrs;wE|oVw zyr^fpUr=%JH~*0J)i7T;wVn!~ zf+#=C7C;43zL+_PT1}CkJ!mTWSX1Ni)TBLVJY*meu_#N7{nCFb#)MHT74w8(z5t93 zQmne3@}V|k&H!o!v|0r|2rcVyy%N{TcG71(-l1d8O^W}laQ(+PEA$PP2&)gK;0Q9~3yH&>xs5OyOFJ-_t<9nE@82Pf9LK>9}C^Cuo&VU~rJ{WQ)zdVHQq~y?QwKgoXL8TM@XK zjtPRoCR=P+A2ca!rN8ewpRm#E0#>dM4#RVfqgMv6o8%L=&T6BL1$~`QP{3;6u<-fc zu7;`TbcgWu8^Xe;2dxfP%{KTym~Gr(#W;)%^If@NeL(nT)iqky`-X17D!!|j>jO3h z1p4~eo0lufmE=lu<>WvWVuW0T7l+27bF4WG4wK`}5obs;sx!1R zX_+ROM0@v4D$j`Gpc_-6CkvX!Le~Un%g-u+zG7%x4V`7sT07e$+Y(yaL2vhL|7=!v zY<5C6Kf54XoL!wQ%Wlio7MKVu1$F{=ftSEvz!Jm?5(Ioffj}&%7RUr`0&Ss*&=UH! zK|^imXaX%Qp{E@*b%(BA(AFRNvY>G+bcSFeBdQuerD~_rQcY6nsg|kMsdlN1RQFV7 zs#mIas()%oDl3(p8k-uQnvlv#<)`MQ7Nm+&#i^3i>Qrf}ELEP`mP(~*r_s_((&%ZH zY1V0WX^b@YG-jH2ntxhI8Y_*R7Mm8ImXO9tNIJZEKQ!)mPVy( zr_<6+(&_1z>DK9X>5O#ubY{9&x_7#NdPq7eot++=9-p3&&PnH|=cN~<=lzrI+Tb(V z@EQ~Njb%3UksDF@02<$fPv=|mt@(C*2H%~}7LKk=F;SU{RAwM6oiy^lRGHb*0EFr5q}c}3xr}} zwNM7X)P_%5!XMq?i~jJ#*qnqMeojG-IHx*CmeZD_ookY7nQNEpp6iwCpUcXP%}vPV z=N9CObE|V@xox==4WE(5zG`z!IF=kcjyuPTn zW!yHdHqV4-$+P3R^SpTeJQgpOm%t;rP0Xw2$#`u%ZN!Qt;=~;>;*a=eFsyCvPjR@r+ zIz@;~DWZ}>MA8wB3`Hb{APVCVfq95N2_jF9sG}j`tPyQYL|O=jNKlI5wc%=w_DS>B7;hTSzQ@>P{yl?6W^)(+V>j@Kel!Z#lM;$FdB^4`bsSMS$ z4fRwTmBku$#T!*69yLXTiXulnp$qL$Ly3k^K!VSO1M-lmC@H?*1@|=+;=~$J;*A)I zM}&wFA96$o9VY|p3_JLayXu7C4-aC&hhpJH3GgF6JgES_q^y}zWH&kT8^za#SN+$? z*`jYOE=T_S!|Ik_D>)On)En7UY5!Q9WfE|j`F0x!bG+A zM!gTg-mp>g<5BfF*rPmDei3TF1bZb#{g>keKnb;R_A$Y}S>pU-hZB%H_RkBaAhL%n zoP=U=7D~Wrh>!D70Zv3>oQbM&Dw6#t&JBNfxd@qCg4``d_Ld`mQ@PqWJDK40WQp^W z9Zpd0I74~i6y=X|6bmOQWmIsG)$@?oMab+D z1C@Y@TJU!_d6hT^4)rzKH`lB&A* zyZtNtQwDyVpW%PucYhI?5wU_|R-bbK+rXII=v`tmS6o)CSg~SV|GWQjd02h>pZ@Lt z@bCT4`0Dz0d^MV0UHZ>Q{nv||i}CG^`tl$D?Wa%w?&8zG+5DgXW&ZbntUvvm^M7X? zoN3@p17{jI(}19X|N1{3KArzN&5zxs6k z?~H>p4V-D%(=eDF#KUM2F7mvN zW_N!HlUMh0T9ru<)UzKC?pYDF>FnShT!l^3)QcpT<#p2BUEWRYyZqGVWsx+q(eJ9| z-|t59*ElGmEXh*ws~i1InO9L>=dJy9diR&CzWYm5iaFl4d0b@;Z~Z#|T<3M__0KF9 zbybE9eI$7q=X!W|e@RL`PyVRyrpa>mxLMy#-}ZOY{mbV0Zo1t)+9}XPS+r>uF5-V) z6Nk-`#=IuNS=BD0IF7@AUK2kKySI&M!;K=E(L#|&3}<*E%;RqQvOK))mXD8r+)W?% zOV>g?Ym+8u=ZoZD&;lcIEdW?nZ5ZaopSAG1{H`$i`o3CiUL84w=`0G9wvOWJCoPEO z=y3VA`P~g7oyFmzYMSEf054 z8r$GLn*TC4#3JyJ&Z?qKpw6FBgkB34VC@j$CXvmOs3@{H{n=WGN%REqwsB45vnY$| zA}(8j%0&12ynIr0aM*v}>E3s*chhGFxtN8`JPfMEPxizwo8R9w5z~-eOxHv?OT#3{ zsw5Jf8%(`++e$WJ@!&O)FNz{Bf6|29nVa8V_6NqawoOFySyQ%UQ#7D+Xmdx)x8>b* z2?kdCHIvcJ*d~(2EC}nOY_o87H|BrSr~QGqcF$Xw!SWe;czFN%dUt!+=-%ONf`0*> zRg0z!AS4Z~TKHG}PY$TalcY_$BQ+cBJmB9_#%*b6Gy#zrL+^`}>!}?)hzd zzkhk#?Vn#iZM*NEUi*K0fnpTaZ5_^Gsq$$%PY8utfxAnoke^p1#Vv$FMnn8qk(SA;Y*#3NtU=*{h zve`2%p)G$AKSga@h4V!@TkQ{r_ZKHmT_boEIWm>krVv}M7ZqG*p69g6PD=B{by$^c z90v7VcbIbqxu5DVZx(UgLuHZM`!`WOZ}TcGW)DjISnpolXm08z&8sj=X8ZTI{q||| zWLvzAn+&mtDQK|Q-QPD3W49HeUm7lg?#I>JA203zx~=LutQT?9HM)j=U8_wIl~olK zv$s7+dt4sAI>2B)3-V$Sw_!3Hk72nN7yAETAk*>Kw!v$04dV&3VD|R8{&F|{v3vUl z*LZyS=6d3-Dy)O3Y@>dV`=^%!G6!TVo2sHJh@vEQFTv_JZ{POrI8jYS^`Z%?(7d(Y zJZ_%9zI}5j;iV>6H0?a;G4}Vz-NW7V8#3RU5@l;G_lpplkQEbBh-QvoMb8x(w33t%uE4A5tDI@>-r(We(ZsmHhU;-99amW!16g zFcHk!ybU1f`K*(zUY4)W-ve*U@rN@G_cjQsw4=|>^ZxxS$bZ@WzIhbb2xn==c3V_E z_P4u7JYK@2yWmCYi^^QM^X9v?Sfmybpu+OZS|h(InsvSrBL%Mq-+RZyE; zZRbBgqr+}KOJSH{n`N5YtvB1OBA){WXz{PDV4K0oTYc5K29lS^7ualuH7WR_R+G**|=YWMQA ze0fzIOl>``XUp%1_>h%^Q-^6CfDj9(Bm=VnkmJ>HVK#;YETef{SJ0RRl+v@31nib$ z#vWt|9dm)UfJ#2lv(wk&2S&PGt{`bO3$>~aIG%-EzULff4*FxatM`WuQ>T9knKWsT zg=sk~yUUi0_%E7BW((94RojHFbB;uFZRyriV9a%%&#ItmiZTtQ*1*m`ia2dxWe{;k z9PTIy3l1-i)3}7En3e5TNZ+#5>hxry)Cr*7^;*mpWfKHx7CF#%`M7ygcYOu@6}r&u z^NrmuBqlm-o2W{VQihS$Q*(!>{?6(8E@xpj&!ZCUL7;UY$$?8^$M)ft5C6DXF>>fx zfY;|9>q!aS*p zrd5K3qq08ULE!?s^9OMKuz7Pwj=C9xfH+%ZGsEQ&k@az=PDWVI%gf_V;Y3lXQ{_d$tS*rH z=5;uW|DkQZsLnZ9==Q_^)D6^rEYfJ9O_j`;NWH|7YM>vJe=B!QM6)1i;;@)!e}aHk zi6dr{f&tk?GOy=Fxqu&bC-d4Mz~i7`06rn%iZp1OEE4Q6>_tk2u8tpctc4xx028FN z`65gjh_&kw>1+4${@5KUS|G7#mtbX;WLZ+65bHMPsdfIiS7i%Tn51#m3NF}>peJ<0 z2)pg#Ak$eH#c7%%lv!4052*v&W_M6i=DM&yKr#+6o27NW0Kae*fty`7Z`0j+zX3zf zP8ASkGj&*miyB$g=bZ*dalw^oQg&F!F@p`-KOull{Hd+E|19Wz))wh8fvd4-M*uNxll%-1lm zCo5Wg7fmP;d69)hEe@Vzj&ay+IIjIeFV1IK5poYig<$D4(b8dePFn$PeD&~xSmQ=r z%$h2TkSrPp`B!<5S#yWo=xx=AyL8M+gS0qr+MmN|2L9j{3}A>^?Hre* z0qtCtp%;nacb$4p?~b498|`e%Ssk|Vyx`KNS5#?E`Zc!iR0zVzvvY(-eJw@d!(#88 z)~A|byg|HHQn^vTSV9ra6fKsbIbw*S-Wz0kETS?D z7h%@D(CG!ZIEXh|C}&Zj>C{c+T9}n@G&2wdS7@-O-QD)=U9(-=NW(a?pe~xl?CJgS zZTF(2Sk;nvqe>&VFjqmP(ONxjl)=M8M>E4XP^a@!+bq9spiRSyE`a} zPc!RoPNBM-Ywq^R{TYC>b@x5cs_JJHLf!Xp|NN$IyWO|suz$+F{LOu-)h>TT3)6$! z@7*iEaCPth+FQ6^_Bl@@#0zzAdOvLB-|_GATiq_-R^Q~4_OO>)(2nwceES z?{0&BN;p71rJHB{d$@UgMBF&I2j4cU-eR%SjAC`|F9{4W_N4Vrys-_Q)(|E5mQ zFRalg2OTORmfsPs#n+1Kg814VHvQiCqk9@Wz8})%I|`rWbN56y7@)iVdf2~1OdW<5 z0tH36hnB3|Bk=nN3WCRen0gAiKCeY%pEoZ`5hR{y66;%e>4z8E*+lyI=w4S8=l%+J z2X^xD_Y&>I>&b_IJANu2C@A-{`X+wV3*vs&U&YT*u)fZS2JEAw(b(sT>h+Y>l}Z^H0b?`!|f4OkBLmwns(@+p7q`$7lAm(TF3%|X2e>%hdM zA9`O)v0{bzko?qRQya1TC1W~yUv zp!$h~?f(wDOT7G9jiwtuW-zgx`PKs^T5GJVWc`C*56hR{eAPjAa=o0acw$D}J@SXy zJu?IS>kId{&BfW_xtMRVsvvcw!g1#= z{c1e9UT)m?qw%b7)aTayzP!4bt{>d@&F%Hg+V!`Y+^lX^?)}YCdz;(a@zu?>h2Jc1 zZ*dy1@rhjrgpUsMo=&zsf5xh~G znD+R7sXiy3Z!T}wOZVP|ZpnT3@iQ59Ex6yOll8-;9rt8(wYs^ST6|4L*AL^#gZS>_ zZ!%gQ_2=VjGV1VP`y2cCn2e9cJ3boUc(Qr8ncDT7jIaIv#z*5B-{=RfzixxM@5`g# zH<~^$Z5_3{_227;>F~s+Qy<&z#nHIf=Kk+1zr9Nh?%*%4H6hscF7@l;_Xmv_`}?(` zYtjD^pLtmO@DH1d)oOWR`M^UrJ=^~3h%Qz~>$*Bx$JK?M&+ku9vu-l>{|%Me2Mk-h z*5lItYF|J7n*F(7DMgH;HS@Fix10D#^TZRc*`NFF73=I?Q}`VI&%8Ds{q%qRYm>20 zSI6J&YyS41jQ#KCwVpaA1OJ-WdZL&N{M*0Qam4L*=->Xe4~Q}d>;L`K`+eYt!6~Tj zW1rNYn`iqcC)`>;)2?Zs4v)B#EZ6rqT-b_&VbboaVp!!hGN3X{}D8ttA zGq+khWT5-;)jek9{w4GEbhG}iqHX_&qYjvsZCy=Klg#mmU+?WtUc2_GY*gV5^r_zj z`ovR#K1Hcr_nKzMSKgPCgXv%Fe)IZORDWvt8bbfz2Jb%u&7$L@U9;=<6An+O``kLv z{*5E_slNJO`~jS35Z%rF3F=f$blv>q1&{32d+*O^gUtO}5xL*Y$)CMO^rpCfczWsj zwqMoyZr`6*@-eD#wy)ZwOcL9v{0&+-`g*E`e|-5W-{R}3x9CB>r8+cr3OokxAGPP5 z-izIEd#-Uj-2O2HBwKs?+VA!bmanIVpdKq1DCOPJK`T|I9fo++aqRofy8H1t8ZPC= zs7I@t=-=<2-+#qiiYA16@SnbM-}yalAD2CLWOL8^?$^O_*cZfr4scA{xA_8X?w1`q z@*mxQ-8^p&yKXM_r^DteYobSQpS`|6yeMO#|MZYKPV4Pt1IO(4kaxvDQZ8v$8j7H zouK@4C;K;N2by5U;cd)8D||29>j}QNX^H>W-DLahl(mzjYLzQjJNw46x!1F-s!Dtr zXTNO@PE|e0iZmqh0$1`R5eAUSqKWdfOw-xZ@^{f`S>{>XE@odJ{}3arqOe(DXkjRC za^!W~L{Wt$RS}RIN|RT(YNm|bhJi?|HFbr1B+h%^p59!%zyvqLD9$hpq?og9W7E9B z6{x`CwL-t=&~RNAm^M{73D$_@Vn=jH>!5CMWXSWV4@enZ_~9%!SzTvwhHI8?Q`^mz ze}U~3Zv?=ziUS}y((;3N$p!rM4BMkif>tONoT0~7SSN^fR;SG!T`vC*m z7UdUh$*>sA5XBsmNK_{F^+dhay^OzuHtPQ+EAOV-{lNs*2#nH3N$55lXREXqZgO2z=Vlh+X_93)P#Q=$KnGwn&i87i z7<)JC(eaEi-p$!tSRHK>9lrG7+vQsK`4MOSFz_vHO9->G$8|_E?N}FaPf1yT*@$?brv61a(j_9ihfp0ACv`XdmoC#O+S~=jE^*-{)>PDfMjPys5EmYB>&Qd%hB;of< ztpzJZ@7hsSi^U!&4)a-A{3J%J>)!VU6Fyn^qy0FW;2IlO9cvJqHiV$QDUWsBVvQv)LL<+B*~@y*IwW z`>T^Pq6Ogx4c7Y_id9qXqTcw|;`kB${$n6(T4x5&!%qI^5Yd5F5g%#b*?;*9-#_dmjg> z7#jHQB#&q9s_P(e{l~c?X|lQ9T)2{WL7}QMB?{Q41Q2OK|^uMzib z|NcY#t^Fy)cjsFX*R!-KkWTT|HKZfVU2wg;XB_H~QwO-BFHKv2b##vq5)oWkE{IT& zn-&}3()e;u?z;aO`V{}#>Cp~?XBZNw;vU5i4)S01KRL@PFG2$78!@z>`awA+0gCE&Ugv>gF?t<-X`;@{nqUj) z{2QmK3^16w3l^|V8*=L)$lfATw_)~sX#64BF&(+@T>Mtb8D7up5+7{~eoVFy%%bDX zn%t%l3SHL%VG%@bRK(1QbJ^mhnibq>Vw{4-r3cCL#C3twWlj`GNOWKq?BCswuFR}v zc+RW|qeZIzW&hV-k{j*m!u85}yx2eNiyxo7+DF2*MtRY6!JUe!_0BQI8AU&Od&G*b zJx}@}cwh9r!h2G4Hh2&48Tr23zw1U+i~S*>-qDBeT=l@YZy)5C^?w)N(9q_u3i7kI z@vGCuPP4P!s~@%DT(=LOabJ2vv;tB;GIjH3Vy)})N#(5n8q*bOXw=c_cq5Y4{!KgT z(fkEhy0!jO`48$plHK#Vn}T|y^M2Gnc=E&&2<9b43hbAKup zZGvCLN_8)2bojBabo1;&UyZTfSVD|3|Hue;+1Vnkk?nGIfo*wYjkTAX2W`~F-~z*a zoLz3O)z8A%ef;}+sygHiIy0-mI#z#iW@saU%+*u9H zcqSLV5pi;RJ-N8t+W9;j&8IW{I-}&uwb#kQvx~{q)%9k5GkLhWytrB4F301|7>9|6 zYZV=F^Kf~E9da|ezTV(=aJ9Trrugyba*UN2d(KFi&HI)no7?dS)Bn|UeYL*f%kp}% zyc}&GCbu^ix0h37rPagrdVPDbUafA{+pFai)BV-xVa40yONA?89PF*qnD)Al{nvlZ z7%uytorTPQt+(xtj$YS@ah+cDuU+)7^%iBI`qnOc8*M)(`;U3vzh=yM#yWcZy?@ON z)--ec{nM+a@lPmp4=-5O2oZc!F}Yf&%99tae30qtO&g1NfFA$-P4(1E_n{jo!WT1r*|9dHmq` zwZG{%Vi5L%2c>$u|J%K&C#il>e*~Mq@8Ev^S3Ir2z5nb#ykoF2kNWdbHSpz)m{j{i z*S+?{($Dl?{X>OA)qp~#8;$+ew+WJZCqMPB{bn$9{FZs1>83xt-gRvsyKenQ$E_OI zS^E}$_#J#!uA7*Oy+QU5PxR7{1HE7e!5{7|OD?K0^CiJuRDS>XdWU%}c=Y>2jq=Op z?aR02%jQ*`dYsE_I6JSPNYb~mzu z`@y09s*JKWE{l++)|@-7_xZKq;i6;_<8k{3(D z-O?0o#y{k$wYzC_ct@|kkf|kji}1fVA})rJM=v|%{BF_2;DcF_wMmkaaBI|yH8`+o zMsjg8kqpHHBI+&HX)+AZXpKy#J~+J!CgcIJJCiy@K`(%`*VNK?xfDRGcnt#}gvkOS zD|TY^trhxIhaON?R_sa4f~KeOvS*&7A)t5`k>?;wQU`Q>J6`L#AjqDcQ#@NF1QDz3 zc;=PybgUg0r&s-*qJtE}OJ)Ju+IWr$)BxQ+bOQT@5yVdbMWhLt$947*h^vD5cs&tR zS(gh^x|yCXFUH+E;g&iCl%+2F~k=6kTas7Q`-@b`8+r@X{G8 zn-T=*fVMpuU2HGRT}kyOdP-*@QAOE;lqjYr3$z>tA{_y_z(^=!f$+^%O?RuM{?Z@O zQ#OOGpuHhR(*TWe0#~nH;+rcz9#GyisM8j;1zN7h9SSbC63PQY>t8eh+F;YujiJ-t z&AjhT0Ffb&Z4oB1g<%isWsmvVF-P=m;mwq*7^2AbkRf4Zk;27Ong(h{h1TU`>7=&6|%Iq{ifPO&}RTy}hX zYVW|hKM$yB+Z3;qk1Nae8<WjmiL-eK8tj$?YswXL^iqV1Uqe z=+|MC@<{XMgv`09lgjmENPM$>7z9di4T%WHv>lO?Pk+WlnYfSFQ936NSDD8<*p~g9#9$$ zND%F;E=dU&=B_8R1xMrU0FAdZ91Eg`qsh+c$`H}uxeibhH1ia>)F46t8Gm&(EjOnC z5w8krW<=LrGA?K1jNu`@I(>1HHo(!x8LTE%vvJmsB z1KM=V1KKepcZ4J4;0phfxOU`!L)cMAAe`gwBXEWwn`BMF<;(W88uhXW`a%aIS3^m^ zEqE43-NocW^MRY8qmDTt%i)JdDhe|LD==O5ffZeM-td|vTHrk4uxIBq9-b5KA|&V# z$H~QXq-mJItU>Ixi+Pa8gwvZ>ELlnrk1R2o7HI=2+^)HL=!11Gx*mHBia7zq*&V^% zY)=MzqtSyDFg&0rsmeto1SYdTFE#^5Bm|m7DPD-VlYIFS}sTz!}miF`P>NT2GkXV0L~z!?<4FY*9$sF1rK z)_pjay(a0d#P9&BW3JM3cL=R+yE$z~Lz^(1Efz@_NakygeQXBZbUyY})@`y#R33!> zmGw3lUl$Jr1B%tI$&hSIf)t#7 zE0V~%oiVwd>K?Af5TX0{J=IN?FYstS?ukgU0Wu=BTu|2qN(u{P#MEoaDUar~$Vlaq z3njp$4+=#788|(o87#SIV*Ihq@HUf9a{!R!<=&iX+$8Y3mTa%TR86J>h=@rCR+d>n zIv&&0deln<*UZj+L{9*famlqxY{Fh^MHuO6@sX^*K?yS=W!s02u7*3p#fv%yct9B- zYhW3JSN{=y9jVOGov$`>2f@@nPM_DRpmUN3$D_yEC?K6dT7*e$HSG_ zc4V%6{Q+e#?%{iZhfAHOZgfmu6X`^9es5c-WU$3NEzy3PDVYP~X0jR_T}>XMB8(k( zWs$lo-;H;4dc#vm)=7Qsq&73B(Usikk`tjMB!wo~)SR$l=5!%9g*T^!Oh`f9Hey>` z@lhzd8Wf8XTy81k!7*qNF}mS(1#~r_Pzw|gDonCrIiMcpQ^_5UhKKlopDB8LgYuEF zoqK|)kBGD>34$SApaC-LG#(Ef?8yw9La>O0R@>0{#AA7WPg!2hqXZ{()008@R9?)F z=Ct4vmerA4TqA%jZ>9r+GPzA_1lYMyY?wLS+zioPg3=$=YEp(N)0+iy@}Y+bLFLJ;&8Q=Qoyl}$kk`?Yq9^?kFerc{WWBl2 zQJ7oC_286H0B2;I=5AtpGOD}rvO9K9^%Mm`wrKGyH^Z}g5O);u@rH*i(2|hd^`u-i z#LMPS4=8Q8x~D?+XDS*<H z0-ZbMAjq!l=438GuszwCm{W$@IKum1NY@5vV(tJP-hCka#`Bbl0cLpSvWhZkKrG5| z_D`~KF0^->UN3evnhq>34$l=v^Fqk+#)dV%8SW`*5v{YtQG~fUjW337PT7n*dk!;l zT-hMva&2a*G2tPiU{d7Mb?an$x)=@jM0g*OgG4f!cFmkdYj2BqJyk_LpQAjsK!zDj z2AL6QMF}e++rE=|&G1IOd9GVqxivEK_*dkJ6<2*jd+Q;6E|Gm$u(?Ghj#qN8)he0s z=z4(max`a)B(7SwP6iR<<sD>B#19yl?jn32FMJLtD5ANK2S3cQj&ICpvy^rc^t9{ zqtNDt(dJp|2-X~gLSx zJ%J|^jcyS!?YJcR2)T7VAYy%D{B4{xiU-J__LOAxA`gU33b|jC51w^$Yxq5pD?4pY zk&zT4j72 zNYmVMIdtVJW?6vg300HriLKXdb4f%;>y*V|o~d{_vrZNf7sJ@g%0-)~fJOrZ57Kji zD-X^I2fhX!ojY>PNrTQ(G6|3NFzj)-a0`0A+KVsAQ3MnxKNZ4lhZ0BtXZ8B4Kfi2HRyj?oWaT^d8VrX>$~ z1t#l7BSa57rSb5TC{9V@4I$*1(T#7134%>g6FOyaXLM(iLERb28OUovDc2LYyBx+{ znWFG+1U;D1ZH@DAx1~Hhl;~IR6m-Zl$Fy1MQ*5Q8iV~57j>e6mY1HTOI|&qHcglr} zirs>e?vAz~E|Ey1LhE7YbUTcQiZmqz*t(5@M)^}1Yo!}5Dj~X8cbvzZ#+`cu~ zLuWLgog&SBR8SN_T+<8?Ol24-3)-L|NYapv6>^pm55ByD2_!kOw9DIJK90jM7k4KX z*=`2)I83M|;mlkp_HGGDQWWZMK!0qQzne;DWA6_Lv$EqsLmH)g(k39yySt;=;r--{ zZVSro2@*2s-cE-(9@WwC9WUJmG~8=g%S4g}45U=|a8i-E6?-e>Z9srZtZ!uBu?uU4 zNA}tQ){mbdrN4+Pc4CJSr4XbBL@9DVP>N_?sEW}&#*H9~@HW^}lAz|rRmTDuPk^n? z3EA_Zqd9dh_CgzI=HwaLkAPC#mpPam_AJnH7!g?>s_K4jos5I9lmr;0*tH7^r{U>O z=}kK)gT0&EVeA!Ej0i!UHiJEL2wo1}is`8?(gd@e1u}Z_(bU^d-tZPF#VAYRt!jEw zDSj=&kLHAt567nyg6Q^Yh{{PaM8+w+`5Yn)!Ab+oG4{y)lu{|zF@NTyx#~s*9=eY= zr>dqnN+tAJrl+lB$VYRcetDG(HHpE)#ZT}+4xc({3r9th>2)`%$johX)@KR7$A`I}$YB zJNu4qhDeVTBX}2a)pCe1Ob>mf^llJyA|cqEWExrZ5okSVE&wP9@rooTgF(6JiA5g3 z9zaQ=5`a0bVu04Zvdte}$vR;$_|Ox==x|TesZ}*xERZlvNc4FA#5d3l&sfqfms5E@`8^>@&11nS4I;R>4@if&+hc0S>(hzJ_@HPqT1|&|GC&K= z1vnR5L~wTMt#Q@+4E2QW4G%Fi!HVnF$uMOOr@`T6Sss)r$y5wQ80_`gxXq68duq6w zz>zEvDgXQR8De2Xc11A~ubUF#^coLX+PiJlb>($LB1y6w3Blv)3U#CU{A6v5AdHGs zSU?OjB9HnY=}{~ypd63e8E#76G3X6Xg*Rr65aSKKj_Fc-JfJGV12GjY?FQ&(Gd#R1 zCN&swlNRHK^fs420V>FFQsA<2eRFktwYeT$Pp>E5>)jZ=;nfMX^MpUNp@*wMu2;=! zJW>fEbGylm4oPYd<2ZSg6odRIwGkIFNUo&1qXtyw4jS}6x(5Ps29$af>coG5d%nAx z81WUY&ma(qxzd{ao)+WGUoR@alK2GjYL$VmS`@-1!UFje>j4o|TqcRocN>&@d&xTo z>sglL-Jc348SAKU>4`>uPlUGxiv4>8;nBCI2oGoxb9R!v>6k%y63)@+7F>vt+uV)) zVgxf%9~rE01jNBvW{c8EU?Uqw;X!$$1Kp$J97IHv^7F#0(M^kB>qtg>F@?*GI(H5`K>`U_#* zG6(KxG~~L{%!nT^@&GdO=vD5%6FucI&abj3i-^(C9gPg9_$kzZaEXAg>Qm`<@N@#G ztRPq6s9-oboMJ#+A@D3K=V-|tGqS@QJf$gqM;J&zxVN65fuhMGuL}TW(Sq{@4 zW>wt0g=3|`9#{Q=L!+6sWMZSfpxaNk(+kb_FQ(VSKy{AgQg~h)m5etyZxa%MM`h)h zl8kmv*3HAaXUIE)3J^qHL>6g-2eVAL@W_uqo(lEDnWPm`rR6I&%2~sDKw;dF4UYV% zrYB>bUyp};?}!gXtW5EFu|VeVTs{n`DglC7*3!~$m4Q90=qKh44<}&aIV!g^3?e*< z{0QR(9v&f{Np^ThI-1>?e^2#PUFoxh3aq$LinkQTkOY$f z$?z?L4ZFex=k%&@V@95V)Wj||{xC~g)dCshk)%%U z2CpY&FjK*`-rkX2bi?yt$_8sP+G^X8IrEI2>C}`kHsaha^knA3h?;+Jbfmn71t*SM znfn2XuR(ffaW+Ih<9#CS_s08e=xU0qGzqJzmoC_q2}r!`Q%0N`UQ`AZ>1Z7l;m6nM$E4UP8KX-6 zLlg^!Ye%mTd55*j0Z##dRO%#hn>du4#l>#ck4*m~P_Du`@qfrf#slk<=3kY3pb8gt zaox6BkzW2hg@-g~IKCW%u;gk=qIE!CKPgTEX)T=8jn(W5ClxUz4~S$Vi!4suHEuHP z=ifUJo*JDhM~^+r?Iy!jZU?yvVWU)_AQ_JXGL(l;)ga}OMH*=)ak?wBO6ZYK>rI(| zOQ1gqFg`9Vnvp?7v=!;QIIb**Fmqb^<`{uJPD)s1iNV_fO}Bk8=a5pIKY>;{oCEOHvPExi&y-5c%t zkz3sLRd>){tp~(n)+xi4D34Up6tgNO3P`f#qng3uKfP?5fjubb89?WP~P0 z!U7pYcp*whJr$}ROD+`1h8K+nc~Pj0uk%b*ATV;7w}<7LTrv$$}RSYj_x+Pr{9(mA~OFxM&=c1Xw2}i_R7uS4Uag% zMT;TY_9Rj@NW^@&d5VKVeeIyio@M#uf`BPv{SqS^4K{?0t0QLYv zSFtFBI=}!OC1VrABhq=E=hz_}2Qz-L{^toIHP$VKO%mNK=T*9~USw$jn(w+tKW755z zV(J!h&vhrR1-clb2zo-z7{Md#IvG~ZDoGyZ^^{;`LM!7op|O*Um$<;Wj|Y^g8gKZn z+Mdkt#`q057`bx^6py1QWmXo*cu9??1Hq46F!DKJYk^3YV#!Dj&f^gP#c0YzB2zP^ zi=Rvh@up6T*zI-;^e~JE@)v_Y;ZbCO#yI_#Mn*TvFWSrqC$AT-<+E(3077)kzW z$kGeFl8Br1%Od2@wLjokixfoyiby67Fa+W4C2w?u=Eu}MB~5`P2xBHee=)%I04h=p z#3Fr~!2<*#`MDLugZLH7uRItoSK1ZdiP8}fEI~>%vBiT8_#0II5SULA zzAO^H7KW{$tQ;Wn9A}0GOo$|RCVTT_P%g?@nruaAbdK!`<9v0)y0sWgfe>}4*O9iHik)_IcT$6sEpJBX{_D8 zMU|>&<8KT(yal%)@+XM9s=LovmZ4@SkVjlVfXiGd#CSt_oEQU?2M{T32tRf@FcX1r zF%;N@owJ3zlDgFykZezb_iv&Jhj&8df1C_@Hd#VWw z;~aDsJCi>Fmy-bwhL3C*#AJJQ?B5)N__hxNA+@3Pb~jvepij0#(ltGiP(x)yu-LOb z`M${ld$kIXbk9w+8RV7N;6b&n9m85an z>!~hCtG^J6J+ruE>KQl)8-!89y-~{Bb+SO4VTxb}ri&o@xZ6q1K0rn-6rl?92&0`r z`Pi4I#GF)d1{{C6)7aq|pxdF^5ro#0*tt}k`2*03pb_i}Hc`aLShsm%OOW=RcMQ;VegnUy`A;L8J>#$)Z&F56Vs{ zXG|J8j7ib%K)pU)1?r|N6d+$)q!4RMv98_&akYQkA6}^l>GfI7W1KYRaqsDeBja}W zb^b;mvp;T{gpONwI|gp93Oxw-f9=7=KP}%jl@KZn0-QoG%7kIWTwOYsvL8c4`AV zyrJ_4pbU?E@@~2P;($E;jz9zz#}X1wrNSMQXue*e^^|uW(1P@1`6l+C(^smN!Ehp%VN(;F+(Yd&@i{8+2iB3h9OuoaSjX*me9m# zcSt;FsN4z{7XwE=e1YOzD#^C%$q+2v3=k{^>ntZKQq=h|T9?7((rBtUN5~~6#BReu zH$%b&Kxs`q`9=u%c5yGf$Z3IcQZctm8Wy<$n2A;xOok3(dcw6{@h!Ir4I&Uw2N03W zC?hz>Fy{!?^hAiZ{D|R^*|w;0B5IrvXy@cdg9{)OvvVM_%8`-1hz(`cB*i5rZj}|@ zEv^Nkh_d*2Jr!ifYzPRnWMsXZJhg`85h!?~2tpUpRrYE=bmim9tC$gXWY?1g8V%g% zN&Xbh2?rEWF?LEMVG$oOCA2OS7{vud++zE1;my^62Lr|poVY`xncdo&o-Qs2uD$?O ziv_kQCv{)DEVxpj6Qe8P5Xl_BXJ5cxuxo|dcq>!}yXxJ>ph)Ynv4(oLGmv-iJ`U2R;(NU2={$dDPm`mP^Bc~nCA zl6q=DbTKoahob2F!$his(71p#Ab~w|c#sK4}WuE-B-? zb_+`8_Xgt|L4UK)Z;yZ59Cq73_^8D;sUdc#0odcZ*Ov_GS0`=J8$?@?8oF2Q}F2FoYN! z4aG&lZMm0GwMh6vTNZUOz@oV6q{{seeEs$Lw`a;9-%ZVqk2c?T@)b;J_BRKeYOG;rMA;}x?6#4!e?d8wZlcsW;SzL!O zPVu&&%uPH`|n+bl7meG7&K0Ph(rj-AE|5*4}WjasFkQC|i7WuN% zw@5#(43i$(mrUIP%=TOU@wj|mf7~wA2Zq~WPC>!QfE5x}x_q4`2Csgd$}o)Yn3+Hg@^y;5D68p93^%&DE%B;qg}#VcbM%c^+U4Beb6D2yiBV2qG8sP}&V zvizra4`l>lVvr|X?uf+SpFa{g$-~JdoCHW#M5uKG=t>}e2vf_5Y{bHW_lG^0hLHdU z<|R2&)o@kG?{fEWSRVekn?CQ^a9dTGULt}(Mxwq+8r;9mqW7;Zzq8ku5Ax*0+L^_u zeMq)!iQ*skV4CXHchfxjZ~~DSoGRJ~B%*BeVY3B+-|nUdst}%lz~n|{NJ;{I|IK3M z@}fry1mH%GNfhM}mlSC4$5Z|q!tM93yEm9m{H#VUW}1_=l7%F^gjWrR-2I)yVgIbT zrEIoE$47i2@#7}!@oE45%3vSf-`@7@?xTa2NZMXR$-_O|Elu5^IY=*O=l;Yj=+fMP&(eG+B zqnm$_Ab6vqog*je{PA(W(z8^Y_V4t!|GqhFANO7l7|Xe@P^92jR5p*Oe_&vP1;dfG zBlto@+T-~1=jOAbvcJ}-=zgv5rizTF`mr3&0$DLtMXw=skl*&T)}!4khuJQ@a>o#2f`u&fNO~{s2sgg87l{R1hBLS@44*HDRDgOO<*OL&FxL6dijGL{@4Wo?j z?cuw8{whgbWtt={T!heJ&Y+(yX-oJF0l}R9?~lJNpY_JuBkCPa?>k12qe|m;z5Invgf(-Lo>CJ#&r@4(#OODuoN&=%yKry>uf^Jd+wYqqyWEC;}s6@}}czsjjlMvU}p zgnKI9@lIGXY>ANR<$;ZL*!qbBvI>br z-7e>(;1ERHiv%#c7jN|)jsa5M@hTpDe)#(S1dYR8&@3bUaczNwIjEn7tX5L%g1nD0 zXOf-1*`?hfa{|i%u~kuFCW?elO~a$%3h4&#iIzGIwvS${L3F&Eo``biO-LmO5VI34 z1m8{H_IJ}Chn+gb)SrjVSLSjM_lyePP%2WZ@SOg5t$B|>5#mu}gNMWB?fvj9X$+W_ za*T5%>SN(spWv_WFE9JUn-4-2FI+7!W`*D2W1DV+6F>jD{JKeYkI;4eyIT^9g+p8g zQEMj{_}~6YRz1bY6>FC;6pm<<5{z+b>D6QS&rAm@J7~tG#B)y~t5MS_Z7GK+sF6UZy&D$Tvb$|+k9U4Jgik00geFf z0UaUlzI!AC_o=zrGYKqftr# z4ie0?>Ksv5lpaq*GhqWq7`O=q*2k0OdqoqF1q)Ki)2-3bm=9NQ zq)}%4r*P||J8{dkq9H68!$Hp`b!8{+-* z{(f^f2)Y7>Yhn__2va8qx`#=zdXKx8hdm2vX9yrMTRJi2FfzYu2~ffi_ZKG0ZQpXi zj`E;+ZOBCKI7P?w#+?O=PY$zr=3wDm+G~-YQ{%APaA0*Bl!wFqw~b>`3NFc2S;7JghAUKXh3PZDX@ zC%4AK#~w-Bm}Ou|h|O}i=4|UuA~#7gBH(LHU3zzqJz`2GO^^rEMr3S28~%~JUthS1 zA?2tGs5$B{C2Z87V?xw9vG3h6qD3Zk&`3z~iIa-9yCn{t-Tg^>3`#Io9AP(8B)}%x zt^4~iS5dY2T1Ns6zyjbKvQH{7BV$vI^utV_812*hlP3c^i3|U`idY}wTmn z(Jlw+G2$tV_E`NI#DBY5DulutQ<+fWnVdK=UH=)kYp&{4VTp>Q6UVz#1Il zx$vDDEhl$JH`8^eWw;ZBrwA^NTNRmT_g30zH|16435^0uAGovZHEAdV8Q@%G6azreU^hQ0&2_Ggm>8; z>87P558Y$0#gTA$F_Gl9(-97Fto8fT6Jw`A50dhL39i$w$7O$&R@{n(-#jbcqi?Mq z9Dzq%zXaUwi5uY^TY`JIRvz^YtllLY!3Z%fE#Yb0^oXUIU&=3>ogO4fL&6wO9gCa3 z#}$faP^w4!qt_Nmz$S}S8G!)`K!=Hf`Rn8ULCHMd1cO8~#Ma7V;w?I(mcnc=EKYk7 znzio_Sg%J6Ar;vvdM#|X71gP1hNp=}-*ElaXz_GLFV%E_;y7n=+%`LD;zWn-f-{T# zd>X5U$e)(4OjQy&w-FWf-x90PU%2GPT0L%-P=L6FyGbT91f7U-?yMga@l$r#kl-AF9A!_ZK4fDedE28pp})$-*pU_rl zeq|=lX)7TqQA@H)#GR9nhVH&?9$%F7;~+Eq?#Qr~;)&w6mL$C+o-QE?cZVyJ=HvTs zF}!J`Y(2&-X(_5b2$I9nM=o4a6Nn>OcGhXv)Cl$dl$}u)BxGlWiU77744)jNyw{(O z{WgZ={!mO^l6f|xjxnAkTA5>R0lcH2VOWna1AW#h%2Vf^?38R-xESN&r6i>(E*SdF zM3+Qmq(56oq(U9ktzn902*D#Z|0ap9>O@QV2w| zaGKkN91=W!2v&ugQjW$0_2+5qIEp(gF*bRS*<2NvB23`K@u8XHD+ILCw{Ff5Io6Em zLDHC`s1<5`B~WRm1vhqH>=KM*gVY1YXWp_im<2Xp#|sqK(3i+3anKdG7_0Q>!*hJX zK&!6IYKG4~BzosE!?*9mb6PC#lZtEzOXX^-u6C;$TTK8OJ!zo*3=VgccxG(O;S2yuS&G3*m<+ZpwE(3*4U)tk(N_fRsH#voxft zH@v-5f=fVTX55^}C}2q4Qz`r8F5&WwJU#)Lw6s+4xc|Dt9N)=WFW>%n?Y^1Clz;`< zYcTB^*FAZ`Q(aq)M5jWPkZl}fxbeuVp=9ztFK~by1(f%Q@I0ISnx7E1ohYh>W(l~M zm(*>?1FWYWYoIX~m;Q>V75@&frAKy1NOA}5!PoW(iL|9e6Ghv3omm(HaPZo}R*NU$ zNvg5?s`Jp2fF#F=)UocIRU}&aeYNYn2tBxp#Af)dnAu4vN2F$|4wASUyy(~-@$9oY z*LrWNr+shzV{dfAU}xKQfGXQAVZ|jJxkqSp*ui_b=~W&bu3c~Oz8lGo$wpid zI!qb_o%~+k5cdbd@YZ*?#+6x}>`L%=a5!R9kCO^YTDvI3ZK;oNm~w#Zi$#W=i1CJ2 zF()-xV0aD7(y&iX=@OxlK*9r<_53(dk011tb)DiqL3J9EO-6$JAmGk_$QWcahvxkB z;J7*$WH%OYW$$ApsA2QFa*q(w52GbZMxBI|f%%saJRv#6PR;4_UrK!_C6Jm(fH81E za4Iyd({i)KJs1(cD99FZ;{0)Yj4TgYN8lilc1ZhA6*5kCbC|G#hWq z-SF)Xb-D``8ty#Qp&?OILo8Y!8{vyrKl$eR&k3(8!#QTBqnmASRk3XPMKdx7h;TY@ z$S=a_$CdcUQh7G+QAPBMRCj$>J3zSTsqmeMP$4|T46c609NxaUE)ix_w^CS3NZ;+xS9Q=oPXsQq^ zr)ea1%Zl73+-`3NhqWQ7FjSF;5vr+KyYIc*(=VF9Jzxn&U97Bb6_s|~^**RdQtQ0a z#MvU@D6cu^R)Q?rS;q8nf~>661&SY|z!9>D6GqY6Q-)o;zq*mOyWgLdFFzeA%%{Sc zLgkDMd*xDpFbh@DkKNlhqIm?jiwOw~t6D`&4U>%9Q_fi}#^axiR7Ah#w!`k?Oz4HW ziXz-=kAtpHhZ@v`_`R1oI*sJ`u+nii9a{R;mvAIFAo7zMXGin%d>xLv%L#eJnjREv z{~k^ShoBhJ&elDv<0AY+pDC_Cd}0Ht169QT<8)Gz8Zt3*-pg1AC z4NR}TEyV^VV5Z^ZpsI#;aFfD$zy1AwZI2v{F-(d=!Q7X+t=QY6PvX_VVa+NF0?)Ck zvh(eTl$hciIIzR4z9|XO$w?%|!!wC`aNK4MsnB&e5H0#dy@ER=CtlbTrZZaZ{)aruapw|0A=xWfGx!bt2NA3uSoQ zVrIsVU8E#6VeFgf=>$UxCMIcFEizDAn9BhevLT{ep<-;(&C6Q5>?&IMhD)V8v56rj zj0v{Joy7#Qo6bo4Df4exBmxsP1fXHO_yBS<2-1>?IU~3EN0{XR3|{wHi%cN1iS;P} zrZ>dCyN?|j)-h5V;2sULwqtwfk}h0cUdg~#2ZP2DmmYFfSdi_qFEJzof`w-VVW>q$ z>Sij0T9}(<7yL#snvIEK)et@B@J+*cbLCth-FZ%RZmlGM> zYo~*JLHIQ{LIQ*gj7jV;zP9B^Jx>v2grFvuK4sA?%=Kko-fbXQ85n#fLyQA1CYFq2 zI!1XVM<(XOjha%(c|z=>?Z?jN;q-h+u^!ZMLWxwD4Q6`Xm2mK~Gsu3RP=d$M1v?y& zPehOE_O`Fk-jR>R8^^1dvQ7;GX3BuPT&eLkPG|u#qE^Wh-~#?l?w0YTm&CyKvrv`M3JU&+3=5{rjh72k%!lon6agt9F`XN_ zwm6U*Tf&5>|Hu(VK1>Tka*pn8%A$&o8yougg481TK;n&fp@bkj@^4!hyFT7F6*wqo z7?d8alFv_=H)oT#>MlK%=PxLaCI$SHK zb*hNRqUQF^MSmW6C%2mq!gfsj1GOdzCi zDs2)#^7?J1EVFplO5m7sq$#yeXZWWn5&P(8Oa}zFlJI5ygX0< z$3MeiLnQc_^RbnEQ<^1I<_YCp8F1IYk|qXDJa|S_4hME0@S+58_d5xz$d*emt)mP> zwbVeC>nvf?iXihwWNCmqc8N+TX?SY4m#X+50q4rRX{dJdVEz&if--<1(=fGb3&$mG z8vFsSj|H9jhuk_vjwU-FzdJV{#k~l~<%(;^W?-%^JihP2aKYhHd}6m>NSR4cAZ4@4 zge=HnYzTgOM_pc=&h>|*CJZl13W`OU;hV8t43q)@MirM=u{0LO2tZz5N{MTds*z|7 zDagT?eqgL8vsuzlL9lUzXO8WMauwaX9ts2wsBAOGPbz>QkLNSG9iTU07ExZ|gl=I> zdgcq6a8AyL%uE3_m54>NFz|YvFUe0f<&BLx96`Gf>9DQTbalG)c&QveDFH^=HQNvK z>ZG&rtsI@BotV>~%s519TbP^iSij3*dGanmKXCm3=hTlhI`*nuc=JKjBo&=VjABo6 zIWmbiQb?2)qP<8?WogGdEJZ&lk}#K|P-Y0~*Z*STv15k=tabq=23b47oaCcRWJmXL zFeGF`QIn$hw0JWa%9fjfehQ56Ar%cyNI+A0j!PV%2(HjX2cqDKDS=7uB8fRUwuVfF zMcTMEHPVci6jAn5;`N2KwMGYM_JXNyG?aseOF&fOoRW*$c4mFHl3UAuIF%_s8=}Rr z{fxIgCm3&}%;4sO>5)J_icYva2kmqi8^{feBPt1|L%dntSz;yo>FGRH_;U~~j6MVV zufc((Q8_X(AC%unfSic!>~XVII;gM2%GjY3R9ZK&av@E%HeKo2*r38K?V+Q?AY#%xHw%Ho>Y$bTGo^$bG*nT?Hwwk3Jke4Quu_UQA;~R z^8tp~O!BY0n+R*D@pW-?D|3}QytOk>t;+s7T-%$-K>aSX*JxSh6o&0Y^WzN+_%I#ClU^}~Jd$)nbU}1L(NZmFHXTiFCzI)w`hW2|AqPcB zP6Nr5oTn8TF`AZZA4y9sy$KqXyUw*4!1syQP>q_sVC3havd8$!Qjs|&ceCRmChZhd zce)>B)Q}o6_{P|N482{-(^Bv^veuG?i=48e#Fe2p%G$|~n-AV_bCz&Zk)~u;X zPJMap>1Sj=&0G~=7MgL>&vg5lgKSyIL5N{++C; zCpDsVg*O-OwPcdBFot#}17{X63;M`fVrR|RjJ$)^-i%BAE5}x%yjYYX<*da43{?P0 zm@4O>Z%9F4`Y|$+U!7g_!zqK?l`2DLVJz9@H#5`FP6rjl1x@eA_0ALkcQspL?5wcuPeyNIUw(G~#DD(Kf*oX*Diz>@vp#a#fdI7-8 zCNE%6pmAR2kx=Cuv(}K(4gY5HlT#Z=;LR!k1~Tz-Ck_ZlMi_LA#q{Ind=_H^1`~IV z<$+E^XkS#HoK=~JF#BvVl4-5j~j_G5Hz5Vbrp z9a&=;$3RuhF?X9cti}3j0M(?!BmrxU%e#f4%2Ov~4UskaK$2{gXvZxK#s0df+;|EC zH#QX)MtFEB&8_4I4h4v3FmLKC zJMj!!?!;L`cgGx&m=bEAp~G@q)b6+eksHlbL0BrfHV0#jsH5eB?8%LdQxr=wspFk! z!b0kI$F~EV7nq6)a1qD1SyO{Ic-&Aw)b2ttOcarUF`UkAd5uYhVDNEtG z`5@Bec~0^@r@k>_;K*~~5%dNOg+EK_gkY{-)Pp)HI+6qp1aQyQ2}7&pZ=105bF?F& zco8>Rves%L?hCGcUB+;C&ZE%^Lu`~txt(ByUiQnI)Zw)1C{;4LPVM?1R6dd;#V*Nm zs0!EMKxdLY_dZ)<9Mv2wVrMY|+6T#q3}FPiELu)D8&Ue(2A@P7ULab+d7hd=rA~Qs za?ZGBUfW+xK@E_5g-Xpx2tSc48dKpRtbYm4}nmWtu-*C0YhbrM`VaI zWh5>y2Ik`CO46}r!VE83m+KNTEdmV;Ci`+SGbSs2SYN>4+|8BALlcmfTy3di7_n*WrpEI zUJXXEbAh3>AAvr?J;lOEO#3isG8TCy>J^%U4+GUnjz>ReCkw2oZhZ_6uE(bjSW=nb zKSeeSM{b4@c?&9shMf|VJ?SAF1Go2HDPc$$#4J+Tkcr(bsW~hs7pD(Pg77NU3mzMG zdCY-?f8c2p0D~eKHMd(*b62J$l|;591MHzBzQf?-4l%Pl{j(c(!V(D~aWDo4m0 zol{cH#OA@K&LJ>gty*a2mCPqQlIQ}Q(c=Ei2l?SZP{xVk`XBvBIr zkXh5qp*6)*ixNk%+;T=2crl<8rk{#R9rzf#!*cS_E3?Lv(<}t1Xvbzucq89^)r}2LRPHsnkvaZmcnFrY(|AMg(k7U=h26p&jiZ~>xFcRfKFhH!$a)fGL?;;9vHe^R^i!!LxF}QMxoL$>sX>*z7ab~z(nzE$)^yt~ z%;frXc{;9JQH$P{y47xMrULwWd(wXe7=*VHe-yVD>}BBkbm8+Bg;_}UPXbwOKZbU& zE1l-?4cXoCv7#uOg;|d~nxSU!NkNz*-}p;KSZ_X_KcfL#2QUqG>4=N2?Z@iuue=+$ zTT_Hb6qRTz-5uA^8z86VGrleGN5XX@pWXe1`U2|zO7(w<`oI61vvXZ<8%OefE@m#E zeM%>vtP?3wB1Nt3bkFP;J+dt)nzk*kWT%t4`uA4_kSKtXyXW0`wqubXj)g*@4*&YS zsrrN~)&dV4u(StSa3rq_`OmfdXCeR5@A~rBzruIoibV8bjVVRmqz%ZkrTja_ z{AV6&AVzqBFW|60I$Fb-d?F%pzdw=xtmQwC@}HOXXRG2oVV7{7Lyv~pMP483ldJ5h z{dzBd>3>%8*Vp!iEBL4UZjGrYC{YK5h|=k!4QQ8PNy{YxDvv!i|FyqK8h^U}<#zqa1uul>jv~WvXEbbopGD37(mwzA!2kWy{{HphS9$Qzy#MuK zt-qW9G|x#>)jZOFdH&<+splDYbBk>_U&GN);$jU0?))1UYpl3Uv1ad`+hQjd{a z?J|$GasE}-#=oEAV!B2=Rw)1nSl{^RX;jRuJg;@5H-55wCab0+Jvqg~&YevBh)z(l zo*p!$)FbSI}mOs?1&kH~B)K4K@5*^?W-4ERLS1D~!xke%t_Pxs%xK$$C^XkXwz z_U7r-r^_*qDhJ=`o(zG~U+=i80~}tEnTB7_uYGodfBkK{-LFwOs7BsC`%SEVf0jc-KiUmf#RXNL3Lh# zxye7}yY18O48Z9QIz_@ODJUNtC}I$8kGwUHN9%_bx&1uwpP!s2DOfrT|D4YODTpe0 zWiFc)^-~LI!O@=~X1v6YUVvFC*R#cyw1x@c@~c0BTy$MIyk zPYpn^snd-7ni$x)N*(bP2}t6{q&J-xH}#cL_VcUcen~!@t$*@Vr#}AFQ^g!KujGZ> zsmH7Iv)GxGW_Gu`KUlO?Tx$&W;&EOyy!6`Pp~S@naYL}HI&g}~LNsIR4x?oXamDT9 zq#_p)dbQrOVH_c}i%kWr;_>-#?{)dQ3+Gqn|+{U6O|;!25xirhk1B?x7$8Gng?z*hmV|q9(Jbt(jAz(+dD5uD?vZ*JXUVo zdFm;s^Slx)bC^)~g+0b~w64GLLb_){!oGt2Z-PLtTj<9t|6piu-ng>+lV1jJo5%Zl zH`b$i$K!@K7DAou!2NG7oz9^$O^01c^YLP}+poXuHsVm>nryi5P#dbqOY!5-iw!gubI%d zZnd2*$o|yo;vov8kn2MF{O*qf1H4|pc543eEO^znFm#+r##75o7CdaWmt7Se`)v}J z-oIu~FRwqf9#bAbtxA#;Rtl!&PmHzXcx#B{$|YR%B<7MK`33abh{6yNZ|GtynZWfy zmJecNRIR>p-9{N*FO?CB^cq!kP{wGB$3+i`0Thj=C;p^8@Z!h( zlG)JQ6<2Z&A9_6kkV8O??L^a@`!)wz?iE1kLmvuXIrKcR#%A5x>U4b+(goK9(eAKr_F&k4ZpXP z>FWAzv){z)y%e;J?VVeS=F~TrWEht{qZ~KKJ)FKR199?fqk#-TpL9MRztW6DZ6{)$4nGZ0=h6 zTW&V-wWodT?B|}3nx|aV<&X~-pri=Y>n}s5j2)HSeI(qed7VmbzGhE}LUBz=|45DU z=GoIqE=0`(FM6RG@D(*z2LRab`Yx$i^Qzfb{U7UgM9niN1a=|_H zHkUNmj$7Hb7o2@7jxlMzVdrbneA~QWB7VHa4^683=0!6A2M>DS#@H70nRDCUJ8-yn zKm7p0(+(LNzhpKa33s!98>!3>R)s4kjQJ;CN^L&#KRw59%Cvf{^g%nZFzsZA!4J+( z`}eCCLr3~78L2*V%%kaq`{ksf_}L+%a;4h~ZTvyEF&MZ%nB$U$UAP)8DY_>q-Gyte zRux@v-4o>5_7BxSt`ObYClfYV`@@}u4n0#JHv6&IdyW!4^%SPh)T_qf-N9}}1LYsP zYmw``K59h3Rwi{%TUpruv~sOJibb~g>%#)8`^<@|rUS?&a^W6wJl(FiS_(n=XNa2n z&hrCoUy7@2+I}3a?49rRRkO71mpn*I%56SFnlom$X)T%r!8xt18zBuFy0K;zfdf^_?apQ(mGvn zyQL48P;ub!E7@{!OMVj`F5bvtN8WmEfu~8=J`pX$mh6_AA${w0%EE)R2q)d^{luD51K&pYdaW-sVJ`NZlcB_k297B;p=qACmipy2lj&0%Y6l zJw+WH&p{U{3Ff^#|M!b+6AY+az;y)_In;s|9T^va{J1>d{9i!ZKc8iiD+v69-?E{Z zmD!Y}5hIdVGKnVj^EsL6$Q4iawafGG+prYpGooC9l9=|mI0jJSb5gW`XhxvqZ}mS7 zQJoVqCXO#f?`35$jCo8<#T=kdI%6ii1bBo5LwRq95-kj=>Vs%MB=qP%4<@YXyvnLR zfjraRGj|G88V7A6z-GOF{_B4W`zR36gZDy2S?~G=0MZYBhn&yx_Xp8! z+S~tO$n(4=ET}&uHS_*u8^AfwNvk~|%y`n1B!8ijdRkT!`riBbunhrf=k;^}a20_s zw{Ir7$~jnazfVhDhT`t{L10?_ijrG*JpgJuC+-8=#)% z`2?Ibz!Z4?_3^fSegQfRDP;j+(d4}0`EW=YiFyFAl|YM{=kq}|09{GvCHPujfHpLo zEC~4Ai1I#^AK}luz=0BPnbKrrzW_Lq?%=2-{ds)|A7o&3fNM4B?eEslrr`|q;u#J^ zJv2#c(?Bk+j3wwHPpg+@NOpXYlTRJ=Em+3${W{R^1xUDM28s+`9AsjKQOQ4{d7wQ> zJxQcFqTw!Jj9yHE1(Kwc$~;VY(rpm#3{&~fv&G@R!0#~!-G;!w-Rk8!)ISsa_!&ST zny4f^Cuwmu01=R3W9l={@t_=&@uatTe0&SL`2sp2&n5ZnrT&{x9$toP4$hr;NHdCt ziY{v4YUeomJPJ-(c)S4b2|6!&=!#Y*$LNJ(dsYNMN>-(CAbcDSDiAzz=9B531(ey3 z!@LAL0*^{qF_DUG6CYXUdQkyh399YRBrp0ngnN(0pAv}1|M?Oq{^MvyqQO2vJ?Nh- zF@4O)x67%K^+=x1VH?`WM>(qlnBv=hZI6PFxWf@p$eE_y4eRzX2N|gz;>@Ej0^NMf ziF#WUghbrIRCZ>7IS?;1;289axv6TL%@_e3gu|cQ$e~vge7&GrLNkha*1s|@YM@i5 zz>Yc8=kTH+UZ$87vz{iLGF1^$ml3=+bL(ec)P&g1ae|)LR{{>*Eci!I`1=(r)gu!0 ztJyFgr;9O;g={1-!S4g9eFSS}K3otRJ_V%h<~me0D<>0x4XWPu;lb{`kEB@y9uSWA zZ&8AnUg4cTuGyKrYw+0Z$U!mz`h#sGr-z-ZdDVyabM~P@*sV-eHM0xhK9LS?_=Bg?r? zz#NK9Njcii%CBsCur;em@6WYj|AjXb08ZwWWX$f*$+{hO=dT6uw>Z-`#AVu<^>Hr~ zSq3p(d|X0pvnk;YLx{yKr2Pgo0|1(UB$6=M{kO}H;VZZUDXc&@x%|hdye0SC$8+;C zCl+`D8pQ7;k)N2Q{3`Wd9u2 z^;O_HpGa&tnIcp+ABFlpkyWWb#pP1AlccXSugFC;8)g6nqD~raw4na0rg9sKUq@YKBz<{Wq(L3D|9kLb9~< z35?nSU(rE8;n$DmBQ`}zlAJl`EtaWQLx7*~$S2l>aMtfD`e66p=Rto~W&oJ=z7s_) zCmey)?w>#+pGSo0LI^|FTC+F4hU4yYHd~OAkXTm4**s>ppK-Dt5=BD%JqI*aBy&7` zo)XQI^$ERiW+n{fGnC4Qtitx?r^02nbN#s@0n7jiqUSPDZcTc!&*U)4Mw}D9o2!ET z1Po{RZa$t)K{d@Bzq~woc@FaNXD}-yTyNT2J-&QfiFq!3Sl2+eSAdUj`AEmN$cDV) zOq_3-z18Iff@=FE%#LV%cB>qXlDzf~V_Cksv$H@M@&Jm%H{z3+yq?Lbd7uoC#v<#! ze#3L%a1qjHPbU+0g6v>bymqSrnu63+2sC2ydwX2%ZXD&=F3(79!L17Js#!C>uRCP` znWh>7>gv$efkFgC<%Bb2h%f6k4t~f6X^)7{LKYweH~Y64*@2phdIoqD&>BsbxVXmK z3{QUG6-aW4*g~S2{eE+3k_J7Zz$Jejgw?Faf#wz&{>X^`J@OBbnNIhgc0Wwh0JO0w zXT+%Jk;(k=P1t>>CP1?n?d&TMgj{Jgz}Oq@kI(19gwNfwQUS zpio~e+by)Tw_fU+CGr?{1y0!Uz&9`ylaw7f4;NjwY7S(Z(b?wrH_G`i@gf0& zfmpy$Is2dYN~7E7bV%fO=e9qG!z9!5_KZz7R7W}T)eMoPqUt)mQ&dqR^^rhjic~V* zFJIoC?_S>wOCNyjRP+Z$1viYBMfZShx8x>GXvo468MZS#NKINC>J!Lx5V@NTdvF_p zeMj23vcSoHBbiF~Yk}#lM25EKGDr&(kkoUc`d)5#)%um&;O6eC;X0vr#GbO>xLq&e zc01ET>Xt(EH6xI8BP#s9=l%W&zyj_2tEYOUD#<4nrh|l25(_vNz<0aVnl-T{ zCmi)$ZU&<7a{v3ssJ^@?#2dmO_@kLCMs^Db6!hPk`>bo(F;)< zm5RylwJ|4tnK-UIaKE`Eb_20a<&Q8936w+n&Qa!N|GZg>z_|SS^0xFDl@P&fS#DWy zBC@r{{qZr@$2&xFVJ_Hn@XR5B5y?TwvAh0pc`@9+J-rzsbAh|{2KFYcYvc?z? zLhdffF6+!SSBxsJ5Q-(fMW*3KB($%R^CX@KHwktc&=ty(7C-{E13$Vkxc22!f?h@_ zU7MLz+VnkohdO5@OyUf#$&ejSw>eb8gj1Tk9{BcT`xLU5?J-kGo&Icmyz0Vrg5(4E2ntCu;M9AS-d*X`*M`c58aZm+0m++M%m zt?sst{0}ZPNU?zUfGWl4c_miSmcvj^fLkumu z-P_A6S22RB5J;O#I^UMuEhW|C;kGuDXNdHIigetBW5!gG&d#432YJf2KyvLlT{9b#c1eXVAXlDe4Y zM%yo*8$>d9wq_VX^I*f-Q0gY31gTKr!G0u|35w@3k&y1^2+@Ej*I#|bR00`{)m&D zj&q5PGtQDP3{t~TcY1kpetGig^5o>><>#Qd#hNhzale{_P8A<62%)O==$tN&+d)s| z33&)ZH^6p6u{lta+>s@a>$xVDMt0%Wtw~#Vh7P%nk3fR~$MnCRM-F4qh8KcTj2SLN zi=f-+(1w?Rg>G|%4F{q?Ca>g?ZWsRp-XGd%HgB6E6pg`mTM5u+3lcg1_Zw)|!vvWR z7U&os_dm%`{zS%i@wAhLdwV8VEQ&%&`?h}OKPDwNvEzNxTq77jef@DJ<%ObI6jAeE ze7P##>2EzQ>SEL9y&dVI#-uanws&m0l)+tyxvnJ@VPnJTxs=!1rEklsx(|Cj7(2BB^yl9F!)N;_IlH}jXDlpThTi8Tl7eE@d$v5r_C=9uP+ zqc+q41QRj<84XyqBTFwIs2V|sLh!V3QTpiqxQHsN`=rq;fjYJX_zo{r&Aeq|fErGK z5W-~A`)yE5GjcP43SOl5LIb4z<6gLbczb*ddOWPXpeUgFAqnuYaoDMFi3CX@8Hfo5 zdqx&ORAPeU;Ey0jOkToqG(~2LjDz!MuxATYB!o1_k{-TH25t6_SFp?8Z`Xl4D4JW$ z52&Tu#*->+|J_mwmDwuFYCwWOOo4`y>{oua-2oUr9FkPB23b}3MlNWw zLJYFDip3OAXzWKvtMEsesM_wDp2*^a`!yQI(U=_MQ}GNrGL&vd#B2~c0)|aF1f>hH z_gEEwqaz@b3^0HcC(Xcox143yBF5-o&L-t^h}t zKzE_zZp~hU%eK8nyL5 z_3yXG6eI{4>Ny(5z%^zLD*BAuZbJZJ=Dl=}9^9qD4azNShm+A{IFg&|v9V9ZD13A~ zBh>;)I|N9F*)w9|FqnN&;SIXsgJv ze%3keA*K(~kN^6Aw$jOPJX?(Lcr%qY`pW<6Ut1{&)C7`k9#uMQjLRzD6nDz;NOa2m z7G&ttv&)OCaELPH;30yug+bHy>`9U}LM9KKBsyoeZ(sM9pLc7Sf8!;Eml{aoY<+Rg z3`_Q3PnAq=7#WK2IXNfr5B(1~@pNTW(|9lb7I=6leT&w^} z%Q6!2y%0}BKJf3xNulhG5lry1=-vK&U6-*zw(MbjgUZ>nt-u@TSKd~*$}ktL1ZUqC z!y#bj=*@yD&~%xE@pwSs%pmR7v7eC`b1*85NWV}IZ~8c{Tp3R%-eO@~jIc#IUqbPC ziM<>tg6~QJiX-lOVjRH{Jg6s1;H*Y9mbOwG7YAyi$mV=2XLx;L(dggcf-v}UV>}R$ zeQ*QPOabmTgfhiCA(Z4$6-P(p6X)yo+h+Zz8TMkzMU`wjjRV8KU)DiPX$254Uf1|)^>RB#LyKKmys06d;hv6!#P!VKgj2*@j~TBDNf z>l%&r5SV%O(-^+J;$~)Ek7xKl33`~L^Et|cKvtmFO=ra{NBC(~)q1gEU$7&wLE1@} z;I~W)gSt2L3i-&j17*DEk#Vc--EZFrHNA!o0-12W7d5V?cm#!|v^@bvFze?4(5V@M z*fs0oLxwoKSJ9<5OAVn!iw)KtDGSs=xv|8z3#mhSFhdbwyaK1nY}SJ#ecOJ;2^0fG zJ8LAc;3%o^gKIs260?4o7Rutih<&q|N(a6bw z%TTVaL>#Tj;3-hyPmBr`0(yABNi(tVqHZDGYz+i1(0wF)!~YPweAbQ!uxE}|Qkrqr z%i#_Ac~zJ#0uXZ_7bC-92;&F~h!F(;(Y}~9Hh5X>2&Y;1#VBX$z}u?MadBX1=qLd;50li}A;A?ITl~=laXP z{D~Y#nlx9^|Hyo+{-^oaKJlf-FnImCL?HCN5FtyS$sbLGu`8w5DECg3)V>mZ8rlgz z{d?jEpWV1LLfAKRwfd+>cOgV>kAnH$UZ!df{275~22eyndE{g{VI? zf6L5cnaaOxOXwm%hjhrF`?b8=Zdv7Rb-$Mf^!~m2BSLYz`}X(h(-~-pExzU1`r_{Xm$Oj* z0Zhbm0f+G4>+gVvdFD|%!~2WRC%=9aU`yBD16a2Puk-BT)33MZ4&%i!x z%HQ(-+_ZQ5+5Dd=*PvcHh|Tc*-REB(?ghNkw{H=o1Fq-U!@c&a!5B5=fBks(KvLb? zUp{|U5X`2YJNdr`H8hl8A1O}~FY|v*`KG<*m3_WCyZ_bvCi~#S?Zx@|`RQ7)A>DWY zr;Mry&m9V8x8Cz#ZAU`+^M_l&Kf~{jXP+6J`Tgo-n8XUKI_Bw_vwR9Rr~u4 zTuuHj{Qjg6q3!SUUljwi{r&OePCf{~X_gwB-wn8P^SkL$^ZPcT``d)>Z#_74TmB)Y zo7)GHOWxg{{Ca->@cHxIStxgZkPhxV$S~zvY}IBh%)gMo{yI{udEI<*q}Z)l04bUj zOKUk&TUyKEVhwnI1ESpi+cf$sh~Dq~uPOG4w7>8CuPOGK^c3&>&lfxMt9R_*wpc?J z&Di39j}&X>ulYAA);wQB>}UCvI4%79{w`YJN|8Ujq{Y!U?Tz*F* zuoV5ie=Ok+E#p|2+pYDsM zClV07)LW}q%$Cd$VeGD&g`EgCH2PGRHe35UqJs}ijCes!1rv!NY@|k zf8qnMxm!N4y890g-#^I0JqSXq|BGR`N9#41!GGuv8BzPkde=UG0a5V-Z7nsVa=+A0 zarIjMxh9?R{nDv?_DK7J1xs zv?<+);@wxohyQWli+k4VZuM<_zk@uwU#$gc@4)kKa;bHf!R|+!yY2pXm47_0H_yx4 z?JE#z2Ws~2DF@zc?_Q7BN-tP)DEjWem*M5|$TXM|M~C&I*Rbwz!HzmKv-`K(`^|UJ z`z()E`AUzEj|r)kD^9mTqFWxeo5v--Gq3iwQ|j9%vWe9{)jrf1fapV_Q-K3D4e5g= z`f7F(`^UW5t)Bp5g9m>hC?Bd45>#KVZTANkse7>6YCPlV^C#zP9B!7@U(@T$EYaGrO;kjxRMexX0Ar ze(#xyPGtj|F$Zyi1SpbMVHh9;PH}W5>k~2B=T97-gK8-&OKD94?9oBhP zg4MwnIgwJq-R4(PLlC2h%Nz?3DZ782=lwaz9wcs^6F~X93AH4Q7Ue#AIqs$sG#Mu4 z(~w9q;+rK9(P;?UK71NtHO1!GeDq6rLuNx>%+bWU`oau-8s#JxoZ+2L$DtR~^G{<8 zO5lu;!}OmwCrgkVLWKoU+2nvDa^hx~yqcnjn@qEs3XA>q&*z|o{ZvlG>kH(D#cx+P zafRhHBbQL_=d~YZ_7gE9C8!qC(rNsS#JK?k!bj)h^TByP1oVEYYwYM~Xz4`uEU1{F z>x&toVkDJf%`XNQ{V=tkhg0&+^&u?AdnQfw+pj(k3DhRTI_99O{=X!MJLqD0M;;7v z7VC&LX?Z@9!J6qX?Pa*ORXO2k^yMPyOFkO%KP-}v z`uOa0U##*WOZZetGD#sF=LQh^0!T_GnZVi!3$6{HQH2kQ zt|N%k(}C${HNgOenVatj?22akGwN6ZAAy2smd<=foD=cM_?kd=+pj-rV?vUM(rj7} z=KO(QougQ%MQQu1Wk@S0nNGhxR-U!}_@34?DZxF#+4t+?7XZYOH_pbsWOFaaI z&+&}>`iS;UR&TT3r$wrHPW*{<$1kGlVuDjE)qrgQQV+)0ua83syL27iBxQ1ZD53JU zJExuQV4@)0yOg#}Jr8j`HDQbZWKhO6bIl>UGN>fdpPFUKa7)o~xnk+KG{YP&s?ruR z9CGRPH0l_3KELWt+N8@xhEn{0b!Q8(r|MnP{$x4RLk3jp@ymYRndfW_ zMh4bd!7+d0?Q#i#1*y3y<1k$@Vqh=}4!Y9k`J%=XPDw+^nfWOs&dK&?Od@;EXd!t|hHtkc z?rl*SAfqJQRX4Jm;dHeog9$Jqoc`@4puuhYDB3RGsgo` zUA5hjz9d7RR2a_5cT5>whyUGfpVIz-XC!f^5@YSD=d43Ll&J?|S_|Vk>C{6oB}cN9 z89d^Vo)bvBN%}*PyZ|%A)w6KoKi6+Ng~hxY0F@v|2;}3J{o{GG>;z|Jq{tBRaXZj6 zGFuO+>Ze5O$sFEDR53Qmb=v1?mb0itsw-R8^}7E~C}3326r=$1Q&OfcKmszZw4T{$ zKJAk%UZ6rHI(7D16v+&RofjTs4NdoD3CjOF_9^3PXEsI5bj!$ zBTXnw&5{C%m@XIb*o4dA<{(`L>_y$O6Y2qZrr>N><|CUu`#%S%VEY5$6j%u|gO2SU z*rSVTIv8b2@QdxsXpNuM7{rVq#DM`Z$R|WFfQ%C;>@1Od1iS*j0Rah-IaE}Vb+viH zoEbVqA#msxmD10(g4hfNo;>36QfM*-=(@Za$tz^C)HJz+k9csN|t@-KhvDzIrg!nUuq+e|Ptmu<-%eusNE^P&0m6@@b9f%t zQ+GKLPIzz!gVKa=naW0v3TQM&hmt-4hbkyFNuTVwH0S{a1>_n*AI(NMR1=|ZRWZcF z6LmndgA;j;nug#%RYb)KsQ?P7J`d^U#Oabuyv=dySwVd5q$b?2Ye_e1?+pWN4tAc( z3ShAXL8Wr4z{C_7K5Y&RL~s+)n6yN9-sPDU*F4-AW#5UnFB8y_C-A}^_XVm|wz(~2 z1px{bfbapaL?M5sYUt6akw+;6f=yQ9T^biUiwoh#InRJ&^ulj*9-4EWnr37u71V;b zrjxiPK>LWHl+oEfoyUdhY&4naMu5{f?$cpCl0t3)S|c_29ej3RGSOPhh@ltu^z!;m z8E?8ObAsSX_!xzlY$by84!?luO#HT!%j03r1MVT}AspO25xCtOiCzOxWkAI$RUT?j zjYOs-et$e3j7z27wooFRQV54lxR?-uoy(JG121N?Ie>HNgrCNR$}u1-da<)L8NggN zFy750G)}?|ZK3nvBr1gf^W<<5NzN8Ji3>?;+=br%Y@zeGPc<78rqEDumB1?jiz_a~mG6O3Vx>CGr#Zp|q~sxGpr0Xv{lPbsv|i zC!FcEP;fL2mQ4?PpiWoxO?bI2Rh*g4N2vk#MUZ9FQm09&IonTl1%A&61B#V0Qr7}7 zY1KN~7Ekw4@6i_nX{C~+EmfSvEu#LCBRlQad0Yy#L{t9RCUns{Nw?3$Rp{m&sJmNB4#*=t~02;2VxvY;lLQ;wtE^?5!MIxe)SxCAbPbu;%poaiXd9B*3J4Tng;53gFV+30VcPyQT)41=W*^KKFh6-38X3^E_ z9nO;)V`wL91S0|xIGqO+nNcZpbQL(-)RjHot0u2=YZ&(A?z+e@2RHi5w=4_SD6h2qFirlh5{q5MA*P!Ao!Ni zVG(QG0M;8;h&!qm_Y)!4taKvsF(wim|NXT$2z*huz^&pYA`LPTzP98FJ?sG*Rt_ZX zJBpmw*VWxOcl<^|FQvq2*SETglLOtF00|0qb>7f3PAspRz&#<4jDzO=5G2tkl7vLVK|c#NeztBF-*V{kD`3A(iBFr`K%h||M#&zAN` zrxZsE!5p&xTfWp~sWT9R0jf<8s?r|C)P>TiKhdK&P)?#nr4$&4C8MN8O0}BJNYyh$ z!k-aY3%+E#v(MjBxs6hjfrP%w7==rion|Sg#IidWtLDJmmeMW66^?K*)xFWL*18lK zmk4+7=fueg+HiDbDqnI=>vU3k63a4m%hnb`Wqb|1WUZ2 zega85A6ByBl1=f(WmAl0bs#JH^8sh6(CYwHOv794%pwWZQ-M8JO7siV;dEdo)f0*5 zYwduAQ-wumU%eOrC!yEY5x{sy_#s#-xEScnF65{^%y$6H8&2mS0BXPdL?nh7u$lqF z7@_H)l%Lg;&a94lgCWuVs=u&IvtToYnV=Nd!UMPkbwxJ8h{z~5C4`k2ZHn32U;}0@ zC?*izoReDH%TMh&y6kwvfe6wEpJoKC4+GdY`-3caz)9M^fmkPJpgH56W(fOCR17oY z0@Qe^%~^eYvAA!;EJIbJ=Yt(WaT-s^Fb80RaCm>{vIdPZK5Db5fsFv?Sw$JKrun9= z*s9PcI8=bfsXRk89^Q0omH!mOv<*Uw*T$G)R{u{i?t3UKglau$_}c8Po?_K_4ra2{ z<|*6v&5HUI!z4J63;<~{dvBl^nhgK~JV~;jzRGIqMu;Yaq#FSA3mwIcT4`TuBlQc~ z3yRrA;Fyb-bTOUNtgJlz(U%l4$}(G=CAgH%!8S{3E7%UUZzD{F%!#W^Wdn!d9+S}s zc;uo2Vx}ddGuc(KBt@GQkXQswCv9@LMk5$i7+6664YlbWO>1NK;YuRhs@gm|)u^y~ z1YRYl@Bu6N?lgM6n2aszp)|LX=OeP8x2_jQT z-;~ezEn(+v3~n*K6Z(LR+!^X^(I`hg%cj^&l4T)5#dJC@uN|^%OT7uLk|Gb% z(tD&mz0T)x^%x4sUx4Fme8`>8t@3vSW;Kcmj@G1Dah?>Lj2ECD%Fz8pa*%fg5`-2K zE$Qk(fR3g5@^)F~(`-ggH#yGj5Q<32P2Xk{WPNoE^_A%DJC$4JRe>w6x=7mE&gU@! za;hR$sac4=9dY0z{lSRCaHbb+Fa=#6WbVAPG;x(9G93++hJVnba46e@*n+-|IhjV ze)RvpM8DFv`kRGqF}mr^1gQ)V$#g>BVtU2=1JLZ;T*8sWh$fi@(O-a~Tgn5EcOfElCEU6-~IURg$al6AY$Mz_fDfSK$ElW273iTCa zUYV+T39c#GhrFLp#1Ew$*A$XQB$Ir4A03&LBj{9p7Oxlw%B|fvVf>qMgTr zIpr3(;SYecOBR=H5Y02D_c<;$>CNpdt&i&wpy?p5=sa7oGO2I87)=EWGHzF{K5@Gw zIa^4&fK;A|u2O_ROvu0oQl@LypV*zN1Lf3yu9m~tp(t4o+(gKwrPlvq@2gvEUe-W) z7%u_p6U`tRh;IMvAxpXWWU!c#tFALINx21nb6E7c^;r==>j@qf8TNz@n%*_esYV{8 zoa9=-q!P+`nu+dllmoh(NE}%=cUSVYrt6Di0S03@o=7OhpE|xYP~Tz(w2d0k#GT;? zJIJ`SlDP$CH1%0JJ$*>%9?RE^M4KHtWf&2?;CshO0yTW5f2;tE;m{R}>7n~v#pLgY;!xUudy;&sDJf<{esV79W8l>Q2m-vLi1^?Ch4 zqwTY*H!>h`eeC1k(Jg0nZcIYo& zHzMJR{#e5{{7!4=G@d`)W4V#)IK)1tB3AaeeiEcvyKZEB$`?)%9rbS>Nk@zW6BuUE zRO~^^Y^5m5;rBvzOWo(uohv%^vmWlS3sSqLq6YO@S%Y%<6sS$>zTNPlc)U{_M@OVd zPUjg}Fxuym*ajC`DHqRQnuX|&tMgdAeeq`e+< zvytJZy4Gl0mi253QmhOYHt8u<4JYw9D%dHRw_>r5VGofCfXeH|oE~M zQZP7^$Sx8L(6BwU;AHHAWfG%*w8RuFu%pG@aa|q#%j2NkE&7C5<1YAlDhr z8X1fewEa{jK1US9=YKxYi1m2X>Ga@YKO^y7$}7`I+8lG_Xj*`}o%9j!s$|p{Bx@4+ z$ihTTpT*&E)JX6tS;=*!6*A=5V7Q7(WUVwE)p(xPI2z4R{pclKv3f40$okA3rYB}eUQFD+?=Sb5O)L;}~-}YFz!B!-E$x;v7eoAHs zEho{mN4tm&Kz?bF6}+(HHTyrJLzXU*#g>#uvVv(r%OMEVE^7Fzn)vKk@Z(Iz0-7og zWI((p^PR}k)QJ6uWa6US5ngPD5?zQXh)Yyis6T`$xURAoB)*s2~?B zESAzoR3oO+ebO|sw`5CG8HvNpt_`uXQH|pfS4lkxqUq@@HSv7~H(ue$O|YC7R+6T1 z-NJ8M#h-|7Pg1%a0~QW)K|0@wegwZc;2io+*O|(3@lua-tf~OrrZpxvV``j`)Pa;^ zI*p>)!lQ*KA=ObvJ7$cZGb%9Itaf&=4=8C}C(K`8k*YG{B_O$aoMq7+AT$)Y? zW5pXPs_~=|I0_M~A}60@zA@S2?x*gUp0wPiPE^a}kR>(Cgv)+&2Hr`CMw2zz_HmMr z`{*xaWum=x{v+~Ap+*uCEOHIMO$*v93I&PU8q7Nm@o5M<1*ceZ$mNz!cxSg3V4Q#@ zE(djd@W=~dqJUz&}ghP9BeD+h>(NIz$2rBq}d6Cyhl~UGrahhcrFw-(u6R9hpq<6WJe9b7Tz6Ky$Om-u?YSf-=#%pDzZh3Q#MG9dBS zmqABFcKRbS;gf(DQ!4;2#+KBa9SPaa&=V0JD8d_9tRAn7NlKj1sIkD#hc~U8M&Ei@ z1x~>llp4GpC>RYUxieD`sCQgteT{a?BOl9L;OZq+t{j9>jfwVzf_O8l7A@Tf@x70N z1n3dUoZ2K(AOKQy3^>yZ!dTK8V+9!n;bi?>L(uF-NPXcb2n-9RFX3hJU{d122#V6E zbwEF6bD+j4Izb0b64#hg4;k4C{Du5Q%r9Zr#7K?gKbux+ZjNe9M0F`h5CAqH1{2Za z`H#qhf`ZucI51^frv>Bfk4bfk9kfHZXK9UCPrzSLjapPA1(O=_f5MZeOONUFNY(=A zOvnsIVV!i71CEQ}V7dT5K3T#f9*cb8sEDUHz){fio%Y5UA8_?xT+ebc6ll}#@IB!C zOO2z!G{;5T6{OO(!eq}7s5&A?fnFM2_`KSzFgYiKsYjfcAnl}sIf<{yG>yIjNDSEu zF;S$l3@}}F1-?&nw(9*7;jnX!La-*sCF#POi>SKQyt=c-a%Ljrpfu(6={&|#Pdy*u zO{N~yEFnyu;Cdj>5W)#*k7^{yGNj zsMtV*8e!mK*C=S&{_^B6oT~XC$8s@MXM}{(Bc&V#$2dshHBA@Nf_6)cxe?bxQi#Zw zV4B1+Uos51>~WSbDLKw@LM3mrxMMi27sp|9V+u1$$*NC`i-w6rKKfO5!M!sf{)sc|uI&J3{4eA*_G-<5Y2pw*F;I29B|B$ z^U78z{!wY`IEk?AvhK3MEtN!fH|i__Ds(6FZy);HSV29Sl0s=BUOjsx!s2829i4Ap1{OWtPggQgQ)9gZ5)TQ4kRO*qT?c$wh)NZ!`X$8SU29Va`%zxjNBiSD?8o9hptque|)$lVP{eh z*iCn(vBc>$GmDZzGl)={Tzy-2U7)JaMuE~hf@PCa~d-e-UX;A1OtUo@ZHv#1=9&s|ab zY~x~~O}beEur;oOJonuxeqNjb*iJm?0w9krlpnKYmtI6XurCP>#w^s;prx^FBvKt^ zvr#|qoG>Y7mXw?pV4sRm6OX9Fy~GQu9yjh>jW(itWui_%Zqe4r#77%5l_)7$f+^5Z z{~VBhsuC*=IkeJl;&YiyJfN!*-7T6Tc5rknh-_>$4!$6AfOIoj_3q(X;bf1JQ)tc~ zuGMP)$DzX&>)wc9D`Cf0xk_f9*WK2D1JODVS>Qi<<&Lqmbw)HF)dl=RgaAf_a#y2} zy6T28A%`M)>NVLe<_J`4i^fV+*&IYMzycrUD@5kHNFY>jJDARd&TZj{b?c}gHnRniKFbI0>h!c9e4?@`;QprRWs6 zK!Bl=!K-^jS`@Pt8p?ubP!+xyGC4t4V8-8ef(ob@`vbxJUWer5&i(v;$dKd(7 zTGz1ojyM#t6pCW>nol$yR+RI)tBp0r)(Y;|0>y-g%+2syufv24#w2#duT;b=iBlz$ z8ma9Vo$4j69e6?pPZDwV)k4=TYE94-C8!QYDNLRdvf6t*ijD@7k zcxdDRT1`s3QSgJzm7LDhXQn-_H!|_ZbxVbMMUOt}NVIjQM zCF?~8fDYl1xM!nFeoZH-L`5?$1Om+HYkl=rh|aZbLQ2#MtTd$-vE&#PY#fVBNzrWr zK27^<0?#odqySH&ga%9Gp1w26C%Z7=niIgqa+26;oGYVxM^QpiF5(%{L9PRSA6%{X zia-*xffB=jAYV~bt}l%<3`{7|rBN%*qoGf&_|RY?)JW28;wmyyqxxxm;B*y-z>bBE zY`<8Q7U)@}1B(1?&g^8eNSF!Y5JBp`*6rOLK>4g}8VX6R_%Gmi&mMC)8qK<{pT93x z_XY|?ih}fx;7teY)+!EAc0J|-H&C>(V99Xno6-QWpEv|78}R$7Ju~7v@uVkkKQ8Vi zA%R2`pd^8Fcr$v{Y$RT!gtY+3CLe-8lT5(=&&_}SW5Dcz&OsqCl)zCYz>|vS*aEK- zEdgc8u3Hj7MOk51?@(buNPfOpI1e-i=IdIG?$c&9GO zb_58@&Os64!q7~E;Tr5m%QlK0>;=4BwI6z?APt*8fUQeee9?yv$KgO(%eg2!;+E=S zvksKC43V<*7KK9F-St+Ix%~9|#&9``N`iGf)0?v2P_MddNXr)i2oG$I91G&BC}B>A zG{?zO5Y7g#558N9u`bz@*3YunjLb*9I8u!(s~M8^Hr)ecmJd0?4*A!1 zAoM6p%nv9&Ugk>01IxiEOJ|W$85$c+&+gNaiquZ1wbLL5B7l;Fa$-vFKq6A@bi{Q> zEwEv)(?Zv*OW6t_F^p8yYvsNJY75HN6=AJ`H6~2VpvO}daHv_Oh>Pr?bQ-K(0-lHs z8bP&nH)!SQ z^6VH%PO+>aun9xO0HM)W{=7)RmJ2+#K^>f`7i8oM+r2SU7MMl?dc6!{yPTr=OWDO- zl+yGe-WDBn<)TLf#BAVDv*~Y#|3}v0DWoGz*IdY_*nI9fuox8w!2tPXBEy94TEA`_mY$j?gXTjv9pp1XoBzUSRL^hSz>97 z9CauQ1O%QDLg|z>B0O9@mf$GM{;9a0G<|T#iDvSX+k{!+X-`D+0kOYLS#uVDR}Ezt z8-*uqAW4eUNW6a29WXnRNT|Yt6$f7m3rZ!B@M}et#VMGCi_ylQ@EkM|CuzhR8E>FO zl$&x@2Tk3@M;$O+L{<(8gGi09pOCNyvA%PuqA=*UeYiw38`<@#CJ-c)^>)KCU_eVK z3~T~kma^&MKI2)|>2p3T0clYr-vhemq|YQxDJ3XHYF@qV*YE7-DN@9A2I7S1ICOyT z7seeOG$GM7#eK#JsM}|fZxBbNHCtT&hHINGO*e3ML%MY}Z?-#l#edd*2kv9{9Zv6l z1zda+RY0k7{e8_?H3J|iK#anP!rX}^DH(m%6!m7~U6U~SEuv>6>P+2)Y;PoJYS9q)>($dEYMNzNP?`3KyIT|( z$?3B_?!1mT*(t}&GPE=an0={K8EMY1Oyk`O@_$DcimYXMhua}bY)E35K zN_3(!PkWv8I-R5&pwtbrg~FFc^L#*ZoMLzx6nI}8QA9?Zj>1)z3p8|xM7!X-6rOYN zVL_&_?X$lDr+r4jEzlJdX1P?7^ki!J9RiNWCf`kI(?QK zLVUrUic1=zp1NGit?E5qKJAfZu%c=wWm&%OhZyaY`H+Z9uz2W(CgQ_r__Fp05{b!> znsK!&%DJ4u2e@c5b@K(d#C;WHtH^)OMoj)La}hnJyUX6xBa@rko!ri=vtV zrB%?@n_h7pav#!!zH$3sn zeaZdl<}mbw(o-V2`s(1Qu>(qXhL=7Vc1~$fn)7yuUIh{~813t z)|@|Z?BqvjlA(~jLUxRqH@}c4qi7dUS~9gwo77d2K|!r0mi{PRPb))N1WKCuNNK)TeFcA$##WhpkpVm|O$4!f%p%M|paAWKuO4Ew-Z#{R5Q zT7dA?=oasHxAc+6IHjkO(E;QGFV#O7ZP8W@ic!C@V~sgI7-a$`4gn_0Y3fGjjrFa2 zhxI+N!Vskiu0bZVid4%klik1xjlPe3oxb1qVy|>suKn^>WIEgL96dn>5-k0W=R}3W z_!yfZcj65-Rrx+Ht@2Q(bV2%wkphUZiw(QdJ-H^&vh4}iNF0t8_IR=L_s+rgO?@B- z+aC#45g#-!=1$6C6GqCL?&^?G1Bg_wEPd)2&(gX<-GO9#*KaS9hGu;q?5$7R`!{5| z%d@EG0DWXb#mIm$`1A3I4rPYgiI99k0+?}T#hrL9w@<8@l%7n6#1zY}Pa-Ru3z+T6 z1V`FFSXj;4eNzRC( z;VzGrjZsQsujF({`41?f_}r8G*Y7p&Z}95va*x|+uT5t;@R=bF%%LW_t?6{(b}eD` zq$*X33NhpD>Af2v{YFiTf4hwGK)+K?IK{hd&~FUi{xoZeFgE#6_kyd~P~*^{SnrV6 zx{}AT&#VXhKmMX<*;9_9*ZP!4lx&7xktTp<@kLR zzB=mx3P`er1DHF$bbLAhQUWrSIwyB$uw4DL%4zE6CRq;qtu%eNecbLEePj~NCZ(}! z;Hkn|9vo%N!E0Q!$1aO;Bt>{LN3x4+pnJv+9P|Lirg9h-Km1lToq`#qy_eXvWaHq{ zZ+)P`ny3Cnv)-aV;gYXXTTE4MzN7FNN`u)s10{_)3EcjO5l2cd#II1UX9w$!*Ai{f z6dkGT;#5@ko79Yw>l|?WxUlCEIWhX~vGFd>&VFf8^Bj8K$IbKQ#rO5y>E*?PRTh*0 zZ*u`c2|$AoeRtKOHKRD7Z{TWB+TM>bD>(n*NE$ACBhc_lT&E~*4uAKj+h0bFLvidp zEQ2_0=-}<*`a?C0p5owV4sw+)oOZ3l+T+@%gpWqhlz}9~R1|rVQ9BuV7C@IBR)4MPFf&N-qt1{ciNLNBsCJR_)ysq9E!!4{`DAFw!KxMV=dn$u2ABaqFcG`REcwY7-yl#OKX66|3C zRU0g1I5@PyYJwBN_HP-Jl1ZTiYSn9$Mv}sBh_#Oo*A{Xx4T-F zNC#Kqu*=Q0AAltPPXN1{lc7uT_>B&5f@sy|ui}vQNRDObzT-GU?GisN4$j({#?z2^ z60y>!EV;xrl>{h@JW+FabMArSWZwe_NhgwdhQd6(s}E*!$t-*I0$B;&ZnI2YY`fjO zE`gBSro4biHZ+KYE&El~)ofg}Q-QOD<%6Ch&a%F^E3t$}zOI)m-LRI#7FmuoMv~=( zX72nYpZST3k(OB+q|4o`e-%IoY@XWThFcx}~+Dd8sEA z6Fq_Vqx+1BnLL&f%f`Ye0Qf3o*rOL+$&$`0U zMEGDIKnl-Zgx4YKVEKRk`X(l!lV5%b41@Ay5F>0uSZU|r{S5^I-x|4!@@Q=e0i+~{ z^Y5~_`3i*~vdQcA^5X0I_449ri|hKkyK39`ic9$%5BI!r@lj#5b6<@5 zGl8pCGZC0tg~f5-RqC%$YEBO%9q<>D9|;K&NdU~fqTL-L(bJSf0gD@BxD`qJptKt2 zW~_Q(ae=pn`YhhoqUgkd#O!MjxsU8>0>MX^;=tyPID?b%O%0kR;aD9U1>l-`e+Vu_ zvFSE(@2{|S5%~_t3d1}^Wr@RT)vLid2esyyRu+VtnDY?7g5#7X2|qOL2_g>l*O)np zPieNIKe~@xDk}Ux!1TvzLjMg@VBA9VInHE}d^pE7b}VU_jBjxQ~xg4I7kERhcgMkDi) zlBUtrHg=1X*iV~ zGFgW)xNsu~ubI|2mz3+6EIsc{P}+h|BMTidw`S0ZeM~;ca^jaL&k#I8#GAp2EprZm z{;(jRx9QPW^uo5hLuo5*c z?K4!oVv;yMPew-Ig95~isfG^u`SCK>5w%$j8yI8IRs1*O)u7F}bx2$rYD8P|29DIV zfw7yC?R3S$HeZlFeD3n4c0>f%NSxdj5hugbj#M4ba>!7)fI zFV_gf$&%n{OeO^8HdfpmVKy}ZRA4+gK!2gq&Pa&8#1F~#sQ{l${6Lyf_}lO5b^Elr zLkaaJp+C|3O=p8C&h!5Ae&8%k1h$&+aD@0m6ShgObhR3Z=a4%MU(9MOSBm&^_@qdV z>l$yJ2~e5JHDjteVtV6?s*l*_9K}S`PRTcQEvtLz=n#}LQGjVX*dY?|Y9%+Vv>_S*WR@sY)L&>!8)WAJ;f^Sdztng) zLT2)BsB3{NGs+}iksIOBS+SqsI7=F1-LYeoUm*^Evd23Ye($C$tM+1^nFdF z4z2u+8^uD>34qb2qBfr(=XhKyUw>DWTmYCz_OLOLZ}APHL4dxz*gib$*RR;-o2eBu zh}=l*5`sWT5@UvEuEVW&6%a4Rp;)*r;_nO+yrbZ_(_(i zC0aNKK4~M34(fszz~D)MlulyGmaL3wTbU1-4>FxX!JQ3y@RVHOeokx(G3tDhwqhlh zwiU3Z1}K2Yb~WkUaC`W2mC5|tJHAXBw|#dju^(bRDWD~p>aJ#B(}c4_zVhCF2vQ^1 z!CZe?Bdc|~3mVbo{_OQG`lceYHmb8`kveLQ7ov&nZHAGJYR+=Wy<%t~QjKh!Lz8U> zCAmb)wmYiR&iUyt(v*@@L2@e5F5XtCYC7{tCrgkt|s4L1ShIrwj&df?#M71 zwr}{54Ds`6#kY2qn`@?DX8X;ANtghW-t_IoXI@gH1ow)~-ClL+(KqvYUgC*B-|Px` z$z7!(wP@LI1krLa5v0Q+|MYp4=2?3Q4@l7VkHv!Dhkm?8yCYiG?PXrQf-ztA8#WO+cI38yP@Zm#-S!hq4xE7M zBpQs0>1qjK}?RBhO-McO39&R$v-`V3E!y{42kc}MgF}b|5<2<`c zHCRZVwjD$U)X5sTmWPAf#S#b`7v8vs$wlAPi;UbN?b*`s@AsA$RbPQRUG$Gadd+<) znmM`D+jeRs0HV?B_vK5GZqdpc5i`^QH4)_ts&7jia?YX#SbksaHo{bwU*)d4G;E)5 z#z1hA7)QugQc*T%v*e>(0pgF>q-vOKJLocjBSmrGv<=k?^N;!;U0&R36gCQnNAdhr z^MU;mK(sM@vX$DJ*>sLZ>1=Yw;`i%6!6)D5z8 zlX~vBJVq5o^VO{eEk3TELQ67RhqrwFqfjRe``us4S%o;*(AaGAU9 zH?Hof#cx;d%%=Si?Ojd61g!tM z?)~eV;qhg#ABtn}g2UQ>SU+>9M`tLrq&Q}rsW1lnDYgwzCW&kCqr4fO{Jl1dJ{kJR zirIXqH^lT@a?|r=Zd)XRrUofT>{_Wb97#|1o4Ue^F;GafgYvi2XBS3N1?PtV!9H<< zJ+d^D(nsl9V{W#>9Pc~}x@D@iFXlYp!wQI%9GL8PbsP8VhZPQdp_d@_6kstTi2EZe zY@qhUi&1R=I74j!W-9g~zvPX8FQ=4~3ei1WUMROTq86|JQD% zLL125eKQgNw9V}gEGF)m?~YUAlsO&3IE9T5Py#DJH{!Bs=I90{Xc}kL5iwa||Dspl zaRzj^uMwGukp<#X@|?X(W?hy>XeO#~1U>RT1=YZ)RgHSsMBy5^%Z9AQ>9c z6USqcz5>0_EXmFA^zwvQkb``~c9m$gIqAQIfE+KrZaJ?wD?5mP?-~?+S5}jZB!Ffo z+a+Q9;zqVx{Kxb5Pd-P@9-7483{5S#ilv>LLt89z zYcffzL2s4RAd)kY(K@LomUHBK7$(@ZP0r~V%7aGYzgDv=bn0N(n`;qlOX3Z~hgfue-;e1qlVSy9e z>>T_3tzSb44NREdHV+bRc!}BIw{VvSjHd?TX5J_2(S3SMWO9439p7kx6`MP2hC_~L z`NvLq{WAKn!azcP)rKaog{Fs&JqP+{S=sgWyG(KnbH(uuX2*{B&W97?>E7S4Cz2M?5s~?k4eN$@R02v`9Fh<@$M+WJrsJpDm*?h+{m`gg!eECY0%Q3mRPS$7 zu@eGq9iX3L*9M2|crVPMcX{z`#gXuhc=T>RMox%ebNfvmx-sg(Hc;wP z*9}0FY9zc_?evQGx_ROV;=aZN$|MLO$dO^cCVA-?E&>AE-xCmY5SzdeXcz3Qd?F$A z?~cK%%MOhJjR)8PFhb7#_bi>xDJ9epxEknGM6FCF7);-YeIF#_6wL#VC8=^Sh)X2kW88*}u2C+ytG_6`;dW&pPZGL;gm<|gj&WwaxJfq=ph zN)n&H+=<>=-YkCTJvXraXoT}lbCE(dxOsYeQjyWA!Gn}+Hy`l5`|BIz>gbQybveP*24Q8a_$tohp+8dO3;lXrJ8^iLP zn)Kox>gR$IW&jkg65v$Hx6?>^O^n(G{X4tt2^}6==1tD$TeEEd5E*7OQnpxGuU&U( z_GR_Toqx~ujrK#6M2iDRMpB2rSo3DQ*fw^X+c(o`MmZr$87aaF5ncy^tiO6)$x76_ z%~xXP12ie_GhnM@njZhvdOI{k=IyJZB!;Dm%`7v* zC6WY~c+dBhxVrecaC==*ymP@6lcLgx`X!PLe%9ZuKkW=88qOb9bKWG+S9 z96rUri-hcb(NPB`X~&J{hTK{=a*ZKY)qcqVjVTft-?61sa%=VDD!0|)OJu$UPUl3J z`!9!&Bo2TUHF)Ln;!kwMj+uM$ulPiEZcJ8__YVO(ZEr6|ElCyJO3Nu3 z1OK85fBEC)NL1AATNwCA@QMdz&emwoPp9Xj&#Tuv_G80>R4s2mob}NZEYxE`b`PQB zH?7#nPB5}ID`r2$8vtw@;I7^uwjdsg?8|OmgDn_p$jD^SM+ryX-2bl6m>$4xsAhzt z`KDFQ&YoUgMQzlG+XOF(i7zzBiO;PCcb#L@p~UR?jyP%AFG;<;Ad0gx)G^t7WnM>% zf;NTMSrQ4Ka@37b-I6SmR1l1R19L_tgJ-2*Wo-O_bkq_BsfCybqwkq%C~1H(W;sWj0ys$ zh%Oti;&u75VwalcpaYU)=HTnwevbTnc6!>552Y2pPEejWbPTyDO8|*|O8_{babg(v zp2tBpB=DakbcC*mSKt*I^eCR4sMq{ zHS^Ogw3lH6#b{wwxQ&aiLMdZVcmt@rP% z&Fl3~vwTE0mskQp(%~($agxl&Vu+XM6k2R9E7$1S+PaCKElN^li*t(4K~#sWM)WHN zkU0*{yvCz+{rl$r^_%$^usf9TO;XjIGwd}Sw0uoiJc0Vs@BZE0+f&pvVpB=}ff7Wf zb10x8lKse3&Uv}0#CS}wm1K_)*LM3lCxHp~1YYOR^E#Rp2{gs7F+i)+reQh{|qWUJJ{leHr<@N6M+cp_D z;u^`R)TybNwFlES;5x*WW5H@C^)z}7JPxwzyyxTvr5O7)GujuGef#xE^z|I1JBQTf z+dhw8<6A>!4ey>Oq+}eDiTle)6c4^Cm8+m5Nia>@^oy4Yqd*E*cjDRCAfnVWMa5E9 z7X?F7IdsM$Aqxs6bk@6`5?om;Dq_jG9&<`U`bOhwSZf+Db#G7R9Gw{8Q?=|djsH%1 zzQBEfG(7UU*#?$c5S05!e?qCvibbypb~ zEu<*U`pLj~&!jAJr6%~eo&jc2=0x((34K)0zakb7rasnGuRJ9Kr_n6Lz>5!U7aU#H~xT>hit> zHK~bU0!u#WeKyMR0kjhzI4d!Vz`Eyv+w`u^PRD1bgR|5A*{SIqo^~Vv6c!>T&(73l zXgP7PH`N2BWj`n36j0Nd-)nQR1O@q+iz8|3OX85IU-x00mYetNbd*mrcZwz*AK>yn z8<42ZFlXSlO#73Z^P7-LzL&M>^dFZ45*;XDZ?V_PZOjwVjHv5KU?KapA?vvQa!dy` zh)S<;F*D(N&|!Kr8vmwqs=^dy<1!(NT3VC0MzQjc0%zM*80lJCW8k_ef zwukp4QgoouFy9-vPTrHcY(b0>@BR2JLICgCb;L#K_*4v%iqAmw<}*_A^k z8sD6lLnl=<^_wth>aRH-XKK)I-kadmd5@g+@CHSO_3z2SXWA!|RZX;-E}!E|q;j_J zXM$2uOaGehqxL050lvdBKmI)lFwOUP4nQ30*TTMb#A`VV=~x#Cn#y^$g5i>^A42A0 zM0N#Jf874GfPQrP1VKnoB-=dk%V-fz_enTv-V?=Ig3&0;;|`RBGZCQ%3a?@v_~C)v zX}+%|eKgiSzK1W5wr@Ce+WN%{Wdw*J?-k-L-CPSWMlcR3V-*=gL-|bo%nd;PN*)e| zE0XL`8G%G4*=eX>w@+L@cQsaL~&p{1Bfhmst2oRvzffiY3CuE&r5KigZvrMT*l@h}8-mj^P(1Is<_r;ydlESTEn!+ibutvI8jct+ z+9r5};MxLVk-QqAE>1pM*K`2rCIIXdU`pLpFfK405}~VtZlK<1j&V8fOTLMQd!w=n=HQUl?I zF7`}hJHJV61#_HqCrW#6P2)oV?d}Mt`mx?>X+o|@5t}0PmU}I}fWk#7(1fF#CdwQu zh?BqqAG1?k;^{vxHT52(<@;z!i_CljF0gWthN%u$wHgN_1mH^H*7#gb;-r&gBE}A? zi8CE1i6seYnB!~2QI5`v+Za9>;`(m}LGTNisTFO@4+3ChI|%OXXl@9%YIs%3Y35k{ z$#v=&&H0b>l+h6HkRggXIr(+4-EyWp+ZJlvLdktBdze8oQ|TZ%Y$P1W$vep5iMWP` z#V9Ml$P=0tYDh1R6e#eu6VG~8GyIX>O9^@fRRje{bT_nof)Zp47%7%8)X=>sQD8z2 z1dR|w?=zHmj(ZyrCIw(-qK|C1`ALM1MTr8C49993t{$y7VYNB84h3zb7kZc)BAxl-tOwg$^M-kW zLLDZ|e36Ja?+^6~-f;M&pZEX(->zpsLp~2N`4l9ITWEr`u=LSnaNhvqH<#1Yb&;i6 z?E=as)+MmHtEmEzHryf^D*D}mvrHCNuRT6^&9$d8di^yP`|)Zia*R$FKvE1#hO}5jNx&zRRaAO zv47F4*^eM_T4hYKD)``m%Z6nCU8Pp$O!=JYC)dW|fZMri#mVmW6Tt>9?z zG-mgdz|D&AHFJ4yFqf9KM)mIfYWFTrE-#mwG3=4x8=^jzVtaoeWK{#)dcDuR&mUAl zpn|+epYEs3GKL5DLmr=w!ry29?`xnw$v+>ya%&%cGky`x!-L;;(E4t@)h9ztHoH}Y zFGjxI{khuRe+W;mMA2q`-)x=tlzH^!#s64ruwweZueOhm{?C7{{`@dhf8SB#IQ~I( z4g8l&+W%p--GdKe_}<}mDOczZVi~_*%bybR`0-pH*!N9K z*$+Z+_aD631&?0lsri*j2&0%0WP+W7*cWg=lJ`lA2%-4zb#jbqeiSNRX8-rLdfa~yci5$Ok?*8cOWt+>kUQ@aMB>hS@k78+ z>yoxbZ@KdRKla|Gxs@bI7vpqKPq$<;lS%t)b{B2hiX_1ESTP?+AQM0$anCtb)!iFh z5Dy+skpvqc&!hL!uh2q2uJY(`bII>>bQ@bK{Pi16@u zUL+)$mNURpV@YOOzUR#0No|6*-xQQP@+xnCvwe+xE32a zt9ej$6-9-|II%Dj&^?)Ze%o-hf5!u_H~38Z0$+{98PNcN@PJVjHcTyJ=oRh3h$M?? zFmiFOpA!9!&d;~CwLtJEPul4sHvoKVQ^EgLtu%(g_Ao4DtvyuuVND;|aUVmR=!Jt_ z_7jdC750MO(gg-Mck3N>e)JV#$^5HI;;f$7B|M7MH{8T&A~t9RVBEqSxc@oiV6R7! zr_s?V$}R-VEE!)&-HE0T;(Ey2;M>#zGW<+R3$5*QVQ`!>uJ99<9{=Ra6#5jwMZnXDm`OKFppCq{SC@_yS zEgzc}Zv75M-FTy}ll0TjrRe@O+HL$nEnBwXvHl|XIJK83!1>a5U5D}AWARrkN|}yQ zA368%EUImNms(>pf)TQvCq0eCCC`-aJmg9u6xO7bV>E{1#xeWqc2W zwW54zQ(VhLZDNh&J|>!e^Y~@4T>CX*l4EBU`k{rr`Q&aDWueLVzRx&C%l9x@gh%u@ z>!7Rh3GD@G(QL#;UQv8_Ra2B`@Am~Je{JT`B!{nefBW0L-}p^Bx{SCKy8Q0@RT8&4+LyY(WZ8tVDQk&FjXSTU#IL6_m05P9MbLW1*a;1yJlwW9v zLJzgw-Lfy`Lxsn2gKt51B4f5dIUaFYLbT_y5Yp7CXp`#NGfxOZbfob}Ua|pLKF97( zSbSdZUq^T^2#?(eBgZYG+fs}WcbdU9v>E+aeE3*3Gkg>0JOaCjz+89c()J>B&fRi! z&OI}*%SgVLi*~-f2puM}t$gu0od~QgUq8aHAK}-J@ar$Y51(gyqD$Y@okT8_0XTbP_gov@&XIfwtuTXY7YcA1i7CV^hy5TFm6EmVZ90|=KnLXi;LYZ2>5 z%uHeNW>!fo;KLHmIOPH4PoFo~hKbr}Lw>ZNKiQ{0(-Rc&rDarDYc-qaiH1))xPtP# z6_bzWJ2bz4+WoZK->!QC2u(sY9dHfnmU|H;-rLwRzOMs{;iQ2e|PLpDzcR-q1*OORo;5A%4L* ze7ckjBpSqxkaoa_Fk}4z=?BDq5Rs)^JQnD{0129GbwD%H%teDzV8I9|m0TI9Cy{_S zc?3`}5m3d9IzQ3_#A3st?RDSr#yTDDZ~#daL%-YO@0P@Bn<>=!I>i5|=o*4!un!)@ z&*Q^}KHB5xIp#gx?4Qo2nBiGtAu$gT5bQzGalJY!E|0?TBX&nW)SCy~*rI?Yyo}p~ zaZ2ip$C4B?2Y#X+b&n~)65TOF^p+R>R>8)e@1DQwSGB)cKhJTw`4g?&qyONfAJn!k z@8wVa+n@j9z5m&J^KpOqvq`HqlWR)c^ahU`v188h(@urSe>AT^8DZ2-zW9uq_fFp@ z2Q3c8qB6MR&T3tA`jwZsfj-k$LY!fj(0%oYD6Lu}IGkZ1rz;_}fh*wIe|n+yuSX1~ zq+9PzohcF^`Z^a@d>oAq@;d-kAq}29Ecx&PpH1G2#Hza4_wWgM`09Py=?9Unim=a_!xRp1W?Uoc)z?ooZ%H~GSBFl=u!7{_44TnoxH+o zOEBjSh)VT9y7M-#jk;IcV(lPe@T?oW@o@TagYE)v+^ks}{;Mvh47f4X}{ul(`z?yJ$& z*X0urWW1f`>=W+qVF2CdbM|R>3tw;OI%qy+8+4xE4oGg0Arg907gau=jo@ zU(nw5yQ%0iZc~@k*4-mlk$G1>sea)VQ2FA~V!=`^ff!!q{o`Nv4x~B_&0?^leJAS| z^n)6r`w;!6TeE)CP1$=BtX0D{NSt=!UPlASJN&exb>f4`%C>w>GTYozFKgaxqt^i3 ztY&aS{U%t83hZHQGeTfo zvyZewK%KQNqE}@-H{xlutFoRN@LL2J`f**-`fl}dzqESuYqv*p6&k2DPxcM6@2(Hm z2wCqvJG>jDwgayQ?4YlSLObaF@c6`YZIih&3|jnG(*xZvVfK2zR+|pae!>a%vjsll zfa4y$cUKoTZ!g}u_qG4NJnvmxzS&y*O~3#CX8FdwFMI2^=S%y(dV96HeCOy_A%5%Q z*Ef)0v$E;8@A_|-n+yHVjf20xp#Lt<`9BF?Z~JeSE%@@i_|MAMKYx3<(zNtr`1CKf z3Todk-&|d8HV%Io;Coj}6ieTGcm7WD>%D*D@$W6Kd7GhoBT z{GK2)$vVgk`UE#aW`2Ec_zdUy`NjM5Uij;gZP|Fw+rNSgT>2pw^DfA?_>aJ`Urp9q zQ@65NnUWE?{Lhl97HXRAc}Q-^v{6eA^c*N8OdY;=a5G#C_kb+q@=7wpwS!y8wS&xX zIgzO$Gh731A^HSaNUpi{&);p8d1zt4CG4oF54lnO{o6OpWy!sjksrUBTbPNF$-q0v z4BGq#WCnbKn;{E-&#*R)z{uVH?Dl@Sruf5XDjt70Z1(eKMlQr*cSWKA6dYim8y?dw zV#Gem%vFfHrPo00MYY8DPoI}`yoENGTAXuO()5Yqeo~sXxQv zVb!+cHbgLXCpy)^R?N+`)CysJkRfJmH`wK9vDo><;Yl05H0fFxnH!LL1|-NC5+$Rp zkupyv#Y_?lvn>vXIQ5}LjDKW_^#D!`>3Dl~>o}D>}6ohsN+kEN8 z-k#z?+1_Q*cx!pA&;qlyl_!B;BCPLXKpa2wNQ3e~S_P5qM&+Zz|<`O6i zA>kE&881NdI=Io<#lYokzAxc$N0VY`$2ol_+`n`PJ!6>M(3e%qt||SALYuZ zj)eG>5v^P5o=UQ0jF$|bQwyzwPsVDKX%WY)hEqt4@P-(v+8e&Fg7v``%U11ilE4Z* zV9U-t?4gxKV1P`mfi2>wVR8}=)hc9Yww%Tv0yPZxin$u1N(k+d>ALNa@iBW;&J?-k zE(3jkn+NbFwknN+s2P=QD-Iq^WgTMM<|?~y?54oU^+*-F1MQZ<-9hcXF_z1(qKJA= zQxvbZJ9*PVtT+)no!;SPeKU!5T95?C{8pdIPr=DIA(#Y@=#z!ChU;^ZB+wS0?J~0B z)EM6zW_emjH!a$$J_pufV^LBD!BQu5AH>8akZvZ@lEH-AzN8NZ5IXA_=^y|t^v7>y zVgn;#xHe+gm>NtDYzv-5@-!H%WE!RW4h8a!m(4u;ofo--0#cVo4nZS90 zO!Mw>W0IhY17%A=R>Ut$+?a#ok?QDv1S%cW!Vs%#Gg`!atX_g?jPQ zk*!N&uNyNUTs#zvM-C!b0Vwjb?s@?jY2OT=p;~y^8-1;YsBFUE9DwPzWC=ZlUqpTP7w&@*3Cx9H5~KpmuHSvr_Ywry zqqsl-PD%&2HaPmOyARYCH+*x)TP#r!?6GMy+)qNsg<5e^B%uj_9~u-gw2=W*nV5nM zUN|@8F5@;{CMUvP;3Mbu)7`B|9bkO<>}5YP0bkxJAnLk&@ow+ik}x_A>syK1d@gGY zeXv?DRo<0M+p&&{a*1x64V#WeIV%gen|0GDsn?ZB#&LG`RwyB8iLIz=q24A@_aF(1 z>T$b+{(UW1Fx}hD{!QQ4j|Iz8Xke5wq;t0^-1*Iomav8b@{O`;n}o4vBxEqq9CsMD!v(7HdByHC`SzX=z1%3%m%Vtm*f)Xj`x2d1So=*SS; zL2-f+Sx{S3CYzXqADs$EhNcSww_iTij5!r+b(V3V%S;lLXsHDlg|2)-Ohg z_B!_v=`&VGP1~)>EVyiNAs^QBa3cHxH+4Dhjq!ZZX$RQXCMWRoR*MKSwF1~VKP<=1 z8^WgMFxowjv|9e=hsXePA9JCv55@c|96~`GdV2s(H(xfcC-d~&!g_^mVI%o8*6$)e1gmPF!M1+`=i%bZ7yy$I;Fk7OqS^MU#b8y&JDZRvDNj+pNTNq2LF2m{e zk2ouXH7#iuAqjdtZywc}viojd8!dY>IjanfTjKz}!(mJzQn#%K7{Bppq-!(2el>a> z5zkY#rVEE=4W=<6nyptOhB!{DI_@YFUt$pt(c=odb18nCpbH&?s|mGlqM9LNqQdYj z+*6`V6!F+%Xut51qLXvz&B;Vw{rQOQoH|t!j(v}&Hd|G1Fkyw3cQ}i!hY?kCG9t_X z8F1GhF|->W zvr_AKQFGOSS5WMRZ40o&C~iq`v2Vvp0EH(~9mKT9%SU^gj)4Zmh>R2Nh?R2|ym~36 zljP_m)RR&>HIC9>o5xiMVqM;Tz{`=h`eujHt%Mf43{cIw>55x*19Su`ZMHQlLpqKeRFbU22wK)*1TE`Oopq)S z0RDc408CEEo(?waUfZI>)$SIez1rO(i84n|$Sbm8QSTf^x(|x0MTH7*i9El>Pb7D` z2bk`hWaQpYbm&ghssJmv=Z$;(E;|)*>5ct;BGk8CqAK^db9KK zklPJq)YMI3r)43DoyA%YETs5gzkk@3jr4oEXn2G%VGn;BLzpAl7EO}7SZTDk!mn6J zIbvFk;8o2X_(EnqWGGgx5WD%@jyR2AKyviu=$sc6XHXa_x1XmqrJOGhhfkle?tJ@M z_PV$)3%94?NY?{h59KCEKHOH`e2MF`)EG>6?3iskHV^Z$Uk^a4+Su)s?mJVCDJ4@> z-@JsJ&t~t*OSFI4?bN51Ej2B%xI%P*?TlDWJ}tQu!{g$neLlI@`V>lCd!sAY0z8@B zx96N_>T`7Zo*<_3)j`}1=DtfrG9 z?QW06f3y2@z3gIZCwhV-S4F&jH;R{iVvIlzMp1l(fxj{mlOd!y%_Jg6z{DF9w5Smi zV$C^(S0QS(wbk-9GaWp*uyfZC?#!1nF$rAD3gBG{oWc7E5VC5EYjO$VS%Gk(vG_b+ zx-z3sNOx{wpd`pnM4WugWrz0Q89LKf)u79D*`Ymng&hex3Uqm_JcNuGp^>3Wd-!l- zhY&}#hh#^y>(pMaLwj&1<8t&mvk->i*dy6> zYOmj+J@}w;0s9@=ga6r)phJ88W91=acX33V*l$Vr0BDC0N41A!N3-kH9?$kW+o?u( zX-1>Jby}(=IK`o}whV{P+F^nd5_GlZ>e%a9-yd0>sHjBO9ZI?;KUG*0Q4dsXB0gf*&GxX-*0xI2a3-;!z0vaXu z=5m&pKT2!GXw8CXUZk95JGc6Pz?1aT)Vr7CM%~iO(O-Qi*~aK1vlEy3<9f5d;bZmu zwGa_sjwFmsYmQTS><%xuKs;Pdw6fR_h8qY^?Q&dCh^=*Y*5*TnE5Qi$wOyaX-nwOC zF^j1MO7u`6&i2&u%t+&J`JdxdUrpKPN|`e zSZ!@<#i*pQ%8>}Kf+V7q8+`)A${r4oT!XZXbb`dM&ybDY*<+mwH4xL~>9QG^ zS-+jqSb(hy1F#M(y3hN!2;S@ig|*iis-Hv>MjUJn6z=-_2in6C2bYSTOTrHE!~B&2}kHp zs~tSd$b}&^jhN3FNZ4k*wJ=N6;_Ssh4OytWAQ)lEqVjv|X_mB=aZGn2Kw%Qb+iWW& z;mE^`V$Q9m*3*9%%kklELK?!`R;gLZX|A70&Tj)uyD|+oF)#Phw406&6m*D;Hq#|C zf)5?#_rel>_TRch_5u-JnywUGMFhM{WJDV}ME2qke)gR;<3%2H8f;V3hdB?zANt|( zA>8C6K%TT9R7--shlUGRbwJLH_71`;ev*kLR!1i6*p74dYFl5xDF6#b0VdqJ#xWLe z&SOAwZo)8czGFabGH_iKVB-i zKf+^lh|BNonve;c&*eiqk=rcpUW=&U_()0gvuWL zeMV9s=U4gA4spcL;nR1?@0>D^zDqyCJ@e^1`A7BRZ8Y*2#r5NFKavUhvzw?!3ErWj z{>-__J}b{@@lkQP`m;{M?$2IsVpUD>PQhNf3IjxUqORg#aO+OgRiKyd5_JgIEt;JZ zc)FBZzkEczCcO<|UV>=f=Xu6Hd7OV|+ZHQr9-nTtMvcAS)fr$fS=2(hYoN!28Yl{!P64ha&(J@`6t1j#eMivR+sNB_so3r`!9lEL9%-o~L zWICpoN-X;O^j-Yj?A4*7AVLw?LW;{x^LEw$>$_10nMRfm06{SGq(q9cP&K|4$> z?(lKttNmJTAG_4lH12Hy9M#h_?tB0oCy$TC(~dEB>ZbLcjAE+f!Mp8!dZftn4&x?x zv=s9WYbAI*0n99B_VX_Dn|GK2!Q(mbbqmo<7}e?`I{bPBW1n{J#!(8+(!0M9XP|n` z%?%=&+Q6->_DbuA!*+3dw_PmhlNXEU&wG6C7auM@Gw>T6qImS*7SB6;`x~Fpvo!e7 z#$t<47h1^X(Q&|YE5(*}dRl7r7NOZ}&UWgvU;8s0{JFooS$x4KKri zuUG_BPxpKclG`qPINNKO3Bcdudw%(?-4AoO-m*gj$v!O#~1i`5sQT1&I8=!^#}QIo4y(%PDB z16{>3PSh)Iq6B|YXuj&mhf({ai-Z+a-I<3cx*?8NBl+ewvTIzBAXw>dj)!3W&bWe( z?llV@D>VyhC4$HtDB#Ew=VD+w0LVZNs;X0wUuYFiWx+s1-{{Lls`n%*LnyaInZj<4 zkw6-0c)z$zpmqpx2`Gxl31mN|cBd<87+S3do9z-uj3gBDd`no12zc@^X+n~3*sc|Q$y_cjG4gi6)1@;x=zEO zocj_-<4fk622toY*DwT7HDt}&Zz)8?5ZfL?kZTRjV8DwOrWrt^lRo%CkLnl)e&@R< z#?!O9#}v1Ne8UUv65|n1?-kP^-twb%bZIJGCP$_=T2UtIyPW)>b`=o_SJKg!eQ*yZ z_JdJ<1Q5H$#$j}C4MH0A=mt$rCTh{PN)QRKX>fqb_J>!erF-41EYNFK5vXk?78hwj zzzG|&;|RcPHCzH`96-2c?_O-(IFR1(#SGfLCkO+eYkv`(4mt0s&r*Ao5Q>3M0oksKrmc?hQOtwK&;O{Jld8jWj3vTK?no8YYGbsg6DPVwS~4$$y3_CcH-?jGS%$(zlfD2AhNJ1Y%#uq1D~n=0D2gO?uu(eC%Hc3gJ_%ShN@vsgAUPMXArz3+qa=5* zvMQ&|WSS=z0#=X4by}54=3v#R8s$|wOG*cujHlyaHlHT%9Bi6S@=-dSB<~%pu8U$Y z8P>_49Bfw9&15)jlIuSXW)9rs&7_&7<76seqj^=AgPKT%66cdqTIS6Z;CyVUFN;w# z%&Kv!7<CE)9o}}p{oi`B0 zhfnLgp44LqGS&Bh{l4K>g z>~3!b`8*$up_}AGHFTX;f0$;|F&YRtl#X~RyH}>XuW&f2{1aA zVm2w0YA%&EY^JmMxSS;)hHqS_(;ubi5vysHtX?)!S)*dy4958^xyL6j9P`n5RL=5r zn2gh0h%%Zs`MiX+-Qfchjv8h@u4gdgpVA+l3H7UNT9i#agi^jPzc})7Iv?a|IZy7N zzX>kmsx0bRktfw?<~ra0BrD2vFi6trN7p&_C*@>PRnue!N62xWpp{frMLGU;w{-C7 zphTw*dt0ub1^Kkh$J4s5lJ!CAsxC*PNz)X`4Q4=&NnMwdFP}G4$>8!ykxZ+Pp9J+7^)?s{5?m4_1fMtMcr=F@SLp{weU;DV z)eQY_g3qtl&c?4GNK>X&m8gA~miyJDnPQy7$TTRjAKZX?RcC`@G(`;;A3iir=U4S; zSPbhFMg8M&%B}a0!;v=w0{SX#1v^&1Q9# z66Vcyzt^|oy}@WRhM_dDpO0Yb5Tjy_TqffrO<%lhFl<*%iP1dAgmvfor#Ga=GRw;( zMV|oo+VP^iF;ET@c3Umt?OsWqw$E|PRl7USu)#QUwz(*Hu)9<335cg_UZ0ngS*gOnpuXSe1M_nhsU2E zcV8bZ<{f&|x-4hI1UFlMr>{>5)EpycIWCd`rbG9*y4<0vSur0?FeH!=oBe*bcersj z8CLVjBw2phKVSFPqOrc4&&TyBhxsn4Zc+5AkAK{l|31sm1)-Bq8bnGz!Vb$?3_9;I z3{8fUQI;T1`taa0e_!MS=%$(pm0p3t45RQ=*zx&*!$)FRv?=ypQaf`&!09o*H^yrW@(a-vovqu+5)hQoRYCtEcpjB+siFUvdfJ6yv-rnA{(K1j<+l9%ahR!kQkt3k1t7Q*!d z)x2o3bTUU%(o|?rlYnZFpoc&Mn!w65)u(2@$cx#h!VPxW01XX))ofBXX}E5zM>3Kp#!NK@ST26tj?e z$ej?rGPZ*M7Ev7N;D<~maQQJczuSJtzf@s#*X~cU6tnrDp3jH#z<#&5c0}|CgQUsF zWzoQ2rv89ywQX=98_cq1gkhDtrt2&C%hy-xLJY~TNV04?%%|m;dULjJ*yi$awYk6d z2{9)hG~;4Sij5t; ztd?@~@boNtTu@f1mAX!;>q5wPbBm3qkL$4a0^Ov_$0PVnvmd6@>nrUBw7X|e&a!ch zp@K(=hvg&kriH)jD_Uk09Sa=7SyN1EIByiv#F7@Y`2FE#caQ!8Lzh2;%8CSj>kR5F zt(hsK4UM}Fi*HJF4jVU6gI_b8&x*mgvi#V(1G^n2*?5XM&|rxE zmajMO&^s(*JRi(P#l#f|>zsSsdmAm$Feygk`6z>>Ym4g;b(o9>IeZFg5=#BXTWRZm zm_R}BhnsQ25qx8wFHf}4EbVTX)RU&J(K-SJgc?PhCCd>Yaf+f&CDQ$Xa5|{U8D`tU z^6>k^BR(S%tEf>@!1FBN%_bLbuHWC>p|yRyyM5fO zudnD*e0(`VvPBO*DiI)YgUedE5Ncf5-npqN#>R3)J~9*lN9ZKua)t&_!iD+x{qVeb zfRnRdeZG6ffCz`!AL2$yolWxDc!(+N=0P>Tr5T;Dx{HsANr~ai4C@-rdYpdvQ@yCu zDJGrd9g=g1W`iLkNH9b&Z9YW*?8dU<5raE@tw;=xX#ZI`Zi-Q946IYhWil*lcz*Cb zy>1O(MtkOSxI*MILFWQjF(o(UdACA~HCvvnSsW6;o@U1bWFfI~&^XB>rzQ)~deL(Mrg5K)Z+= zdaI_!m^Hv`!WG6!N1YPJe_5FMU|OJZ#k#n46RaPOuHcqho zfcAfd2nqgWU!ZM+2xB%h>mJjTR|w4Izzi2%xh|Q97X=z8VD0ieqCSpr5iuNxR}qXW{yP% z-N8P8e>$Q9B$!WYEM_29uBQkO%WrJ_6@P#3z-7;eYd@zUBKrvKRxaV)x{N$;Y8a?d1F!2{UwuILZ9D~Vx_%FJpnsq`@e~3Um{<%;`0s`V zQyNAz4(JxHQr}%)m4A~WgSu#|E5tKp^0C;Uj zT{fi4^9tcs=wH{kc1p;>bAQU!^NK5D=g59IpBE{{NXsVwyu?)W-gINcN-4=>66kE2 z7FaVG&DC^F&*I^lZfSydK!ZYAsH&x!>S>mhbuIjZswj%M zQ_T#s62wEtD60{fjW$x3x;|mH5SH8^ET+gnSq5gKG)D(CiS&grR|t++QO@QV5j;&h z_XZt2_jyucgsvy$yvh>H?w;>f&Idr>T0>YxryWJF=;e`kQe#PL{@UI!>{_K9)dY)R1Gtsl@;4(4*50B8G+oUG zIfk}Tl77JqzJ9>9sF-iUwD;KU0;QvktPUb7ffVz6I>qvhSED>`*wMFLqvHvBjM;d0 zL_SE~maiU;o8cG>Rz|<4+TJlG)sq6VOe{KeE2*BN?n5Ot6ZEF3iuwZMoWZ1wd&#>f;*6Yh39Zq!bfo@EWprSd=;k*s1Y=*V+umtQAsJWsJ zUOMYQvhj2>$1)7uBou&FqF8=Ceg6sfpKf%IWhZXeeUHN&YnV-eA+0r#Qg{R+|1qbz zpX%^(cwDMOIQXvDJSm!VT#e_sl|M(k7~bmg@fJJ~SmS|B?LzSij&<1Ca1Jk2=C5K` zM>>*uQs;>7*VxrzoFW*i329M?^b!BOKPZPumUfm^HMV4YY<`#x!p>l&g0IL`Z77qe z=9uhEn-n`u?CkREen$qvt{CbFZik;)o}!DKl=-BZlMg#U_kmrPT6>snrggE%A;u?w z+#mG(B8EaR$qTfv6f4r{mk;<7)xN7KTX~VDKp-ibVd+@vl>0irPT{Xm?M5pVd}_qS z^C2c6#wgVYb7f4jV`_nf2&*FKi!g1w_w*iA`#f47VwwQ|r)az+eu) z2NRDfNq-nrjj{q00;IiqG--KR;k#dl?Tg#KfU2Aiv5Rbm{WUUU1P|!0^|<7&B%TNq z1)mJDyy#b|RYko-XHA}0L>E}jFpJ$eLgaNdnNBL~2QWpEos6_lv`(3@Mnf1hV!VW? ze*V>CBzxt&dVK0xHO{d9WObrk*GvZpf&x51B3|5f+mm4J*gJulINT)TN59yR+6pcb zSVMgW)l~KN3*}HdIS>OLWLR@o;S=9?n87orS-t6{Y&R)WW1|gXrr2+xY+LQQ;E}sa zn{MKgkFZc&XV@5}hy9M!w-hU2hYjw7%N#-2d_1PzZ(+ldd9&lU;@uTu?u~sN1-ARm zrU>T^t7*aJT)!M>HbVXtxhgL1aO0-0lyU@j3z7S-lr%=!)*vM=Mp%KwrX^=}CdA_` z&a@&g9hNid=`3^UWEr)a@f2>gfTSg25jjGS$z?wth*u_3eY(5-{7mywnduavp{9W^ zOM^ESWbJ zJF5xedPhxjzro&o_#^O<#qOsZG0yRLRL>wePLt5$p7Nt9IO8fxw=Ok!$&4|z9n~48 z1kSEPy$K(6^NrSzuCLsl2FwhHQ*02cn^7Wd&^UJJke;!fj5?VY+IQpf9w%dLe;UD? zjvI>M@PH#9-_WvUN-TTi6qGrY<-_v+USv5*#u=<+4ENBPi3ypgE@Nqy=BX=jIZhL7 z6&)1Q3==im{(hOBYV3ZQRTDVu-7IvAW`EIW(@9Y$qv-$}NU;Cwo6$KozH3n;4GT|5@x6xpT7`gSwcyB-TI(nQqJYyn& z)ilxL&amQ#y#DDRS93%^d~}mDS#}2!Wt%dJ|eU>?PK~BfC^SN7Tn3AF1ZxAq~ zk<#j%c4;DnKEdweQ%YMNXuP9^7Nt1J0{b_|Q>-Q*6TlQ3o#?>JpIrE~ZYpmIC%aG{ zYAF)xDjRZRgXMgT%@!(Gu_^;05D2UUMD;aN-pODx!ty(nK)pTF7cA6-{6$danev8zniu^T1z9!=`#rG+Ar zEOd;$W}|Y1wE#chbyCL})~2%IY=9}bs#%wER+k81U?;<|)E#+a z&eUXsGEe;o{c87sQ~7B1#x=%5B}QmB%wS&*wol+p&rA;OmD{%Nk!)b-wbvw%*1#c`i);z3=`{n&IdwNdw|0MW15DV(3C8+ z8Vl970yP;C!x7frhs9(x8)FGYrdY1j>QJjzot|(8X*iw0)oWYgK+SrvC`}IL-Q&yM zGYX9lXv)NJdZt*28?}R3dD{!OO2sqgj0XexQuE47LEy&a zjg5BIcmf~xxMgu8#`U?+@{}Le-R4-{$>7NTq5{_m&X!K+8Ma(X=}zgXPO!PU%x1KM zMVQm6WH=?67Fb`UK(yaYNiN3CR}(;Ki&ziOvJ|@#dFT|41>AyJ$pRj%=xG{wH8>eM zfjx&6+nzdKEpL|MxEXq<2In2H*S^)ezDDd}o=ma!Hcrj_LRj+2ylE>ecGux#AFJ$W znf(@oq*x9`{0*BPPnx4{zt$SDVQyGuqcKK(vBNAq(8VBnii%0p_0<pjGf{IS<_AktqZ*iDO|IV4CovrHu|z3)UpBch*jM~$x1bJ zs1I9V90yDZ#)uKpCTJxBiSc*+NtOr)4X{-!JJyz$&(F)%XR3O2AVwx{&>C^>4|VkB z?~{d7IhJLD8OUUkHCm!y)Xs2JqseMoByZWwNw<86Q&q$9e1e7Y(B6DIgZHEM)H<1Q zTo-4-8XUSmk+jm&K9>|1AK-M&Y=~PRetGjo2R<9)TyWi4wR}=!tlW-p!e&$!bc!@Ghmjrm%OkZPG4LRD z-K6;}r47EPQsWc^T-6sB+DB>}4;@Sqca^zFAHpmLcr)q|&d*gi7?)xCe=^s$%!syN z^8y_YJDs{MGu*xsJ6wt}H-}c2^KpYYDuudvafTjjC9CruO@k=+FDx(yX&e|t+_CKe zog65!!iGKDd0KbX5p|M-7aW)Uc70)Y=gX~^h|%I8(hP?w+ih`1Gd3(uhI_eenNhhJ zd^b8diCc3Xc~YsS^TwrqR3qnBc}p%C+&0`iGsI0Es+PLEdgopvu;o(M$(Xjj4RQZM z*d(N>#Z%+nf+EM+3mm|TTL@`PYKjIZwGqq;02VVG#vRf6X4FJuEQqCOTsTk;txs@- zqQh%GS#c8_x5d;KlfiBwj@CRji|2E!=3vE;4zz~bWr4<6h4ZHZ5wJ@{9EZkq3TNv^(}_9U_K`l9Zu15jS0><69b9EXQTF}IlRTMMC)meEUZp)3 z=oJv?X;UK1o8n;0t-5_`vT;XKaPSS6zF>M~_x58oOk@owtHzBpxVXn1B9Z8_nB({$ zhRyvBM?i3N?@sKAuhIA9b%lf8y4)&znY<}V>>0*EWI7w5w}T5j?nIi-QtT|CnlTqY zv}=bBCZkWrbvN!9AFYjAPBUEWQQ)M~EH_8n{2BlrS57s#P($5_D}bWPr##_!W}O&+@SJh`E(avl`y0A3~Y@-d?eo)x8rY8K)5;>nGkuYaNhTpj$R!$ z8+V=;D}^amapo8Y^!8C-m)NmBK>H|h=;CKA#BA={64W@|QqsX@&A{(=a0nCkN8xZh zjx3uEp=yJuP-4@}aFx=O>`-5CKoJg0fLPn8!bUoD`gCy*9s5AbN6&pLNigVRWgJaH zA30Bd_|wAOqyOpgsXtKF#c;qD6{ZElS+_<*bAX z*B6;Wqc;<8(w3HG{= z#u)llucVh4#PTun8;>Ul9=JojB=K93+cd4R$p~wfQjbzSb(P@;8iZ)`-6xzt#|hTq ze&Z~=fnPfx;rNF;h)r4aL>5>+NAv>mi}~^y)0&voklIHBy2DLa&86Vcz!gn1To5M- z+$C^`Hk5N5A0KB*Yw3@FI-<4tyiTzj&z+tmf!#%M4ekQTaPJw8;;6Av`WMsP?uloi ze87(mwqOCu%;_~cDV4-E>PJr&k@MS*-ac0 z^~!wd+7c*AEG*&>l1FjjQ((Us4qBS4dRk}1=eQdLw^Ed7kW#gmt|@^6_cTn$p~55u zu9~C!>EKU_`nzyOfIGbq?{4N;Ad?iAl43k-h9fMydlcfDpgHylrE}8Q7Skg-xYVUu z^tFQ-?tJk$T{?4`CllN#HbZF3>#YkHvIYgTGNYAZDR0kN94K(28&?eZW_0OMV5Xnu zL0@}7}8IR&ZQq0l@HwwbbkaAqQt_=t2aH|*MsqWqn)vP>(tN_O|T1disLrw@*=*L0-Jh& zc0&+oruCezsq^!(TrRH0W1NkqeXQ4iOw&F6b7NZX#T9nkBK|p{DN34t^^w>fkNTpM zv6ElnTjALat$ zMT1?2yGLBsyrXZYQ>5&Av7jwr_lv_b?zLKA)$H+kyVx;Zf*Um7pJAC95iaFp*LUAG zYaH#M4cPePnZWS$)uEI_q|)%x;Mri)#YJF3E`{2;NDF3X?vZ1(X9zW^op*F)*mU!F z`~2Ah(IjlMJ|p)|icuZZo7&Q|CmKv-&oq!F{ebT3y8&r|d^%4`%7b|_*d$l7c`qR^ zb&rt~LA{y;RAhdhVxzAR`OLmEJN2&eioeqpTYQg&qEwl5x{=j z-9ris5!+s?jpeF*s)12O#qfTGNZYdBg0&d^%8E-UcA$$bj?JS%O+QEj!+d} z6Y{gkN4*(B9Bvi*I75HK?^?O^?x_#&tXN!Ez4}=u^WHDc&+YpS z6WI4vK(F5!D$)V|?)=?_NOy65dER&L0pE4NcN2ea<+C}zTE1JpvwSzbi}m^1<+JIp z@ZZ|u-}K&Xdhgx4R)A*g;LGjBx-a+;8^LF5Bnjl)UfitTu9lY1_OkzOeRJd9`~8cX zw@#jI|K{R-&*ihdTHo~6Zyo)c)w|x+#=XBif49B46z{8x)zwP8uUFfvEBC&n|3v;b zSLgk0&*9fMtDCns7gv{WHdp5&pUs=)`FkvuZQtFzm-27VFZyqn8~u;tv+bgPe|fRJ zx$5`(m+K2xPus16zX|l-KR=Js8+e=kqJzGNBWXaBt41%H3OU0Xf%&)>dxshwT- z&u_Mpf#bWP^tOEcbMOZhSB1)QHE^kF1h^f zo%68o$dy>Q_p2-aJ;=AWR;qXOn=8uDzH7C*_bZ>izv_|X4j=IAZ#PScSJDXjtAL-% zUE;aAEdQ(J1v(&?-_>gU*5l6&*wVi_zg(io?)~EJ)_=cQd+(?nsMOLEbIJeh#pPSk zkM`fbU0(Dg{rk&z5W%KjuHU^~^_;ydRqfmMsJmfHf5X+|-na4gdb9OADwCg1&O!^h zSLgBewCb??)j8Rzvq{VU4au*{_wC^!vH9o+RXFhvk~y-sTIBYxM`k+i_OB%)RQLae z3}raqoNqz-{(O0UbKXC{I)8Ic6-q-Eb(KmsA|X;DAyOhCQjid-CNl$S*RLT%1-aTfPP0mLstu_p{>PH_Z~7)Ij1np-#mb#c4!2a101Zn$0emedd4 z4OtKSub^3DVn$!)*N{=`2E%^GuOZW&V!z{8lXbUHZoQTa4d%$7CJTGK@LiLI9as2n z$aFup>i9Kex`eBaUrok6-n;Xz-?P=b_e)&Fez#iShyvYPxxl6AxR&a6gD?nPSAlmN z8(-Z$FD~Bv66)UNFQIlUNH1S1)LPs#JDtE z?}*cxy3^%-QHv7#Mc?${zma8AtV`)bOM>RLps5$;#31y-Au_XfmGkg_H6)yp37Qz+I|BsErp#;4X0 z&Wxj9?$#b>Q8}uuZN6znw&jKI=-eV8)jml8n=S^qgIEuU+gmME65l*-W z=2$A_IFadu={gavbYT);IkMn6)4pz3dAe>SO=eq`*bXEiOvq>L|BOh&_y}?X7)%!4_|PNtc*> zdswVKZ&p8p3v&9tpfgO}$ocJP`Hpg%p~A!ci<1ptwn9`VF_5g z$7kB%Xmuj8X;a;JG=7*GX>i0fpcVd)iAFYmgDsPFEO<%j@Ba@AQKzCW%O zxC!cRdxzVMU`PvfvQkZDREAvy^l=ExI7p^05Nz<8VMxhCKzqTU-0+?>&4C=70s|oJoNJdpAl%KLf?ch zvA8nHB-C#0U0fVlIJ6iLQFQ(r%14CJnQ%xL6`z3UNU<&-lH)8;3l_L^5&RYkjVffn zQT1@T;D+#3g*U{nQUDQ0l|YDiakru48!d9%vkR3;IZ$`00s=9lXg|_aDBa6rOt#Z` zcCciyGHBZ&%PehnH#iRhFKcyAPRI&-+f?UmpuT-;DB0rY&GHEi^>30|*(ltI$Ca`( zO>OEzykch^HiFPrI~*4wU27a2nxgSuwke4USSj+oy4xdU;JxmnKzRVgWK%$2 zG%1;SjtPcwB~nAkM8QSb7~qM@AYa_hV)~^Ng><2P-Eor*LSEg$viptiV666cPuSQ= zcJZnt_)Nt8-9a65RK0X(B1y=(@rQ`~oWz2`V!4IShyp3sjiSyh6U<*dv6oFXN7r@70HA=)P=AG<`epZ3{v-$gf7~!Ji7Rj<~7eSy;8u<{qphWC>KKbzW%|DP$Nn03`R@e?v%tWR4c{(j+>gMw6<&B z4{Az78%P)S%P^8P^(?!sgb1tT)+*dO-F{6!gk=S)2u`;GH#01h1%Jp|;J<%PlR0+zW$SsI_ohtg=~P z(TN+i-g!eSCS+A+BMw$kzHF6Gr$M|j;AmPCC8qPhXzV-@h~dOUz@Vv>$6|I8-xaZv zG^$cX<5q>*^Q=3zoy8WM)`2*FYS^hBR;?!mL~4;q4~Ck*qHXI*fjwn%Hl$#mLCn52 z@3`@5q^x#qq@sli@~bIy0vA|@bF|V`)~={(@e2{CFB@SjT-8`6Y4ac;)fJSqRI#S@ z#)9?%;44RanZjjB^wAzhaZ;E_4h}A}u~08B1&w4#O(_sukt%qLEkWCCrNXHs9b>F2 zOC-NmR;^rQ1~eaAEU=K^ttzNGqZ?mniQxtpgFJGDy@DEc!Erx5scZ4(?;0GZQ7gWu zNOts%av@jC8kMwaaOY{Epe3l8ZfZdZq^Fev@}Le7>V>Up0sqCKc_1qy;72Z6EU4ht+Wh*Pl7(ZaOMkVr)zsY*e{>*-mPr-k$DK$TUJ@eCiEQl-Pic=H&YV3~9xg*X2Bn z853GS?$SN5?)*cTPl=#>C_-EIaN7qL;Fd=8z%($<5tQR{plr;59Kl%yVRtuC{o<$qTMkHEzAy6|7HWd(cn)gY+F^U{Ca z?eEu%7iHxk9*uwVNc-qjmlu@?#|aiwuK;8Rlc*OtG7%Jc`V&A&^641c#l&1JJ zy|Wyrp&zBZ6QS zZj|l;T57l0xZ*9^jhhzaRH;GHxrT=eWa0!Z)(jTxpSBk*#SpBm6a$qCA(+kBytEZT zm<}ZnN=Qkso^+GhBpk#Uquyw%7vkHUcneRWo>&lwrtyY= zC7bh!T%+3`4ji?h*k6wzv2Evk4o&?2+({1%1=DihJ~M7o%Mi$qlD?$*XD ztwmyb?mgebX}R|oz=^~dig{M+yyoQ#*)qNCH@7rnfmb5}--PgmczNs~j1OFx4Do>0 zY6~7l*1JhzD^CL2m1eLVm1WSbyRjL|f+;DZJ(wnETp&}}lXuCsdu^8afz5>zUQU{)CO(pC;(Iut`Fp%i-cB*tLo?~{XctpQHKViLCoI7KNW?ik<{S*OHu zN0_4YB#sCij(JGb9`g*)*RNEsdX8x~ZZT$v6UA*=ilOmK&{=Z7szgn>E$8@{lZYsr zj*o6baS^bX*4$*%Cyu9f`d&9 zGi!}wc&Ukc;Q-%C<^!l;p?Nb0g&_^J1+^#{S_)D{vN47%C?nH%fu(^j!pE7KqV?F) zORI?~GGf+UF@*J%Zy~-2Et#Y=*bmuOCIKU6Nnj_sd5g$SsHmO@LE_K>m%HZ|p3Oh* z3>fQADk|k5^nFM+5u%ZT<9@+buZ*<|f<{EQaM9OkYF8pf)KMJ@7w@GsA2+6GKp<_j z%T%O{@#J7oz>~V=wzCcgjmOU1wVCO?i4R=0?L}Y1S1-^wZdufSYap)wx_BSG+lg6MRws` z1x6?+gRa%*4)R}6h9jay+G`}g=n8R!PL>e|4B=e+9^VrkJKU?5iW6+wek=%Bt^@^f zLaWz!Bh(D3Jp>F@6VVLOQXmNJ!B+h7y2g44oPS=I)<*!y6g;@zE!T$gZpk*B_xH8n zyc3SV$jO}brKaN`A}dX!x8X?|$6nJo#_`e!sK`JNT(^4G|S? zAg;0v#8tG0xJriog^b-1dTqR#MwqIB2*#XBFmAO0anRl{)<^G!#2O+PGsH1==jb&T zcaYu(IIiw!y+@&WZk9i{e2pgsB%|>{K@KcD4F*~xQ7P%It9K z3t_50{&?8Y(ONz70Vs5IQS){Q;wJ9!c;YQx4n*U)i7B?BE|}p{TR&va4z|8!S(socP4)|H*`|1fEo<6W+Oj>4-l2hK6rQfQ`6azAjtiMYztD<>O&3LYiyHqe!blp`V)4?WWU7jOp4do9n&7MJF+6I;YG)S&Z?lLW?J5k zrlLfLhc@pfGJpG zb_4sxx0`qI^)tHU%&3CT`v$Z)RdJ7bTnxuMN`3mSLD325D58omBBK%LJ%KJMT}>t< zXFi5@J^I4n+pS&nz_jUgyxFk@z=n|p^bP^&wN-9R(kJzGD9`BRmS@3B-vFo2?>WRC z7ib~g;TMRO6p>xns#PN(!57Q*b!DXI@&p9iX^5DQe|m^DNOL#pP1i>+d&O zPJlC2xH%HndEfnw2N<#8QnH{hmh61PaY%6^qF6H`cxU_Ykgqa(mEx$`6NMW5V1n{i zq_EZ{UEq2MtrFF-hG6h9V^+8$4Z+~M(ncBrCFyDi3iq0Zz=V;8pb+MsPd6gi`ZbLt zVoa2@qahIL^@fJUraf;+q0!@11^U#-tMP!-C2E_=>lh2-<9xfCFO@q!o++tY_NWiP z$d(s+ld6rIm=P1Un!N(3(-F#11C{5GIkcGw2tM|fV5rEQ?~4+sIFrVBlXeShbvty3 z^F)UeoqaP$QsOdsa>pBS0>NE&=+Dz0&vXdQ!;^lQHUG?ya z&ViYo=oW~m-61GwFp>wI014o_1kvzKi^0qW_U-w>0@dy621K@v1aQBlbRoOjOPHeF zY61#>0v;fF5m0W5v?c*PP+?oA#o7eH3@pgPYf2$5Y)}!rZB_wJFHjzn-HfBEzJufj zXBtX?Ms$S_(i=LpukC2%$rcuH^DI^1XpjhnQv*kML#kA|olzVyQ%gfts8xijWXl%< z_;e=7(M8Z%e2-11!Fg0huVL{$B6T}DT}H3^?4zVzD)#uvGs01o#wx^eczwL#LBs+&kps+)*Tsyp8OngDk&hKQmO^SF-^5XCf1 zi8~eRAz#%Cs}x6jVWK$NjWR)ZH)`;)u2A8QbfX5}mA1<;D4oGY`ba`|ba;g7G7nkd zclay^jv1Ph6$e}bW&v1A`F^*#R~y|dg1+Oyr!)?7>YsgkZGb3BACfYBMVvd6XEiXYMM5*tiDP)h#NyPvM!nfPdHp=yUA=zxj@*;P2aC)c zf`n9Mr&2gD&4nW1=gqxZ1PElb+qeiWIZ8G%txLdPzF6Zj9SXzKXJ1sd4Auu7f#O?& z=z=slCLcPZ7H*8m0wN2w78jlG2`su(dG5l)U~z}ON5{9idzj!l6c1;PXIP+Xa$i>m z+iJdUxfXY88u-rsic`kCA}JpEZb}J&i-F4~6ol6g#iO8R94$c^YH~*Trc1R8kg`*C zNDo|5cv9DMu>G4iCzC?*tIJ6N$<fk%7=Ybb;&#r&o>Bt>~G+2u)G3bWTaI;`XEjOMT>xor&~gaG_8!#H zB+Aj;J*ZCsi39}R?Dx2eJpihuPrZ9HL@Bwp_=wGOE0sbWuq1j6#ZeWtaep0hP+eJ& zp|<0=G>pVIS7Y*c$Ya?W!l>vTvWttd4AsR7=`9d@PFL!)K`~@l|I)}p`j|PWu1yfe zEl@#uwk>ISLxx!5)1NRpN`s39AJ>PoFNa552=e&6J;P^{HuwPaie@u=dc$4|98crt z-Rha{4y3pL^*{RmUA%ew{^HH~)tjCVKi999Z{A+MS10`44CR^?&2)esT7H-b~Lf|HIkYZ_fUp|NhB7 z{qF1^?DHSaekY#k?Vs>RX$by%jicv(z~Aq^l+2l6ME4J8ztz+X|0m7)_mF{j{vPl2 z{0H?$`4~F>rGGi^-zrW36TNe-?>`lbJWi~n66FrHEp zoN_UevW>9hoP#M9mw;&*PpJ$g=f-)Nk`kVHkTtQqq$R_ZY?1!h)||AIkKxO5@tgUV ztc=oxf1Ha;?eN6K@T4cEWVx8rZ@`l@7yok@exiSW_pkQHI%G*)&Q3B{5-N+)5S7Ed zaXKy`)dr{LvdZ*^D`U(X{hBoNY|=5z$z*8$^>pzo=YP8zptdiqM_QMACfkzMXKcz) zI2`pI^hP}vj||+ZsZTUKnA%ymdouiDznrI}<>!C9y8pK=In|M?4cFha>yB)~Q2KT6 z?1oc?cEvro&#_Ho?8@X}`dE{W$5Hbpe_3jl&ZUm$@Go0iCO7sM+O{pFl+UCw*=#hgDDy2p81Ki zXwn)D`00!UVM;^YhC7H%%huuZHZ{vBjK|{AGqvgaNmhen3v}(@m4PVO?{q$%)R>Xm zaPwv0)J$V|nqOHOL&x$M3aTfP*2gl9$&c*VapEUa8p@YbbKhc~nS*Zy2FAaXj!^z^Fm<#7(=n2bkrel2>t(o4kZ9SYn<;{O>Z829LZX}>I z24m!rIOgf(VtGvM6PBJ02UkKW3%?PbWh83SF#S?q22Q`fwPiQFnT~bBJXi{r*GNQK z|DDpjqm()#DVP&$$d!$uY?mx6|I4*#@^W_TdQ8#*=fPzlTF%F$GPI@+S&P5HES`E@ z`j;V;p7LW3%!M&59p}Sb2|~G2M1}Y=j-gIU$BFa)t&SY9{ZO2OD9k+B)ji9=HA6h9 zeux9rEY}sKGj&5S{v%lo7b+R2pi@ns94wERag0wW7+ zg{Vx4DZQ~S%EL%T`EVJClIw#Z#Fgb^3_+;`^hDfJ*UC5RVW2}w=QtUr>Bsi{VZ zit;vEA}T5oaiu>l4MC`mIUPeOw#bykkK{HwAv|#;x!G0>f6_2<;aVXIu0<{%!HFlq z>3^mqZuCF>F~p>2D3^l&HJajbaZHwKglvO)C2E=UFSk&RHX6>%+vULdkre#LHEN(F z3;ns&hA#eV(itqLH(Z>ixgNOuTwbmR)(7c{%SPH}o~&Vl(i7Jk*%09kjP-8v{(FB7 zceW+ACR4*kN|J%JLgnE9>0i^5n2KALk&iV<6f8T_xPMtk2FJf#&!@`4JXl&vK{;^? zaop*NS||OP@)<1KH@z9Vr)R^#Xu!Ze`4u{-sjVzm(cY zV`!*uI0fmEOTzVKC^%K93Dy8nQfuNoCHgd3 zjIP-#OwLYnQpV1Fd&>!(JfB)$5G*I(PxzWhrQ_-9IBN}>R z$;@wCPLqmyeg2b@x*SY-LLJa}VMa(}-675YU*B1ie(k#&@}JthBWcal$v^6TLu%6W z%M#|&P~L1)A>Mx{+h@|##E#?C)4lIe=wZJL-G-gv?dk*avx5V^lmg6|0Vv+lWTx@G9_zX>YHoP*Rsix z^Q1Jc48BzVI&WcatV5$E(i4}5C8HjcB0J+;O@GNUlAN6LKZ2h1NEnix{%Ex3=ih>d@xY8PMtWvGtaH}7 z@h(_iqt)=2;iWV97ptFtraPkLe9 z@chSUgFGwtTa6cF%Ir%?vQQrM>zAD5A`D5wzwTd|hMrA{eq(zE(hQY{EyC#8<;1xe z*?#@~`!ztV%>8jaQca%vGj(oK{QLi+40HEY8pK*?g9zWu7Dk zbdhDvps4d?BtTU1+yN=E-*fE9xiOfmCmE_7(q0Iq zTn;Arq^f2E;yXMz9>u5`X4N=VrSM8}In3&MJe?1d^xA3da+nuYF&|Hp+=C9P339HJ z%!3xypqiCwGW4LsB5TT`Ohz7bR1eXV#!2Bp%d{MhvnCmM(7G;~X{O33>*R7&Pls7H zOTIddUY2Ew7KOHReR=I{5#V7tX-cjWuU;<4gZU`g3l@`6SwW{@@yBu|n&l-bpePGy zZveHr&f~J4r0FC@V;TnVDU5DXk5P1=zOJXJ$RU*K!{-IMs&a}d@ZhuIbT({e$*gfT z*^CF-Y>GyGeRb`+r^|U>jfd1_UH>ulWSB73x{j-t6-_xS8fc~e?ZNWy4YDk4 zM#VVkU-w;i*c&#J!EjKH$f%}&5*=l4l;&xgje+UG4xQS2BXG*<@ho}S-#PxHYFdnP zRQ|*NOW2!jw~-@j+yBM%1&9)<;YcKNp7XQZRlWC#79~+KyJS(V!DaW=|4$$jnE{aL ztzKQOl7Yk&2*mitkJs_H=_+0~HJmU@Zq;uiu2=@^|8h27`m?lH6-mN(udn_`Pb6#8 zJXojc@_(Y6@f$^%wPjwGOR&$!-sn z`;i}=H36rdKt0Wk8m);}ZM05=)VOw{#X$;dnScLyR=;n` zpp1D|vf#@|ZS!>-C2h$uW;gN3spr8eXV|t~K7RjDTQU#Aw1C`723=L-#{>2?X8wG< z8JW~Ph^s8hxPjH`>zQg@R!v=G@lxQX)UTViD9bRHnZK&$;VP)(f*S-})yQt=;ffcb z4OUA5@fg1nrW|k%=Mh8;_3Nq*(>!ivD&x`5q2nS7;f+~PspUsu#HOxOrm}x}8ov^S zaa3=3MV&SQ4{No5*{hEuAw+eNF0)qCP+YZXnHBBw8_+bU1sS(+{-6DLzvr-yCd`9+Db-BXXVSK4<(z*xGf(m) zt%Fs(%vb8cohL<>*G-+v@$0$3Ppf8~FF^}a2a%Lb(5A4|9YvnikX6zYE6zZW#MQ6s zwpf?7Z27-m)g~rwC5%5`3U<@joVO#dYB>I%t3T8!rzw0q%(LZR+qaRg%+ovx+AJ!T zK^*Jd%GPC+HdV}^KthdQ&)|h&g4lXJ-~DIg!t;F9hQSIFeg62VmXyaqot9;_yxZLW zHGUD1mo0lcq*cQvD=U-}X%R0*AoZAoPqMBk^H(6UJjqIXgTyXw8 zO1QXhpPKtstEOoJ1pEI!ZpOD|UWG`OL9=FtADTf`QMJkwSgt@CjT5iZ0M^nJ%YXgP z|7QBv$-1bMm`ik{cu18d$lFb{yrZgCN0->7^KTD$yyO; zlkq4tiO8>rX8#Dw>vR3UHk@_JelCAK?$r%z^0tYQy_a{N-xY;5MG`_Y&~<|pU^UBm zQzqIBA<3{p+kmoM@Jt`<>d$mNy#-KU$XA%~#brt;?iFoq-2DkJ8J$&Ee}| z5-tVhOf_#{RV_k6w)!%DWwBmE)oav1Q|EPPz6gS(Nt$)FeA~P{jik2->UFga+wNe; zyTtF?tVVQS{<(XpM#*Cl#yJmfn8K=GKgT0qge{6@S!7G}p=M-Nizp9RlzEb$p4C-Y zL?thE5U0!c`|XRG5U+1g@ER;P?;vrG3y4=qjC`0Z4MdmveHfJ~N;3@T^>*ClMGW7I zLm0EEx}(|`ZIiCDY*|sTYJBzLxLUze{t=g*MEs9fYbJ{-t)lfBcKOZ?Qu|UB2q*z+&-3dILzEbE#u?XPzOF))Soyx%_a_dW`!kS`Tp{-8%477U|qHA1d&Y0tr+j)d4PE# z$yd!1EkJ7@=g@!CR_lNs6lfl~$+@Tp4KKy=L#M^10CkQudxj^$n`MzHg!uImc1n6;f>&(G$nU$aIE%){lI9MO1m z=TVbI=z5VT7=YuBJunb4`>H{LyWvdKUxYE2sYsTel#5e>!+DH>5dIZ(W2ilk^AKSL z!<0F`@&291RS9cvQf1%)2?_8er%pU zx6WU*&{UBxSF2Bls1jbAHbJ-evPjO?>P%B~&O~VE={W^Qa9lYuWC){dcth%FHS*i@ zv`O1K$CTHVcpiIXtF*{c6!abPyPj1RuF+KZ3v*@Ebh9{wK2g)ZTqc+6OZ6#CR!xeT zBKV{n!FY+!Gi($|%>wJ@3--FPN1m5hJCkBbkp&<%)nD+orE4UG6>9JHMeTduCRvU} z0MTOe_C9i!^CD~5E#Bt5$?C5+U!1~*4h~EE@H3V%e-v=*0G7j5}<+<=Rq ziK7zR3w~HuB;u2MQ`}6+!Q$5ueQL@SlZ2H0G_2ctxq^Jv?UDT2)UH-il zmZVl1bDa=o6NCuwV{us)D_Ak4WBAy(oVdhmkyfo?>oZvU>G*eP6UTMMYxZ?jCsF-% z{F@B(eU%PuM$I8xui!L@-cQc~n6M*XyvWiDNfKj<@bc^V{PEG@`4`11!xqNIf=2oR z_UJeox=EVFn2!EjeW^2yR91ezKxWF>So6(+z?GDKQREE_2?o<$Wi?T_dfAF(g(c{E zks!;AUv2R^h-2gFdLdUsf3OUh2wFFM^y81+cGLG{qq<5ENPVdRara-zZc&PO!|eUGhMhtvuabFXHxQ{98=K z94fc|E5OG*km_&BHVW3*BIGLI;87=9ukm7pT!nwW{Pm)_%LS@MBMzZ%qtb9>-xqbf z;^9PW{AXR%&7Y&M;sSlLKryXFp55Im-g42dGiWg`mp7mH{Ds;k-kK&(@vd|Ty(8&d zLhd0HS1&(cNL+@|>U)U=Hi+}QSONh3ArRifYA=Iwg(0HAAhY?Xq{^uJD}*tg>1z2k z`WHfqGFM#&brv@0HT_U0s*^Dt!m;}KjZ?qG-c28D=6$d65?$g9!C6z&(Z!@++4Ha=~aaRVPpdsV{<@4gIAEBIvuwSI@_ zzG{=!Ws(I2Hf@Ie*VoxCPtdpyM9>WXS0lz;q z=2xSvaHr7DgLqVqE;B@jDhRV>^fmAXME+=zhf{N@3{>_wnH*PG))vKb^W*KqWz&~= zn_)MO8qO(uzxnlYue!C>Y83^+5^XyB%5y*d6^c!W_8FrEvVtdNxVhxMpmCwALY&(- z$`y{i$}~Z~L-}w2`0~}=uQID}dvWot6pLVNjT7nvIgYe2?j@nsC<|S}7D`MyvN5Ob zm#aE2uv5}$p3K+t)qMP1onu=FxMDqVD~hU{gui2fu$lcM2q}%63~W52?|*Hdw;y{& zD=qeWoQEyaEt{;xsmr!Vk?k9iVi)VhO7WBy&X5G0%|--Yh$|C~b@Z8Dt$F36l+F6V z(;>w7X#W^>iYvT@c&d=N8&KwN&_~fdZ-(_;!MF&M5LM+e`Lg;Sk@!Y|hQGt>AHgVvO#k2KR_XXxVYtTOPS}A|!Fze%DP`s= z3PN5Rv91qq^D)Yz9Y!1+hkXC$e)mqv<#9n6dAXI?oGsa^IY&iMS26Me>sff~i3*z5D2EpK;| z0u=_4j8&BTr`>%s8tSePg)qRfOWe!a6!aKZm|`WYS}xWTHXuq5=+$FckCH5so$qLR zv<)MB*#6*= z9Vd#vGO1de!C&`0^v|NjjDLyZkF9rwRi$Ug>YOTwHVKM#x8L`UYvQU3OB~7Q9~<*< z@88r+tEec8O1yAr-R~be^|oAL0j{#DkgW-K@6LU{;vDdf5x?;D3y~U0sc%SC6X;UF za}9HG?1@)(lIQuF@r-_WJ<|@fs~TfD3^`wJo?pLh;y3O|TMw`?V8{)}O%kk9X3vDXQ={ecH2$R}v-~BID1$Vm$mw!v6kD#kqjq%CK=<=DW zj(H1Z^*t|Iy}fOIjkb7cgPgp|#9k)4$UQYK;?2Fjx3s}tiFY2}*J~`@9`2m)1Sn~^ zaP?^2QH&)vhvH=m}tDkYk{2wI^$ z=G%U0&QK6*!o-(Jc?;p(K0Q-RZTIHvVTh>|1EbiYARzM;?tFTU!WuE!$RWY=?iE@3 zW$Vu;ia840B7CPm`T4=gqrzjaz-5QA02zt9Xhi5!J!g~vWKu%CBp#ucStTSVo}FHH z=4vdY{|NXM7Hj@=`qub-0`$?3FZIp!;_uzZHyDZVHm4PyN}T@b@?UrRpVy0EkBOfe z_UBe?9GAn#V`&+<+jk3&8I16`9>_cR#mq zm)D=p3B(Ef0CJ~I_8v=(gtO^DfkmEY_Z+ zg!^&g%b&)nbagws#cZsNI?{+p4J<``XP^e3vM?m(X$s#Fi$Eau{KMOcmV?nYj`&Vb zeP;($oJMODJAC6e80=r3;&YqSN5`c=&zX9CST`7elThLo9`Gd4%ki} z#gJm#Km3NBJp73MH5zP~Po5)>RIyx)l`sR@Ab%5!u+E7Wl%drAjIt@8DdIZ9zC(;x zXV5e@uXpcaAls#QdGO!bMp9L)*Lw8g3eFYVl-#lvHIja88P~C2%823&CKMTC`S$)3 z@$_h$22RD3v;B^qar`?a5s$b>R?B~7;@;)udi(r-y(o60rG(M&#MRhJgymTdesG8I zvJkY$(ehS=ue*5v)*12i%CO-PlvR&B=E%!b66>>CM?(AS?bFUkH@`fZt#D!!niuvm zHt*>hFEix<^&&O5dPVFE)*8OUaT$u7AGC=HFDY=AnKtlF!(eBjURg~z zNZT07<~z2{ncF5^VO4B|Y^}I;aAY+OqFmyZov}{c?_>!<(1_*c>i3`ebVa*5&okrz zxkZTBW?hf|O{;NthZ4bVZ~l?zrCD+9YkXX;VCP)5W`)^jEffTut@o&dn-}l36O#nN zE4{}1UwpF|e=*m&yqb`=C`nfGE@bb27^%Yuzj~v^ClqG{*bSRFJJ>{qs$wzi$XkzH z;06ubKh$>J5_^MTr$=eE*~&kMAJqwK39$iqUa%hb)7zY#oSUXsC$pi8Gg7!riJ!$2Id+C z>6F5qO7Xi5O&(6nInDImIa?ktCB~enZ-N>6bAlqePLtD1&`rhiL-@1p^w^Wp>Emg4 z$Ojui8VrHxX|W!+eCV{9?$i((kDRSWx;!)lwJ%ZX`N4hd6%f)@T)2Hin!oIOC(sn$ii+(Bd zv)RPWD7k|r*(8WOb|lM;E>F)+)dbZ@)iTM`oOn#aax4cs@2->G!@i^2sUdu$!i8)* z-JhS%O~cd0#G0yQLs-N(j6K-Xvwl0eanvyNGOo+C#k4yNGc4%hOy4G_6BaFu%)IM% zZno3nd_F-!%@X>?UPA2Y&}qEtnuyd$%`(p#f+_Ka+D?~e9Uotu=E+0?2x8iYX_vloi zfe@-SbmH^f0i8OFaz+Z!R*7mE*JSU-$s|i|myxK!5hgmj5wp{-IgC<2Y0gN*Bo+jX zjw9K_-9Fw;c8b>oy^@kO47BKvXLhO2$r(t3Cy0-%hEAMpPuWvc)GlF@*zj?#^=EQF z?@sjoWO^XXw?*Be@Yzmw?@smHyraz|ytgIX-gdG?bTY{v+GSl5vKnOLNcIYz%pNCb z9N$yiBDj|08+dMsX!2dBQ?qVX*qw*zsZJf6@Gtv%xh8Lcz!VXGt$J|g8JcN?-nS+u za5Q-wXnxYDMx{p=7b)5JS+>>g6$kNnz%(KhzO9UgaAQi`278Qej?yZPNcPBx>>4b@ z*~`QBr`GD%%Yf)C6hzTk%Khd6BROG@t_(~gOoiA_l3u>OlVafrolZ0nk8(h4RA-GC z)RyzPBPvUqx+p?p(l-WRBTgTTNB)9&5_@H0b$|cq8Cpmwjq>8IDFNj_;K*dqvp&JL{!Cr?8AjKq3|vC5Uv0UiuP-w63EH_pVhJ zI$}_sDfv=H=%EC#7`2NLqn95Cq=^@Xs0sXjPtTGv_0Sp9yw%~3gn*548gu8w#9>$K zBqS8>>AAW4H-Sv;$6L9%Q{gAfDMlbe7i^ZnzB5>6>aJWR>eEp+y zV7oz8(g=;JiHv^VS*4C`fvCaclte^WZ?`W;jg45-Bg`N&Cyazdn;*XkNm{KX=R`a+ z-OR<%jEzU%PLh)GUgJizJI+Nu*zq)tG7=P{<(KV~vCsb@0jSZ>(RIe^c+?Xd+UR=L z?u0Y*Q*3j3JfsW)a8{x<;#l~r*Ur7e%ka>xh)Ehf6i1j38H!}i5a&O#vDv}QvyAXt z(}jr-cB6e z;tQ1vin9g+_;a)Sa3XP7T@e)(yxe#)C#e&cGI@~3nFj@oMq_0W=1WLK673*9ChV@a zkNc;$1JW=Bb!r)2dCdFB^BBm_3eid}36}n527_*InbD zIGrs=HO-^ds%MUmjXgYDzXRUS`lh$ zg6Mo^UK0C8`bckw>z@wS!_1e$wrB#<7qN>DZl^VV4}HQVSr~0gbhVr?4w`WL>iY-R zB$rjVGVo3fmRgcfcaBS!Mufn$F%eY5)tet)J;7sGOSmD!5nsVB9at;*QnHdHSVMKH zkv22ZC_^*Co5PoSTigdi#NDZKL(m9MY*eD|yN%A=Mg{2$k|f{zJgkLGSrPeCQP+8k z+1vfn%>5Dp>@lJBUZc6&h@da>Ob9Ts?(v>h^s!V;L|V7Go$Pt{q#e9xq--OPq3{kn zes*NX36m&D$rcjlXw8%FlT*E_Nq%d4kA)$p`2hol)u%l#5OO-s?}LQ9#G}v!tgMlg#=N_qoy0p9bQHh3=x$? z@VJd;UZb4obRs$T_e8YIULGOPmR$6(HO@_EICtU=Jc^(%Z@4peIC8*1Q<29}f9X^= zBB*3lML_rr+L2Y>9_ACa9n9JxB11s(&)8|(*&0wak6Qrfl#pp#k?=Kiy1bh8mO;#Z zX+L9j!x^b9R_hGZjiJ+^#p(^$ znmME!9l`1z%+Q%0B1coylD5(x z=H|Y;Pv>{tpNHoZEV;GovLNo$b{b4pCle+sM7tydNC32$q0`+1-Q;KRs+j*$)1wnw zDZpK$&FcQDThrso)Flj%CgT8bsnJ$5SP3sDtb|Mt5RJIN?K({F;j$yx`|YDXC}(;# zV!LD{4V}&(I(y{F-Muzjxt&P$SP?HZbh0CzT-;A^qhJYvXX|Jra!#wGZbAgjwsrq- z2Esbf#dg|bvV4VwO)M$IT|uU9$|GPq4SeO~@wjD?XyhOz)V|2aPQ&z0r>2Kfj%SPa z=5WVPW_os-UV({ANWBrvGCMtcabaK+CN(!f2!RhsXwjpMG>BK zIMU_hNJ+U4!J8Uin#ad(1Lh}Znp-*}kq^<{l1)|!oYLF90*fK39wSA}?>p9j zxpd<7441Ivydht2nBI2YIU4DtdAYNuy3R1x6EJDlH27fVi;0bhu(FnAx<)a#ogPkl ziQt0OjX!E6I+1^d7e-ye-pM_?ygcrVB1x1~5HiKaCv6z$e0rdO94#?J46}Q@w4{pT zdi-%_NAv+1ONt=AQg~Xwe$ukUeG3)4ncWr{kad87pRFe@lbQ%U)Ob?VqDKYP) zui6bCq^U_p9xVmFWsSMU_OX}gY&Lb7qGgUau)>Npbh5MKu4}g9>|IeHuP711dWiZ5 z%I>(^r{b}dykk2%7H^1jt~tMREutl;gR7(@n8J3l560#EesXp-)&nqj#=FEJ8HdvB z(s??a=`{h7y<~n3BiS{boa+Ze^E_e-2t5t}r5ZZfHJ$29;jD?60%9v#iPs+1bbf9a z>-nTuL`(q@KDZ1=$~(EFIX~y;6aIH_q6k2XFgT58Yp1u++`*e3;zOE5|L!h_qCGm{ zD}yVKEO|cbZ<6CPbTxfLA0VWd$$bauiSsZEo#C4k+ZT}Mmy-s*vf7Xd)1B`9?0 zWVMWo$t4jlLS``tDkG8GS7x^9p51;dHM?X<1aw-oJE}ph#dka%Q(^_ zKf_AKe{n`4MUaddCHu1!(}|a9;%Q36G}{10JBkoiK13uR$8kt60plS~Vk~gOnyjRY ztfCp8Gd=QVNY}uyXE(yC`m_5fRX*bkn_pdKl*Ej6{50nS*RGbh0es zT)$^dCqi_B3J67|cUmO~wx-iEx*E~iI|L24iib)*QZIn7R|G^ccl z&Q5fs;>va-&K~S4%}zKQk+Y~8n9*TPcBIpj>5)Lq0lSYhdHY?vrjrNfiZ~+yWwHW= zW88AfjOLTfC|y>9keP;~jAN&F(ns_4_rn>92x1&UO4YZt_b?UyLGCqa{AiItgxEEq z*BX<|?BrsC_A)GIMI3=oGjy^WG22WXE}aUTm+7C7c z<#8&6l=v4kj5Z^ydgx>y!r9f-<4z||iSTbVQZM{pPK8s+NG&`9``Iwk=-xO+%;QaYx5fKhE@m2u5Dw2C*aEZ8}4Vdj<8`GLqyw z75ElxCp$g%ZgTem5PksC8n2VR?T(V>ofBX}HDUeZ?%9zDP?Jfer)Q>R zJNKL6bV5CWCxZuT*L1h&xFq%neRZ8qF)3YSw2kjH0ptJYNHO034EO0U5^}#GpUVs9 zKDi?m%uT>`-5PCYjdmvhaK!#7) zZaF;2tOc$-xh7D+8f3R!yK!fP3)H#D7K zfStOx70CE`rXt!Qx300KJMRjTq=_`DtRBOfuBJDFSWH4hN$s?2z@q$rvVTzF$eL3$ zKJeE`GacyaB=klrB5v$R_TKVF=~X$0TT8MRENtjxIRr*T?FVr?m6^aTk6aHK)UXrs zr}R_fcETJ_^4)lE?e0NF6V|DGNhThkT1ri`oj9%OPU#wmSJLH%jj-to8@&&%ydoHQ zM~-%LHODS&Oj%u8hd(8)#uJf2J$BIsn$X_Yn5uE}weap+sWF= zPZrL7a;8^Efu>R=x7m?qzZnT9AF;eg1kuOyDJn0PCHdJT|BM@9306C3{M`fgI{}Dp zWd5wlaMkV1IbLT?fHr|`q3l_9q({w=y>pWIKu~0c&9nP(`kQ?qz_^ZELX7Q>&leXR z`<_od7{!tZt_TMTJ-cT`HYfGuREunGC*ZpRJniF)VO{!{i>ae6mw1Xz zwX$I(Ce=~5-Ue@aARA&wRr%1vn$D)zRD-h!TOPN3INS5-vjqWp<%lXoa&_eD?1Q@z zEl9dx(J315a|2H-hoto4YA5P*lyQhb zF=TYVnBvKFBDj@mbmK`tr(0DwRvF-lS`sSxt7+5o8xPbyUY~J}9f*U`0+PiDjt;tyu)%03G{Ko5a zevY|OetvVd`8o(mC>+HB%ZxUc)1*gGIA~JJTQDxkc?O;7NpXU-QDVHM*BL{qAE#4A zfh$4N8aBdqy4+4ruOd5;T886B*gLpA`%R}jLR2PXU?`~aC=R-egEk}pK^qnh5J1UbZ~Hm{}t&8h-1XXLMJnxO>9Ra30f zi4vw|94mXb-E!wHIaiP>s2Rz?i3*Y#0u|02(a0T%lq2#PYnLD#`Zg5dbSfg=PM}cj zG1=KU5{@@J(x|B1Nl8K5>GXutl^>nk>~-SdEK?~&W;>k>S=UZ4XLf8i^{c3SX*=1= zem{BHsdPuV8EgaNNY<%8ZKtI6UPO#?u3S#m!wl5P1d#(}z@-f$P^j(ntmHB6_oWkQ zn^-PJ(i`kjlRTN!(=bOHRN;E#b(&ASXmmm_N^1)8+UePgivl^hCaLcuAmBr%!7afl zn?vsYq0Xt{84R#rDDReiaKV?E>_qxho~{S&K0bez*($(baM9m0t+yGiVTn;N;hEhfNo74nxT_D zr|CC?@+?&HX=}w`?ak#+{o`x|x+)pgDh1uIm`2OkQV!BhE;ki_i z*VZKCOwM6p0CrH~J6e$jVMiLmJRChk>kNV?g1HF1QQOBJ6CphMM{S-UgAh#8Dyeed zD+4H!>Fac&ax2M=)Jd}=S@-=))tk04<3Ie;9u)3Y1lNaWs*Q}el|lG{i{NIHhy**}ksB-N?|9m4sr?O=8u@2C9p zAa+n24iK_oc6Re-=Tor_^vT3PpybzK9}vdW;X3<3A`G@4_^ZS9T-GmrolX>-CnQc; z5G_H#Up2#YI^hRG%>Yiq?zmN^7oBKsXE=5Wh|Z-rp`@?7S#@)rwoEIK*Vj_%-PB{* zz6fM7$%+CktJ3diNA(>l;Y!M*%3O96j%g*(AAn!_W8SGGZ(4!I7w}>T@HH3{;N|{0 z$PtxRpuGt$j5q%W_gjcBpa+;t_YRQHBmsjK?Cb?~zDfXDMm&T4t3b&+@Q>t^uZWuy z?~glVcBT@6X+?XLjnfs!0Vl*tk6ofh0q_Sjh4%(7u4v^hP{=cczb59WZ-? zsG<`jvza?02-kwg;C(BbyR8WOCjeWvbvVdVFV&ZMQI;YNsHNxb1mNR(TLX$RahNoc zeBh&C!+eT5LR1;_X=3J{BLy=_gp^}cIqyDsp@#s0OtMV}4)C_WqqdkJAUKn1W1#qC zM^yr^|D}+aID+Epksv4_)}h$yZ-uxxfiskhcD?a4_jmw%q22{%%pMr~qr+akeS31g zMY{Sb=bduDb?WXz$h6`N%qp%1<&QTX_umBj`%{(8CjBfVEgH7%?_peGsRZKGCX{3*0?jA)%-3m$grxjWA9bEd2TN{n- z!^}g4;SL%C!tJup-(6q?S^>q8QwYKy>v3|6+8l&ulLig4M?W<|#CM3YD;RGQ-f5+7 zirb2+6VyGFyJ?^px{0|+*a7%76*v;6wt&Jr^0y186Ntb-j*r+g2T9y~i`3S#Bocgp z906}6*u1_gI2dU~0kH_fVpkV{1HT7iS@3i9VaEyeh6(KLK}`po426Bbr;3m&7*g`2 z&)0w3f>R8B$0K+)Qm9Mk?9-g!d#Uf$ooByX4^Nf6&wvLKsFr1sez_eAdfe_*r4UIe z1!^0yrAGh;5Z<7r`tZJzdP*{SP8iPWSyK0Z3C4`U8PNz<(hRRzK{zCk%O4+``)?ga zg99Q%D@taH$z>Vt-T)0Y`b*zUw!3h$ssvNvi~do6on$jmBr9%sFK+ zK{^tqV$gF3LUZ1^jMQtq+&=3*b6I4@$Fdb+`9lBA=Ld^Cz}#U(sv|T&^VrS02b1J> z=c3qCYLY@#H6_#hZE!gh1<iO-Lq5d1az~iKNt-FP4>ahj4)C$ycet zePB!bd+XuRGh&ld{~bHMp{@ZV-oa)j*Lqcic*q2jqyNzS(?>a>Rk~iK9m0|bBZ?7g zf-bp3>jb}Wk2iLl!-5TkmDzx0GkXxZOsOyzGbI2MC&qtC_O1b~8mKUH1#GG584@i< zE0DH!oYG;H1irOiQP|j^Ju_kl;SN^;&PLCkN*3hPNPX#N{j_;3hk`*^zl?BT--jdn zMWkVnf&av}hST;TUziujs8YIzRvnnjQ6^UvgyRR8O5X3^06K%wNr{bS#*|)BCMor6Dk(;a|U*sx1ClVizHp2I(RI1HF#Q+Z((fw?OZG)%)M9z>p6OY}opF_o1F~r&Wpt zO)Aq_o+%|U4&E$)6q*$85v}?WWKS!1}Jd}P{H3qplCrB)=yffgN( z*dowi(W3NDzeWn@6bEZ0LN=hzrQ9|svENh!(WKW%1U&FWq?8PIa&~x*V73HUB?M33 z>aEraL}tTrWfw;zW@0pWW&E&d1{-bZR9dz40pkdSyhGc}y@=7p`rQ3q7gxJQ4GUBo3c8QxCab@r^dI-Bu_i#=h-g(Q19tPyrlOVU zByorWaq5^P^bpTbCf9;gqZ?(T49GTM{vxoRJz5zbf!` zhmow?g?NHVdT6;!xZTH2)}9Y&vR;`p5}_p+idEXVP205o&%-r=C_|M;ipGwlhjHDE zKwR&{^rRE&bgaXoZBo&c$BztD@KK9;t*k&6=jE&i?mjj>w7v@cexxGOqdHIpZJ5{g zCPs$D z6>G$s8G!j-6e?0{bJvFpO(7>sCm#3&Z0CdN&Gj}o7ehLMdPtr0q0``)?R*ZFD4aF% zmX*y)WhU5-AbVB+IGsqO1X^7M1lvwr5dGtJLg^;8W8A%=lj{a{I&m$iIR)UXJtte` z!SO758v*{MBx#I?`*7YpwC4{K-Uhaux=pQsj1D8&={fJ2Hxdze31*yede#Tbtvc@d zWF)HJ0E4K4ob5;s@`E>0E@j^+)i+Gf@}iSTUW5V%c0n4es7y6IEqXXxPU%IEbyRAy z?Q}L(EQB@HRSuqCGhV_Wj^7O>a7Mz@jIrhj@DIB;!6N`@S`p+d8oZ^5A*$)#aq+8> z=!B;$BCO7pA{@?d=+^0kAO-c272}8=`dB+!cRHa@jgQfPx}v2mMk# zG~=V8d$}V45-BAPhK(4a(5Jxc2n~+|LOBUQ9y$TO)m?NaY)DIpSf^JJGOsEIU<0TK zqMeXe=tRU7r7p*j6at>!cxO$Sm^&jadh}tf=jRhiMXU)&eFApl_5P

7Ci%98v@iAwXm!kq>8krccS;JftGZ?ug3soSYpnb^>ua@=7(* z~zAN8-T6PILJ67LD(HXd6?dD z9<-vtXEp3N>1^FSI-QbW!MDmQ@+ei9vyEXS@csM996vNCPh-31_MkK_bM6C@Qjd zkkKYPHIzG}j^+4f3|l^*-g43?skL$>pN)H~@4H$PP+E8_fjk)b%CO}YdbV4b(+O)} zp2rGpW9T$_aY4l*6%dKw@Zz%R6B|LNSW5A!9Oz-B(QcW*{G_Si??T=2J|5XY^`|FX#^v&96a3<^fJ z0u5xXP$&m7(vx#|1f3#$8mgR}UDD}qmV|givGr)Y?L()#>3zr~s~acWa5HSD*>5^g z6BIl<^-S9(A;{_Jz9KxZRaZQtP#E)`Xzl#+t4wtR@NcPPTyJ&8pD-hSLY zt8txfhTt{XdZ!bCLlu$OGK|FGhC=Dh zqZ2O^6&iXB?lF;iPuX!*$naqRI=IrBq_gD|3e16R83lPu;}287570OO{`e_*1NTUf|{ULAh86dTs_iO&2XechrQCLMwFuJ z_ON+&ACO)r*sGvh5wDyp%b69xFc@hyNKqc0YAL&+@Ww6WVJ4ZNhn&qLgH?N5tg?#q zs-*~Lq_RS`u5}to4;FgqmaF{PT-xEDiDuRseTCPC?{!$6ZJZ_=&TWFk=n zXqcU)JYI|m%A*rVp@f%>`ixENKApmgz|YyjU8#sMno@_6CiQQUv;h>rp)qm@s|`}P zRG+RQ2FRh4hLNm3 zb26XOXDW2G7TjXxFtD_Tk!9kXr1)(>ysHL_>&=dfb22x_A7@P!ZoZaa$zgiKntrnp zxR{BS(z?l2r!mYY6>yRqLEGRR996($iDHM>o!;##SPqlls;EteVD6gG;rJ>fz>48*&Mx!>uKGUo2 zQ7S>Z>TS1XQH-_|hf604XQH(q5sYjVoQ^7-HBq;efGy>kuxmn2oLrN@1FW>^-xgLq zb@E=FfylP20Si5Hwv)D>T58l&#Z)B(4lLqqibasG2!fjlU_79rDdY_3fc)Ad3zYwD z7->E|5+Mf#HMK{!XV3O(F(rbLuSm{57k88*>^r!aDzzKXiK4LNnvECN9ur!|#4$A} zX}mMIWd|Z3M{*o+>YV6QVFt_9nyiq6Q*1)Wp;IGe!c}OEt!cb{n5aO)nuy?$idv&g zZlgnR+UXx>dJ-K;ZLo1ocFQ%Rq_@+F;A+Az6oa*EvT$Gha84&&m*|~JRJOd*DJ9~K zR41iC@{H57tejKQ&S_^PD%z1^s|O zj3ePD1wyK;G^#TaGNMzRR+I)<6MjpmoMdwBp0{1>rW3Wv$I=4G;DS`&K05Df)84}J zzeZo2uTgd$!E*+E&|tE!uZ~8TjYENj3*R%a(SY*tsA%%`yZIiGfA({PB zbb1uca`FIqZE4oWKHgB}k`0-K`WVQnj*As#Wc+4lZZiU+sN^Z3pzhanB})da00_v) z!tm#&Q_5&YkSe$^^0mJ9qK%<-2#yvxX5c=8lOWY6Id&6W>MQ}@EUK%}rTaCVRmPyy z3Lx}HzNQa>cy)*1f;JZrTpm8D+;G$Uly8I=4G4x(Fulw#h! zn;PdjV}OrI9hVAo&Ttn@1hbo~L9+tLJjtv4qqvo|{=C1tefM)2XjTyyijLs#u9Foe z&EhPsR?@6LauaTQFen8s)&MUJ`(dJ(54H`4L~&<{;IDQsUEOM7Nn~*8?TDhhj)?N{ zrbaTPbMSb1K&CNuZ#8|i-X%rzB;X1Q>`j+OLhcX+idTPc-W<*lk(mhGn?yxRO!x81 z=@OU0`w0G3->e(Bi{;l#AO$Kwp_H@Y`VCRhnNw(#uazrPs@z*?>(K`~8D=jOEE@~o z=Z$%c9KZd*gJl}P9>`T zdVV$}@j3r??tGmLKH!%8!)v{_DP2hvx2YK3h4)Lk-)`#`rlxurB?+<0QW~?oWwo~- zyYJh#+yBt^mmV|)(i+tJe8}x0pR2iE{6X>M{TtO-yNoZ^;5;sZYlJ1%r1QM(g)tu~ z0#98rN~u%TNO)xSK2ks*oY&8KCUM50+6>TXLaT?|K9kXN=M`t=Yv4Y&g#1h5 z+s)sbS4mNM`>}bZG__uMM!-5Xc5pM8B(Lm+e9cQg%Zsn!?g&8RV+ooZ-CP8k6@Z>d zStSz7?mu=vwmtQDbOw47ens={!Et*Q&ZXJ7heEn9N{PuscG$Fbl`>wlrp(n9q;NzLXWb@)&@(WUjE7HNfGw@{qz2fTx6Yw7lH~%juCdC zgC*&T*fb+~Yt@+CGk4{>1h+J+V+2;HUoOw}Z2$Qoe=fFfZ#s*UhCo7K+&|n&UH6-2 zWYSXkTxQ4ZFj>r9>XQ3<6%;fgP4h$CL_>1Z@JQFwlZY(DbEKsw59Fef)fP zX$z$(CH82gGJy|M;R(wm<+dqIYN!aPy$I+*8b~v2B;wKM8@v1M^}@ibynk$D(Rzz1 z3Q$ox%7|7?baVR%^2)>Qt6X=dS-M7gFxSl`rcae1%CKldCTYMUrcamV8sbs2*61+$ zYv74E=gJi)K9+d+kGIXsd!J11=V20bO71Gz(LR;5-V?}pfY)PT?`49g*U#H`)Q;`j zLa!9`j*z19BS3%^A`Or1Z=8SES{^n4w2CFSaDDyj`X8%^|Hu4)<^2D|`7i%(&3{98 z|KIiXZLqvO;WZ+aj;alZ`~K-(JAgJwB4=&>zPlSr8qGRbk)`N113AXocbwiU;+J~W zzQC43&Jt7Myr$_Q`L5-u) zLTZiDmovw(>g*oXj9a2PM??GAX`+NQ(`zX^MDpg?2|Vl0E9>-e*VMMm4!%6>o&~OY zIGxDD39)?es8a!QjQJR*H|0E_QwmBQwWvm8=h(>!&QTk&mQuL^X@R3z6@=T~9qB|~ zIh_iaJ__ui)fX?oajP%WYY-VoFCE>~L&VIvb+8$WtQv`u=e(n20jrI$Weujv^bj7{ zQhJV`(YIj)mcFHqEr=%`IO6-msF&yrxgC?%Fobtr2xH1)9J}WWN z9`h+L3L^nGCopBMqHSCW0|2h$L_{qKO{t1BFS{kJ>y!W)kcX)Xy0^ z^$^Dffw0-Y-KMKKfF*e0c*f0Mk2C!{wGs-{vaT&qZR1}s&c?E(v%yRPS`06kgdm&Y{ea_Ax~U( zd|jwH2)N@zV=u-=Z-e#}q9+zLK`E(vJcmwGw~4~^Qkh;7pBf9C2Q1PCT#n~wEzr^s z>;^O|UlhvFLzIw1JF$?51h``+-9GJJjsuO+E<$t(5kifa->Ht}{@%mxqaC@gwbY1m zF`zzQ0O}aYfOgb#Bl|vegxUk66YX$CQ{FH$RuD0I9u=?1X#y{o)Ho~-SoxoKPv1V? zZ(l!O?ms>^&w5;9dJrTG9+5Rj^aeI}UxEa~Q%K|#7DwZLcpKDyWr<^4$`T>Q=VC*^ zrjB;=uoLB`+Pweej7vyuN({K!zZU^L+*Z3+Y#5FTrr?I^g>m8!sHCtpq}5E|2=#gHK1W) z4Pk!T&gy-S%Ab@$5|fVpp7<@?aZ^g?1_s>9vtRk`63Q52{4wM9O%DwEJkKRMKyF|; zGmIQyzP#NTyR&y5B(RYgMck~|yZg_zyVvdW?nQY__?|!q!Psc$%}?8PXjfy?D@Z~= z*cY!I!BYvym51NcmYs+Q<&qFE0~2UxXAu;Y<&$UZY|}0P1Z+Y#BbAU=7~In3zdC#7V)b^9s(Zb- z`Pkh%_mdQ3@&&Skd-v$wJ5V91wtb*tiWAeJ*EkhB0X{&V9vp|9Bs;DtLP6c4!8JYb z8Rz_v`bl{;-onwU-g7R^X8@g}_y}&CUcK*Bdu;xDcfCZUVHPv=b%U+%e)rtG-fUl? z9Sw0AEpZ8D5yhmLANN>aQI}p*()ysBgL~}n3urJz$lwvPClVWGedI(^vXpS%4tn)R z@238NUqr7s4O%jLQIY+fcARXiBy1@KYFsPcO57WjM&O2o1e4d>kH7bCe_by=Uyi`J z@j=QY02toe2lUpsqyU5*K?)|UKsTECS0!6X2?c;#22!vA6grwAT9OllKGH0$ZNB4M z*Nf-fclV9Oq`q3E#!lP6toDOC?tu>yK$Es4Wp;kE{To<|9S-sL*AM4@W+4C{l-W9* zqK?bpi%|?H3J4P}SD*X02{)mj0mzbFuIV_k_#XaV?g=@3FSz}7*el;f>e?hwtY6eGm2^q%wx9t;9XfF?cV#eG%gpEIh%q*N$^*_tFX6Tc6Vs{hCn0;LU(jEq(Q%5k#%y2my0ee=RWgTRa>78p()Yedtw$E#R2OC*3 zuVWUCw&8y7%%{XWr|J+gf!B_4z4g{qCpedM=^G;ARix2^W@T`R- z4+%O#Eg|o)MNK`FM;+oXFkOL&dKjGKIF9%p5vUxA?2Eg9P6Qk6@GtT%8n0Ft7SPL@ zj`M+bI4OvY>E)X4K{nnp9QB%1DZd+2M%H(r%zXJ4F2iXYJSV<5TH^go8uNVWJ0}4a z&agm`;?6M9f31M3e-%^u$Kf$0W#7@)vSqn95kN4wU*GTc&&JR$W_FFo8{zgN zp*ti4PD{BaV9;H5#hV9$qVQpuO@DGo4fsNw;Ys))G!p5*ml}+c)jzm;Ig~?)bDXQ) z_c~8*`|(z8?zWDWB{0REOV8|L^q+2rcAhX*@f@QSr9+^UfkO17Ed`$dJm${bsC~%Z z8B+!z<{FC#Zo}%G+YSv8sICw*NXvzi0P=ZHO`w9a3k7vDsQm=fuj1f^-hfp|2itjG4@!h ze}yTyR7W9ZC^sz7i-W@yiH49OBw6Bn*xr3U-FDKAUI+d@K4;=C|L|gCoV(rt3rXz6 zA!~CyVG&Lxf<`i6dv`Ca^L;BvY`o{*E>$P*`JkfE89~OGnyzSJN8&R(UaN8w#!uy^pl(l#fF;g7~W!|~1 zF~?&g4^$Agg~?nv$wt>|uLGxP=wuE5ljWAd z=n!Psin1sDHD{lL{r>IY)aB(gBtW}e8JO4+|#0m+iYjv!BonXjzKkpbPGl5LP=$&+Z}(+W;GqJUGrFdmzm;#QcGbBFpX+?!LK) zaZf{VS%6d$3CgfRJG5s)l7^(Jk*v@InZs+0X4$J8XJN zJ&5sw;qstHmbVy0GH)ZPAdyop$Y&vheE1D1&|9rcte&%&GxsTBXt0wqfz#p=7+m+M z?IA3ix0?;`4IF>(Ud~PrV}c18Ajt$MFqxw>^xPjh1YL#TNqOVDp;fGlVi0_h=wT^% zK*M;ueYo4)|J7}_Pq|F5AShgfE=?4OX5RK7`{d-^3-yG;H36i5hhb+g?-XItM+nQN zxZ!B6nVe$YViky}r)=dA>_2bBG9DE~SQ6o_kcTlBNsJmW{+s8cyIJFG0?3D%_F_mE zsC4?%5jgo`L&fME3peLe@&E6e`~CaTFG|t3!i1LjU(}`v0B{nrE7zC=dvN)QhmwX_ zgZN;=nf10)1;*R<2we-{=mXO5RC>Nhm??>JV)d2RMeVv{W~3pm_cAlk(W((wS5!WI zkboy;M6b#fQ?)7j079oB<|3lAWsY8{3vXy@Ya$OB4aBg3k&K)e=oqAn5CfT!OPuXF zph^+7!EXc!ffrM#;`Mp+Apu6WKW8&%j!gq@9*LV=i2ak{;=Rt`%@GKGP(X|p;@riV ze;0-210g`{pV65KMfxSz>`-Z@;zHP9MwH9weA2UI(=O%}>0*8kJON7XkcL<(BI9y# zzIf^icr=vy=CR>^>^Qy@s#a_ty4Z7vVI-7s!s#MRP474=vqz9bv9Bm!moM)&*hY+; zDoX|je)me=jNWsKbdvN#0Cz9V{4nL3`Vb(eA%R__CkO%g>()vJ9|8qtMV<%^Jvesn z6jQ9RQt!F1U(#32z-96Qo$H~Aho`oLDdy5&fsRjl@m+vN0SrJC#UMJ~KW{g0HlfA& zVoa{@+Q{AxvzY&MlBf701>r$&5@o}0sI5mdOerH&fLq&@0pTEx*njwX0_h#B;i=vs zqK|ur$eX<`z#H)zQswBNVG0-@J|e6~1nt?VHXF?6tQ+-;lEBN?ySGYM^YiZhi_{i# zt2JR)6D(qK%NW}=2e^J18WNr-RZ+c3Vh!*n30f=_fOx|kt>_3xgWXdus~N;=AqJS< z?c?)a2P86d&9hLmKf{hQ)x!!n(h#Q?)drZOiV*G-$n@@zk<6_z8A+UCxOnf(N&6&%|qEYukQ&+dnvChXBAuMjGdvIx?C#QKunL zl6cu=$7$Gapw%qgh8XSEAQQUWq9YQgA?Uw2PXA$E6%_&n76Ota5)Z7p;$@!vZIj5l@!HS>9zp$=_jD|Hp{~_TwE>*zx zybDY4XbDO|xcu@VuZCws!Vvf(3Dp#gJKRTC*`*<&%N4=No{_@0LD7)>Iuh)9D^yPuhe6#m ztP><+lP=&a#?#xSA?4i&S7p@>h0lLF-VYiQos5(u?8k5DvMGYtb0W_VuELrBMIsw& z&;}1K7Y)5HM%dmYz;lI@VEY5t2-(E2f%o0h%f@2?HR?Z!YzK<@nZM_CTw*8z(#PB{ zU1i53$y$n4RajJ9&&!Yf^XGR*D#paM76=uefX;jZ!ps^0s}y$(8Xq)KBIMBBf7=k1 zu1uK3x`Fi6W*`RG^qY4Q&&a`fp-!gL5bHC70OqSh^O`FsHQ;U)F>o?w*`2u86~*(G z-GsynQ{Sm;2!|T%bso29NNtE)lh>?y3dsluUqqftjFrKm$(b*jHVI-ewabQZ8&iVx zR)lx=F-ADVJa7CZ&KFO8iM+|urfTF3>2uJ;dWJ4^V1+^D1ql>^$~H8~Y9EIxP*cV& zWrLGtpMd#rJrf@wf^YZ7(f>Nv9E?)RTt4&mvb!Q}3_I*T834xNdNh@uczbztan*eg z`GFN_`_uVilM~8o+#mWR&JJWZ)JAN(5MU?7Ox0Z_Y;q;Jx(5|idHlSyg=K>qXN2Vg zmxXc-@kNl9F!Co7osUCd_J34~qC-ri10oG{=lOa(H+0!aOK`PV z#fPT1LL|P^!z@(r> zOHfbe3WC6`O=dh-T9P@19Y`*>L*~9IhL(7>z+aOmzTbnj#9WBl?__iXw@Khp4A#Ci ziwnZUks44m4Aw^wp1~zyR23JJ~G6>E!>3-E%6=Ye6=EhTI#!XbvFO`@_O89LQ9|`6N&jY%(~O+dMk@R zej8!_J9zbcqi3?@X)IbIJi1S6iQium>0T7YMeiR1rEYj{B~44H`boQY_$+`aIL%jm zL=Ak3NP&$p&XPi|i8*RQFvU$mi?jQ_J%MjF;L0TCP1CV)2P%{VYBz0P<<9-)!HLG} z3K`0nNu8FyBFs0b6Bk6rx8KJm9e2ahG9&^yBub$t{5uoEcl+L9h3K`%Igw1Ud9QA8 z)9tYH|MwUI4BtdjUkMJNl1};??VUWiP6=G38lzGk`ZP1d1QINr@f$Gf$fx70ZW5{I z>Bq=U*#+F42eOQBhLn~ybzDu1s(y4tnvSEskEq z!>8w?3DOCu2>~u}0LFj(#o95A8z()VHl_ppO`Jd#+4te{?6i+h{LQta!cPdHb}F5l z1nVs-&5+*_%~_Q8Lv`~|HUXwe?N8Jj;U&Jw&EumI`ce|5>7UX8HKm{vgF#d-Z+^Xh zY`BxCTNG@0)-&P4w(6Y z7xizc-p!osW01o5qAO?}yox!6$?MM8p|5*yUe}*2&|X$BGMT00syw*y1(ouO&eEd4 zIj=o^BOzLeDmuhN```5I*wRu052dUKqkAYg-nJJ~$(CGWTI$g=-@e5+$sNMNB?r{G zN+%Bp4G%af6IJEx=b@BQt^+VfMOW8@OO%^8O&qFCf-~GcNk2OKx)GZ;-}S}=eV43> zE|->aF-%;+uIEn6eM&V2DaUR?v%rgb4 zrNWn-mZZUYYeH(ELbLIAxvM{5^^$Es$r3pv?whrg9-2v*XNo(Z0|jzM_f;lZf*Bti z*w2p$)>TQE1_)UGA(64}FNiV~#!Y0V$vqqNKmR=>(12WX%mChvJCs@~&|UCm$In)sIM&FGePFh!S|7b&`;sVql^{>cIt3w#XTG2A6fY6*e5f=g z@oEUAe%gHhPRVitt3Ug2Y84hnhYVRmT>RY=YN}ydx^fms(>#~T#(pr138M9z!qM;| zWt53FvN+oh9>nGs;RXjF9())-Iu$lMVe6yQ#)d1a-*K8Yc_NXmOt*WT9mzy_R){)W z^WFn(*sV-!?Vf#y$oMry$^^Esk0F@U9BGPi0b^~fA=X}Z24cwsX))?UKKm=1S3&8!%f$1CJNeSYhCp8R#qHC)8p!Zrx(*$G(GN(H- zFo;j532h=TN!l_cpwYR}I5Wwc;;V|5T0trzi_z6OW2ePpf z2uf4@>w*`sbWlHbmellnNn_$?YW%5uSG?DT$EpwvJ==u14@|Biec1yTa;-e_PU1Ev zn@(mcXrp2<*-B}2<7?7kdFe925?)buY zL`4|`HeASDX`D}(S z5e#5irSs_G6PE}Py&BPiAh=uYhNH$ya=U-s{O8lT z6~y8|mB#3(=nI+j zx(1jiSjNqlYV{TDm%7)9Z{MD`w{K5(?$T2H;}OP<{`DC#Wo{o|&*yq?DJ>&f773>c zU-uYZC`%Kp`ZYIGH#LS*FNBz;^|~mD$MA_}065Z9K*elIt{jvQy*zNPUB>R_xljqW#j6n8p%h8Q9a~294`CsXa6nZ{iv- zZo_u_mrr1c$gA*f9F>3>`N1p2yU4_V87P$IC9Nv7RW5#8W9~iWq33U3TQSKW*R#UEY@% zqu(|dHB@+03iLbniwO10eSCgw-gX-&uZyN3P6n8Q@7n|y>%hAytpSFvFo`0b^az@Q zs!7D*#BT~3b45aqMKzkmJ|ggGC-l%)~n3@ia}SPygBYYE$zAGeza_p4>!*RJOmzlr!5}^GejBML5}00{U#jX<1h!59xZkK03c*0BF+4U!|}Y3wn=5RUI^}I zd{o1sZ3s~6T0^FfPT_Y)45clFBf$$iWQPZqU)t6bcff39XYmMnb=3kcO8X{#T7X$yKK2s$n>-~*uLgSK1|>==>9J6ocR_75hS3FM^vH(O{JD& zLNu19sG}KWw5`Y*C*j|I_ZyDlF5>XkL_Fw~VoEHjerB{ZKPS+QcF1tXrO0k$uF(7I z?(N4d46KLKbiPYu3s|&1%Iw!Yahg~IKw#!!8Foe8Nrpl0O$ZgU(>IN+^Xm&j_kf+3 z;Y~wkKbCoWc6celc3w55)w6v)OTYGf7h7-)pInOVlBs^X6{79!myR`sw(JS^6sQn} zYE*#J&=`t31B^3WLY+)G8lQ*Ek4#sr=A{W_bRzofU2wijlouNOXtnR`0!J+TOqZB2 zl5L0E=si}a&UZ;8D=6K{+C&NQv0{|Lfwzy~BMccsxbk4^z1?_eJhV-K$djaej6>nW z_K~QQjyb>Irja1ckRWIo*^#jF`v#d?EBBVE$I}mdiG!f*T55q@+o}M4XE=t zwisc<3IiwavYfdlx;qEnCnJoSMB2I}im4A+IiuTmmh(0HyxYF5e|-V#X#e7T zmh>1jPa}2st9$pZ6v)-o8#mP{v@VHn5o5o%YXl>cbkCXp_^VSSk^at3d*Kfu)tLj8 zxguD$$0s`}g$J>FOyQ1v7lQZIFa2V%)H~z{pNY|CBvS21w;?^GB4M(Pcgm4HvZ&DSp_G8g#er2 z-`}%$xl#LfgEgM0|Q4o_!^d`@ouYA0AdH-%( z_J9|ZrHQ6@uxCzNszR;M$?SKxF9ciOgRa}j6wdaRU<1^GyAIEjiUq**{zN?$DqeJGvYy~_M3Po+cyDC0o~y@NALBUj-zw^n&lHFZ zL`@tY(&d~4N9J8(M5i(;0)B@(IxA^$J-{W7JXC*X;n%c(r#hS#_oZq8!I$iBW;DLv zYA8Jn5l-Y-lGQy}O{SB(GO$Zm;2>dH7t_`7|3w)6kp&SHh0eiaCJ(CmYiGAG(G(S7 z^HvEJ7Zn#xUQjHID)^JZh*YEaWqOSHij@M4YrPWUFe8NFd@xT7_5j*UpHY1G`L2>` zGt$(_cTNlx23Od;bYobflPf}7s!f^f@0scK;_ma~ zL(sXogc?|fuM_G;+zrJ(dx>xV`hh{YGjDs(DOle`x5I$@{p$q1+vgrKP~CdaGyy7# zNF!Y$k_o^~mt)dFbsr`*QC0`z73GEoj-rJ3ABJU&%aj^C@OElRu_YZT_wRxAoj5ZA zeGhmG9xw^|hDAFvjw=Ole1KRI(I(UziSrCi)Fe=oL;mU2ZlQ4vAZ({DxepT2TAps4 zqsa%LUzzL$VXvlm#yir5iClVc?jMcQ2#=l#do>7-zcFainB|c|nl8V7W24{um>`ZF z=^_LwQGgZn?nTt%T=6>EV~lQ2&50jL|K{V=mmuj>UIllJB#|Ag5g1GA^W?%Tj|6FW zYm9-W76csm@`l;|=D{H=F3k%Hc!)%9Hstq>F?CZiOO$DM&g9V?&KX$_WGVAy(F857 ziIrB=Yrr(fLc;*ieR;Qk^iQNSaB2oh;@C9w8^JUhCzXM)Qn2NCg;b_w|2#Wiu80?Fpc~8Iwwv!jXuaPa zYFYUbWVe=gN3;!n?f+ZD2e^^57e5k{&4lXt%B7*PZ%%dq>qNy~psXmYkXK4f(bK z+U9om9f*Tl*%95CKv<%~KrV>Bd}+Rj-Q=G&xRZa@*9$R>F3hjJ4!{N)ai|kCJLR|c zdU}UaAb%wo3Ht&nh#n@P9mpqg+kbi7svuiDYKidouG|q@1E|ncfPhsf528($|GRUB zJ9EYrLaK#4Io!`qFC3Tz6s@cce7OS5Gc}D})+Uw|*NRNz8i}45WxlL;qc^1cyCKEC ziRkU7;oCf%P}O`{67vGkugE0YE40QY(2b-Q2>ezPC)oQejT!2iOQ`6LxdN8Xggy;@ zIlWsV1asg7wFR(qF8T?5Ii8{wIQl5TtA~GozJGL1nJ+~5L_dA+u`~`!^cbj1?mGyU z(HO^SE|8uE;vfYPk7CsxZakTaSSbwrg4j`iC$ljPanKNtGx}#HlW20#+QEg*Ounlt z4EBfW5KA2Z?MSUKPASGQ^NoO20t-6|^TJj6GB{g;Cp(-HM}aS_XOq7%RM3@7&#bJ? zvwtYscyvY%9`NVJ)}uo>`!oda*40#(5$T2%xa2M>zfbPXIs@zqL#eq)#=p|7wY#J4 zLr2U9wbqdDZ7Sg7sLtQ|QXvV38S&18_bR$Mo0gcG7>v`(#<(2_D&91bnou)?5#laT zyekI_&{7*;6INUpU!p&XwCL?GUDsh$ti-xRaL_1t|9z-Qnd z7!8)HKX@sptK{LAPXJ#nn9d)c&wp)RjKdIw8EUB=^%v41Ya={9qd+7Ur-9WuET#aQ zT+(`yz*GKJIlFPSw9ZIs?O;)RRwu^S?q541a9ZaGwZzs9+L~0+?Pq-?ynxT=Qd_|! z3LAtLbEB1r_Nb&pT9-I|hjZ$kPoq!CaVgQ7@WF`ZWoc~aAl3(sBt#kDi3r*zE5dTiQpYB_V>-t&P$WMm?gX${tJ~nXkx&L7Z*9TmPQP` zk#FsHr79Np#1`8p~H}9U5R1Dcqib$PVRw84b-=r z)=1N!0QDZ;7g-)M~m8qcMy@@Q-A2c&fX(hlK{Q?0d! zk=CIUFgEj+Zx3~~vlkrv4=#2fty6r&9c+DPt<(!Odafqkh*0`ur5o9riPoDi)SKf|{P%OTKJPW0&PwZceiV3yEZbu@u~ z?YtX==!y@b9Axwd-f4?>c*{$m13L;*@R$pT*#|Q*3bgwy(K;o!3}?kbYom}IwEq8D zJJa>Hjb&ZuV)g}ClZRg>2m+iiElGCPI)C_35+!p-616qh$-esYRuAZE5TKo$<2-a$f|210TkgxB`*mxLGYT__0(*-WiJcq{-G zqL|~|pB-^Tf;{zhtX0B}k6c9i(>ev7h*aI%Oh$kobwwS9L(TpeU3j-wz(nH|d&9i@ ze4-Z(CU}zx?~@7SIK5~fl(QtMnmkb`OYCr3O{YClJJ?{ZhRPBE1toWpURfK#wg~)= zs3XdjLis8q*kMrgZZ_TP8L1MO&nAFjrNH?9?RmVxkl&-hrXM7&gEVSAv3Hx-)sqcL ztgbqBcDcIdzsk61f=hYuydyCVP_;qi>tO7baG=l7z)iq8 zGWs3hw6m(v)46#q8^Z*~wcl@l`y-#>y)p^+OwPXExQY%7Y&9vTB<7mX`gIPut{A26 zH{2kUGV`7dYjwXm6xO|_FtPNK-54S_%#MK;$6bO`qA6=A0hP|%q zbpqTD+ZfDPZ@;?&eNm4KoR6Meth-`6Ic6bQxzw(@JrTmyP%s!kZBX9TY{#cOSThKr-7#h=xI1&gYBUkgCOr{!T3>+@ zcXj99bJCs1hB`n!-wj}~{!1e|xHt8vr{tfG>=;(NM{6Mh$-lTJ^In(3=4xDmMM_4J z6F6Z0ch5fhy(dCI@!&8vl$yO`66*vtEDqDk==YK4YmVRJ?(qvgh)^~4(w*jI<8l%g zmH^%VbP6FaCCb=LZAJ7R!P>PR07jAqj^YsE0kmU7uPx*xgeE#oFRa0CV%rk7m>GU< zV{63Q$j)ZO>crKUJ)mAvrFTI9d)Id8dt1=Bl^U@W`#bru?K|U=pqS6XDHfNmgibLld6E$c4M$nl~OR-3eJOz_n$l}RkH_(ns%3UcC7 zs#e$o(&YRdUdphTQ04-BUwamKm1;1qT8yalf@m|K3U}OOkKfxVKaEv$E}u<{gn?#> z1fvZ7S*a5Gg(=|*9W6F<+okKbXL8d$GNk8x;u*xE8CRQiip%19XFiF_hlUP#q9_=DXHzdCE^K^QY$4Cq(C0q9!_0GN_ry|S$%IVDwcHa77z zwIHlG+2gk$bsm`Zgo0}fCradg@PcT7?hLR#fRiMcR%rPEwS^&`STgK+H=7qcORR0t z(sh$^hT}2`HO)z71am(qfv}*dL)bF&+R(j3w;3h-7LoJ>V>2d;q6L+_(kBX-8f#)N z)rlgr!VfGw8Rm6;IyW3nl0MW`h2(M)G)frKTNa-=uxo4{;S)wMe?BwuFa5f(-hkuD z#f`Ez{(CF}aEmYTVgY^U@>s-}-1v?cQwrV!8AXY2SF=mFCy4YEnS{DaLcm3wY%xln z@350eUHg1yz)@Suo{?ij-rJ*sMe`K6Tk~0%vKMQ%LvgvHyx*>SBoSDL=n8eN?G=G+ z6VtY7K)rhm0t0HMP&5#yP~RkXmNl0XB<7TKo5pMwPjk|BY82>8F@?LAWLJ@))6^;p%2768io?t2u|iRk z9JW(Jdv@z6@z%;}Z7%VMoNSSt;__yzxp(j`yuB)_Twf6mVJmaJ+Bi-F+RGm=NwvzR zb1HxM@dUZEd2Z2+-BduXrxqzvy|RmtMQB^^*+Tk#sZN^`>=04WYX-$^?_fz& z%wWlqAG}`kS8_c;mt!A-sV0qjPcu7IR)dB!ig7Ot-O#ufXcp}> zu9xbwOI-F|i?NG51=p~H^ULV{XQC2{{8Kgts1q_%;lUUhfes-s*QemV`|1K(!>+?L z%=Hxg!>46-sd&r%3_fh1pRw}yW{}cIQYoYhEx5RT-bkH7gM+d*59SjV4?rieoRlN2 z9Oa~9V|^}1Dgb;5efb{}jx5)IZXezh(+t;_6MP$Uk>`D@20rF^7356;F}m>s4_vR! z+mcEXth2c>UF_-Q43K_;P_EBdX0=Il=(|7kt8srIkRSoHr$(QjlZdXB`*WJk1Tuyc z@5K*B-u;qN2XMQm4(+4%xr@TQk4ga|p5SaQ6X^Gy(3F#ibqC)6@$OBaTU2@1n|6-V z1voDSM$|6(0bbGtwW*NFardl1(L7_314}iu2Yc%6SIX7!Jf(7QJrSO{)M_>U1Qw8f z)}1&iA9jEVHUCjLTCm+=f0{~dZ#;`G&b}4+nOSx7>)rG7+tVvXbi*QC=$Dc@mSlyA zBz1EbX~>;u3(o?;Ah=v3cq3C=fDh)h(zjm{iEc=gw%6|s0fI<}0Ll^N+R_CTJ?-`T zvFO-^&Gk9FG`Y{RG8VKoOa=~)^g(1J|+ZI$3inkq1MB`;;iXRSKA8(^2Sqz-9@UeBO9SkASOSlQr zDIj0*GW6QM-|Or`zXCWLD%fG!v~t=2rzGGDj8KWUVc`Y?418#S@Oy{PPThFVicts zHGWr&@4JmP^JOC{glqa$Q0;ezYQpqQd4_6-5OlO3Z+z0Qc2368YwPV5+uD@t&C zhF3^JhOdtoT8;Tk{l`A{<<~E8p9%z3K&ermXq3Y+=7prwEC)=ilFW_<2d{}ED>cr& zY)T0%6aAeJW~TxM6Y>fDMUO&)xx`6*&6#QOzl2U%B@!wi^0yVgFp zPJm8)OWb7>%E2&zPE&Y$++xc-3^^KT0Oc(836@}XZ^)QpP2a8`w)aTRAsJnbh^dlu z4dak-?SmIEG0QWEMC=Xr<2p2vlD$Hyfh5946IAw@@y3N@HCo-To*h#}J58(~#NZmst~sNp0CY|1 zMU`uyjEqjg0WGRoffX94QcTL1xHV*%$cwGyRTvPvM&9vHv`A_k9hB235NT)~j#uz! zX9tbah2W>%%2GXS*H-NEp~bXVLe(s~=AKn%x1=P#=sC{GYc6KwA^DuspPaKbH5cH7 zn^5thTL7n<1#V{d&@ZEzr|h_thsj63CttJfp=aZX|Ed#<0Maio%^+Klg2PTwcuD6o z;cRwS)PhpcNYs$!1HXwd;r#+y6AK>o4%@m1C_AM(&yy^MX!p`$Sz)b(5dG;YA%@MaBes{X*p>0_L*I9sd zIWYWX!vQMc9zD_E5OCj+G}_~~>K}g6_#p`(#~o=cGSX*)ItwHyg-X+@M-@uw|onVF`lK+Easd3!N51ub@#_&WKXGJ+LKez>aAD zak|Ve{4zR6D%eW$iK)&p*ma$8LPu)UF>+K!!!p3!SHX#0J7taZUCAT#3I|07+rmxgw;8jZk?;)mSkFMv9l!3Ksmi&f{*%zmL?de=iy%-b7 zk~xx?Aa+MomB7Uh)ErGll-;669BYynIRw1xj-UHE+^Zp&ITIVKK5WHXv`f^E1DA3= z&Jr73!ks1zQSyT*hEwJk((c)T2SH)MN zi;2+$j(JK?w$b`q&s9qk^7tPNkV8`y&_q%?0UnGlX2~QoIr{SAE$gU#`C|JB73oI8 zgJz#d=k=gb@+&3(M(k4g-Y;ffdP^hIPjoxHb?`$HZSSb5HWCRR6{X;C>_kl{rUIry zK{v2eA8*#roJC%n=mARL@qpQAPKrUh9@1yA^uYTW=nck~!QWg-l2P<>7y}h)%p^*w zSQrl#1oEJ=(_j%aITbM6lC|L-P6=17(s{eJ`+z28MMWKQX3derk-m@Ii=!6|c!HiE zvC|3LgRHLYX930@`VjF#zzy+E>$sp$NI5Jf#zoHoxz}|O)N&l?$q|n`#W}kQgfQ4V z?PR=mx3@1Fa5GLShCar3smBxHtZA(;)KTyz-UxFtGHN2>R=_8IAvs;y#04QZT2sD& zqe|I$4bi=3n!!Hoo3xvSs1MGd@2=1KDNBk26~usB7i3%Bu)79zD-t9MqSI|nAs*z3 z=T^N~wTAo%a>~nQ)~0NrT4NF!&$l@39{KCji%I8*o-`E(RkMD&%AR&?>n7v}PbmOt zJOu)M72)WMZd%*8WB3DE8&e)W9bMF4s)ADNIoi0tz;Q$zCehV~mpx^r0(0 z3&zEU<%8lwb0E}nGflUlaQ$QoKeLDh4UV}EnAO$G$?J90rUV!WHpq*TJ#+<$P=BC9 zM{R1{Gi3D+wgFTq$=bS&l*1cWkRZoZ`&K3)8ltCKDrISoN;65L;)w z6xGn`0#J`1P`4IW$ja5z?gt`$ce{H1vD43?9t=n*0Ek`jMt@qRb)KY#vi<|gwV-lHG#~bX<@dTKc67A0uSoqv&N>v>pcDiXhtc^Y+Oc4}Agy!ckOb$b2){r-;ivNv#Tl=YV*Z_>YZ5qnSW3 zqF)mk%AT9`SSi`X&qA^E8&0cvn!~W=6>t+i0QhFr?}6x`G{nGzZc8oCU$E$_K_ zdP7hPvFpWuaA$gsavoMMa-7JvhJlSW$68pQ@NB@OK%tuLD+hkodyFog)fC{jQ$V`= zN17Ya^W^gIh>ig=K&(Z1nzlZjY(n-;j*+l<-08tZoIH#}7EkrXQAr)Tl___kO$mQ_U`C!u_W= zQ8#A^Y9Zk#OPMKf0dNG8G+~%OB$oa5*!Oy5L1(iRpMaa@r|r{5guDT?TQ|1>JnLS< z2+Y|IzM=Q9w5Kohm(M-Dq*QxBN-q(1^W_EEOBut&I!`A2&v&+=zPHo{0G=NK4)@GD)>qVqO5S)RC6~u7 zqythsYFJ?;)H7;#&kLAZWC@C6LG~faiG+^zbX%PR_lUj)=T=2cD2{gjY~93;yhDEC zM2=gcUn37x61Z;atrTleMhzFuRA@7Pt=F=V&~-b#E-2oIcHVYci~yrg2w~UR6*~`B ze5_GBB*>gr=#Dx1sC!owt$xrNrQV>Gm=9Y?w?U;SQiD0@4J`TOP2Gej5S|7@n&do? z*waROdM zXQee;x+cpQs^h$=6*9qkT*dH^Pu|~|&cE-r0>1)kCDfOpBPmADOe$pT>GsT^;6K)n zR9l7pQ%PUiP==WrL4kg_V?#XeAcuZ^R3`&%P(%pCO@4OfmKSW&kbev82rAC$80dA6 zW+}BAMQal`fb1pl@C0WXZPO`UIB+^%xM@EFhcz1J`uZCOnjR4<)Jj~S&kohbm@`v# zORyJ!Sm8*#xIE92QWnIpWQZCv0aF67tvaiBrhX{$Rv8}veZ~veI1GYS7J7$)Swcg0 zsq2TKr6*b9E2Wtgu0?Tsct&kNqClJ$TUokeR)%@sU(^)7#)`O`ngUxa?0QFbjM$yu z0eWtg4Fb+?mZk8_IGDN9TD$m5-17Q4RE7kaZV5_d^{!-7`kJKL=h zG-~ej^0ak}8v$ijT6BX+l}&(Ph>C#mutoG5zm##CA=|`%ijIIZz_yMW!mmD^VEVT~ z4{tRAyb_2sLQ)`(;>b_TZt- zK8Fed4L+cBL@+h$mzURX_-*gLxe*DDmGFuEsGkljcusIH8BWgXJqzkc`d-W8*Dhy)mHUwN5+!EEBEh+vaB5HBOWBv%L z)9SITdV#U}qR7#siOZAE$rk;Uv)-kVD9%MX0m?2V;?X1cY|1lsmBtiP!!edO$M>Xc}lS`X-+kn@M^Bmf-R~)Dg>hP8F&J=D(Nk z;uOT$v-&QjEa3oH-3i=jrQEf&nWkt1C=l2jq@HjHcnJLJX??$W#cnZ(VckV2%BUUy zCs(_dr?w!t&QE?o??9hKVCtqMBvhap#lne}$#KXS-W70&l0uz>pMB z-B(l8Z`{a)%V;VNK$Ln{Kh7$=9JIP2M38BjsX}r#Qt#=#Lacsj2*0fMs&9ZuT~I3v z29ZITYBuK+amX!UVay6%CEOu{ftTt*;%hW@C5-csnZJ4_70=uBtRJV?L=E#KPbq`f z@rgZMJzp?MZ{*xrCRyDE)3VOMWrS^QphM5tEl;Lo-YJ3ZQwxxgl_#eOrAo9aMEzl? z=&0}_jQGyj)HCd6ii&9uYXY~*uRX z0<412GEDq@R_Ygm11)2BU_Y(*|-4Y6wUL#f&Y_5<9b!z$^P59>eJ%+@Gn zW}@YfMLH#GAR`QIm!fq7Ll^N%FBwsugMgV=Uoq1rtLTvswo)e!Ji_2gQh{w8HzraW z4evC;IhH^XiawQ@op8XGxAXM1{&)Q5q%>!9FoQv+>38?~302(?3s>>er)5PtTDQ!v z6rvLK)~>9duP%(xhC1ncOVr6M2}=KLflg;L4qpIH?KntX931H1)~pe+3vkB+E&($s zZgs`zE%nezl7Xh)1Ska0;bo;i5YS;))J|5meKtbkiJsCPIL-|q!EDLeZN;pf@7Zix z7UZex;nn7gOQnuMhIVj%KE|^p@n;Hah;096G?ItS!%hT_!;2YH z!HkwxLV3|kOD>sGO2nOw%fNHOqaz) z=hOv1ASIy0m4nxr^_#9AO<2z!0kuoow5pQsE2T={JXSeydmCbI>JhYa;de%7N0cSS zt;S<@BQt4ZS1X~jqr}Z%r!yKj*vuAb2Dxr`&J4ufP1g@&O2#9OEC-Kim`w(4d@=a- zn?uYpC){XUkiU8eP(xJei4B~bc!R;_-QDl50Gl32t(i;~h*|Kn4SAy%(5a%^T3Aip}T;Hc&HAZ4;l{ zppMejc5x#_cUa;S!$Rm^#a`|_tX~)`tzP7KYbVt1lDdTLDihTE^Znhu+V^{B--DnI zLl3x5&5M&g_ct~%2}#Op1k{u4zGVX@tma~5N%5>L9T_8&1j`W#6>+-UQFf<6sd3*{%itYAS`AbIi^7UY@&`> zJW21PO_ZSpMRguc{(3=`;J>ep=TK@CfCdfC?eIYD>(n$v#e(564VKDma*n7li`1|6 z7U7^@b6FDOp*rO#^9CfN;hbAAY($6*-HwVR`1f#|qgknd=PhUWTObo)UL^f6YKY|r zX1;e|A)5m^A}$0|VVxJyEgK3ONs>gH3;M9(=8TDPO`A0YX@w zWa+=HXirCr6k_*0`#T4Ya4YM+FJLKK;AuSAcVia$-K)$~dVqd0oznSU)zR2Qz8y|& z{orLW0U3d{X+SM1r~@s94O70F;GAv)GX=U6k*D6L`6K?@<{mpJUJnq#=JS$z*FRA& zL~jkplYVw7G>B7RR2TobxXetrGiOd;2zL`U7Ly;T2xh~0jdVlU05FDlQIFo!tKt@| zk~Ij>$oO#16!c0n+hLMJ?eKA4{%kui!x)H~d`AxuzRR%&J_lg3RU#!6!XRR#0BApX^B& zHOEL5SDbs*FtpR7hEyA4c(c*>KU$^?ADnAXW`eQ0O_q-V0^rjPtEhZ?5tlVF zP>v?-g_g?vN_hZg_?>|?3IonS%V^z2kDQYD1Wq^@bw0`x1d3OuqITd|N>T|!J3XK- zd4&Vnf_V;uu=Gc^-dO`oJ4|T(M|ISRfHs0J-nnpDtZti-M3e9_Ujjba%2i_No0(S zQg)eg_g~osX!{7_S_n~0Ljx@C`joAR`BLd8Qbwz8U<^ilcVR=GLq($E z4>Hp6#<4L8-4Z|)+>4}c1*}PTW%ViE`W9e=$@L|sAt9hMu-!&Ew+yyMuT(mSP6ZR>Ej9CSUttzW-b)VKY{JRZi#Z+SU`%I_o^l zNc6YZzc?2LFLLN`n}v;M`GAb$)xWD~`AE_*C^Re=#BC712a`Y?5rl4-;*CdLbSlpw zsl6{_=9C&tD1FxgGr~e`UE;;cfin9Q9>x}aDgy?zhxWztpk}8$bV;_&o zt#1JnT@4a69bx!m`IF6O^`0{^&d(}H_Fbsjp4L&*1+-rXwElBED9=(EO1C3S1p16e z8o!TP@3HN)Kg_db+SGy@wz0IT2CdCJ35BE!d7gSls5vT?(mjXM6UA;?soG3o*`pc( z?BcN5d|Q9l(L$P4;Q3I1f5l^qLjAQUSWCYr=eRqkGOcZRb~3r($Ta)Osz6Gd;g2cDImzmH9tI;O z-a4Rl^iWigDW`c~z`mn}Mp4rFi24DL{osWA+0qxKMnAHepxy(U|J!!hoJ@%Y5lW;X zw#(*$pteaFWa$ST&G|}L$7^Lk(UfgU9qWk_Po1Txbr>I;4aMg1y^l$}hVhV)gAbZd z%oc0UB?Hp4$sXvL;ho7o%&E9s+d>{aoO%WbC( zF9NBO)YKg56W<$de$%tS-X8yWRI@{X0miKaRk(jCh3x{=j$zkbofc!1NpMQPY-lb< zvjkrof#J2}m|xNOl!^#dh+3HAzF^E4rQ z?T}8r?^C9bJj|t3HSZOA{vD0&B1H?8u1RGqsFAXaKvd7r9&+2$5(h&=G1Mq$3izBD zD-K2HK8D}um#rbU0UniWr2CMCs@pZBf=fw|p9z8o2|q>+fj#FCs}Bpz`GfH_SXt?u zIpGdcPa98823l7Ve`Xu8rwkg)f;S}9OZ`X|=>6vR_80m-P}fn!lY?r>hgkGD~8 z7gT$lNLpb}+|KGt0dS#{7^%!eG4BLlm^ym&(S^s((4&|__FHv?P$Ci%77o^l6_5_T zDf`V5G9aS_`sXC19-&&2$cfSnIeEqmmL1S$mL)w?u@N zq{1&G#DJ4F+>A?HX z?Iwxf=ElDmTk28ss8`3E;|?aZwsk;vG(}sFu6D-5P7m<42^2kn#A}SP%TR>D#%?90YA_a-t zC`&Y zw-S}p%1p%qbTE0y423FoNE z>1;whSALAu`9S$3h8VQfff%uiDcG&(4W-b3DPcqftQxdfkF-CiNh5!d+07Ik6BmIA z^D;G(MF3-*g*wa0VhQB*6Jhl$GB|PdCYBfPdbE_$BN#z_iz%}ORtgXa7t#0P!%adv6L9~S9KG7Vwz2V2=||4UPn0r#!?P6)wcpYD7MN7fn!zd1 zyHtYRxs&rsMenF?GY6@eCS*DI{20A70;Rm$!SO(@Lz_Liy^EZO=?9^!h&?rjpnzqksrD>Eb94m z0?Fl16ko%05;dGA;P=xZYAG-0EO}1UkTL}DY^gl@-D-#TySpux6iWz4>C?Br2%5@IUasrs5<;Z(JUrCFf#=t;^gLKn zhP^_!TnZK(+}rSW{~hp|*Tk)G-l($|4*FzC-VU0nJn_r9kQKO;$Lnuf3GKEJnticM zYkdCTS~b{GkCp5^8$%LXOn1D2xCFPQi!=X(*>Qv&zjC%gxwP|FOcISEG|1LREc?L*F)A}&x{*jj)= z#$Ak3E{djM0n|6bYfOo+IbQC0PpyxjhZv|w)UYA6R1yL{nAjM-g<-bT_aJYp%4|va zK~(Qov>Dw-irZ047t3})pjkhji5K$5Fm#ygegFFU1ciR#fpsLY5Ryva{Ozg+CP7W=Oj^}Ie$=mCf>IeL^XjLboZZcv zk`S=*Cd7+iwT^t3(sLP{9>4&oe+dNXXHygkofn+zS8I;}TEVP%d-8`|Z#`-#2mySf zIhJE(OQll6S~MYTB1mX3JP)!|YAiz=nU9W$ub+NCJ3i(g{+0jj=TrX3&*pF4SptEW zTotsAAWo)Gcsn6D!F_No)wNEJ$-;k$_I5J@S(ae*D&KxQl@OS+hkTxz?&^Y6C1MLw z%SyE4uSt#TL-~5eNVJ|FZtykHP2s=8%Ek4eOg)*G1InH#Li!d}u^_TQ&C;R$5WR-; zF(_)b2}FTJCJKzzLu=V8yH{r3)J)NuDz_C1=K(F-o&}PHG?+|D zMr_}~I&yrZ!vtAMiWs50sx3iF9LM-#gf2NgucMcCkY?h0ld#65F}f7;hf+_qg>ZJa zgb}6P6|Or@>;j60lAyqVFj9`m*6XLjEp$RCA`;1u*Im|{wvF}))Hv*E+Re!k1eHiW z2CuGa67gdtHH<@*BIDQ6y`EDbfofO-!NS&p{O=upykJoAOp+<4HN`Fe!840F>zweH zGxgXf`hA`8xy3+QKL*p2M*{s`rghT`lMgn57uWhN%gIuJXQ-`)HPfDp`m|;}+OaiG zj;Lu3?`N@?4XZcyZU>e$bWD><(m1V97=p!$WOxqRHZNRb|J4g%PQfYBS(Y~Dc<9;a zDH$SZ*GNZwYr%V2FLFF^1q#<4JjrrK{<0-}cCyx-*W2d|%A{YX~C465(L z8X)%A6AG{}Ks^RKml2wgnph=FQ`=$Ar5-2QUWcjZRZgc)#s(CRiuCLKAjgyL^t`Gl z07NR~ketztt@bPaS$zvmsp*1<&fk+WV{pd_b?^W#olCs;VF&-3{A05jTN6RV6S>U# zfp8Dars7?*Lp2DE-5aU`?;3z|yxqZhs^8CPCjtakN*R+=v3gUf*yojEyYmx@D%{~S zFz6U_gtPO>D3S@*9mauS5jokvoBBeCdaV-eQzVUA3fgo=lEzT407)(^LUmx{`uX+fCDxvM76z(=tIZ+4P>X0b$erX=E| zTV|BLglg3uC))DWeIM8skOoOf)|prlcCrno>1O}oh#oSV^m8FGuQDm|<$UeO&eNT8 z_F`XOfCD|YpQBb(qf3^6B02;8OWTQf5hc^W2oHk}{CQ&3|LDPFY~>)neON-C-%-|r z2kF+wIP@LJgMt%yS^c`*WL2-|9`gi}TFUJxJJeh5t(svCA6vHb^Sh`yMVt~UE-Sk~ z-#z~jUjI)b%Wzj3TmYJY+R-V617U!fh(Gn$fOZDXi{C{*8`25b+6+V8u*QZKATDex zf1}n5B4|`T8I*&C%PI&)Aex4ZguY8dESbo5AUO~}?B`P;4Horo_r2Uoq7bBf#jUFx z5CG=8S$hL61QFmpZ!m%5uBNIQX>f-%{$~59a2?nK43QDK52?u#T7rlED48jDiDH$+ek`MHYjF;&qiJ5-`gtton-*4$)-j~1{xUB1MGFm*RB z!4As&yn>;^)g-TGHmfKh@oJ$pW%IJ7td;{d#=wdtr>+Z81LM##UKEYpP-+8AE58Z5%ms85wXc)$vNr2J?dO~D}ax3X()DABh zV`elsV*Ol3PIq?*>bB%v&EeiUYydB#HTB{^U8#Vj9$l1-MFGj9NC34w|y#2PD3JhY(_5GXWjpV8p=un>sjQn3~N$1yK7*ayUymxa`Z(3wd`fa?}XF9mStf(8K94P zVG_@QQjYU{04N{AuZA}xJXSK+^K3aqnHHC+IeGV#={`5Jz6DioDgb$C(=9b_7a8ue z-*y4UMfuGMXn9Z#p<;qwpGG&Z3V|d{X)Tz{bHMV81<0fxNI)>|KwWk;AGW}3nO6`y zcQQBX=j|PZ*-`i0%5)>I_K~EUH>j;YH5*(NGJlxrp#pM0CIt;CFgV(}SOFOppRDqz zZ&JYi2DulmC69n_$?ionu+T@(8=xDOlL=Z#J{-15EpeiWv|O309t?xNLz7HEQ5rsf zSuC(ES|VEx8cQV|5|s3I2CPYSOiIn8{_Qw)Iha_^R$QhcZ*F zv+W}wZeEA5MAR7E3)*>s`Vrt;TYE6uJ_eV7ZU>5^fU6XQVqd|j?yk@+shJHG<^&|g zKRhXBqk=p&7&WagU%9W*dOHs7R5UOB^n&u|xY2=DpIN_*9Qy%Uec-3)E?GljD4>p^ z+14V$ZVkaK>sye)1BiuKh}SgBHGxCXZOOEU4F|;jGgaPE7DSSs7g1Z{0Qd#SNc3CF zPPLyf5#VyXqUmerprlRWK*<1>A2un2B55=P{pcF>eIr1C!*>`|F-WIeOvN=YjL>#z zUSPgM61R*&pevn_BuRZB#JP3r{GBB*2dITgxTsVJNvtKA`JVWuojeMmE8QD#8{udw z9|Nf9Q(+^kHVmF%;$R;YpWD!~`K4E%Rv?%tq|ixzbxhx_pH*gGA3q9q)L2Mx>teTV#Um`{rW`j~@T-y@w|jS?-P$*Wq<(>Y{T%JX>+ zOqK(bd^fY~IfGl9DGdH%G%2VIJ0FY6WH|=CGQLGTV$ivnG%B9r2|!R$+!Zhfa5F%1 zKh|QHBE=UCW z1;tPm!4d+qJXvOAJU)j!07g9T1B9eGWSsK}_@cwxTZ=bQWOU!>;{=yHCWPlG{ORrz z>r~J35>jCx1Q}rAUs@<$5zxITIQ}7`RHU_5M9O~dSc`w@cBFg(E`*NMhV8tS)%wv- zgw0!4m{~8OCCGJ>HsJW!2ZWt(+6`esYkT-AT-rIvJNO*{`m{K5e;_-Jfd_l-Pd^o5 zKshgByT*@h;&qmI-&-q?N#PxrSe`n5u)PWVp@{S3+6J_TheuBhBqU=XWN9;u_Sb8} zO3znHScX0Wwp~&iWlHSOKl`UEq;m`bwoMz-Zp>A%Y=( zHY<}tg3w_cUf`{&YDqP9@AEXF09S87z*p_U>tT8ELrSPb(LaIIF;c8d8W`WJzuM!SVjDQ zR!|!kP1-H#pDrtF)vd{r#Z)rI3B(pn?6?n1+5+PHzIZ8MIWp5eXSMJ`drVLPksJareSuO=XzA(_$|4C;baqBb8Ru z&1NI%;Ae|MV-bK2P8KHMKFy9cL7gb5a4X6$Oy0%v197r+8R)1oUB7y1`3gP zyA4)|w5%xm3r=78l=SYgGvpMlt6+!H5;)(iEON?Y4h*wlYCky4psVV6a=?x;WW)z< zkzxt~o)|-B(e~oY6Ad=T4oM7yngk*|;F|Rth8)tKF-%1iYPB0%D@>^*O2YSibTfb{X{T-T!nyW_gbD#L(plhYKeWt@;+^SQ6N0?Hs;^O9_Np zmYA+yz=W2mFj8PhxBd%D_RbiuU$0T;z5Qs?RKlYP29vT>*VMgDeZY&can>8GEErcN z0(7%MBI|Yp$*2-JO-2dBiE7X`59BT_c15>?rWp)9dU?CXJ9@#w7T)z%1U+C2=sPT- zFeAT2ay~?aqf)Upt==LgrvmVD2I+=Wlg*NxJo2B6ve8)Ge5;ck?kLiL;k-cG_Fkf2 z8)b@NWE2Y#rq-XT1SU2adQA)zflx!>E#|J}H?@}Xb^tRHSQ5xlw9{e?Akn<(B$8U@ zhl9qp<2Sk~unY>L!0aKxTyZjWX;noroG>e<08G?!DI^j&wcD{lEry%tCu0M7EH!dK znI94qhQZGSmpL)QLruW6P8;y%{d$1W(d_DF>27pO4jD*LYhXA^iw=Uto((>cOgEg4 z%f_Sugd=eVCj;^DhE(~zb5S>?76+&o!k35MRrO(`GypLW1JNa;if^BoYE~2(|KW{c_RJ^% zk$}4JeKs@l^25}_5n!mP=54#J+ohsd&P7k^LaMg+##b+^*GWU&ZbG#Tp)vc_91W|6 z1n4l_v_x1MDA;~M(TY9j(zGbB7%)=~&2Q`R5NR6qoe(cU@fchBWNMO>$!bxLSC{{3 zvK0gpL4)U^GfbldjcHJbSAymtE*42~{a}zpB_1JF0|E{59CXC);p_VT4SEruRc0kz z)HbIW-$JO+yuaNU!*&C;lDi|LW-ytP6gy{Usm|%Cz%is zA3k+1*;2+#vs!$3Ur5lY1eOyQGTm0@BX3c~XneEMaS7Y#-ec3=q}LVdWhD4&qYA+qKkTnRoIYf@f|XW1DrQOlC}-GXp>yP&^3 zI$X9izCprnNQX3BGoc+0?TX@OoG616G>@a4oWtmW`VJH$SmJp+tTJ0$+_6sS)=Vv| zpAxNfTf))KdCCjf4DAH#h7|Cn5E{6y!Iic7(^P{M=`I<35?79HKy6$AF3CtNSo8{N z8Iv|?Z4-Ez+RuNf&p);|bSHclK=y#tz>iO-IW|X7XE82$dRtqk)n@f3De#{p2}QJH zq}k6TDEwXxBvxbL(NLqL>K^K8XCBtxdY14lH{6kC9dYb_2fFI4%|}I(3cmO z+L)ND-J|?tG(55{T>5fEyGwp1)i0@MOE}yyFB!eCRS1J4074w>nlQ(bl)cDGfophU z(>nTWjF02NWz0&J?te{?2>fUAg}y|0fx-fO8&>hqh&g-Xhb6gk%T4#AN-`nfIG7t? z6lp|}Nj%mI1V3U$wk;0oK1n8amXPW=aTcB`dBXV|LO1eckQr}}-~@Jej}}_j?g)el zi(gwu)Ieh;BZ(~hVDGSqd^Q)6&!z_Pg~(k}B)xk)?&r{-t*D;xjgCCpV%R?r*>ggbB7wt#1i%aZ*BS4cDB1sp(oU2deXi%NUsckFY*J15o_ML zy1%`GF0>U^Dj?wmYcQE zB9}OBFM>@;yN3Evc!@36fA5icQ95-oyeww^BBMMC=;xn$7_Emf{{%^KA3)!W_6=TFZYQ+kpYR$_)n zGrVj;)|3^3>F((-&}q>28NkXl>l!kH<9Cq4e>#45O!M=#@{DtXIVURceuEWnSFNbf z!iPdMkDjAEU4IjqA1r?w0%L$yk<7ZT*zlmVc_QWEQd2$lWHs0C%p*%E()>HiOZ}7o z^evY~f>y%zv;%Rw+1v=X8gjV^bI&3(<#pDesx<66SGQjY?v{X(qb3e z|BdcIC}uVjxAK5DSt)|n8ssR|F@qd}ss&nXMO4 z;=(Va=t1tUTR|8yq2|xnPH%|T=sm=VL_HD-BoGqQ>k@=3CrT=nmGJ)lqc^avLXYqf zP_0pL5%fsh$>xHyX91iV7rO-s_?<@hNp@PPZve3+WT}=yPzWcy-)g<<(vv4&=0s<%G4d~Pe@v26QTcB^RXl` zn*Ll;5>^&Zz7-BY{6cm|i9^o>MV0I%OPB-?O5XUn9$Naa^7QJ2+<;Q01l3i+I@5{D zRj%-uI1%5sycK;3Zf*Jw=TS0)=+k!n=Lf6|aTqv|C1llrrf28GIe_WWy3n3Ify;&JD)2Jf#yUm+=kgbSB*LHEKuNEbKOqi)zNKm?7+(l_23Wk*|2E%W@s z8G6s-ZbI}1FX9|(u?johh|0gyS7}O#sHWMsB7Qzb!UmQV%ul6a_clnXv<-7~FvIP8 zPO0c5uvD02`}?bB^$m7OF(P#964*bKA_H%$TN9_kBk&fGc|5zWIp2Wx>g#lz#xwOt z`E@Y;A`Oz|n8Zst%=gAv-)+CokdcEUM8mPi`N7uvea=U-*_?{U3#&-%wZ6bdB{mk; zfK>R94`H}+JoAvC33uAN6UV`E_U=kPZO)E9y5Gn@QJaj=7}-brZB7Q-Oh+}@4AVK( zQr6Yzozbn@*(MI*MF=3=DS^WTc0yq+>UQwx`e@zTLBelju}!Fux7Xz3U=#9mKqA08 zw%2Ao(1slJDya&1K3ZRBH$;xUxx6vjobhmzD9r{BBS|43Y5>9o`Zt%`67FFL^W+HV z_V(=K(Wl-)!I4-k8#u1^qY6J&p(*W_l4zGuAEJMK^PckweJk`stpW;&{+ zdL_JZ)I1c#q}Gzd^BSI)5|)E3$`9+u^|9&W`}ZG@)g#+B6lVe6HHG|S(zfBc+e4kC zjre9Lof@9=>G;Up|McYaeeZM7+X)FJtWW6v9?eVGh2?<>kH(*MYoZ6CdqhHr7QzYT zfSJlgsAW<>8o&_}T0_hW@%kheU8Q4o{ZebVonX%)Dbx?=$;Wpe{{tNtlK zzK*Ggx&ZgtwmJK7WY*)c?wNiLqNtpd;H|?LT)#Uqz54X&U9b2eE<4L>Omnu6@7vXl zT^>hn`MV_&#(+37C_BkpZrfacv=<*8uZ=wKX|tTsGi2pno6Wm-{qrLQFr@U7+Q#dX zch_?7V|`laF#yB{%8F#{FmCT|>=t1?=#dNW15lj=n{kQc@ng`=&xcdG*Zv7@YD!u{ z^2$J;n#wVb9 z-NekHZbLq>WcLI~dU|WO{>KkjdR%pzd5-TYL#g%C*KU<~5r;Nl!wQlBNcV2roLwE+ zWj{3Kq)rw91gBs;{Bzniitmg!3eTaaNnR~$47B0tJ9y4wl~FFbo;Kq!BJDzpjd7m@|Qb^p_jvcq9!tSWL1{qUTeIw=>;w(6+R-=Zzm zd5~BqSN?QZ>#l|&MpGTmgdL` z?k$B4{;XB`N4{N5Dd`Fa=fA#4)ihAmmA*Az{jtFNj8nvfOih@HP47y{yjNFCv9~E& z^2h|FU?x@7lvxoNw@5}PmA_q!hp^Ml32fz(COskz1oj?S@j_|^g;VejK+ZU!PSuqF z3_6W7rhP%);tlCZSSFossi?twG<^L7V`sbfHQ0lM6sA%0cK@<5F)Z~`>}#0Yd8xbm z?D6JbZ=2^}34^V`;|>j}OkBBsI_?Z^jzbl@e9X7_O-*?jb!TuWz+s!w)nBihV)J;X zGD>lYkX{Hq%EB|ibzW(T29N@|7!ibiCY`7AHPqD=kNS!sAEJ_3tJi52J3Co6EOoR+AMK=x8MZ*En(3d6htxlK}2-^DEE<}Cds zxsiAG^Ov!y5~06E1EXpqV1o3LN;<@tR49k^pkF3ojbFRN#z%jf8OkwYS^xsdL=;lkRNmMNMhwUSvLGdc; z#*p5Wb9A3jSucE>kQ=vz9ScaGKdQXO@b2`i_t*i&4kaSMLn3^>4Qiz|UWxPvT~r-A zk`zX%Evdoj+ib4oIEh!rhOm(3;Vb* z2BN?g>6m@J*XI3kr20o~zyX0%@6oi5wUrmp&LPzoQ)2W}KZu7GPyn`Vyb*k+Z7BUdINC~Rf~5Yl?;93_>yw=)*FD|0n#`C52-3Dq`<$V% z<|vgiR-k{{HXm=_8PojeBpU4S91`;jsxHq77y7>W`MK57TE7qG2+4vJ*HHWP)=7e+ zjkedqb6_ooV~MQku;*AicEmpPJ2pU*gGHyvraDVn=gyfu9`?qqLE`}CH^->=@6)bP z-81z*gvQ`F5%%oSchoKn0ODuSKfx5>TD-}GLpguGuum_V0uJf+H6_Ycj0w+i=3kH? zdcD0@RM$9nauT75?DBO1D)V>2bF0RX^FruDKdh2@E=0ciYpM|t{1ZzHr8@_A^%_#0 zxOvl{u;8=4yHBpK-yR}`1BQ!YT2mB2G(f|5R<2+EP&dc-R*k7FHo6k>8P$33WrKt1n}WBn2~%m^|cwZa|v?m*7$ue zcbd`t=2o%)q>P{N?^Aq@;xC&&J2nnqQ^t;5o`kRS zXJ7)6lY_5`hEev=+8NoScscYylL$mQk1;gnFC+m8+p&5!bn3*Xpc}OYpm4`Alrxe+ z$O(8Ky(6ZSq^&JS0>AvoINt8GAxfM+!6hQzecUZleYLa60hTUjHKvv^h#-!*kCq!> zqlnW{6&O_=E#O35ju-v2z?QoTP^fyOf?;_!fwLzH)X|^p!sHeiP9<)?h^D=*QzB% zBul{Q&Vv@YQ)pd5d7eD2Ky{?UN zR97`+#yPksP7M0?W9;+c`vx9y2q}4vfbP2*AdrBzjn|^z4QT5)i}AiLC`A{vG_TzbS(K(t zNd<>SJ!j)$9v`%^tNKQK1{J?VA#D5RHR96&?Uv_o6k&&g#qneC!9VByz;kBcaMIYgu|7&@*2(d1pTm{bnm*d-=t^i~IQTfe z$e8i(^U;Ov{Lfu2nv$(RfLYqgOVC=BH~khRngB%1P#ddp!xpgC=dlYs*awBa!Pu7I z&#jUAzAwk8$HuCDKM+#HNx7Ur>qFe2ZPTuu$jDJ+O&d~6P(VX`iLRLOI{x^nH{{E6 z7;082ilOgY8y&JyX*X=)Iq;*QAyObx_Otk(J0g?s5vS}HIV0K6#^2X$QpeZC%rN4mf9F8o zjG`1yI=%;jkmQ6jO`xNzkn(+5H59^-6G5tGCeP37zjS+u*2rt9Qgeu-G{z zxafl#RwDdW_wj#$Z$uiuJ^t}%sx3>|K7Bzs<1|&O{K;)N4!J+483oMpk?2Kt_ucpb z7c?Zl5aQwmNG;|xh>kq@zJLssl6XcDWDGkKK)M`3RKE3U#EpJDVV)!xC;j=!@$}?) zd~%$e9IM`EoVQczhuYEGTOAofWC@E-xc%u{Fhwdjp*aQ%7Nk`)EJcC3JxeF0+6aMU z6G{+GvM-oGVk$uxlqp#TMq4@QyyX;i304xB=J5uC@HjX``#GGy(@NQ6$5BUTa;AzI z{2e%IWJp?Q>=?3Uf)DHe)_fz`8#|MS;9Co)}5@`y-}M%k2hgg(b@Tn z>1lF4R-;0c4=4(F@pjUV;?5RSd!Cmv<%Ucx*57zO0R{p*V&R#uPCJ8z;Q>W}H2?Cl z>8kfoJdkHID}jgqFA+XTlQkxg>K}9tY-HR;hb#*D_$^;grs6BN{Ce=op}?r zuaYS$EOE7)??fT@HyxXr%vz$DW>aO4-#a5nEp&X5xbDpNbBTDIOwNi+S%95fE&b%`ZIErq-&Vs{pKKl3E=70VEZLCPNJL>HdCmC%h&vn@w>4R2YubG$fC~3+~wb;`=eB z2LQiX_YipMmB6pn8&Fn>!wU-ac7%?i5t1@K&`Qqi4PMVH;*;px`VJ_B*^~ ztl}jpg)&C1Dz1fZK_GxSFv`X|j(SieHQSWZqvmY1)1c3;BAqsKN+t3AIrQ9Eayqz- z(~}JP2{n+z^N*uBpcpRO%uL}u3D?H{RlnhD1Ad_x+rzKS_OkYSlGs3SE<0a5Dgf9y(qw$lZGDKZT3thsZ$qAdC zy*vGMdV2O={#HYXa+!{E2w7Y0M{u3$0?^Mu;qYZUYZyA7sDsS!q~ZiO-`{Tt8S9`g zMb?2lq+>c@)H7>o>TO6Yr{pM+ZDu5C_XXg_EtVy~BI87z&nD-cMNWJkk1@M3D3wZq z*IIvgt1<5OF~M3DPV`~R<9GcbI~1@*mQH~k1Ow~p)P|8z$@`y!YbB+=c?v0#S9rZL zeliepz*U`uYVz>NbmU&0#YS^W)#=>?oQb-3B~EhLMTx=`Qhe>S2j)v_l&TCx{1t@||rP4`L)Z z+TS;LmB?+yVH%9)b{%X6*1>}M>Lsx>g%S3KHUVNCvaq< zDR7^L{iB}KFAv0^=hSX+s`@$g>)^dbP52EIoUpuGKa#Le~r<-TYVAg1#3~kW%gbKAr-}RRqZ>+~)b9<%T8ler@W3zIxgm$}aG>6Ln6OU7&rKT(5omlZ)|3V|I!u~7vwOF z6EEUeG#-TuN~&#w6PpW&8$hR=I6tOiGXbX77jRRoW3yAP0Hc7G}P1v^C-T!sBdlVjM z-HCEGM*fK(A%BK$5FB>FOjcHpd0CX{b4Y7-H3lN3cb=t)C{a}9n<3_4g`9$$rfR^5RKM5#BiGo!T|!$$9J+!qvg zz^VA|^QR|UJa{WMyuJrHwFHx7Ul^VFB=);O`UU+n#s$%4;^;!dP;6gb^}9}?d;^x) zI2@=G0_qV{>_1be=1&tvI$CwG!;G7x z*SjaClwMPHl;re)6CuIyXf31L`}Lh3zxkY4U}a$X&U(gWr#n2KL#(yLjRtr_c)~h? zG@emHDpX-n+*pt< zR2MOH>P1S{yI;yDUC~SK!nl$$>JM-CuUo?SU)4hn#z2Gfp?V=ZY704UqUkG zoDzX{CYoG@@^vZ$r7stUn#v&CWw6b3M< z8nzF*JM|(5B_f<@WMU0aXJF?Q+P zIIP1q2v`*^AWBh{mGg&+zqB(kC4`jZ_AC&Fc$CGJB97(gXf5X;PuWa(BrkC$mYawC zd80)#XBtA8gQ0br8hTMRA(WFK@J=v@oB^Yh#h!2aiISV3=8{Z--}}D>6Q+>j@_jQU z*foo$<3vA!%03CseV*W5dhuujA)t2X0unCob9$g0ib_;r!Htnz{24WC;cD$u{6yAI zMKI}Q5#lo3!w@uaa{D*!YK9cGY$i|$8O8AQ&(p4ASRp*AC7n{m*2S$hQjbNwYE^(C zA?9M%&Fgr#W7ZzE+^I8!C#nV)u&N~T)R}aghmy1@tN+U*p}|fd1hga&7xK4&H>=gJ z6?srrcv!(M%6?A1{`t zb^41M670l`IFh^&Xvjahp%d=Vl*uGv*!2q?g*%XuI-X@S=oL+7oz7q{cDpA_nrDfN zJp)K+jQl3SqsFV$noq~?Eh_ieXY_SUJ1DhqUp5py4DPOzkJfSo1+H!U@En8@xqBtv z{q{NDT)$ac)7Y7wx(#Loe~2`C6S769YwWx-Z_!WZ#Fo&>cbaK%Al z&JYF@^7h)flw4BdUf)2%60f z_0NIpNB;@qMjLo3$Y~4a`g@0fW@dX$e0fem@JXBa-c5M=p&tcK8vx)W-=hTh`5__G zVja$Id(CxX+GM6Nr@_Mak2$&;c#N>ILHx82aP z2G|e%B0#gSbZ$Pnt@bg(_ZAWJ$Z37DYn+jPN>sO5;r$ zJqH~YLU?e6?esW@{ORVCmIq-7aQLCS%$CYw&RVt(Qoru(zSC`{$qZWUd61&*jvH{| z0u)=!0T&UnZ2RUj(TQj1Cxz!=A(H8v1nk^OD#9>_m_58=+t7M=Hm!cVKGoa0 z#dr%%DB+#?C!hMA`IOOP0EnDS#po~Be{53Abkz0)DxFD2kqtn@t%7)btGzQ^0TC+2 zxwrt6U>}Cc1$h56;vcw}c6aG+_k44c{rgfsgZxsmR28P^Xxn)PqYiDL03f{MFw)JM z5jC(uEm=3z1%%mM#~)YZK(ofqHg?LcivP+5Ge9il6&VKzrt?KykdiCNa|7l9@wZs$ zWJti)9%-3eLbePKG60&kJtZ9iK#Ld`rsy;7ENab% z%mWrxGOkc-Mq~7a=3KIsCc5& zV5o3Kjc0d4)N6}TNzC|hlK}0~SL6u=0&}A}D@`+KtH2D$W2goYpsle3aXo{mmO-AT zWUb^khkD&9;B739VzhbK zzPymj({bnU7(gc}u$_@HsUFsk(3XgismFD?WNKL042d_FJ9~$^YTzmoF|8O9yD#G1 zHN__fxI~7PLCHUz!*_iC=L%C2d_I<5K$yJ)Ujyv6>|yk za{8FTaD9!|#~hR(aQ4aQ>vFZ6ov$1#oSNEsMz+D2kde8&mJH87)>n33GYdk{KPi>jJW6Qo|$ z*I=8=xk6$Y^5Isv8V`sXKoyj8C09`2=~&+h_V785Y&lHK{86n{1gRQ1s?8CSHt7;> z=#M+g1RezrdO$WTM)A8ipSr#WoN5>@vRvIgjygxya)xD0p&YIdakb||0<8>}Lq#Qv z2u_v-7ZF#m)T$}cO26$%IFPvli?b-P()1O_(G`%Q<1>$!>yf?!^F7Iy5Lg+XgoO2Q z>nrG8GlC0;ZDjz#yob9&f%mvVAg>&c(LEIUjw>j-!GR)cJ~1@xdmFsKP@fC&d-N{B z6Tm%ktR7rq+yfypgDL-h6N{Mwxr*aA_CKCP_kbRRDgd$MJ&LZNx&RO*5fW`CSNs%C zSBjtmop6DJJufD(a=?brD#=YGMws1i9;DE?T0*2Fk-CS~w-rK*mupFwoGWh<_n@#0 z9E>7&OC;j+c6}eA)#M5Y;uqi-q9F@W1+Ku4Jx-u^+fkaR_gp2Pp+Oa(4xMr+9qD^u z0p~r839>IsgWKBH;#k5oGakACJUPieflZU75JGTmIu)DLh6?&BNUTi zF@_{T?lMJFl<{Et-M&-kJic#mz!7})(F?ch)To1yNGTx8p{e^3Jk-K)Qh`I}B+^$L zM^^~7X-@5$cJrTfHop*iz|K4wJ)oc6-*2z?&fO+u4W{7qTx?e|%FtR>PdSufiStUY z#o6f~2EI^2q7ASg`e6m{aqLaxihPW!*eD41X{V=T>oufr6(h-9eY;;j@Ap&~^{J{9 zjmJ^&xAPPd5|<5bpEfS_#|AY*qF^EJBbTL%1)lZMrG)LRssX#mA9_c+VcHfIs*K^Sb>AOopx82mQg7y@OXy%xF+zFtB& zK&HLX<=ea)AoE}%h*iyCehscG-{$z^du(O7gT{@5EW6HAM5oEW_b7$-bX4x zqsN1XZ=ch?&p;{}&!G?-W|2akc_aU$o*iWr(`GhrCJ|=#&z&4D;j1;KNbB?+O7$9&M2;H=(!jqY2ergUbV28}Ki|H`0QXwDV54 zk@75KXqyxm%KM>CkNf>l1gtPjP(KyXr1$l}{MtVRv>~Mk$ZeQX4{SR6*bj6hVt@dY z)WzT*^3xMzl-`Ae$nV&)%_>yN7hbkJ*pMQd_S@%#vPogb zsd2;gOT9Ikg(cd0vK=w3YZv-9AFAe z%eQ@dbKA@DMDzo9RzbRF*bA+n{e$D(w(BQ62VfIvJkWK7_2$F0YVCJ7$YB)O2k8u`n#OXSmkLOVjQ;ELgE5XN?Qq3PdF zeiXGj;UE5blfQ75B*|9(Y8hvafLg%*1|I?zyL{8_qx_B<^{zXh)sm!^zpBs)sj0%? zND{7m(|3mx`NDQ*CLgIYmn8S{*Himr>vlO}ixQ^6TLCyizV5rDz1c(CngW+eV*Xmo zr@QtGd!d<^*1$Moye3oP&j}bix$>+0Wd_O&J?x77Y=%9ICiMng$HTMC$e5Wi10IHz z9ZkFu(2p8b(=pZKb_7AvjVt&8Aq16Y^u4YbK#|U?`bqrdFV3+dWn@0DRuuAB->+U? zK@YDWm3@4@UG403qtU0)r(bDC0m{ctE9-kP#G<7*VZmcu!?Ch^{!M*@&vUbW2w$1> zV3P|a(B9w7kK)yUqQm|mzdoLX&nNEl#Wil{-E(MVoj&1bXP}2)d=+Qg^JZs$lfqW? zye@b6t!+J+-@z`R-XDhW2M$zQ)8*_{Glg z58F6|{e`{aH>ocAB$Q#7yDyjdM}7t`n+T(o`e>Gz{dsJ-2^b?DFP9P#g8Aiz>6M@0 zXL^`jd<{R?h@J4p+TXQ5+aE7^u=})Y+g*~yE5Ch^@Yjpv>i#C>NNzUralC%nygxO+ zh`yI_Ti@=Pm_VHQrn`IE#g+XjaOd9~MK*Cz*>>)y>^ts3VW^coWwHvWoOQKZKi|YZ zu_@zU$Sj-dWm0I&k~KdQ6nc4MmgPJ5`FA{OJYIfb)~fo*h7G@;KCf@KbVvQlF4u4g zHFR*zsSE5cx|e;mSG--he()juN_B_do1fg5f8FCT-?-bmA2Rn^?nl*F|HfUFv45Xl z>_gq>(6zj|Fx`^Ko%tYNwIAF_$nVCR|J}M?gdfwltF0aJ@VkG#t;3yM7vx)s9X+*o zwl633Kh3Y?!~F5(b&cQGwicOpZ@-gI?ndUf;dR50?t6nSHLc7i`xNRAxOXyp-o2EO z6f%kOK{{wxL;I7vO0wRZ`RkAKy@t6%W# zReXpaa4sv~4Pm&-{<7yOt{;A%o%11F<)pp5ul?w{V}A&}tA&+00^sX)7OaH;P*P5oH7*7ns}0dLwlY428m|1MuY+S|IX!wC2* z!rF~~!+k6{gcD!(hej~yXOI!#a>_(A$5!_P-q%_t7;lezhgRvP$1sSNz&-c;I2 zt4LkQ{uIV@k>0j$;cxaAp^%~bg-I{cpQFpo2DL4vFt)o+KDx_tQXYPzu;IqZbCX_> z{mtCI3PgX}i`Tl3^C7GxH?pMNcwz`EU zZp9+wGy6mL?aJ^|pk10^U-Xqhny=giw)kw%_pfg4>YHB6(d=8^3Ug`PaIm-X9&!e6 zZdUHTt0ze@>hB*H6U$n?nDGDJ6XdJ!YnC-buo6|}Y4w6$(7EpEFW1lg-umR< z|C*jP*ml5vw?gyWJWEl=?j0UjRkyeF@o^`^gI;N7XYjI~t;n<5yS$La8nwOK?1(-- z|K&EyY3IvVj7mdNy1Fu;kG-$`PJDU0TJ7(NJ2vOj_W66zAHem~ruM*|Yv^SKIv>??m^dYy&y$^_;)pUARZKt*%l0SB&KFw=&Fd zQTuZtzR;WiY@Xf2_8N&`fIc`$I{oOos`rvB1QjTZ-F|=VEw1;rvESp82+J_6Z_J4m zA2!i7dqG8WK4E@6w zZ68^CXhPA%(v#>;a+|%`7r9~85?Q+OOTUU5aBtI6`;K`3l2;r8EQ|fawY|U!S39t) z=ew(ucnA3FyzbFGmD=z7mT31&D`TRe@Rw{Jzpo%N?)}cfQ&&_fdfB}`@18I$^=SHA zxXU0Dcv%10f5o1%<=g&W=H3KO@~f&BugP?_A<0Z2U=lz&VFH9D>F%oO?g{vRv-C{5 zp=V)wW&$Kosdc)N?yjP$dX^Y5KoG`uc(UjNML_|53Oo@s23ZUSv#^W6V-tcR0#P3i z5r`=BzUQ2~oO^%wSKawM-skhLd@}vJ=X~$E_nv$1zAd(B^RVct+;5i~^&?@Hg+R39 z-9`udFO$LK)lXK&5-Orj`xx@2-7NQywUa`+VO?PTrn;hzcdT{GEf|KTltV3i$Y^2G zFj1ND#lam+QK7==cUz$%ZPz2e+bd0sWOTWT3k-um18$s3JepBweozuyEfp00^$}qXwwa2I(Q@i&r7@Uj1x$>CQZDf zpr9Ax=!bV5n8R`|hJ?Ou_O#Ii&R1t1S4`l1cgy2^_sr7965)=Ov*8vKI1FSn;TFr; z_!Z09_>~g!N(p(TguD{TYb^0_ekU3Y+P>xqG?7oEUJIbXsdMq1K!2fv#>epe>{U!T zfHtkNkO3Zcl>O-7x0d#{TbOaQo)2Pt>>St4<3Ul!rwIl+;6QBtMhm09TQ%+w8J?XA zHQ4C}Eqf@yGbU&tme3Hx)w;m zah1q^nLl6%=6-qR+~k3ppCbX7IpU(n8^alIDSIW)JOo0Iw%V);5Y3tp&AG80v8TQ{ z&$I`RP}7t+SWYo?Se*zo<4k{e&Iq$H)a|i^S$;avx-hSG5bc+B?#1{{e_z+a<+;n4 zOQam`lMzofniUK-*hw|7^?fbAJC*u&EIGJ@DjKb+(QuRe8S;+he!sn>^l0cd4%aqt zbx*f}g$_*ka>43b5{Bk{T8E_>7-)xOk${2_;&gkVKDFFs>rvSK=t|DV0+^^IES%`f zZ>JJ#^nWc8W-zgZh8zKitBEcL?m43FIIk`3;9jDm@!Ao&aMhAZD4F~YwR{2q&$4G| zoWo9?CdZ{nl2k*m3Nz0A^Cx;JF$)=-W$*(*%D+87rAP-FI2h5J$HOvg4o0%_i02e> zCow`2lY3e{>z2s}K`eLbJQFwU%zb$Nr`V@dSdu~-BzK{z$D zi{@kLogflI1u9cIaQ{oay?D5?u*?`l)Ri?_%z`&fqRfhEy#5m5Tn!iawsYAmfu=>f zK3fj3+bMOfhO0D|JX_oc+t;R=ZPX5Xml3vwy~n{(y{T;G11%U zQZt1L8B2uBr)3TQWtLbSN8GZ`k|G|Cy($9v@@#S`CKoc#Wv61h6)_KSq$oCyPF1Xn zqoXRJ+_E|ZxnKzF-i^k0y4`Kvg0=~rCPzCAJyR`cC_L|GzOk0iFmc+x29pjnc)~<| z@5Fs7=(Q=z-o3`f*E#Rpd0pT%E+1hX*@Nx<`wkZ9Mmb)%H`^A-EyblU(__XCo=c!w zjz(>UC}_H@9#$bZv+^I}g6#mPB?GMWE(HihsosFW_r$qx$rQwy9(5h2V09f95OyTM zg|e+A+sGfSv=(R$1k!>AehLpR#5CI$M$iLTF~Cv*ML7_Go){=mcVMPx@`$?m+F=md8Bnk%Mzp8-L4_dlwjk= zd+R-JiyX<>i6Hh=j^oX7+WTVt?7j zbdQ~`2_X%oNT?i0tTAAZqA%WeLtJujF=YoVn*DGem$v3us_pPvw~6oo=>{um>lYKB9OKNv@Xa74~c|Uwdd~s{EX}sqF`GI{Cn!?FY+qhjtu% z{{CHM9GKr#-i;e74i3ic-?^tC1IX=|o0Tsb+3>?0Fg>A|>q?Dl26c0vmhpvY`VQj2 zO;k5;x8C;1b$u4d@8lUzm@2T(Y8r~XLJ&Bf7rLJRg24U!z!mad@Orw_L^K zXU#_MV4HU=95&p8U^V>rQV)~wft%(`!IwJ5G>m)DFrfP5@~Xa37*X7|FJPgBKIk$! z`isg(NTymcLi{E@y4v*6f!V@-^!XaP_VEN${V;(C9-1I_N;Pia*}5$h?!YVD#wP~% z{3r--Wa$+!DM4%Rrj27_0fP+K#}bC_WHNzE#x9;T)jEn!vBH?$As#{YO=EKz^@j9a z*tXYIp1CZ@JW2?Z(Q)x$+k7ZL&Q`q-W3QfI26CE!`rkX98GF)R#7skc4tk7Oo^nTi zoHZ(lG0<3#2iqwf9c;%MI@p#{s3H%mUh2{EZs7n|NoesfJA++@7;7E_t+%`w7@DFO zYY~dJ7omv7%uyv}n=k9&;xLEHQnar*Oq$UZ(54fK0Zl~V&B-C{aC-sqb3loa2%w>~ zZ9J?e;qOEttJ1PvNZzkP6rgN}4pBbDox$`OP*O+lrmJR2GeJ{HS$dpOX@14($ve*$ zu+!LcNK^_?(8C<^e5KQ{Z+|j@yP%TwY_TrW+2zwCyXI+z5`mczkXul>B3y^}y4Xo= z#Vl@EQl`f32WYd6qu9L)AyUR>YMA2;Tx=i0ME{hhgdE?@Xn7C&uyRaotwZRn6Ct4l z>B2hr!B!u=^||@>F>4WRj3Q_h+BjaA>$f|qOnSE|`os^4Fx;lt4cNwjIv#v_8lzPHd!@7p-2z#5^HZuG8kWhCaDsxxjk`GaQK=>sdvi`bQ9T7JILozI&UxNA}_w|bRw z#m;$_>!v*zbc(VNGSNEvvy$L-F=pLn58gX>rPQpBjyA1(bV3fzTX(ToAFnpIZgFmN zVA;91OpX^Ps&(g{7@MeVsnonXl4s83J3hH-`<{tk5hvrT6QdK}9s9@oX_{|thjsW0 zUZEZvcj+lsCPR0%RN7jtj5~a_RL3(%KEBl`ylSObpBSk)yt#WccE@@x0yjA_IjV4@ zxF?|G-D8p5i7ho;DdG81JaD9cWO7W&n}kIaeZJJAJ2l}vV%$Q9@|oB zG`wEwV-@_WoiL!N$t`u|zlxkigJ|=)UZbD4n|fpG#AMy4 z$2>UY@cIENC|l9DR3qZEeQ*ix&HC_OgDi<6C_!bj=E zyHon-Nre==IXvvUPM~+}n8*Mud{$<&D=Si(6EDCPpTkRV5Es zQE0t3Cu*Yz(EFdD;;h1(sMnfXyxyA=P5OC!l>bd!6;o+&S-?L^Pm>T^ROy_YsFs?( zJT)h)TgQq@&s%Y+$*6mf&WDFvt(v8Ado_lqS0H%D@tbg8Lo%7A!hoR_O=x1-FR`iK+ zWLzEhd2QXgMdd@C6_C|my;?(3N4JcPH@1wZ^h!l!s~06dvO9~A*n3<9d9}4suTlo< za?{9(Us!=CIbpqI-|sZa^0?-RH9j&!MbC*x6EAc&E6v&@-c*=S`N{O^mQtxSRv-2C zXH)30zT^>NV${w3LM2N6MjH%G+cZwJrOU|)^&voZdG^f1TIa<2~RHX z@$r@0X|m}mQqtVd-o59PW=?!^t6Pj=s|gbJoL}JeV0bIlwg=DUAVVL z{k)v<;?`P2;l{^x%cXEspSt?4G%^ufedBTVUZps`C{v}X@*mchCDhJZ0bZVzQ17nh z;KF*RG{W_XvsdF*`5)FdC0qlfe?B}>n{uPp_Zo6^bJvb{3&Fc1`!VL{`K1PWKCXQ# zjgF%~>f_{ba)Y0DM|vEUTj4xkI=;%y9=to!?`S3BM|vHtaYNz#*CTwL+r=gxTA`oE z1?H#ek^hGAAL-q^qv7RACOEgbTg$s6{g0syZH!bKlTvOyPRgryk8c@ksPbSQeewJW zPMCLd^nH59@DR05w<#qaUklS~^4RmGgQnc92<2vgbDKNTyj!{o-W{c{D6f5Z{uaJ9 z&bucf`BD0C6&_JM9{riXy_Kt8&#y%CBmK|-DDYp8{O8zB5m%aOf2R6$;o^DqKrVV? zp&R|^z<(5Oso5Y8PM*12&$}b}92<>~%H5U(=kfJ${90{{)oPV7m#(U0v&WmZ#KylG^@HKAj?}876Qz1{ z>(-hZPgR@g{%EzC?q^nW`iUmFEYUX?%R5QJ*YT$BSc=^{tiB z(FQu27=)s$TbisE$MK3zV`O5Yff(f;(_wg_?G&3 zeG-n!LhTgQ-RllA6!WlOUL@zom8qebciA75N_Q*KuE z_HWUf$RHR77B{X;$nEe|{ zGj)W!@6x#wu+gn@`KkUJ!t^bzqzh-BX_yJjHawG5m8t@0r8z0KOoT9d)vblwBt+7z z6#LhO8cNHsO`g(lNX5+#l5Lt2_laq?S92ov`9^)^~2--m5 zfhl(F1w|{&TRg%E&0*Ef^h}#Q(Sj7`K;?;^o0nBx`ic<-#Z?a7Hnh8pRdH zqj->R6c5Z%W{i$urj0vztdI%Z^E}``8z_yU2K;AXTk&YYfd4EEy(x56nvl2^mw{Jd zQd@9|Hkkk|Cb=XKgrEc=C_xAc2tkcB`|3m9Ukif?AqAs$1uOn*VRc%nYt(E7kAQ-o zgYk5-bRGeS;TGn5j4Xx6a7vzom8um?W)>UizYZpgDMdt&7FFWE7G^3J3|}PB=&y&3 zO^!Av089S$FkWc^Ecw^LMz=Px=2C2?|2mk=D;CXqOZ?Zt#>dA?b;K?G*THN}sdTD7 zSAp3~TLl(1;?|c9CwAvZvoQNN2WBV!?B5)ijgyT;1hauyw*9*b%z9e|W&_WGSt+Xo zYGL+ojx-zCD$*=0N17dvTekfh1sY3P1s21dG+ERtHq(C{%oI$Mw4!atjoZL*X**tZ zsbLy9{nx?5ne1F?;lwpk7%%)$yHLVvo&2OX5W8)lqhSSCirgM%qzN3b!0lk6LP};5 zHOl%@QMyfef338lO!ZmcB{S7oD!M5~PHC}%eG}uhZ;1wmXWA?Fua!mvb;Q1u^Vh;m zr^&vh6908DnU2CV6~sbn^w+>-&9-UglCpmzn9-?&TepG5b!F_1V3r;KRWM@Z{qJA{ zx()DbU{&7dF@d=+k|%TeHsk28g_%hM&7yBx5F?l^zV`1bFw3@oBWaeriZlz0|2k=* zktb%l$SmUtr`T^%@e8dRH z4;CwCM;Y^&`t0@zy3g)r1+=@%8MKqPBFe7tnI$?X4#IY9_Yw~~=i4~%gx8eiWSV$k z+F_jOk$dTdNY|Nm8;;sD{@ZxKwnm%aap9N%A-j()Z3qbGq_3S#Q1{JY&#R4qhF=%K z`Off+Z0vnss$&DGBr3zE4a9Va2p1LbmDEc|G7!%qAbChY=;+Mca<_>y06APmHfL1a z*$`I66i(rE+b1&dG<0}J5P=Z7Y{cd$R7k4D39MWQwuRPGD7llEcT#gi_>gTTxZVEl zD&E&f`HNfGeOA&I#*Ebw(MD17mMDSEDT0!QiyGWv8|=r%5t@j}xs8JlAsHsL7jw5q z8%Qi}D>#wE1vykEf`eBalIzpCsL+>6IUTDAnVjMSxRx>`PvddQnS=Wduw^gxc`s>* zz%e0E`8w#3VXT5~N{JY9i%z~sqt=X43>}wK+>A`Cgi`HID{^F?PP-#p`I3&g_OMfdG)poPF7h6Q(&z6GlZ?88r$yl0-Lr2t&!B^F6I58DD5+bbErUBTs7Sm*(&2RF+(p+W z#%`VbCCG_Nje^^>B}lYAJ3*G43lfZJYFYmrd?z( z4ldDaC|;iACU2~!LV(&j%ajI_OM8YnRiUewGGwl8GgMgNOJh9lVC=*W)c)_gZdyyE>oEEet&z9iu8Bg|QJ9Y0C5d zO1IZI)NRe;^ogX#*1qz_`5s(WemuoEh^yo|iWYAg$b<*O$@q{ar%q3R1d>pv;PfQO zb0-$7ZIk&n7%*uMKHgWM++V60TZ`FpA|MuIS|rWKWyA9;U@;)HOn`=Q1WH z*F2dFG{p#DRFmMK;R*XMsP*Y!vTGUwvFgmSqR-)8mRjFtiYO6U%I`}Mllu~MZZ;5P z=wUnH;2|{C4FEJ$Pv|9;DtG~iw81wa;7+qvJM<-NdW#2F#RZCXe)$H2u*2kdRIj82 z`l`|P%$*m`U!0Ka_2=)cs_iQujyl2!WDL~e?ZlODPQsStBn#Cn8eQkqIV$=dV zIv;D*;&8xK0@Fk~9J*uweq$Njp_o~6y%^oYI4Cz>^c$|pb`)E3bo?Asx6zKM8)`>% zt+l84CR>gJnjQk(>Y-90JhXSzz0#4OlR{F~sdB+}h{}`aX(F4OxmPDcpT_w+boMfI zX`WgMj;-&reh%Z+urR;NICM+5VQ^(xZZ1}iV>O7zvG{H+xo->@3>gUfh0|pMMXRKQ zU|oDW>3hHTmdOnluJuN3UOPm2bft_Bbzv zThHlYWD2Hy1Pwo~Uc04Hp2zK0jcyZ1{|mLrt?r_A9{A!0?;1azh7BOyHm(nM?>LN( zKO8g)wKg)DkZ^T$$qU+5? zT+cA8a_u%Xr%25O;2RQkX{sn`MSjXr_L(5uT;9KkX78^APD62jdDD^^Gfx z(XSA~QR-dM@l;%ok9(_H-9o*)*eUWQ*X15A!zlOp9x|b#IM9(sdcTEOd=qQW_~3*J z40c^6A(+=FcWR5}CXLMHihl#Ph%_hdr-crQ@lKzT3JK7;%f~cgQ7(@Xj1&*UZsT|+ zM~_X)h1V-LVbFrlh4fHD6oizy7E!slNS;J`EfNPHz0CXs#vJcQ@*NLX+PpLA#Xajj z4^Z#&O}L^8K}Mkv;2Bo$W6Uf{cn)9mF|J&>$2hszr3 zSrNo8u1_L2>dP1c5|>Ykfb*B4;9AZyUcaeu6&%YwrnxEKU0m0l3HlgOQESn_s81Jy zXT(N;tj<)F^RammQbFfJsP1yQadlTjiS%mffIul(F=bAE9$m$44UingAWw@aJr15wz% z52Rea4@5+%(Ogf;Ho!628()Uw@85$1aYB!B` z7oP0K`3Jsk&vG$%l&Qa2djotfM~4P)<}NV>7fKRFFH^f1InTI=4ioPg3B5GBmw{s` zQIH>@#@Gu@Nz4qs06OgrWVM3OsF_YzlXN;)qIXRA^qsBzsOo)Q&)i1>5YSue$ zb0VUWu#;XyQY8|*M*4W$##ls}tJ1)LI1!Nydg?Z?Grru5DLNv!R^C}6KkSfcP~^D> zrw12F@+rl@q%Xl~y3A8jOv{GGOA%Yr+=ayDh#I8_5nzfgH!O0BUi%HA!<1&0l<~@1 zm1OCRWU-2uN^+bbQQ|Y~FvT%DN_xzWRWpa>tXgX!NFk~`xqs2x6=fNSh~(BvpjW)Q zp6j)k>(%CGPMkeEFKmm*iMeO5CLkyNRzQ9d$mT36Cm9-&6HyJ(QCT{QOPr}8#V!C; z{ryHaG`|EtG{(+}bWMk)1TIO4dQe+{&ILBtSIW#fCoEMbkEtou1dLoCS`F+&>qu)l z!_0`(K9yJuZToosgWk{fEf^D30~c|kfr)IvFvQI0BH-HYWh9UW4lUeYYfBG@ue+TQ zEAC557*SoqLWGtRDPfw3`}&+cnwm5UI5TF6_^Q|GIk*;hH@ysCQa6R?%8y`|Y7gBH zcm4AKo+`D0S8N}`rlX`(VdZ!<7bPb`6i(m`k8j4-f#=aYF#}Fnjrh@48+GC@QJC}=~>fRlzPUIJDok+Io|pU`X#O|{iRiS5x);~|i< zI^n16kvmhm@6QC?S~DRS*m??&s9ag`^k^vS8Lr#rNxJ&RTOpO&d?Jg99H|CZlhQj( z)^f$El4zcVOY-@}xL`PlO}`}0`1gFB-vV)+7TPCV>DT6|pMw2WDkhqIEq175&%@jyWqsT~ZXwjCNQiJEo{^CFp8D>sYTq^UFkrA|7L``HoY|WA* zMROUn!E2=i3?Gh$WSXjhOs9l_C{)l5KOsrEoC!rB8FBK8g%vKY+>#rxeZfrn_H32C zBES{fT{LHtGnEM*Pg{E7;tr$8JG`lGb}uYP4mw%TFcYdlTfk7^ zs$Oyk!NV4mdVY|z(N$Kx+i-N1;%G+`z-EdT0fTh5j|BQsy$&~gaE76ny5)9C@pG}7 ztz+a7(zx4M-(K^mvLF?XX~z>m7>@7NXMK%MrNcH}eV;$;b!@O#KO)F_Ee`fNFrC!# z9SE4kgST!9D;qYm0|DsU>fW?@SxlP%p4*PvBTrGHKvdzm7AYbtg@a@IoSE*WXX(-i zYSgjxlrSRNymU+gdKi_sGYQdgACX91vu(}R3|hLXfHk>6^V0Hqs5MhaQq(Xa%rHU6 zzRa}L_I?{nWc)I3!^}GR39@VPtP@XOh26J^9O%ne7`C&9D#EqC4HFONUxzHgWKj zvaPms3Ij%%#2xK6CL@6E2#8?3?St8%gg?Vbd5R`` zDB>*4&_gfDc~W?x0YEsbs5F;lMnbh`nwANsb7Sdx-X;iSm1!@?(bENZS4#PgIAQ#z z+RGRhg_$cft!X*eWx5XtYA81^Ej zxV@D{((Q6;5*k!xdMPR`P96pi)isSXNxV?+yaXK(s9|QQ*@pf@Z!<7mJTNt03iad2 zIu(YPM8>!-R_kSRVk<0eBt$W_zuDH2`F_}h_R+(O(_vqCijnkUOAiZH3k|;3nl1RI!}(BmWdrFu~>e6kMmfCW%}zny{5;56?{BCq@l7oW!KVC7j`{LkMXJ@ zaqJDm6p*ZVwpltRA2fBw7u5_4tA!qda>BR$x!ibIKq?wIoJ8AyF^@t=9(=}`SXy?X z9?LZi8#FUWaD`+h2sy(IlM%Cn z$~|U=g8BW;Y-zF!E{z(FceR&x%N}}PWQ30g?ogbRiEDDGP2q%L%c%z?lnHLk56ki6 zhPbGCj_IB!N-a&I1R-MVgE}s5EJ4MnDM5{UdjRr_pDvREJ!iOa(4pT%cusDZ`4H?m zVa97#92w^)j)!9;qLAw3A`l{n(T_vRBH~~P;eyVjFyv-Z8L(4fJISeFVJw-vjECEY z(Q48m9B+=95jkqTU>ubNtiskcnI2Wf#%*{Yx9}#nic-Fbn#62@4~hnRK+y>lJ?EFh1aqVs?{G*Kf^ILXM!C_GT2 z_LS(crPyKOH6mAX+?&&$g8T~^`61=1ByRhbY;I<<-g4p$oo?YwsVQQdb9#g#1U)jv ziM>rS)P$ifG0<;G))w1^m$8x|M?gF{^!)I>fJ;J|ap>`AI!tc_dc z+)PhaP~3W&Be-UCrk9G5CaRvuOplYA>2A)@z0S>Q0i! zX=)Hl)2Z=D>0ct(8L@6(i$Znxq_Q9SDA2iUc_Dyp{G%n)4&A!G>` zB-H)h$yv;dG9i?|baSM2;4DdLkIpV&#NTZl54?lQ$?V{avasusr-lWp*x@6c*|#*w>l`7TZLro3v`*}2T1#A zzo4VL?(_Z%ZV}`*nAU3S;=E0oo16~_q^gG7PRST1d7)T>TVRr#hh~(76Kn0G{)Wwf|J2bxOQUt-g;FesCScmT_>ghx(-hA69U4OkyIRF#Ogv4@rZ;3ZGwra zGc9jIqB+k9GK7bWnUZgWnaP7uH+GHb-h3qx>%p6QM9=dO$JPqMlvOsmikVQO3k_2bvRBp7x3Zwa456!R2bN zl%qZLLDLZ|$+uXF)PDT zHB`)V^>v2fD(sl!YU~Wdd%t;4B8OGunjSgPLo|3`}f4S z3JiXK$qW z$p=TsCPDT09V!unu~>J}goO1QjRqY#5pYI#;i{MQn$cZ6JK=%hNYv9~-4$cqsZo{j z<)PH?D%?uxPQqUi|hH?6y1am+z8Neb47EG(nDcy7W2lez;u4#-bK7{6*f zXDM-+4c5XOC?h$T1GTVNchO{ogC*l1tfx6>Cg7Cr)C7g~m@c!KDG3jc14?yn4cZL< z{aj8+_XElu>5#qKwIhob(6N5@GPi z^P(I~Ln&^t>ozwjn3V!8}A5d~VJJGY`fOwyBxJoV}nhF2nyjwKlLSdt!_2rU@z zSW*@ijCBMS&Ws3+hre>@Ga7wn_~G{a40~o3{%kJa1U%I`+EU|l6@b|U6y~Jj%jcTd zJ`d$WP~K1L7l({cL)AGLz+D9w;&pKeIIdv`sd@5!6%yie<)>4n_eTVRdg=HFyC$>; z-{%UcIq_FjLx|6dzwfXGc)fZUGLrERcN_&ClKL6T(+@Tj*~%f5k{5s9uhRHnA5q9i z%14Wmqfp-|3&iBH8&;*bg8#~g^YAg z=Gv}bjSIx&*{R#0P|2ioFME0#sL#ZT5i5+ zq}z9H>e5ZGX64vuvQ1}yGox+6e1S2PaJVlgpOfB8vlg#H0Tz((B zj`3`|w*_)CA7;~?50KOFbXz>DhHF7&{IEVEr={oH`|N-u@6R!Aq9?=I535X-Zlb3> zz|4{!^2~34ju{X=9fDl9kPJjvnJOZuUysRHdK%nGGVX98j;3r0W!Bt$2Rfp=xT-6y zo5$n=Sb3Ti;aCDjaZB||x1M3(jY_5BM2zwEqjI0 zse*8OaZB?U9BP}g*?!4n^N=Wwr>!7Ef=c<~OAA}99Kfzz3ob4Q5kM&@`iT?N)MaH-tnq;2B+g~Me@rl&ZapudIFsC6nZePqbjF; zlirfdqqnSZY)z%b=7^<3HR%2GCweVFwQeoT=cAz{VrV$mwYxW0x(#~QfMaXOF5Ud< zu6g&|K;&InzOCJjli9Cj;5L}!R3;UX?-UHtHUU$Oqc}9YANdEnZCeTM5oIHh zw$0+~vx%ugWzB%zb;ePky0sKncwFk}aat=NdQ{s4##GF?EIS-3cYYDk0E|=ij9OXl zP2~*11&ud%qY{SlTO8Y7uXM24#rk7flv1XJgk)D`Fi0`) zDu<#~bs=7}!eYCdZt>gJwt_UT%ZqOoJ|mB_G>_58c6#X+588@0h+7Da<&jQc>nwN~4#|#a-)q5E_o?oc8 z(J(24Bsf13$)P*fF1ocTxYaJGZ7&+B#cVZeh05LIY2x2z!YEh~mgvJh6?Sl|j z`ykltjKx@bY;y2|8aPH9E6*V(WT<*D_B2<+W$6ns)m1HsfXQk9mb%RdX9Bn=FQo0H zhk9d~0@p=4jo|J;nngt}49OJ2G~7O;ox^RTOq$~9lBw$oM^pwSiAWffFb*{EzG-hh z9pK!2dwHSGx(O5EsvZ|2QF4TUBd@xLGWgy0kd!e5_msQfj@cCisn+MFn7%$+B=arBJ!1a@C@!kesUc3sI}?rb@TG z*sjylvD6tX_xSWvuVCqTJ#wMSTMZovSNisy19$J?g>HIY+WNqY=ou;elph~#aj;&a zUuzz5&gCVN#LnY*(wg2rf)s>w0*_Aj`uWUmBjBO`f@fc0+1&Aq>BXv_WU{lL@CR?5y)-nxai8}pC=+g3HHAs_~AgiTc_FSKs8~`rB zM=mYpaJ%heIUH^HCe+SCg|5{pqq4@XO%+*KB)?dwY2C(R1to*vst6fL{VrafNAh&4 zx#Wm8teiz$_aEme(|oEel={dnKk-?nVz-dVFMi9teA6-pPm4ul7TqLmzVJ%DkQ$Bo zcKc>_a8V*EeKfj`jsyc;!8_fpBTJO&^v1n%o2S-^(&;RmDAQXycmN*5T(k-Ns&@`c zJ(IaAVr_Exjq%lG;ek?4Kq9(6PV`{v8c@rVc_4aKG$$?tA}}CS6I2g3gp`-s{Z

zKB|q%jiXe1bJa`%<^g)hKQu^#Aj|UR`yj|MJoJ?#1J&cgplArchi6$SA`2*2>3~#3 z`C4bZyjm+Z>6LT#plL4AnnlU2xSF9tlMskKXnx*XWLJiiD+x_HC$?!Sjtuhu=?D zXtq)GLzZf6X9jKaLOIL0x|$0dz+9*dZwcqBsl%Yllx9Vu7~XB9s9r0^e+TnEnEH#% z+AuRRly`d8)V40wPID|1KcZzdVyV>SvicyJi>!5IbwQk*=n_jsmYgc89d!C4<$;un z8xzB*>6r0%Dq?6?5;=rGn6A<$gdnOy3Zt8w%rKQIk+sS~ZJAVDSh2 z_j;pO>$W;H=7cS;$;%?fGOb<%`m1v-o$E;hB{c3hMV^?3+*n4#TWO-xi3D-qj}F^N zoY3Czmvqx9=Z?~jAMP>h0$}>_3XsXsG^DkJC!%bZ(bjxvD8`9v!rC0pN+C|hVzRJw zhG%i!Oe_zzBdMT|j&#o@%5}C$rACngl%_7GmC?@DWm!e*p1d?MM0PUrYL9WA zwLKcP`i?Beh)8B^Vk^6vrkT!aNRw`INRv)+K$CtcCHCBIK#^LSipk=qzr>}wrkxz9uv`QX}P!Dp`|}*jI0N$S=vo4LRqDh zR@JS8FDk#b9>PW35;haPwrNbfSmFLB^~bn@4#q{)1!eVlKO$)$IL^DlqAl9y>Kf4| zzt@O1masOowUJaJ!;xZIYX-9xon@fT;FD3!!Ut+C0UxBc1bmR*vhX!1u0w5#sT`YY zkiM4mnGx#1%rHaMffyD2MBb@7i}FUC!MLPnN)>o9TSuU};^m?uj~;8vnsbwY6sy7`JV4Z$84L+x!S5 zb5_}mrQsC429?mhWf8x{jY1^TSJ%vtM-t)&NVB+km&tAyp7CW^$$@%8gu$r}Wej4s zZwz8~-cUCmHy|vY`|Hrw1L`S<1uYhc7umUWO3|q+Ez65Gqm*`VJn;zk#Pj6`Mr6FA zLqpLseG?sOYOImrr$owNWUyQ^o~Tt3QuvgQZ6KSmme`YK*xsrsO3TvMS@G zVcgLs_vs8tmKL~NGA1)n5?nw=VV8kGil+twmQAHRHD{;!c{5fT!^ka3t|#dJ9K;c>Fr7neO5opNh$yb)P4A;O~W z;4V-^wvrJG%(=!)DY8nm)Y#ohXFh^r9Kw%3!Jw9KM^zkCnK^MI5+$)udqjP*ye2u7 zE_$5Y_L7DMJh_yf_Kbcx}d zr;Q?I*p#du8>lCm+Skw%{V&6z1RlZMx2e7qH8MQb6mPLm7T~Hm>(5kk#;GD5Y!#4= z1Ae((+%ej&_%~@=NL&jDk*(hBB9r|e6gkg}`pd$w`WIKaha)^nGkvj8RC0}SrN(=@ zJ;4cMHa3RQ^?IJ|)6`^uOOvhY?IJ4WK{l0!O34h&NzpS6l;PQkDQCvO3@@z$!?XrM zX^Kc(uPRzzRJ;->A-2Q8D{8i%q8S101h$`*X{J$XNR9=Bm?Ce5NlYlWcotmtJW+%_ zsUsI!Q&*j?xdwB-)thfDV5u`I$c~;-d%#hXV2*B;9uP8Wcign%9ox5?j^tHoNXfBA zz>DG}9x|eZti*SkqZ!2zEvpnu)e0e+3)niciXcvo5{RW@NzNd4*=(a#>s0K78ph5q zn9q|pifSr$c?;(3DTtk3Fb6lGx@6p#7)DL&EjME6Y>yYrDI(mw1W`?7b$%vQ@k;now{ZrK3j=r_!QMu76g)hf+iq|kQsMnPf3)S?q3Zycpg6^*=jk- z$P}&&DqRg^U~WD?!=Z-C&gkbd{hWRVqB697#LZVai^QsL@V$Ue%R;ySP7rG-_M6vv zt>Y-!GC8_<{t6=&^lH?^H!;FUEHC8%(+w8}L(-sS%0j@=`EGr<%+rKyrde)IW?8nc zZd|}RVI0e34QAlNi{cd5WC2!*r+HXM=``w zN+D+uV>D*rJ~_lL)4(w;72`|;$4C|9oCc0zxiQu|!WbFEI1%Bv&4Z_Gn`eokezkh} zJEh&U#n>iJB{yR!789l*H|1egshsj#&KFz9)r_)T>8E}3$6Z>)g;6u_+!2?LfpuFx zx6?RBfSr8dLjlzhfc_}`pYt!Uus)2)}MG*%2WC$Iy{0GijFuQyvo$d zSi2xN*3Les7gy9c>2a}=(bzhXz`D*REk&ivnmklIBSr{2kusrWlVsr zDKBD#$y=!%vS4 zNz#XS+kk843F& zSElPEz?>S6z4SwV5ov@4N{SuJrXTbt^=ZmM&%i}xGaMd z7Diu=Gb~evGjv;ivkX^u!LnImK24d0D^*@Wc4ZacK{>TKf#Uw*;!*+5y}s5-~J@ns-E)tajSZamP%K}=k)*wdQ^FqpLWhh zyTNi*akl&n(k4sf?frwr1zURuLaAy}gCJAN^3w!ixN>h*ShA}-Fd}53YQOP7>;T*3 z+&A_Zb(_;74ff&Lsq*yj>{NMNlbtI3!?RQ4aj=~#5DK+y1Rkg*wm(^PUL7~UPHn(z zuu}syXTJxAx@KE8G9hfBEgRUwux00C4Yq8sYqVu|96d(^eI%al$ay%mEqdbC)5El4 z?{RHb?C}rNipAq9R_s9o>rj*2)#^|STZ?T<$ZNMdi(kd=1om+3&iYu3-3fMp-H{bx z4KG>A=Vk>hHPiBT(pRU|Y0x?)`pEv;6~DhdW7D+wm@mvQv5+n|sbsyIy9{!pWB3E( z>{cx0+(O-5T9FAZiIlCQ`B>R%x)!M#xtdhF=QTfEe<&h@8DJ7>0hdaAGLs`rPE-{t zH?k4NNkVOnxh1)}!0Z6+;pV8$Jg$0l!x2wWo7gt9 zoJhuUyFwRiF3W{UG)u_SxZ;c0NIp-@D2mz7NE;8;-v0oQJT90*sKa}n9W_1?1J15Y z7AXeqv90k9bd-TEZEj~S&3)M2zG3nmq_O~2dR54Y;|PmW6$=>0rFgQVG{omMiavrK zkyM0@G75p&6X?Ct-DY~`EacFx$1pOBw1-yBv?)9|S-hDZ_An6KG_s<$FaeFb(aZ+- zR7^W9EEI*2(OaICEOUjNIlt!_bb%=5J3<+>q=?|+QtdKdZ=3d_{7SB&;lK@Fu%Rz! z$YBLVhyATqfE*|)MxH*fFgcjBQl)|{Gsnuaz}0Ns`^d9+hsfByf^m z^U~%V@bmnJrtQ2W4BYcpF>?hBjomZs{fNGX%J4$NckHbBJJ!HL;82O8;CXJ(ytaDR zKuK|8H21J&lo&v<{~3Gz6LF_ARk(VRAJ&!zMs2v%B50C8SH5vO#K99NRg8$9TRsBj zn#`Vk3^aQ}aN`FP)VCtVWmDs#u7}bpp#~KM%TF0I^9B?I%g^(hCwuOKjQEd@b< ziGsk4oPwZv31cF5PC+2n+6@hhO}MVc7M#^GFhmc|M%+!_c^HBfc(B~O;!EjHw`Uyd zj6IseFS_K#y-6FdAfu}(gI6WJZdD^7$aJC_Co>Oh+=@5It))<_^T1)z(Smz(Q_3WFxONI zvyXwbFd+t3qXNjUMlC;86*6x?HEQ{Je)9~2{8?V2jwE(Yg-5JB^UxXI!n+)0P6xAiGkm5V)J$KZHC4p}4>0iVVy<2KU0j+k z=Nz$8R-?BO(6z@G-9Ko)mo#L_acC$dO{N`GsmV-X+PKJt^>`2nkI_NCIB8Z=x!TG> z{>pfh*)hY=IQ7@;(`h;S3v8Lo=yG{*X zVX=q9Xf3=iu+W*W@TEh&`8HJphK`G-XhvVVcta<>*yE^2y0~0op@MQ?a5y`lzcW5~ z(l4?+h++<-YCdyUOELP-Gnnhh)Zym*c@jAL*IhyJt#`$T&9rrkW zm{k#WK{VT~h4RhVlAzhxJW4O&Di3^S25Z6dn%LsYtThE~8_x15e@x)IpG$_~;JKqV z-9Xl`Z(3<@-8SEErr5K_ay5Vo;w7Ej(HXw`dv?OD)5Dkx2km-t1kP3y}Dd zAZdlI%g2eC;`AXgk;iGvd?)S_33NoM^gv&9Eb|$)%ck|qSN7S zezDd%@MvSBvE*aIOmxJ6Z7;ODCI5w96%iLZXfq^m<3`gU?kUuU6dKbzC*l~Qw#HtM z{ZdCkL4d&r-Nv;8mvLaNy|Hr{Z&cv@2*;4eb9_&ed8y>{tkqE-fZ9bBpbE9~xW2?hzNl9J=C-wrJE-eU2EvhOkqT>Vb#p;fv$^ z9CwDuue(EsF~eo8ku5TWx@)1qPujWoU59-Ud+00~D6lM*^;wD-prJ=GgI`54!LT0E zoEaRsq$53?KOsc3cJZZa*=!bikjp~SnXD)#=Y$ewvCzUCHZ(3NNUw1Q`D zJ?w8CZ!Aa(_R?d39D=T==4d3Ts55o*NWCT^Nxgtkr9UDlxNo zXpnNu)u2cwy7r_bVo^yZYg5kW;wdZR+;tqAm?!|s3xX>%FqD}(-o>M<5(N;}3gks6 z-GGF&Q|c0r31jAq1|f{g7Ys$@f^0;GC51pjapfT<`O@GG2D0{GAE6Mab=u3r5pJ^f zb^G&ekoLDb!l&=$-n?@hKzl4L9$Nxwj!9u#N+gpe593}Pg~#vG%Llh6L~8VRP$RXQ zpL`^#5oNA{?jUv0Jjc}508*<5pN6S&(UnSo6xkLyP<8o((`(5VD@XJNNa7$+Pj#il z`AC!?@RSX?b_8VCh~nED2OPfGdxy&oPnzRrL(x$p&1GxPEYX+01P>z)H1iOKsO)UF zyY(^3FPo*h1HyF&b)5-th@atAnszjmYDbI8j(8TLFDyd!8WDF`5H!sd1$iSm4x@t| zld2ympr{aKiK-bFEUUwOwvZtCP=_4yKn^ENV+MQ zzGi57r-zH?7ciKmD?s_1EFE{?V}^o0aN!{hIeHidE!jVqYV7rK(h!HwF%E847cr}V zi!h3snn&?F3X})|)44>%!AmyeW0(O&2uq#zu`$iYNoG9hkPQgk@G4&LrM<+8d9>ZF zV%*ccT)D49{ssUd?=3IyS6?;d7jmZw=6f@3$JpDRbZ{Rs~dJ(3mQ#{+cQWLtunQ z@CF5nl}W75K65xmVer5Ky$A?7Et-fuN>6;Xup=LbJvw;h0F#8>Bh^*d=I(SsHE}}- zMzJ(9?qNEO1@lAVBpNUFF5rn|%zMaqnYr`zE>9Ta&ymXFVnzHYs!X6TwnZahR7iM& zS==;n?!Kg^vUk~;RPn{}Za-2C_9d@XM&ZUq0`%~>NVLwh*pO@OMM(+jO)C+}a?&Y@ z9I-gYy|QBkavfF2dO_4jJf%KGRqCTEU4rMz9d`|Iyo@6mnSd9BOU*+n`s^c8cu0eq zRlp3*NTx~hBnNE>87oONh)8{kElW4|=CN{Fgux5Fd}JAk;t9)D5oWTJ7hy8srM66knkQVd@o)eYA$~!X zhMy$PI(%Cgk+5?KcL-skKS0w-HdE(137CTK(6Bc|E~8I|x-Kb&c#~Q92EcRm09Xbhy(xKaU>0}RA*?^!l;j{)F+B!zJz|jU7V>ymF z-&pQqK@BSCH;$vDjHN37b)W%qYw1M0dJ}DK=Ki~R*zEwgALL%x&QljSn@e6)wEfV;iN7t4)i6G_9xeBAGjGTU2ZMZEf-0-;rMvzh64?B=X#ABmiw)R-c^*q|7%e+`AIX|KTUBzrI<;k z{gi|qS!f>nDT$)u@>5fP4d*L=O7W`D8|yzUS+rJiRefRMDwsxL!`0S|jSX9CFO7xP zJ~}coK0ZD?JT^8yGRmwQH`ITrRru=nA6aN7!-c3eePym@iS;vT!cP`LKOLZNz*P!M!sc+>tHW88BP zpV`M03jghA1P3ok+zWx*esQ7j+m{T+T>$p&_{7*khZYtcfLBA20Bdg%f1@6Vb z+_DPpKY+U(nA;wU5B$!@|EX}l0Qwn^D-^zj|LK>9I|sZQ9$zTb@jw0Y(m}W-V2-W< zcN;LTS_AI2!2HGjBG4y+`Slog zoF_NPEB~li{2?$OGPrecZ`(Ao?JAnZstAVuJrDoi2h3*;4#i4v33=ZG=B&%fSE1l= z33;1=8HsU`JSyUQfq7AkOUSzwm{-NPNFJs4_kj8H7?+Uu1z^4r<05$!zcZeQf7CBe ze~$$2XARcrC6Y(+dloSJV_YJBOTgR`;}Y`T0L(jMTtePQf%$xli{w#yzYomNW=ZgR z{K-r2<-lAO;}Y^_fw>{ZCE|ArFuxSzB6+Bq3vV+RiD7>HJ^jtFv zoGS{2i|{}FoL&;~8w2LqF)oqbd0_f6E+Ox=!2Ds1OUSzqn9s(zNFL?y_kcO$Nt_Iy zj)c5nV4fc167rr6%nM>%Lf&y;ZjW&ZdB1Bg62tubeGhOST16g}x32*6-58gM-vv)b zdw~DxmzTdJZxWc<7?+TD6EH_(Tq3=%2j*=tE+OwPf%#;NOUU~tVE!Y#4e zz&#PTb27MWxKwxBl zzIwQ1S8vJSvihTPbWaAC&0oTOVhy-+f%|L*mkoCWxW8Qkj#P5~Gw_f4rR;$0bTWg> zri0`?GlR>jJvckF^a%HZ+7MDQ!C#)b>6N|!|?x{I|y1;=~L$GTi;?z?MIe!>b$F&wBAu_ zpPF9(iT~fxil3Q2HM@Cu`<*mkUjHMG-^|LVBsr%JZXTX~+NU?(an7sGJ7fCPwsp7P zzx=(8cT8;_zWuKL@HDYEK4Dwo)byKgd+3s5Lr))m)fpS_*s*T<^k3e7*YdZgYoD4u z1uT+nw6bgElSTo>FK>VOzpU#oO`rUe&96epGb`VpJ^9YfllYuH#a7yEHa9-ucG7BL zYU3Se-T8@+fBfS={Cmj!@OOqz4ZZfm4%3s+4R_^1(zT&PE7rc*(gP}io-utL*8`qwddqvkPpAtc@ zxNG@o?_Kxclff_$_ROFMFU*jpS3V*BZvXQ1DY0XT7Wv;eg~;ChgD*Vx{+EAvh$X-| zz49w;d|HRh>ChB ze}%ga9mJhXI}cw%y9!@FW_i!X*YlXWA79UAS`}Z{GwmjP?PuC8_<9l3UWKm;fBh=H zX!drf@J4)1^Vd7@b%?ot>bM`m*JGG=pQHUXzIL#WFX3y3xnIZEZvOfqzC`i{nBGCg zO`lxYeDUGywjZ8;`9BR8|9N)hdncbdz4FlXEAHQT`?>ICYeg9KrsUQ#;PE{7=fquHs#&ZB{-xTQe2t zu2-CX$qW^(lQ(SMCYafkPm6I^Xj#JrCIsVA$6)1dqrH{NswwLqr{6mNV<#~Ve z->Ye|Y<;z3a&SMhtD`9^|{vbl1LqYx^_r>1{lmq+XtIE6RaLUHD|egRbOyk2glPo{g9)TEI0H)<0m}i<>geuaDC6Jp|4`xo!@sl8 z=ulw_Ut$JzqA_<7|B4yB#L@E1fcy^??#I9TSl&P2>i~cKGrlCFe}FGBgNwnD+TwD2 z3HMp}5;LH>KxixXOYu5=1-uqE;Q#ITf2c4m1k@3xGFkbIA)N`5#Dz@g9Ll^+WJfTj zThV*qN@UyE>Fq1uMMYwb>bKxY8P$fVm3vNq`rB_JYS?ssi<-_GX2}es;Log>Y(r~! z-l^#!gMaX6pLtJzKx682-872u{`75shSoHd&571@+r~RM>qn>xfJyhM5Kzs*b>H1% zi26hLADY6ymq4FGg}wNa9KH!(v*PvZv*-U> zzf`~6eI=qOE$FlGB`xRbzC^R{ceLq~=i|F@HyOWF=9(hqT2qW2C|?qPjrk#D4HXOoZE%4)C_^;7w^9)V-x{3ia&B zSJbmBUw^ms@<*hX|1CtKaO&FAFaOb*8(;ZKd>h-Ce#6SIkOm9W>pyz>>(h50Jg|M| zu4{%14_2n{oZ7YH(6#h^NCrzMr#6pl{IfHMfNtWuwDFEJ&%*bsrZ$g1IPtxWo2b4h z0B{ced~f50Koe~8!N*SDx$D4zeFsR?hUq(ZZ$G$w7T?n(Z~ER3pT=)`<*zY-xb0bw zDlGr-PEy!2KfQ6sUrw#uHI2c<2#q(UPk;EfXPpB!Q>It`W_rDJwP`3bGJX2~+fJ-Q zqGr}D{{T^-m^4qWdmj{2u)T>dunu+=@8`CVMky%qe>1&ujsODeeL{Qr>9aPz;uW#UM9s79DeUX_{7k#L(L>%Vcihr+V+U@w-&0oKTuYLUW-yQdl z@ioJ=yYaP)zwX1=^YFF4@Ns-SpT9nhuNUywXYqACe^KX{3g-I4SMc>h{>n5ZS%M5# zxWLg&0V>s#2RCn;g(+M-dvbR3@Z4dl-jFf>K7Fdc`9@T5VXjd>(dQYe=#lb^uD|~P(#g`;APwQLe0bypTH>}(n#8B{FK!(ZBdK{ZT)`w0Aje`qwd9=_}sm6{gQ zE*mn?^hahrEX4eYE-;~^C z&`B<;x`!2KlKTKOWPd5yKM&^m!n*U%Dx80CL*e|fb00XnbJmUIgNlp&-G~p-qA|xLmzK^dTsroc2f!@+2mNDy75o(m@yFPbv)2(iDEy z7nK~rl2rM+2w%n*zE%*T{iWo;159Y~QA34CefG(PbLyik+xp6rFTM!%&?@q&k0QB5 zakg?PmwX!Ki^3AQB=c!!z-fM|c>fuAKKDsB{qp3BK1e3*1GB%BTpF~Zd~QVE)z2+# zL}}PK_J|JopeD}#YWR?xk}t}syP3vi=o@D<(E1>*;3$pqMfoK@2u0<{{)A5{kuUOn zKmJE*seB$hi(_Ja5j(Q?O;Yd%TKHP5)<4{k1m=9HiVjO@DJcR&`1)Yl;#{Ofz3TC*~8^$i^;iI^? zt6n%3$J)u_GXbHnRJsU;qtH>5DeXOMuC9may88doZ$ly8tUdfw`CWZAOP<1xx$QkV zl|3vM+%&qwM@O$38Ggp_fy%LATKKn&`f#N;Tv-~fbg}z;xZNDCp6EAv*~l2li`W}H zOh=^Pr#_60u)Sw=8*~Enn&IIit^WLS^{QHX@oLEGRhG8UUu@dVO4Af0xrwuwRc!2M z!M){<5z0u2xxUhWp-7_uwEz5XBY7v@I_uJn1;bCNT{%p9*`I-bicrO3due#Cved6E zR$Bz$BfA!vL z9^8Gf^x5D3vrk^O@5Zs6U--!1JnPrD|I4nE-`a4X_`bQ{oqF(=vH$$uu?JqZd)p;% zzT@1F-Fn9C+>PhI<+~H_eefM`I`!#`e(i0~`rK`IzVxB1FP>~&a;QE2_LpER$ua_!$8e{uD<-ngUqnN6?x`b)m|j=#U+>=%Fkl24xhk-t0R zfk)r}<_or8eeh#{y)<@btF1B&%54s&pXy1eEYXw@^??V@Wp!` zy6bf#U;WCa#&-I&I|vsalvE0_^RXQz5kt$J@s#2{OG$r__~SPFPi+wYp(sZZC{@G zYHjk@KK8@!jX&xQe^B1^igzyj)$wco_4j9g{>l44GXKZF|EZ~4kA3Cmp8CY=4wl~Y zvP*Y;w*0{#9_hX7mW97Qed!9gk? zJp1)OsXV%L_U}Gw$NxC|yq|sh^Uu1V{<6ng_x%^%_L1wy#}5D2o3A|c$-nm@>ZkGV z+;gsd*ZHqoxam#ni*G)0$LH_Z^t9)`@8}B-zx97T`{%B>;(~7Hif3Ma_M7j%>0Li_ z$@BmBWt)%w>r?;ZspH50>|HDS4?g#0BTt(6@?+lj{r`H~|IVgIv@SXLo4@s} z2mkBo-~7ri{NzP%`uRhh=Y8ajZ+*vKUir~Sz3V5hzv~yz{KMy8cJjB+eQ5ew?|H`C zp7zq$yz#E@K703Te*NFS{LSiytH1M%AHQ$!qrdvdhheEzUIID=AnQ4+UPxf9r5++=wIUe-pIP&$YQ9gwtgKAsR?uFYg@0$Vu-tb9S!_w zDzkd=*S?a)Y+wv^Kne4u$N%EjvzSLPhC-yU-t~hsF&#x;T0hjyUcYWIhC)~kLz-C) zvvCa=8mf35{@c~R@YZacDVNr-djLtf6kkvJ&mUkeBu>{O13Bruc+?s&G{E)g`kVci zY?tE?T8EEj40Y?tYG3*r@BFtc<}r++PCQ|DeQDF<kVbdQGUlz9_c9WHk5N6g$BIzTkj~J6hh%lN1-7X{T}5g-w^`FF;+i6G?ap) z(2B49k%nO#847L4us^|!WhmP+6skMucTvHHKA*w7Btx;259CwAdP4^DwhZOn8OjGT z6q;eSKau>ofYLO_O9}Jnf{pXP1{izu3Sl1OFc*qA(5$b^0}9UB;_h1VLqEcRg7diI z7Ru(?y<=k_P%OEe7C;#%#M|*dQO+XD1X2E2QznT*_Texz7hQNjQ$|PNqI%I`Mn~Z~ z$Ara_$H>BM=tAMZ0$;WiQ0u^$QA?q^mnp?9_@W=RGJ>IW(U01TkV3UFQ#hrBq0-3| zP8U(A1~{v5mD(ErGoY+rcM<+Y0t#Qc?7CmSkY&SBxW;InF$H}v>SA!$uj6_fU;DOS z`>Wp9bBr&>1Yupmz9=k8&oA%3>g(Ru^~M)tg0QH5^lckL#sp!ZLR4Wr;m^| zXM?alH2V2}_P%J-5d9bvg!Kea*RP{=(QkPCcV9c?^6OsXi!ni1!@znSe(m4?zU+N{ z#rR@O5Y}bv%ckq(rLR8U`}(f&#h4(h%Y(2sKJ`7jy|1$<$?VI9RowI^-}Juv#usCPu$~fx_3r<}-n)R;aJ7H`v$Jy!-BD+% zf*^_p5vL@3Cz41ai8$6FAtHj*A#en@9aBk_MYqazSsZ%zuxy*u6s<@eAai}_d3n&*^^0gZ-0BKH`P)y<4{*4 zxfIPiN#0xMxP#OZ}ymk{O4(UUsN!lgAg0?WHQw zqKhOm4t3Ed0;54$yKuhv=V%jqsh8DKGUHHJGr5#?96t4*^Pas_yjn_T9O|O;hBB8a zi0FGa-m#Y&pq7#uhq~wtVDGPC0~?i!Yl>P*W*q7Yai}YBPTo9wUGJ%-WX7ScmJW5D zyZ>h$d#TUWQZnOE7oD~2Yt+Ew^Nx7f#>Tg5DVcGoi%whixT5|_SY$6%q?VEyhq~yz zYF{_bAHUqmUh08bN@g7DYU5B>|3OtR+e`V-sTE0P9O|Nr0ef9H{{FPKy%cukBr^_m z;lov_xazG-o@Xx=s+N)&hq}V#Qr2~2-n__x_EL#zDVcGoE8L;3D?Weqv6sqFOUaBw zT@em-ZS;TfC3~p}YAKmc6nGbz!V`H^i zm&`cS6$#cpHr5Y+a>ib2hgwQz9O{a)mBNm6Zbz$Cm2Gu>rwwAjynW`q%Y3AlGQ1^N3@@8{2K42W3V++)1t7 zo|B3k8lm=_A;_V%)1EU9IRUnu(!X>Thg{`THg=@re@#uIsFd^uN>L&Pk(T;ZwRq$h z4Rozb$@6yGpX{YpsHKQ;ER}#9BRv5wr#Eli`^#Qxms*M#$5I`UV>D3DP^!6g54Ki~ z<7z2l97`o4$7raBEv4Iy%{VPsOI=k<5#v}2!J||IDuOie)`QRNrRsSpxx_e@N=A;+ zP)9i|o!veTliONXmRgD!$5NdfO1a;O#}KfVTBnvG#<5h2T*^9H?!WRfs2VJU6Vy5mL;Y|Ni5SOHeUW2dql%Ud#T2xb>ZX<= z#<5gCxs=+((vO2eSJ_LAQcDrzSSnpE)eKuo^ViJ#*Mzgxpz>Zw|a7{^kB z97>r#d$*mvlz({~L?Xtq)L`To4Grla(pS^oZDKDKq?RJavD6Uc7!5B`5u^`~zJm*4 zYg|LsQp6~EpQ$;-Dmh;{&hLh&7DV}0p1%JS@ecV`n8YRJ4bxUlsdNQWto-+K z2veRfkgO$1u2f0+M{7y>hd8{I9PZPL^n2n#0lcO!7A4ZtvxkpN&r~8;evsdYr|hcl zJ5+wa_r`MjC_iOQ#CuoM>5t{%j}ndEo@p zT@{ocwcc<|Pmk*skH;y7WsR2q5(~ue(qO!kogZ1+T8m8Je9X1>&#t;BUDE zT8EAlD8DPC)X#WOAbUh$vr;(|Yo7tMbG|6)n*528rS)Qw~ z_RcQN@?3?rcXnx(=dvMC8nq4qB~Jyd6I~77_M>{(I@8s|)*mhD^n3MKtGeOOmf=O! zk(TBbi?cN?GO}%CTWMI%;O>(~W+^9*VWmzB(wI``0$|DsLw3}9ME(JlL`SAKYZaZ6 zlF})$L;Fa2I?xhg35}H0Lv1@J#3sk5By^5cpBQvF+B`Nkxnop^gv3ZoD_fBk9b-Dj zMUEa|%ZQGN?3@_WF(D?peWdb44vAO-J0w{GqdSbjPA5w!of0gewxePmL{&T;Y4iOv+{hmI_vV{QVz*yDDucA8yy?jxkF0(&QXaSoJjDlfsS1P1(T9H zM@J`gbfrK;&(8C3JjqOUq`ctF0xpYw5!6qdRp>>Kq@f7N*B1(Z_gx z(h`a@z9p2NptQ7A9-)+{hkXvBfjYO3ii%H)Q43q2kW`DR&qykz>|vI!JtaC0lQLdy z;85Fxke~yj6Ed;sXbGhUA}wv{iAea4M5;4*L7y8H2+$I?v7a7++ zE+Huyovu9OXbH7Ge?K{TAcfeF^Hj%iAmS&}vAS`H| z6OuZ1NGWyH-kxoeu#hBl!kT6+i>l%~Sps8{N@>JIMW!TmPD<&R60be5X$+tjFjeWf zN_8CAgG9R}BzEkWfS%J{_)1MsWf)mP2ihcBv`_As5FLk=bM#nSW;Ar8JG75a?%+h1 z7I=B}fm^mk(Jm1e857;1bElZtWPPqF>*3g}iKQiCqZ5-;QaU@E`K6*$*2B^gE!rn` zh`~fnjGSPPu0>2@bYen6CyaJFJ=p6*Kg4wG7#|zwY^^F)pSs+Q&9X}*Mnpn!3vtVkmaUXG6w_OX z|MIwsw-9fd?=GFHsC+mq{YV_;(8t`sd&)7}R`3?$4{-2J#zoRwhzHUqI(r)VoFu*U zJKk3JkCKNUrAVpszS6gJ>B#izc!;V*VXRwlk); z-5^zmQKApeA}#>=O~E9);HHDi0CQF4=suH3ZvygT@zl@P>XSco|4_uuLw>oM25Bjb z65X2+aqh_Xr(a1gl|&rfY^nsVmda8IEv_M$W-d6oiQf)PR~H=alt^h{-cvcP{%8*F zOE5Q7POCo>!4-pvspY)i=t0R|DuW_&62(im?6Uw9R{zo$;@7}b3RgI-INIPq5SadE=k-RTqCOUbw4%Mj zy$pR(95kM@V+_)lFiKkWravSA_ggU^>&Qf{)_u?Fmd!c6C^K~sNO;xo)0Fii^6H?Ey012V7$63oQH#j%ZOFG(S9FQM9ltClU7%;&>U{$zIOuO@l+fgGowL zI9gvtdgq}Rj>WA~e}yw?aPBz#37F3^6t1cU=YxgpUA&=S#UO>F^P;HU708bpY><9} zQPS$ScX9X$n0eU>r*$4Q;qdQZN?uhsxFM{!4+eU}p$2KjScUV`;PxT^9+*wz6i%yu zyW;RMFtsN*=l0-m1em9^pd)FGXNoUsl0iy@QKGG={ca(@2bhT06i&;(X*iq;=Hg`M z+(I0F0%q=1h0|(3dcnhHFjGkwNo$=9M~6SI3O9z}V%I6xSZgUk*YrKrc zgnb4kXMuBWJnF6fwn19(j>2i3k9OejQ82kQz>u`An-1deDKJalbIvt}#w{=vmna-< zMg4XX2Wo-2w^ZS@+S!8gRhJp0S74O1^a2oIe=yTmDqK^rqI&VYl+=C|)=3y8Ej=2~ zgTUJoYwW<_c;6!n9;ixPHUZf1A1q{^xCIzT5$});dNmA_bZ%M zJJaP-doWW96i%!C8shMNFt-ml=hmPtf)5&`(=bYKSJ-}^VZhx2^WL`#r?qbUit>?1 z4N?43XaE|*1D!nhxbt`q zU?5dEVUW(8R=CO?sN?PNY zJ|Ddcrt39@(;8R(ad;+}pRPOS_Cv4APX_5cjFOfftwX*y3{vBt6;A8(FMaG-4d%#A zh0~fJte-%FCK??{DI9w zh0_}Mr%?VAFjF5XoK_q(AC7@Jr*cG#>ZN&o70fLi+#g_yU2qMcXZ#bNYhjeM<~ecfay>+^ZkI}1!-ya9!hKTI?Z z=sv?UFsYsjr`2!I!TlUCQ@xyX^`N&9%$F*s)y|1%usvXW=w-S{bUh>TkIs+f%ezT6 zVU)D=3ZYjY%tQ6}zwkVgP;Wd0%2jle-l(MLY4uwzaG!uVR9WHBoI<_b$iD&RLpre| zX{}ct5I7CyLUo0s+oz&2(8H|_ zDH^Ycey5AVX^pEKaG!&z-A&=NKKHx~E)~q&?#}gAfLjYD<`w5$MJ$v9z>MpsaA6v8 z(D|sKznk=4hQevhqc6bi0W*>=c#z_@Lve_!FWK5vbMKl4-uyK)lwN8?Re=_XZ!QPOG`I)Bs!WBEYgw9X53 zcoa4j)Zg>eiWgsLNJGKQrW=MxTI2aLj@?li8N@~u2VFNDUgIVe!YFCQ@e+<*0Au`E z;k4GPTHxw{F{>QWTJ?4X(_7`V>ZSRR31*@TJ>uqpS>=MGc(;Q2TIICr#jPvp8!!p$ zlz7W)#PJCEN5Sk{@4Q_qL+?j04?a;it?RYf&})myw2vkfl2$w8mWA{qm^mAr`xgSv z_cJ#sVv}>d4&YM3toq!!e;(j&g86l`!fB1?bol<_7r0J@QPMgu1mf@-Fh{<0&e2~^ zxDO_EyTWOG?)d`#Z2;4Er*l1;U$elxrE(}H9H+!B1+&TpN9)xFFu}W&dbQSP;?{y` zyxTeF18y~#PxmOC);OT=t-b}5vDZ0Adegwn+2@?A3+`huhw~Lq>w1GY_x(7((TNyI zizELAfGJivtvFtRUeyD53By4}Ppg0FYk=Kg8Xi(Ot?L7dcQKgv4=bEjz4U$U*I>Rp zqHtQ{nd0~v%+zn4>(RVk4(3CZgB!weMeFIOV9x5$dkE&K4n2>f7=JKITJfI2v1BlH zzf(A^b!Zk24*_%cdxg`QzjL5hxzJ5o0i&c1eRkVCtPzIIVRz z3wmq7_?}WYt#-}_R|(7+mD8&CM||+~I_)Oi_)XCpf^wqs)=1<(`om4idf>d?P2h6C zy!cSzwAy(xxPf4bRE}s-y>DZJJphyYRMDgJorpV%{2qV1NdeEC*E=2^Ita`U>aQhg z%_HjHj&4TjB#e?)|IWjO*Y9AaR8~0poF?+`Kge%c)hHc@QPS#&wCAf89($sfKX!*As-LMo)NNuHFtVgTyFZEN>8ZULA=Y>}j1ih?qTGyR# z4I4y8}4&_lLCRWgsT@3t%F9D0*~1P!vZeR?RXDA2e;#@-&NNDY!YFCQ;RZe5S$O~YzZ6buywKNpRlw|>t#Dd#P`&rT9GT<1 zUW(%~nAg;|plHQG_cykInVaWaZ#DE*fQg*1a9VmFf|~;7#Rbl}Cup!fV7lT}9+b2` zPcMO9jYURj^ScVC)h>f^L3JHW#}x{vHP82ZK$ae~VG?!1s+(@k&LHwjypQ z@~eKJFr-CE#EnA!8#=gRNId}e>qm;FRy+R#|AN*Sr3Pyij<%wD>mok}%pjFRF(G#d z`6E>ZyK<8CO1%P$GU@($>vc+0dBqvJ-Q#h0n8!J z$-k6k^;mh1^ahywoD=wGT5ptU!zkI}5a>mKN#GpQBmV}2$yGV(53Tl_4`!JQJ-Sb` z9ZVtT1peIxQ_MN$AN6n5PmEGS7$s-%#)9d>Ii^SRItNUy$~lb}%rX~xa=c&)IVXx2 zOflz}f23D+gHZ~GQF0b|U^a73pjQZ{h;stHXJC9jWpN1f z8mf#OFg9A_uQj-67kbow8DJ)HPT=1XFsnJo{3E@5Fc&x{(0dHVxY2dIb-*;|oIo!H zOe*J?e>lxZlT-$~a?)zQ8Q|u-(4%-a=+r9!SLi~I=G$E`hR>9CaW>!lz*JQ^+qh@( z20||sOmEH!+HV4wT+T5)@^2NGt(+6+odQ$DIi^SR?HQQzo7gxI=rsn@nsWlZ9$>OK zC(z3Uvw(92$63P0lRY2ink89rYcJ%WRB_4`jQAHopS>Jrh=KvIi^SPt_8E5a{|3HV6JkG z>5+dWDuZ1)X~kRdOI&xtC~3t@?H2*22j>L-jR7-_bId=AcLkV@oD=9B1#^ybOpoGy zq%zo*lUBSwc#CFb7$vQEV{j}4%mmH}{96oW73Y|L6z^Uzg`5-U-33$3Ii^SbQFWUV z19s)46>l)OFqPGcHvkH~!A#5X>dcv3RNdioy8oP-3>lA<%0GCWLcLk3J7} zQ5o#YNo%|e2RF%u9<|>RoqC(V?Q)^l5_%WFl;5eu>+E{6DwujIXKNQ0FWrxfQW-f| zY_#G{2G`q#UJ%Mp0JD;Fg8tYI<_PDQf7E_A!IW@LpjYcFqtpmSNh@9&FL7Xca!#N( z4$KVBG5<(!C74Z|6X+cSbAfYAkJ|4snA*Eo90I)vFbSMvdgR|=FcUZ@&|3^<73Y{9 zjhDSDgIzgkjhCa~&biQ&&qrW2=>jI3bAothgIUBmrbq3!8B9Ls z1bRha?r=_^=d;@=RfkcsjZ=YMYcSEAV|vsd87d` zV6JkG`A45;O2E|H<2v3bFv*-_depx|!Q^sI;NL1R8#%}HsDF=wxx_hvUNIPty(|ua zUOg}&oD=AE0n?Xr0=>y#@;E2ZTMuR{=a?SdFFB<$*p-vkc)0}brVBkfUwZ6Q+C-Jp z9DjAdHC0*LxEJ`Bs8g>SxO5kKw7yIQvygLw_S*zz7w4FNq;~<#UCs&g{PJ->2S!ON zUK)R)U}8BZ(8~mq!#RO}^TDj*oIr0cn4_FydgR}2FvXk`=vCd1c@Cqb6)%myD3y^x zY_!H-0=OP7^r%0^fSJuXfq!ejZ04LG-a;@%oD=9h1LITRJYHI#8>)<}ctgNhT<8Tr zq%WAMoD=xB9L!qIv3Tiv;~<#3oD=Bz9l&^oQPS#PTAxF~By&!nHx$eS&N2UJ{4EBv zhI0bF0x*S~V|vsdcU1%@d%vZu=99n{M7~%#yNq1y}@L0j`>IHOD>oVoD=9B0dt0POpp9~0LFBL#UapZ z3Z^aRm>!Lno?wP@PM|jz%worbpwYHke?}3G|Y|^yZvEZvvRvoD=A+0kfHN0=+^oMVu4pJpAy$fJ&aE|Fwyv7sy z;`IYpRb{o}rSo|xm@b?X_?H7_GUu3o6z?)H>p3UTI|Sww=a?SFdtYU+D<`e~Ee7Xt zQfV8lc&UHufeGWBz`x#LvN*^5qxCNr%o5HC^tOV@=N!|c_A3H&k8=XO@~3bg6GllZ zUeap~CXRCgy(}=JILG{>>z4&8L-kV9>W}5%*1FK6_B#mX0_Oz&JqBYu?K<8%V48DI zpqBzBm2)g!8h?{ihGM0p74Hmi^IhoC_}c)cfO7)>u7bJCIp!bruiqJ5pTa2F#(_Yu zEtpu&F+GYmQ)Og9Y_#GX3T}c6Jz8HDgW1eEfq#WyE^&_eNAVVe@j2@{-iBa8ILGuT z-YzPGT{&sR+Z$Y#3q6WA7tBh|3F6%i<_PDQe-!UcFpoJW(5rk7*Re24wsFApX#QGM zMh3CbiZ>BlPZxSLf5(BD%Q=C6Yr$;c9P=*#dMCi#=bS*#bROd#MoBAPYQMH%5;!N& z8w_R)=a_$_w-C%K&I$DPf;q}LrbpxNw#r~vPFnqOAKWt+dNlrOUcmh@7$sY~2>j~- zCWCX#KZcdfH^Dt{p-1snxQOdI7$s-%CW7h7Ie~xU zz|7*DAl}trHgQg%cT8nu2eHwL_cFNKF7#-=d0oP|hf#7CZ(A_2oMZk4KqC`OF6RXC zt^%`>b4-uM%TX|wI49662IKJqi$kDS4@?N>1bSV-^yM7WqxEmH%3xPcTKzE_+#(lx zG=Dei)Y}Q}pbI@3&)30}a83|!t;=}c0!GO;4p_W&y%7f{opS=csbJ=Ej_FbVt_8E5 za{|3HV6JjbpjQIM^dpNypw|>kTh0meda4Yy3ni`o9Sm-a3%vl8UkGM1=LG&0g1N*w zfq%tde2QGh+Yn3$=a?S#Zx@xpuAH>u%?3Blg&vLPMLPACgInuDkH*VEoqA`$U3H-s z0KF10wXe8tzX&i1oMY`r{tX5*fpdcXT?}Rw=a?R~-(Ho$uAH>`;}E!0F7(L1`#SXu zSMgjLj1q0-dYOL#$ZrfLk#mB0v%!qx9MdEJ7J*sKIe}h2m}8t1=-p8nNXtp9{hosJ zy5>AyT2JePiQ=5VzjQD|IVbRME|_JU6XKP=mkLUDVUl!Si1<~Z3`xr zb1YuEp3DR@fpY@A#b8!(j_FbV?gdlGIf33?FvXk`=vDn0zkdm%WE%$py;v|^ILGvw zK_f?HWI=4S`gbL`4KDPk{f_9=yA1BO4n41%=wBEmXYsZL6U#XkuiU?2CU8#Bev84Z z;+#NlFPKxD6X@Ls^Ne#$kDgDgc?-|oz+A=K7fd$im>$JD8_aUf3H;j$<{;;op1fXx zdB8b=UWMCOuV4;w2=v0hByvummknkd=LC9-z^vw+KrbK6G0rhPTJP_uj2s9yTJyu} z7krNhqhuSWOpmTln}bPEIcLwycLS5|LXY})s>)Ekl(hU?2yTTAy3c+1+p-1gk z45soOrCprGTN_Mcm2=j931BifC+Od4VDdP}`h&*vdN4aVC(t_w<~rw?9`&!`S9}iv zqhyOipw}8qH0K0*8DJ)HPN260%xcatJsL0hV9sz(p!Wbw3Fnv|wO_5fxZeb$IJ47Uu;1tp>A+a{|3%DkD3Hjn@3Q4DPlIJ-Qz9`b~+|m7WP)O_jB^3-gck z+UnGc0+*~qZ>UbaG2o`@&|9HXZwYW33U5B3Gp1%I@0asaNo%KhEPQ5U2 zaW3>|J;(wxm2-meyd2D0&av@AdI!N==A1z9DHyNcmA27}m-Om`iQt?-FBQyS&I$aR z1!e{31bVx`9O4|)qxIzmm`9uw=vBOr`yen%TJh3+i%=OE#71j9hy~Y0hhC0Oy$RrQ zb?B|qska{7Ru_8Iey4QmT?cp1g&wtE`9G94cGZ5B!PQY&t^OeYEIRd4z@@s-3y0n$ zFk3k%7%!*56mgD?zc$c&1}5|Y8&?9oZeY?m$Mh)PsbJ=FPN25|%y!N(J^DO-MrE)o zC#~^(72I7Hdi49#eh-aO3XGDi-vs^*2Q!It%s+~E37EB<6X+cTbAoeBkH+6Ul_CEq zX~p{(obeHhgXz)rP#rL#oD=xh4NN-c1bS1!EaaR(ZxfhZoMUva93UE1wgL^ zOzp?4odx|H0VaWStbZxq!C)qEPN26K%qq??J(?eTRR+6q(i$&^z@2iTN9}iCr`|Jg zK2KP?F#kxep~@)UY0uvfa26MOG=KYo8KrX0K3`4-Guwq;0QA;?IjBRg5X>bVdc|O> z7c1@J%)feIf>n-ax!+j((dX%8Fxfiv#(=$!&n#5sZ9Gce_!x{kLonAV(QdK7OD zFxi|F_%|EOBF-^Aigz=Ze9j5(E;R=AaI}LNJ$H=*jo5z*K(bI^Nn~8mpXEyz+Pk(^rSyU@&7`=u!JE1hZL( z-YzhQbm-jx+`uuwV%zYht zPr-PVDD9#ZFP(qus|vn3a+gSJsK}P!3^b`VE)bpvzT*i{?dA|1xx|w1bSD& z+~pk8qwg#H@K)+z`OVbM*MqiTVpUG7{m8#eFk^J+O$9U8g&vK+wO|T#=p6%d!G#|A z_ZW1+$2A0=>;(c5{yD1wii-n5Qb|to=OP(Z4WCTK!AwX)u^L zm2;-o1x#NZdXvE{(xJBk%z7Pqhrkr+(7O%hkqbTQkBT1dQauy# zIXd(vftlq(kNjH=W{VEJ-C&Nm(4)_9H&uq>rKEL!djPJ)g&v(RYk4YdCyP1Js}HWZ z%4)SA>80q@>j^H?g&xh{89MbAgInc7F93Rb!4#>Sv+;5p%p(_ip?7-E}UcQ0gaa&Fw;0E&|3j!J?EGn`F9A+CC&--iotkzvpAR@`Bx822`2$ADS^xG1lf^j}FSTDT zm_?iuwBKehyE(`7$iGWqN;oIbtL5u1HG)yH#liH*zc?^GIVaE?2WAH6m>!M4l`2E^ zQqo$lwt(B~LXZ5rtW)nUxMCN2LC~w}hwC92C0n});_VA2n{zB)8h^9FtmK?PZ#S4D zoMUIe~v!U`BC{`A7Y`0L)6x3G{Y@Il?)nNB-SZ8H$6FR=g$P{3^JPw~@*yYT9~H z;F4YF(e?9Coq7|%0s{Lw#YoxMT$Mnd*Ghl9T zPM~M3>MogJlx+RR^k{utppW&-B~{w)TxigV0A(%TE>6z2qb z_rW~l9MhxmT(g?eCfJpeR=lmjMXRh<`vpKD1I!GSb2gsyz$|g0NAYe2bA)q(cyEGv zz&RE#-5;t@U0=M_!PQq;t$4}5XfQoFC-83^m>Ha7{*m5FFk3h$&^rOcag&vK+p*rW?#EZgWnc=T!^i8Aiz#2h*d^ ztIfgmRyk+mB@;}J3q6`|^HqlGrKB}KmVsO2LXYAt(5ZJ0+;ts#h8OWU9!AO5E`s(8 z0b}7DYd;!)eZdUpoIo!R%o5HqJ&Jd$%8-AQwA$|oxHCHR9)R(x?KtX){V)F1U#2D@_7inlGeSQmQaU#3pI zY2fl)=u!W!*QvJ?+(8$50nob+##mQr7ia5Vc`(&g&Ni-C`%%2DRR+6q(rUkM;L=^_ zQM^-i>dgnY%!M9ZA8gmDR|xKs4!vS973#TeznWkgs+?B)k$@=dzeeCfb?9}|sh0|FunRq!AG37oEd;m1 zg&vKUU0@11Cs+^ef+^-48-Fxjss>@*g;BE2OMzZ2m@b@Sdek2|DkBSGqcuM!fXj8E zNAa%Gskaqez6(8C4~lf^JqBlN#M*_$E6-mrp_~)6UpFx6oMU?O`5erA&I$B3fZ5JD zf!-OFan&C;z}@q`=a?R~Up|-SI<(3=KkCFcb3?gn#&b1YsOFE_zF=A1yUax*-S1f!%CFWvvMfElcE&gRD` zFjHOVk$=lohU%rHHU2h$+wMY-=Gz%C_cuqog&SkAger zLa!OhKhmjJKNR<$VU%p`!u+H0oC0Pj=LGT21+$oQOpn@c3z!1V3G}Xlxyw1GNAdc# zQewcaoV4063|ySbYQ;w;S9M7kbowH+AZjfb(nXJYLdkq%zo*lUBS@;F5Ld4b`ca3vPi9y^T8c z4uU)3LXXzJdph+VgEO{s-hQN4M`e`O(;hF4z=i72>!wpL72IGQdb4!u%?G#4g&vKU z?K<@e!Ci8pN9|XvQ_m2F`3s|@HGk>)zOl;4AU0a#xiz?G7kcDhhEBa~aN}I)(R#l~ zr`}p{TU_V`LGJ{ZV$KQHzpCN5E`d?fYQF#+ivp9uIf33ZFnOF4tk3Jg?Btw4?;M!x zoMU=4{tOZLeg;O#7KcEuHJE75F+J*!3^3z3C(v62W+msC9-WVNgE_`If!-Z3k2%Nm zXgpUoE3sl%PFmx+4!EW&Yik##7XyVvFbg;*@NXlSot$HO6z@4OH#sNJ^RVFa42+VN ze{FCqSY>1o8?AT;gB#;QkNS5Zm^GXe_*Vd?kaH|v(z^@B5Xs^Y=+y?(m~%{z+Ajf2 zZ_WwyCVIVbRM z2AKJrWByV5Z2+^2a{|2!U~X`Z>Ct>MwpU`nuAH>uHG!+Cvd-dd3nqhe0{^Cg$>SXJ zkK$bqW+&$adgs7g=N!|M*VAZy@m2>{UuCu8rTYibU~*K>+5Lz~U}oviTMed=bAov9 zf+^-4iLsWn@8Yw8qP9aEn~%(fYDkr`|zuCv@oD z17nPJ9d8{lO*zNnrS?k%lgc?k`%MBfi*rnm+HbYWU{_9B?Y9fuAs2dWpl}0Btq!i^ z4FeO$Ip!b5n+0YZ=LGRC0<)5HOpoH-tuk`3*l5Lj2HaH_dUU^}M5kWOIE;H3CEK`X z{x!p~STN%_CyE!$O3pDoYQNoJj&V+)cL&U4&M`f@95+d8RfgiFq}9I`aEUJTsDHD;Oy!)wzvW=o za*p{&@g4+ohI0bF2VhD#$MgcBS1VE9c#Z;>tg^Oo!1Tz!p*r;@gPZL_kJ@hyn4O#x z#Cs0Rbh(zG^Qdh5QM^@ja3*jKba12>s)M6` zi`BtVzje{UJr6Eb2S;%X*TFppZi-IsO&uKd+fp5zyuRq*s9kpI;HW2IZ>$cE>g}q7qwBQ+IylmMRR>4o z;58i_)jLxMNAb?n!O=Karh}t;Khwd{=i+T;IR7%|1sYe|%W!4aH5yk3b#PU|oz}ro zymxePG=HTOedD>34vyBzIyyLN=cYP1KX9QsI4^LKWw^5EX{tA_3|F>4sGU=EaCE&f zNC!tPJgE#<)<3#_o?3=0>mTVYF2j}83jnvQ3|Cf<+GVE>E(lz{4vwyyZkOT8`bY8p zT81m@UobfL&aTHPtwSL?xc1|TN$owyu|I&$?em@)ra1} zGMw1IU&?S||L*DF>Y(0-Ww^5SwgXqWi|c+Py%Zf>2)L0tI2tdjb#Ub0NgZ4$xN==x z$3guYRfa3u&W*rzD8rR)zd&#~I=DXI7M0=3j%VWT>g3|O@p#30t8{Wtb#gtryRJ7C zact7T)dc6;gX@)TXIh8q>*OMIaJ0VkD8rR)zXsrzl;O(yN9VWQWw^5Ains$hIQsl{ zv)@Jz^LWK|JJY;uu7jib)?WwL2HavDTx)R0ba1o|x%YG(M^kY1b#Rg3 zx|ZR}j)PX<-YLVC?GN(runvya$=f=(6mT!};_;UCFCN@b9b5vqEjqY3aDVIIBEUuW z=Khs!7g|rJ>)>b{tk=O&|6b9-H3L_^k8A&^KO%H+6vs#%Tp+k*Iyj1Bw+@cx+b=q} z#^7qFx{jCHxuXuQ1GpJwIE+7b|Ie{T6hfNrU-teVafiz2m0c%^JF1f_)XAOF$(_^5 zUDC-F>Ey2KEs^h4ozux((#aL+f}mva>l;2O52m>b(2ocPX|Z$ zflXz&&SmcJ5?5O%7p#-B=;Ts#a_Ks`9G%=Wo!kPQ+)AC?CY{_~om`=a%N#OvOskf* z!FC)soQfDH;Y-MXfPmnb*bY%WlDa1)v~O28x!WtzUAxzH%uGp&=@gY5+YQ+n!^UQf z9+5FNYedHItaje>n<7SOI#_Y zU0O!k=!{9jvIkiI8#y}X)vV01W71yf)}mR97HI>S|?WFJu(f~<1E>)E3O5aSuZ`-T?Cue7l&KZ+4Xly`G*G2&; zBgbYB&wed?#NdGFoZ%z0hh>e1F9sN$NlK88eOE3LyBcY_<>jw#nemz1f9UcGqW`z_{NdhVkg zKTLY@_L(blE}UG_IBA>D?kSsJ_iDQ1=E7Qg-yZ0{z1ANApT8PEYUhI=qxQ_4dir9G zJ3n0>-ev3QhlggJ%6(<&u!{TE4ITJe@qlN)9?5z$CCyOj!Z6Rw%m~w8kIH+`KO8V3 zte<~&(oa$S&x{^5_`?%F8N=gFyC*)IRsQ7At-fpiTDLWH*wQcBpFOhcQe^ShpI#q! zzQwq-qS(UnXMgA&abm-#%`P-(C;ixEdY5yDt7IJCyY=Chb?P11^2)NsUlp3x?B4PI z4!0ohIUea>TqyTV;BCLnv!~<)S4bMtYeTJ!{D`K5w!Izo!+6h8mkeJAoLu^n|CxJp zXKfx;d+RpOH9zfL8FG5Ztq+fQO>9{#nciCG^Io;3&t2VB{?%zsBZhk~88&dCAuaRg zhh2sa9gs2Xh4am_W_6MV{Bd`&=dj6Z3^nr~dcV>0fa%dU7e3GGe0%%zzwFqPH)YPw zzl&;J9+1%VV&w-@PR+|oI{ma)#uv%ociGx*tn~HjYt43@j#^XH@!aC`5yKCh_~_}w zv!`CYogMx6g%K?~%o)7#_>TS;$24`1xlzj)lAh%I$&o4LFNcrv==@2PTSI?;zdip7 zD0ig()*(H&%*qMyIX!6S%AYd6f3En)eoK#BXjFIU@z1|pckWQth%LQml>hSOu(aLV zHxB!1UqJ4TyW6(x{dc)*+l>D{xp{2cxHG?Ons9POoda!zH5GU zc=>gGUVY84@VTE>l=v)a_?hIp`F*dcF^f#UpIq%dd&nP#7ysGsnccVNfX7D%XH6f~ zYFPD~ox)jT zI%`!mUw?erbE_q>)fe#>8<#(yRMU6UpB;^@`oHELRdBC=QIDd* z>+ZcZqWPpf*&XI>$v9dgchJ`#oXn};>e`U5izk%(&KT#nYiAX=y1@-Rdh7}N>R^!H z?l0cy^JQcASGT0CEjhQpdExP`dGB9nQtPuHQ$OE7aCw72GJpNg>Q~44E*kE(-qYtl zmR8T*nKjsJbj6;M#~U5@F0S<2j%%Ma-aNTY&28nDzjgAR@_WwQ*naPaDRqi2`JFy_ z>R;`zoxcBM%jF>>axd0CR%OqO)CN2MygK3YoC$H;tNq-^d(OyLO(oxkc@9eRGgK&f zKWjnuX9J#`DjAv)TR5!B#B07E{C2YZx$e2{o%U}rw#{fTc(?C6+rz^&$xzV9~9d8zdtzb{w4Rj#0Bkw>5T z_uS~_sk}zI;eYx@yYzL8b%COV$hsa@ow};!;Bg)5Kh8S3e#+}jCNKSMVbcwxpZV^a z-#nwN*JaoXnhesdyV%q!VA4H{m{G|Go zF`Z*Vc1*u@e93DyPG>jXa^}vv@AQ7I;Dt^jll}^>_H^E`ulD@($@aX4UqAeFX0r)z zfBELW^1E)EIO&xiP8d_~FYa;dy;0|D4{Y?&=CjLgHi+B#S;moC>0W8A{@FXe?&Vy+ z)tSF^xxVN>pI3M*w%iDF%@S#U*w{b*u2^|jXyJ^=*%3i&?+z+@b>+d`=jH|mRPp$~ zJ$^4A56REq>0|WqGkE*DdwF{rJdD0RzLK}Q!NbkV+sn_#*C4rjf$}uCyLp50@p1F; z@-cY1xq13|c({A|;G`vadHQ&}`x*@(e0=>p{QTTJeU0vJ?moUoH&3IduZPjy*Ut@= z_(8xOf8W-RMy8jiue-tMhl6fD2KeD`zL)(>$B}1E^6}C?<2WVKk^fhZ*?#8v*5m5` zav3mI-m2m7GaWC@W8eOBvjHpHR<2#UUDM+u+EuQ-vfZl3-?Ur#*>COMi}njcepsqs zNZ7@nJB0P>of>wkcw|_EpK`-8t}O`5nDd{o1IN~fHTYzE*ydK>guOrDOjzeuH^Q2H z^(gG-Xk++y{mX@a^Ks?y(=oNf8(A8Kzq2qTynUoOyiH<4_{ZD2hxd8CfB5W=hlMu| zo)qrqn;U-Sv$^4qX1yKWdH#}c>CpS(FNS^`KJnDX@W_w1hNo@V9bWSD!SE;DzYp*C z_-uH`<3-_XF5e3OSDin?PcM5Kp0UO);)P{i5jED8i%30LA>!9+RU^Ke{6fUDzv@Ix zeXn6ea;K&dlj?;;JgU?-;#fUPgrRe6#KL8X5u-}FL>!vgD`HrK^oU76XGQ#eU|7WW z`C}rgTz)Mg({DyZ&i0uRt;WoWXknfgakJXn5xtD>M!fNCNyIhJ|3u6P_#k3H$B!bO z<*tk9cI?xL+YL5H#4X$!k?!|Z#E!*#BDypyh}eATP{f5L-$g_XJQ49ru>J(UPZIztt#eP3#ywxT>65!!iL)BPrs>a{_U6g=DyV$nYVUoVh(#N*!;=a7Um8? zt<2Bmwl%xo3^zCE9%&x;ZM6A*LY(>ECp((I7}&`iCUrIc{!tHeQv?^!w(<1s|A~R$FbB z#;h^VI=R-|p!Fx_f)745_c3iUH_P2@uKV{Ev;S+`%wf-Vm~&_CGT(ZBkNMR#`^=3Z z3d{{J9yGU~a@ahn-chsZ_%Ueq?;k2!>iw&-rLaX+OW3t) zmLc!fuuMpJ!4hY9(Q zbg=xfINmbjosJgwcal(FC(H3=oh>y!>}u(?vAbo?u2(D@zUyT)uzkNe@Tj+@^gGA5U(0BU=DFE9@d9NBCmZj%SkcYk6@?H@3>dJe~ zut!h38KgGYqfht-DH3}@@?Jdl=sRbF)ERs9Eww@FWy|Z2y_e;@A+|ga9`v~qr(4Hl za5LiU=tXDVY4}_z(Wg_c2Db@n@sf*DIeZ#-t6;1kVUXAp%2#mrsMFl@`KT^l8KWxJ zZ85{UQu~FgHs|})3+eiMQ6pXm8H%iY*?$V3+$&8;~$9VV$_cH!5(DPIOP5*6y|F*#YIW6FZa|W#e zZcgX@KSp2aA20g7g#V`hw!nW|;Qy2s@Wpu^*Lw0AfcI_Sy9#%y2G08van65&bN-*0 z_ivQ=OSv$uR1RfoqRb?e`4iU&e`1}O34RvrU$EJ*IWVpC0?HPnuE(hBp{blS7wns` zJlH(geArtst<(-H*JITC2xS+5dmFY8_6}?j>|NMmm{tly`6sCRJupjPOJU1k|AsAx z{Rg%Jrj=ep+>a6S`(ReWK7g%)eF$3(`v|rMrj;gByTSL5!K{U?gRO^s0^0!l6t)qj zmHwi(L;26ZY=V6b+YI{xwgvVjY%5GFJwe;;n`V->f!Pk*0ow`t3bqUOHEcIbD;1;s z9vt5b+Xu^s?S~b>4!{n=zJY0_zfk@Vjvs~{fqe@*3i}Rr4E8;&5T=!i(Rasj`~>VI z>=f)Y>>TVoOe_6`@)vOYBJ2|E2iRrUkFX-x71&jnR(gWIzlP)2VL!oczPSa7fT2Kvhu{x{`<^-()579TY2GG3JO0;IQ1^*|;;UnV7C-5}qOV4Gk^0eMO zR_8y>gZ&tbrRTkMPHUB?wTIR!n!_{?M020!wpOC`gVrr)bD!q6R-*NT#-OvgPjg!< z(Yi_NhqJj)b6YFX`a@&T+1#hOt(9o)bvEy)JDm8bQ`*}S*TZLRXO z{y3ZW*14@!p4J~{^WHkQwaU{RbT;p;^INO@70Yuj=RVDGQKGf00Q2R4I{!<~mt2wj zJ9bFuK;OXNG60*BOVUhhUEcpcOFsWECohd;Z5HeIqt@?3>CPEFTS9kA=(qmq6B9jB zVS>?vF!Y<#RbliSdUUU^9*pkW(QnFx!J=W^V41Knuw2+`SOM%h%#Gi-L!Prlcxj{W zbW58NKbJPT8Z2!TS82nK4vDl$k2I(pvD5|>KgCTkSBKSs(Ou3cSO#ncEFVULZU)Q% z5qx_m86aZ77t8n>PcqNgT4S`vW{t@j3w?J@M!s76 z%-V0(zO(ip^&y@8$S5WWb9-hycYQEs+?p5BuMy;2O-sLJ(f3ZRYjDK*OdjTUDx3r@_l1 zt-~wVtsmT?O;|*|z-G9c;g0u=E4WWU>q#P7{8Y$!ir!W+`pGL!YX+jlqP$8EnW85 zDusFWGA!|IZ)oq;%y8W+z%beSd4r#ir{P_nzon|ae@Kgcj~YyVpBWzdEjAo2H{Gzf z{0PG<&-F8uH+43AZHhKz`VVyTs$h0&^L#D0o)rylgDTxN461y}(5K2iLrm38hQMmg zjsH~p$L+luC*3N)u+i=HTJzmbzc|vZM!+j>UF$@;O|2X4zOvpw#(nh<822`O$GED| zVB@Qeql~qh);8{WSu!R!``qJ1^Bx}ST6%eOZGF)FOxry7*5SR}rrO)%_TePHT+%@lOtfvMMiQ}FrG?xvpm z3Lco!PMd;HjrKtaTC^m}f%VHTptbBD40LySwjQlWd-R*M{_-BgWFBftIXg~^gHq5G zblj?I>aI8xynnO@s@PvZwbPQQ$kBqJRDlBW%7?PHGT)AGVhY-iDo@(0O;fAyjeNxg zcx??qiNzGWe|!_WUOv?e0hq9GzU&jl!F{TWymoTfFJUjq))XD&JzB7oyg2MNmh-yX z@@PrvCFhO7URQa~)LnJnU+J6R^Wz)BPqoVq!$-LZ@c%yedIJBW9n&tFf(p^%yO_UNw3igz)q*YYm zXl+sgw>Rzomab|8J-J;>LEqY&APwE7*=0(9(@@gtwpZndsN2TNdo+SGfEtAVGTw0OKHpay#2|U`;zjGd_`yJ_`JjM zCH1i*(OZJ4>=vK8W4$4mAfiU|y$C#Uo9|6G`9TTEaz)28E5dHeEjd7HL9 zp^WM!hfJHE$XWhT`M0W>w*4MevX73`DEY>;>37ej z9^Y4hy3}a#d2mzpAH%Aez2B4t5{`1Lr0M1`INdxPo3ipO=rmR$L($ zf(vlq7NMy>VefZS>Yt|6yW^k7DsvG7;5zIM?7^KDs6t)B_RCW^4dh`$`bG2dWj&1@phU{$t9Y)4M{9pJW%9MT>o8I5yF!hP`L?ufjXpDY)RdZ$rz6~{{9xEGT>Qw{??Vg4{ z>U&(3K1b5WN%}O7(0SfL5>gATQt%z2!*K}2K!G;rOhITM_?vzlhtW#p`f2Q8iz~i!8G8xxNTv@TOL0DS zmp_gur_)i$Q%3g(*i%ZZ!=5tEcVJJs204H|rR;Y$?x~G4VU<#jcEg@h7VR8WE-9~c zdt<)|bypOv+jJF?PYbm*)18(fKQO&%;YKd?nZJbP-H%$g z+~vi%f+-bM^+U-D25a8)$ix0&TB0k`K~pMbA^u7N0r6OZMv71nt~~w_ zhBCf8qMucNyln%181@d!pHp^YPr24Qi9KafUBsR;4ewwtPo8`jUE5BmC%9|4Ai?F! z6>qd7bt_$@+^&Y7{qhUY>b*?A9l+|m6hE69jl7jKA9@fTy^oWru-9j<^_I)Y_w72QaBiYD3aC*$&^}RY81JHuGCWh z#KHLgn1b%1k?)v-e#U>-O+7CmcgP3WO#B?1{vTm8@=Gevh9!@fHF;k1!9LdeYe@atAi?>#*s(6q{aiu*~}R!^(v7&`6wDe!|Z$ zWw_(#Ve;u~Y+z^P{zr^{J43{9MzD&T+r(dA6R|BQbQd+ptk{SC6)yXW-@$bITI&J)Z1**iYD zPYvVXO3-C=(ST}^+YN(aOe5O+<7(_4?RBh#{5~&W9K>SQ)6|PH_1cI1BT<-DrqoNL zYeHdc6?oNeUu26CoW8EpxuyVI+7+5t;Bmc(56S@D6!36li@N|X68J5F7vSOZv8JG> z_`jn&w9@{@bq+Fq!O?yPqVf(?9xgp9(6w_=KIKv{F@b?}Jwz^HvYnA(IlCD_re5FE zA%#YWxIXLGJurx*9)g+~NSDCap}bgAzlT7s0!fk^KJ7Y%G!Xly3doTMjJ$!1op7^( z8r{>HVZHo9-ps%NsG5R)#C4eUa9Us+x;E=6UzUJL3Jgcfn0m^~g$(WV!YGsXFl*-p zHiiUtW(K}QTHD?Y{C}8x7x+4>D(^qZIl!TfJSi5eiV*ea1XHC$QCotVr#**0ffHKg zmeNwHVJZr0g$4?=C72X*e0n-nQD9!2VMb{6oESly-Es&#aB7fZ;Pdi$&}S8p8WDjpqG$~CS@f1*qmZH=xO-PxW|m5z#ag^!Lr zXp8FGpYz(!XC^FbHEHfG6~4VRBML0F8F)MY@d&?@VRA*6ij8MaBfa!(%T@&c@%XCN zco5&wP>sqwGIxKpSm>(aOD$EE@c{nG;s2v;g3f6v8pctoTTK94M~(58Q4QWooEu|+ zw;g=YSJ82MOND7?u+|lL5TqU50_(ed zOm|br#tZ|*C!7+W#x>QzO99`UZe`~LxZcjz0Bh2>xRCbr9ROa)+K+TyV9#$i8-!`8=P_rzfXaoFQ=*ze=8*W$3l;YeKjjskLR{&*ZV zGY-=`UoM@z4ZC#BaoEy0tUV4}7l-|A9QLnq*w5pz{y6N>IP7R zEyu-SpNPZi;;^}Kn3OLr@7Lq7tK+cm#$i8-!~QW2+YpC!$6-6-uwTbv&%|M`$6+Zn z@vh#ZfLxnD6o;J{4$H)0^Ww0DaoAVlu$DONDxe;tNY?=U(xB^r9Cg%j zKi@RvT#m@1r{T;XeAEuftBYQHFGL{7FRg+DKoISx>Q8({LIH^aIL+4g^AT*+j(3`l z#q)0Cqe*Aw#T_~yXT1}i;0JV`U(b>3V_(r}8R~C`yXZj7X&3ROouTSCl(Pw4TAA@q zKs3P7dD{3xuj*<~S3&5r-X}J3+^ee6M^jRtOH=w>UU}7LTTUV2!n4vd^tCX33gL+L zIfh@K*6yI6uj}VRcQ}U`(l1!5!S^{vz=>(uaveM4)eOflEu>&}s7~)(lPePQ5`n4) zDe#NY`H%yxJNHV4PepKR$erfzAoY_RX;DJVM+(yPdm`JdQIt3UhejC-?0#<%2<~0B(5u<6M$?&Iz8A&Z z*fye_97|1~Ejh}fKd1!bd&PS7mnwFnONeVbJf)R1v_KG%$>FR{|di!vz_YUkM=OS7xZ-S z>GW5crC*t-@`FIPu;h7E6zGQreHO@ZMPim6Gz}W!sK?1bjw|{ikmHKJ0_1qBWk8NU z(mBS_w0nRYoqIG6do~V}w+ff;C?J>a#5gPyhn*LPT^xt4h{M7-Y#orJeK!C_6tC^s z<&64yDT(mBsxMR`YAo5KID3#>zCGQ__?YmMB<>f$nshtCEDs4;t12X5t%<~-teca( zs>3CdHJPOZvGveR520%$uta`D*0Z1!-lPj52*;Du<{Me;@*XM7wi)|*Yz(ahilmrt zEA=&rFLF`Dy(O8>IN9#;loH8y^HRU&Io_Oeu78$)j(;xFxV6?LDKu8SJmKz(bkq1 zMMLVXW4Uk->N^!!9u$lMG=%QFi6Z*!On7Q4C^!XGCOo6k4+jGJP}30J>#ctfLCeJ0gkh*9 zXm&lwh1+srUu0i#U#Yyvej*5?kfChU@}I%ZI;uHz;#)ei?6~lp%1qc3o{@^GJvtM1 zmIjrPXm#^fw(M}47u8jO*+l79j7n<^djl^s5ccig_5LkwT}dk_S6G;yx4PI6E|}2} zUL1HopwQp=7x;_(g%>R9kv8L67HN|E(AZfTvA7Oso`p#Xs3S=dn>wr;Ele5?E%0R7 z(?CaAj^6{h97jS*p29pNS@uaFE&pVhBphd0DPIQKYhkN_ba+aZt&PKO0CFYY0`ze! z`JaGtmhPuO(=6=gK(4m!KpQP~H;`-J3qY=vVW3Z0j&jmWH|S^}S6(iB>`eb`n4{$+ z3ql*oU^*;Qd%B(wR(vjerXhdv6c&MB)sVk>59n_ylW%n8uy~l(m~Y-?n`&eJvVkSu zWsjhoTeSmVSIU$z4PASy!yQ4_Gu4gxtKH_3Yu;nnGP_WDVWF~d0B$yD-cmxG{%9J5 zaIZsw=3S+bLS?N5CE}3gZ9!uD|L?-4?-ZG=_cuy%pKuGgA$09DavIbQc*nJZF0d1+ zj>?LlP+#7@rR7EGW$Pgw)t1UTuD+}g{7vht@4X^9wYsCi+c2v0*~u-W-PJl+p@UC!=W(!UyA#4Yzw6b~!Z4AwH4JD@XPw`@S{3m~V+yF0$|2 z(^_8byO$mDGZtlutPWKgd5Rj>7&?Z`+t3q)YivOT(_Po$Gqhs-^B43~k^LvOu`LC1 z3vmt5Beo=e2sG0c-CqO!!NP6>I>o~NEe^XI=yMjfISv!Kap@k3!=411W$B)a!(IW( zT9{1kT^)Gkit-*6haC$PSUM?cT)GqEbf1aCP6ayM(tSP-`wJk+Tasm81NwsX;}<|@ zSh~$|x`%*1Z(&cwVJ`!nWnslQ>_|#D*TOykCZ*40v)1QMsD2lrHVej-U zH|;NmFNPTOJ#2*3TYry98u>kaOJdlkh4cG^~kUexUsBg!iA6 z+ndx^a&J)F+)(%IiXTPCo$z*J&$XuKP2VEEa`kiGTJ25V@pl>{)EGYO9q)E`4$&FR zf;d6B{iwM&fMO7u!$OEqJ4~xvO*xpEV965iIPtBFTvv8_k>McfluX#a`W0`jRzK}~ z9W{M#CjDo{93x*}O7Dj{^6b0G|4&&x?teWK?jh@pxIA{KkFMV0b=*YRbvwL*jG2Pw z=l#O`V%QUO{WjsP@B2>>r_4|E`iV`MPzSsl8w#gjWpi8xo@Dp(oL~3&$~oAd%t`v; zy|tWIryfRow)o)={diiYGw6Vy?sW5ofcZu5JT&y3-g%hjoYz|leudzDLE_CK1`@w7 zZ~1%Gg`yuFt)_vwadXsmpu$^|r85Ch_5RPrGM1*mNsyVI`B;7|+D}V*{W^>u=l1x; zKFr)?0QeF9KgzzI#s~%8Nhn&MsXO4Ux&HuWp-fvYJPUJ>Xf_jPrJIUfYJk6C=KmDb3dVIALU;565}0M=J>3kA&!@~QmNRQ{sMzIw?)%KGXj z!yriTt+in++xcSJpuE~&cH2t-dJNqHbh?Gz8AGCR-!%#y0Cl)S2x*?Qbf4sNk3sKd zDjmHrb5k88rkoQmPOOA8bi9>fIX-ComuJIQgXTxIOl3RTIcBM5r|-^%`&K`P|4Gtai+ z*0Bwe#o#^@Zq9~#95H-k-1u(Eg?mLsbcAPnZlx%7VzI{gq8!lDTw!Si>+3lQ<&gSB z_NNP;6YY~Z*b^9xuoQlq6={5c{91P#FnK^#w-XsvF2qD-;bRR@ALN4=p>;Kcm~nlK zM49xJvR#$+!?k2YinWP6)1Lm8q%i-DR5t(RO22Q8p$^|A+?fXMu`D;6~fr?&bH*=~i+>7Mr$zF+rT zCfv@u8;q<|#xiz+188bi zSR%0t`soJPs>)7eVa^02GO1P)R*gx)h(r3;8Kx-ZNUO%SILj+(l)9I>N9K0geY!y58C4plyKl)Lrvrnlz9tQQT4 zGsmjBIj#M}N}d|%@XM~7*yGpz!CP}YyPb5j(@3CgOak<`QwBSvA;G~_zdE}J?{s!C zJPaLf>g*zvC8JwTYz4q>DFyk7`HNGT{Kb`hvmM=^UD`Ia6#etHUuG%Qt=&c-XQ_S& zv2GPtu|U3WT<}MM{)_))*$h5wY`^?0klQ6ogc_C=G9Bc?7jn(d_~GUerghAkW``5% zFBQg1@&Tn@NA052%LC}MsC9iV4>xm0A^k7Ju<%xxP3Bw3wp%@82{)xaMV@hlyCHl~ zgxgVDa6=TkJ)I|EiLi>5b9gX<9WgO(Pk%?z&||}^QFQxzmTeT>Zcm3%QV7u)(*1o` z!+6ro2C0IvC5&nJYqlSiR#T><9zs5^nCX~O-?1FQVtvvm`R_!@6E7PfA2xJjR3mE6 zfaSyxilnmzGqer)L)j#<`LCyZ_G3TVg!wL!^Z?n{`5;9t&2&g{8IVJTh?G0l2jP&= zj+;!;c0B0l_?|J-EcPao4xrF*47Q(s7>toPpx!bY#g*biWYwYdtD>xX2om2f3Tu?L z(*bMDEP@bcj0^DDUv@MFx}$$YhvAbH_8BEqOY6he zgpo4ghx?pI8xdK+#tXYPLCcWq))8ogcR<^WsOWPd(+}}W+P+1IyP|W)tU~exh|e2J z139g^mn5Cxqq3GIL$CBEn>EL!^bpC8g|cnzgIlfhVt|_#U z=`y2aZ^z!U(x-QFF(SzORq&Y&;g-hm1s^W_QBmHq@FhQg0r$oBo18M->*uc#S2US& zIsZix?YiHW7^Q~rp@#fn-rV1V{kdi*Gcslvrb_HMt6~h(JDp;F!RknsH32#H_i~{B zWo@o^5&`3Z!){|;wcvvARTQz=a5xh_88q(=3YA7IOD8DA^Utli5Tf!)3If9yrWbPn z5s?K|r@pde?^xKL_Z;gmgHr$^reEH2RGL;f_ zm|aL74Q;KTvFtAsmw!A{x06!6#_nw0K*&wZZr?kjGh6ovdJ)c#zSr1=q$5+edsV^@ zcZbg?*I}1`%rDF;uiG3Bc#RMGb(lf^sVoyMOU3_57SFOI-dPsEtvi{m`<1umI1nvc z_wdT|xyHG=xa$0D2vu9Ze>8RcAM~G_q7=U37f`%b2A7j^rf!$F<~z_f6Fmuwn{qHz zni+{P*71GqYnskwr}@`HmjL`stuFg?bE{Rm!6Sa{BSm;{`=PsTld_U1ZG-pL>4V?r zCpn!6I9vB3CN**fkIu+q357jcGxZG|JK8oa_RmM-^eNSASbYVMBU|6*_lWo*B?3^L z4R__j`$4k~tpV0b%CEcME9fwzD;^yZduHnVO0V$mK%qam*xxpMxcBYv@+;>QW5JDn zxTcj_${G^=#U~oVik}u4@@<*K)`sRSi06~#KAJWD2L{)YjRaA2HnF9Y!rQR0d?eYI zT{1Xf(M3m?`{1}`I5Fh$Gx)KyGysuI*C})wf9hkE$Mn@A|px! zE2m2o%B4^cth;u-sl)ME!+s77N~blh^-+B)a-hG^sfrR0(Ez-)A{RWS zvQp5%V5_U}ZM#Vg-bl67nT$ecLDUIdDT+FtQY5XZ9IRjsjEpiD+A0`kjc|h5$dse# zSy5i@ZJ1m>cz{N0bbnf8wpbSp&;@diPxi1TmuWi@=41Uf?zdQa3Z?1Ej=1;U)Pcd< zE$M`xax5y{AT?BQg(FF*%6u0pRaN<2vS})|+Mro@(gjJFF?D$8FW%Ax5{;=1rW-pd zuKDTW_`uLfky>Sx2KYUhusa);bXg-2C+?;%^y5UX3Zr|0SK@LQ7}`IvtKQqN!)}Us z8@AdvYpVK!9xdc|^w&VDpPK^UOrYo4aua3$4CI_d$Oyzi7X!K5Y^&n1?*UzCd)OCP z0dCdGgw{cwF{D*|v(@nwkW(_e1oSr+_GTO=#lt>p!3;iMFi57cFBw$N=PL%uFyuvp z0zO|hD97g?44TL1euK{9bJ(CJK3_GcxRo8fN<-838ie5nDi4~wBii7H*S9LFAu&*V z(%VqpK~nxF@qZ-Z@^_01sA4~^>KPa5ZSa-&-En-zyQ>_Z0G6q1@5Hb4OY*#NcIt!e z`v(*EcfFR>)yd-$&XvF+J`0xR*?|@$O4(MO`qutI%b?_kgj>4?k4xO|yJ!+l8e0w_ zN2+p;z*g~}tn*N+997>zTjr8Xa&`Kxd&&>ifme2^?)P<;y5Hm7HA$VT1k*3>H!zj< z_|cI|S49EI)+fDE*d)TZ^GNKGKz!LCmIgQ)SW@^EngzZSrJ6=h#Q1b$XN#3sURw4R z!-`ddoK&Ke=E1=I9WCsp0c!m061|fRkysEb0 z$ya(^Ia<^ zZd4_rqNyGNj`DIwQd3ey{NMN!$L?n4BS3R(TOUIQSorZLbb&2!5-*n%BJcyP?HxSEkCm_B#x!1o{Vqs>)YQ zddtQbo;$hiwTUZ^eoMsQHml`COR(N@+2R8_$J@aUb@S)TL*#1&a@c z;kA4I#@y)UJU7v2AqOshIS3C^0(aqlQZ6+d1#A&pY!}v*d{QR$1`z<2@O{9( z&q^Vh<@dO1ldjsn!DA_sp4-9M$q}g-A@avMRV!kZ`Mo0oY!p9VdC{A?E0PtyCGx98 z?t8n)i;3KOut<76eW!-wMQYpyW4|`fWa78xAs8el_RNLeZ11k5SZZ&HU)O!b@o+-D z-iB>Ux}Hcbnb^;-%@GKr)DwYAX6LQj#cq|}(AKGuzH?AFcjGRTSWK$%tOx1o+eKPW z4;I!W-*1wvO{vAU9qD~34 zt|qns9khG@F*H|LL>CR|OIVb!>D*D*y=oeWlSyA3ZZ({#OkFV%TyZ#(bf{Sop=L#* zlkwVRat}#zOx}vzj%5woS?@36C?|Ja-!R5*K9FPfE&{sL!Y+-&M4sH1Br&*yb^8r0uKsdUyX58+Xs@&SjrtM$by; z_{CNKWq-~uB#TxIU@o1(X4L76_{>TBLjD>)(aebymobv_7WC8ut)?T%vhM?3Vvsd> zaX1V8_9HX>l(+gTj8ZtOawZ4f)#n4ZT{(Fim87u63kE3x+eM7bFkg^@VY!KdtWD!P zL`+bHn-wPpGPO>C&7vu|+J?)Qd4@hzuL&`5Vda7pE>1DrF2{eIof6%(UubptDp3&KQ^1+byA%1GW|3<~-_}B_3HWa)3j-=>Ba_G^~o6pFw%B$NdL+zPB4&4_6EwLFB`}S3X zwA7vC?@%Vn$u(ql<{-(|T{?M)z1qrK2jt4LdAGgPuvGSKZu8WJEll;=p9B)NGP(0& zY^@$Yx#8(4WO&~C(-FxGW686&gKS`>vAsbdz%!2Qbi56puV~-dGI2?t&#|TB^W{VH zT3;((b~;RU5ekP}o3T5e2_!l@{37EvLIEYT=`K|yWa>Is zd?%jV@XX1q5vJBAFJI?Y1@kLIiF&8EbHbu8(R{a-hk)EriY0MF$z3NY<(w6naU##4 zo%7nKA6^>2;|UIi{2E$nL%l8@=1l&JsJFgYKJR=tDW3Gc( zMvIbTv5Z+>vQ+FDkf?nw!RUx=xTq3q*{m8Ba;ay1zv1DkWkKO|sM9&AF`7Td;XqLM zLKTX>pwM7WnQT{{Gz$g4|2jw||3y&F)1Kw`8!?hinuWgKe{)p)%dSSOEf!T$D^k$@ z6@R-CzLl#1Ut`gOC zMC|_0SV)Y)`cqSA@Wi)5&Cb?X;*%FM4os`>=w9EeFRoYP*CuMdZxFVb| zD~YtA#Hp!lU6;33_PXKb{kt-SQ_7aC^9#ou?-!ECt?pbtjmsir+ZlG(ZuS#hF0)@` zBVBk5o>3NFcpu}m@RIweZsD@~Du)j9!=0ob@auN1{Mf05(UD}E!_QvzS6t(dC6`W$~G=EDlP*upP!IkveR+bqX6mt$Khm)OMYi!x2BNMp*WtCEhpC zy)E$;_b>6j2o1a6xkH+C?y&r%^md=^^=|zquXksWeoi{qEQsf*=aW1mpr~-xo)E2+ z!ZD-fKRhSp7bQW}o?rRlMgtQ&$2{p3F~Lg+=(7P+(Tq)OT4F-n_} zRXd7l6d`WdNXlFEh6biI;o~youwXYHTJTu*l+53yfsgt@e-A3XzOD; z=`JlDUy_zGG>P7tU%oN2(t@_V@uuLd9(+|+f-9V+cd2l!l}tIbW#XQsHPZ$N(d}V* zuDX(KtTHGxRxDWuV|AqOePZCMi7kis`O;mK4f$Ml-g;>rQL|*&wg`%B?)c!IIAT}L zf;g9cOC@m{bXvHDgb@Me)CxFZx1(d+WjlH|v|Ieso)zC^SNFq3lOqPXbkQu7fdN)qLr5JTd~Tq(x>P7?!X?C(#g(y_lkGDz&3 zc4V3D)}w{i@gtbN)0EZljIN&?Q)FLA3AN!v(WS)jbdD>hvl9*1-M1<$#Wd#J`(=*;%x}-H6d~DY9>nVl!gyU-jB$r{a32CGME}j{q5Sx-dQO=jCh>#-i3epdL3l zJ$~b(X6yS4sTqu4t9#s?;JmqyTbpHf7VgW;oLlLw{Ra}oyGA%yX997i-%{{85Nivo zIThT9B<#BKTw(HchzG8#NIbx?XhNbVvF*ykj5QcK1RL79+gI$3Rajm$~Db& zGzh)$f(WHU`ul0nIWnuTUTM4+YrLBzlhAnAU(nM`KOEL+;2chBSR-uGc#~4t#CZR` zjj|+>|H~j@(|3Vbe1}jD-xqY5`3M1~-PJf>6j@BXfbZ9R%#4jVRFdC|UKlw)z_D{r zfkVDCr@$sG+&A-FCO~`+<$c6eQ1x+rmv-@y`4}K{$vQR@`B$!a440X11euPtI#OYP z&A2(CA`F_`U(Od>qi=p+(B;x3*IJVEos4eLK~tJZ-}zW@MS`zInD1IJG@4m&&52BCvAd1|So5BDFt=tT zpb5Un$(s<1TwvyT|L|_DrBfIkXFwxcAvfP^fE+ct9>~diG?@+uG}R6V3||LHVh^K? zqB0|g>>Wh9b-39e;l~$}btpGb>lz#<4lPy0kUot>j4 zLd!IawmKH{oJJ?yXmtX)k&)8CjY0-q&?NY0o}+cLSnI?L!MOF{wV%xhx)M` z2dTsOjyPGWibk_*ZMesLMYFF@-^tedO)P()UY#&KoK$8Uv$o|-f5s(i%Ug2U84K4| zv}Ch0&RUyj`7B$tIAHi4zvGnaU`xc!i&M&WTymYXwj;kUysl!*?-kc2sIAydO$b82 z$Gl|f=+c@i!DsCP^*Lw}J1I>UW1#*7;Suq!96rEJ6z+gWW~Vkk+BX8plP*}aphp{o zo1F6)RyR3c2Xd1mI%Ja*ZyDjEM#Llsbn|k7L7ErM)!QKJsCg+-HKR?Eo{PCd6*38<(d2uYgz4oH$)MzZ>IJB?)BZo19|a+F7N;U;b+(8$Dbqe%CsMjSCzhhMFl>o@ z6eK~b*DZP&YB!uA-1(p2&yvSbJ;=@Hy6vMccSH- zd_`kJ^EONv{*vUFFg#p*(lnhzfBv&70>ZALk8i9782aGGDf)Wf#>M)2_r_LzRhl?t z=n%0dWtM@ZglCiWBkEMY?X~2}YF}E__nAI*vguO~bG01ibg5klu1begSN*<6{wxJtV}EP&~7o0t}NuS;$WmWZ4EfBaAM)2Va60rXQ2A{yETSx19J7=9z%D;v3JIhcr=&po;a*ChBn2q{XjprI^e^veb!D0C06_cAPaV? zNF~~j6xdJ+AK88wpctfi5SJ6p3o^h}DTJlm5s{FMGf*$TI0Iik0sdmYS93tN;qrG( zRHqywH_hT>(kx^$98Pq&8_>y6r_QE6J*mSp1+T%P9FTPNv`XUT=2U)?=c^opGs49r!C)){x*TrIK8U7HuH$n{OO=<2W<*_F$GSo_)XO#U*~ zD80?kt{i%+ir&tUrV6YV<0eCS=9e?05N1J-I1Hy1{I%Kuh9t|L2Xb1$;}~UkE;<>= zt)zbeaw};UkfW&51zuvxk@o_Xlq2Uvm&G?yp5s?u$ii!cui0^N@}Z@@ae_hG8^!jS zuI$(`N}X#rsR-Q*UF39TnhcHPtisfa#P4(b(g^C>tF#P$;<>grt5&@?6K)<|j1B!@ zfzyL+zs}4*=8P6=6<~@Dr?}KoG6e|1-KpJ_X~|_rOLz6wA;wDjkd|qF+krz{-tE`z zZ<)t1R37&5=|mNYXqdFV9RR<}&alHM{Mk*#|kal~v5 zOWDxW4EQxIYCWi2lSLzjxD2q`%nwOOI_IFKq~0^ht!r>!dwLJi+C}X~Zvt7R0zhbe zWoDiUzxPc9?JRCP?bu$y4?FU3Js|HcbNRJYJFE*Zw~&o^vpztw=+|!6br>NLp`YQa zEL(d3CN-C-eVSwHr=TP4=~jY82^e!t%Vy%wg2Vd+-}AVJiLay;=}d<88Z23d=83bg z1gZbbxY>DEGTdBq=d5t*x5Lf$G{Zi9L$NmOLb?7R=4oBeP1%VOV8af=P;6}Iv0wM{ zYnT+hJJCqwXp^^L4^9N?cRt6RxB3V6@R_M)6YR@$xLY3<6l7|VNp8w?+>?HS_CBzu zc3-CB*7TFW^&PjTf5Ue)jI;8|Z^Q0G-X4|MO*YmAv}_Bupuq47H>tCBHWY8vOR9&U zkbYuI&EWTZjij%9XpVzBM6mLEqB8q$Rpn- z1FoPBlHt(W{*j_7_Rt|+>Q`&B5-j{!Jwj%JUH*Vq_yNDN*yFp~jEK{v2IL&cg+)pB z<5u8I-Zi^#r0l5KZ$z2KW_YvI?6+ok69KU5nA&Mt5$-AHZa6Tm(FejaE7h*TtfIB^ z2HGi^XVgAudMEX%1#u%QZ*Xl?+_*+2Z#ZZh>9vOTAQ>_@xTA;8fTM?@Vq7yTXeKxT z9vBj|(Ms3il~;odnr8e2&fg9i@b#df!c?p&L4|PzG50p|adllb_v2DA;bT)_&7QmA zEfX$R1-^F|JJ4MZXV^qIYpnFxf@GU9kFyA9=B%9hk z3vjetf?H8>wx$tk-{TYVZQEIzfZWcaE$}-Q_Psbv0%OPV_XD|I=`o;!rF%L~C!aCv zENlsoEAL7mx3|fG)gFtz3+Q^2XFLq_V}qUp`jJ8JVwbzcpkpA{uC^fDl*r78uOWP-Aso(yuW`x8Yo7*9bVtLF8l>&-7@(l-WFR@tMaw-U zyflS(koMQ1)Vcgp?krwfiT@(Z3J7Ss@}Rtu-?nnRv5DLHlN zO@f43kn=r&Mz{w6B90I#8&|A4vYhLWUz6^1DXzDvlJUvn%RP9%xvBhn;0xz+WCFdb z&K1AdeR&lz=T_#?l%OuDbgw*IBdYmp_%UcE(L6lUb2%yu-l|xLpMXi%Kn$v`s1#Mb z&p1np)0324N`x41;fo~FLvvG47uo2m>uRCmsi!NXmmd?f-FSnN(Mm}^x5}79pu@tg zUe%}B-y3hqh1px=@5^{$@A&LG8y{-3v|exTKZ#d_r`zZCzM_lOQ=iV{TUzmplF9!? zJBu0SZiIgf8*fE?s6kquZ(P%t)wzL7FHfyn7-nyzRcEEo68q<^Kl?@m9Q*MqMj-oN zWAiJRnS1M5mMhzF&k-cfUpM-Ckwn{wRwJ2sL*lW9#48PL&zHA69fare^bGY$#0<+) z)!3m%;(pVcdS=QdWfUL7aLdm`0X`CNS^ARcJDCw~f3nH140^Nm<$4-MZ^Be@uj7PH zzCS<@Sh&!vrX81aGpz@wnk;PG7}N|5y;pN{HhVCBQWszvx3$Fc!#3keR7JR~_g(%j z%gU@xnv;z3Rgw?kK`9@zxp1E!wg@RWMsPqFzMOZ5hE+$l(gOA=U|;LX=AwURxp;+i z%dvhqcQS(&DpWcCt-nG2!+9*26ZfNKQz(-0M;j8yN$L}jz-fWK_3~0W z6=TmDw>T1A-g+va$cON?lgP53IcA9*YQgD7-Wz;}D;I|xo~G^yxK=x_A-vz5{x*j9 z=>Ss?k2JL;r_6;ffoIwFr&^}^bkLtUXL8F2LY^fAN04NLNuBUYhRX85QZw{TGZI6v zd37dy0)7f(-I9mGY`79)ejmP*BL9upLZ-`>9gzw9^oFDr67I_CR|x@g&Dh)Jnkl#; z@nSAq88jyLnRfRlaxsIi9R?$(%^|?5YzBaHJrE=qDqe{~`iAO`G;S1De}b87U0Dy7 zIjW=WK_qDzOgBjFxLCOs5JRtX&pdr!yGg`UPChPJaDLBKjNjiGwQdJ;wETNOe{W$o z$6-20yHm`|K<*yvc~Ee7in$)>QvQ==_wwmHtNt)i${|^R%lmD}r^|60&<4vPR@_1N z0^Mn0yMgX9NM6m|-hlhUZ2t7>Y<_mh3fo+1u{pHT%Grfe4#xqOga~Eg@at>);EPWJ zU1ns%CqhPhQ0!XAF_hYnUyx$w=f0juG#(EJ!e{*2K{+j~wM)2*g=Nq$6{JH%Aez$9 zwo=t3lXKwAwbZn}_5q;e=D|i5B;tYJP#~L!R4%(5s6A;rV7#D2W?l`Y_w4iw*Ob%B z9Mzp-_yRDG(_LNBE9A+;X;zMyr#`LvGg^LqBR=r(Dh0karV`sBrn%-98WSy4{YLq! znL+a_e&LdI@wCDzpBmBh<-%SrFT*-mO+n&7(Dqz;%OL!WPQLS07k)UXd&LhjAW}c| zXNagLA`sUz4FnQX0eBL&BqxA~HFFA;pW@0BxTJ{~;M6c3?50+Au z(on*u6@%ZxQq)M-!2XO}kl|Yc)A8bcHlfG~R6R>P!+QLvU%a=tx$Suz*SfYslQdI) z?Iz88q4L_ct_eejv~?Yt*jj22lwd}-?rE>^=V;7zkY6mx0P=!Mblv&p66e%PE$$vV za<)DEaJXAZC!MDAG$4n?{{Xbk@N{bo{Vs+K;r^AMpl(C{^winr{SD1S6Bt+pDjiOx zw@^V44mRX3+m#8Q`K9nz?lo(Ng^po2gOetx%&+ar416ZOYt0(EtiWVouN+nAaNxPfMs^25{h3d=wVz9`CZ^h)socQNKF<_o8rVSU?d^r zH|-bi0|#obQ1y$OBq&l&dYa}o@iBhlUca~lEa~DLtuwt}+gCW{+iiUlhEi>Pha##? z+zTR2W1LT@>k={b3eQBBgX^7QLU>=gwi~o4m1s~MtYCic28eUk57%Y~0*YWJay(xPXM?Aq_;l!KKI zWQrbk;+9o&&AdG5*ZxX4!fCsNBp8>m8rIP)_$MgJHj%@Slu)+nf zhuCO-;ux3dXGKx0S|XC`1&I_AE(eFP^ETB)}}3ArRaHo}QMhZ9r;PGk!wUFWy; zP8gcN=b@RzzCVT+vTVS{!7U6>VxA)eXs>Ri9ygtvV(5t&dNqdRjMJr)(TIaS6+=2Y zxiGMReVoZ*4Qsk_*X&$IhOmrN3Aa(D2|>??D141k8JB|Y+7=ivr(>N;nvaEB)3=a8 z9^AtF!$-5yxxA67-I}R=69z4lcP@!;GM@r{nd#k`+U}cBTnJsJZ>`-*nQ6bSf8~Xl z!qmgVm!MF$Q5xoT>|lTJ!#6XvFZi{?kT#Q}F=GuOPxzeiEdMWQt|C-%wMaU|UZQ17 z2JehpP4v2dm;D$X`UdEt`I}RiS|(~Z6xBvetOF{mebs8gdq7;#5EZ=))rm-zXnO}m zki;r;5@D-KC1+|K&0NiG=`)7?uHtci+wTsr&lT~9`0_PNMP=&f`N}#^#^IT8|LWrM zgr9hR1igilrCxzi#a=MY_kuV5!~u#}b?;CuS&(ZyPXGt`1Q(J@D}$`1c3OR_9%Mde zlzj7~mLopc>h@p4cA=f?xQlOj>+tLLdWC=DhfdBN zf2+{CZ{msI2A~m71bKd$sZOr&E-D1()Z{M6-DvmY@J?{8A{r7~icfIVu~cD?dny!G z%1%QYdb)>t zOKi4K8gF~jo(!GS%uZ_>Au^)HUoKdH z+e=x2&i{Zgtc2)aW!Qm{;9F?dt7s(DG?oUvw=z6qzgL` z>%qE-cfp*DV~xACh%{j-`%S&}oAY}#+VAA=A`&?hfNO!?;5?EjTMOh2Kz;#~G@87E}@e815t)<(6T;2zP+_lVoak@$L+U3xLEe<*}hIH@T z<^2wj>)ZE$Tz~%#$n{c2CobKmK_3SV1HEZu`UcPegQT!68k7X8AXlPHPpKhI0jdNl zH>e6IVUYBjNrR>U9b%A#=!Y64zMwh_8);l++E{^VGYCAILLIZ=oMuU)j$i~_bzUa5 zRaZ-_@d82J0!GO;kT1Er}wL- zBF3D$FPnIpqg*T5j6Z>cSst2Sx`Oyb@h3~+109Urfna<#-WO|5hgGjR^A5X}5I@|~BYPw#Y1tSkvePE=D62C1NH zusT47Qcqpn4X>)#>7yy-RZT+$gm#W!+|J%Ejf)wJI{(L1bP|b!Dymnx+QIETEW001 zzG>RC?VT({_NFH@jgo}RPGzD;b6$v~^el=!)Xt))Vo^+CQB<>JFWbioxWF87|BT%! zS#|+w&bGa=4M@+ECCemzl>k0jRtpph%Vp5kNh04n{<6JepZmFuU?>U=cbb7m4=QG#x5e`uCX6f%N$$ejq&}$ep2l$w2b74I8AdqsyokPAHhb!HTTg9R2eAA z1RbONi?9I7%sf4{>YOF(rgvrw=anNZJ;mAOhi9g^o2)Bw+&A@Ww-mSd(#S!H9!~Tp z26D})!Y1n03KvW_RHiyAPps=(f%776t(=}(@o!mN7nMvER@@ld*J)RrVaEC5Le+fp z1?o)VPG(S@TIqBkXA*Z_9JUn5Q6o`LXFwog?go0?@IFlvH@uG-q~YCZ(0^-qMXRU9 zV?4u+alMFtV6=lPRN+1b8t1U1G}TvEPJa#!G6w(4XKE@KzK2TcMSGP66QcXDOuHnialn&1gqO7CcAoc<|k}jLX z5u#u|1GI$-X?Y%1Hy`xosvFlY7^HCxfFua2=bJ4OcRcN%ROIkP4@W`(uL1Y~*a0G% zPO*sH!+F(cGW2-Z6kZG4+nB$24>IaqA|cNVw=YWePx-vc$8XFw|B+Q2E~fUAqiH~L0XsSRQq0}d(`xiQSJMCL1~wFQdUk@NT=?5DJ^`vurJbXMLZmx`p`E`2 ziO8^bUY9GK&?D4-$yee)4%$2rhQo@f{Spy17A{OzAWJ#4DAOtljGUy1Az0$)&q^MM z+f7fd8@!2=P#ofDRrSMoX-H5@W1+r^Ms~Gr zPG}4}aush{{IhNn5Kmg*0Sjc?7TS~o5lu$}O_j9o9|q;GF%BFz(p-Irqtw3bq@{fa z8*GB#W`s4E?|g)9bT!Nx*l2uJ_RDUN!_COzaNvaK&A0J?>!@cC5U=?f`~2Xsf23<; z`lTnlO8sgqd>I4m=QMbk^f;U$ESDD6s89Q11X0>bPPZ03s;ib9YpHSgMDKWM=fZRq zz(b9NuL+rw)|rFK>P$>`=#p9avuZ}8mbYfU`gk%;kNe`}IB!KS!Zm$IxNeR{ugJ#T zP(}Ea9D`r9-B3xl;;ZV%;g>_Yarots?&Y^bIvN7feRojzGU8SX>EgG>#;@=5NXgVh zbaQS@H(4448;NrC=<|+V`l6SI%iD%)!$Iifq{$VKAtYSUN}xr*9MoAX4spx$;Ejrw zYB%X=gH|c^`=PDQN_G>iPF7|JCg}_*q{zH)YxUlBz~MV1Av=-l7y9T-vWPcvYpsb%o9kzdkv{ z2yU}f@XtE#W#2l#?lGRXt$SnH=XgDYx8rngi7+qI6YdK8qMvVg8Qx%gj7Qe%-iS-=8@el7_pG;8S4)Csj66zLn7F@m2#9l#`x1B~nC#xVxmp{0l$ zFFShJ>A|rU(mHecKsjxxWJHC8VMoxc!=%etJhe)%Or1KJHslhoQ}f<bWbC6qT=_B|lS@BIgm6Xo^+brPE>6F2BM z#MgkF@bXY*)(I~s0XgC2dx4zDas`mf@mD}DhwNTlj(-DkIerG@a(oJk=W@t(vJ=ee zZAT~6T?OPssyehf=pSQTVbnTIX{sPDyo-U8m{Y?yQ26C?0hJc*?-2ouS_n!!J z?&`<@xq7byYPXWt0lAWI0&20ae~H8H1nOcm6J;BLx(&JqsK=mApiKsC0@`d)KTxkh z_X719Gyv3Z(64~D7_Fy$(ietTh&u2;RrsgX^&X{r=P%JBUuH8%o9v-j$ zql<5Uo&_c$ayZ}i0Norzjyxs2(zbyv`?<6#d>D^zd)?lFU$;H%2e@{_w(QEuG9TP# zjm3Z2sJ(&k|H0lc^XpY!;YiiqECVw~B6Yd-|D(;}AR7bw*QzD9X*eT~|97^DgKUf? z$2ueKXq-`F$?=XZDRzPgqpT5y1k&G0^5<~oA7ZEz$dQcufgH)$4dfQKBu_5KQOu5m zqy3SAV)HEiNlp#Uoss*zbF?9d%2Hjl7yd-#7Po< zWRN5YQuaA1yL(57JE(_w-=9$h$2_qq^K^&y7V;QN zveF)?eaMm^W39agc+RLsa|kh@*s^vdJ>hiNH*tD14}KH_oL5ZmR@RR$>pJC z5lX2&Von@EaeW%;%OYaktdBgcx{I)7jAgRy2_T0Fk}kXJL1G2nmevB~(tQiar3+)| zHlXpYH!y-7?Y2@+j|zX}8^CKnjY)I(qv>-Fg2YX{%{84^fck-POw?^O8i&2-J2@&h zt}=D|S`M$fxYBEvc`moiFjqhvypMFc0j-hJg`QjNJGyj*462pi+}@V$(o*kSE@m;q zi?epi8&UW?AgtPshg}822kh}YUV*mgV>`^DwD&P?W_;|`)x|51-v3{0A59p5oV!Ku zhCR%iVLON3oq+M~T?LoiTib`wTb3!Sw_G`SKl(rJjh}1pk&$OX=g^UO^r+jsYGSy# zR*rA>p|P{ovV_Mme@%+r*pp|x^LN>dW4LaStfAhpAEV&`^}?{vAr9xu{cMKQ&GQ%X z{PnuIZTB?jQ$o65%qq|ru17m~ey>g|8V7Q9=0QZ9k$gqzdvs-37^Q6(W_`V$C!5N% zv3uDZvAO+I_qW|kn_S{XeYIi-EcG7Bl6kOjPlVE8Ya}S;N(h6?Cxgu=(;%9u#VN#g z^T%CoH-);+&GU$G(=j6S1SEA5=`W~!kSbZ$4CExzSH@u%fgf%)l^ zSdM}#ldq3o(OvA60I%AkT`zj=BD4;Z=NVgEJA~kb1j(eqa$k&?6AwN5n$7M47>Hkb?qrr7^GH(23*XqVU8IQlto_~s_ z|8b=l8@I+^iWBzl`nR71y(GMM=4F+uzBGM{v|?wiWBgeiStg^MW{B1#Li2d1+h%<@ zS>!5P!7t}hb!BaD5#C>6T+qdCjsZ`WcO*ZS;o-6VV%Jbbu}g}ve<}9XT~@i`uVb~& z=y5jX&i`PrTWF#qNZ$c+3!n%Tk)hHl3cC_L>W$J@MDdps_(0j7sWV=8u^IS6q#K=> z1rm>AKQ0UICVP!^+elO78=d`a8bZhFjbD}=pFOUA|MSMybiG!ghi`b*hrHbq(V(vF zG)1gqO=Q;L$noaUN^H|#pGaez{(3c#Q>?}Y0!wN6@+s~ya2doDF1n3QOaoW26zIny zW+NMG{cWQ)*x7w-!MS|)4s1hfUXPp!HOPATNfElfUMZX#ioLUEB&W6PH|Ow;t-Qoc z(~p#@n{DhQ1eX8NN^7{g+RF3a(sKu)ZuJvzi+6nEI!Aw2AUcp_e0#|l1!6CJ>)U$o|iPfB@T@wB6aIX1zY(k>rQaAugPQ-#8 zdlf=o`e&u;)R}l*cKUO0go_!EGQKZFasY3ML|k?RXuqfS@x4&>%=0EC*gj6Ll8yG- zwPXl?(LriQbsCzt+pOU$nPR39UN+LhaDWc7<5O%Eoa*se!Rp%ajRXAJV=1X;M%#hU zwMTxk56Jx@lIJ=}s=0<$e9E?kRqvPtd~dW0)1DZm%L!2`a!r7r*y3aC)z{ zXWgqZ{gP4V`k`%dBw={Dd=`D^MrniEam9=L$aPbVSoFf#t(rk%Fr(q~!t^pe&x(u* z7BYy@^i#nMmc1&f!9CsgxD?vY|`qc039{h7HmFCv)lp0+y5z|{^0N(UIkle~7F^xCf0^}~q6Hd34bTX0}cZ* zbe|6|(GVWsg1k=MIM*&*lk6IXyxPV0?f<#qYFa2I>aTOQYFXA-*_6MwKv zv3EjFWAA^uhg;7@ApB;9+kj8PQ;!^FMV|ECkd;nGLz6Tloup)V+=Uc#qSd&sWcwj% zB^-uSO~ck^1_o&LW^cpC)qBhotz>(q_h@^jGd<2Ue-7I|j({pdSHpw6Pt?aXNnmsVSeo7V(i)A-c4@K8e$LZ)n*UylojEm!V z8n6KdVS#%iw8Uj*Y#=yQruB1l**uE;Q+Z_GH%<0{W+95F!7EZNhi2;LR4#j;wj?{M zKLmlORuf8Ao3f2qEa95uX*kTx5_c10l`Lxnsx`Z)ra0_EpdVPQj0gY5pljpUH8G@f zhD-P3IGxTQ%WU?<*Drg&25;3-V&hkNI9DoLbvW!x*{Z}H+;|aAX zOT1N#Vls^ctT})*>V*-`Oy{<(NK?kVwkvDOR-Gnv#_r5wKBI@%M&|1&e(T&^>pd0m4$(?(fFc(1Y+Q8W{^OjWaC>?=n>ido2McNp6R=daowWWUIuVgk`k`(; zqRwy|oTk_nZsf?;RDQR2dhK6SNpv+(q_g$W7TrW&-N7y3o_>%kz!oP4f_!!{|MPMM z9)Dr?sMqetYAaI~HigD@3e5!hvoGQwkHs27qN-K6Srg66BokhSzVlU-Q5gv=I_Zjh z2T;*H=~nx3HDd5Sj*YtXv5A|~$8#bNaT<0n2GhQ-QaTIh1}>_#{T@#kI)PmzuLGDk zy8=xbX``LfbH)?_ z#5i_D6TutSoy%}<;2M*m`g$Q2_pm{%h{8AxAD(A18XP)=uWSdH$kqkMx~j#bG#TQF z{~=~}mEV^wQ)?Z;Us@vg$O42wy3UC&((~=9X-CjcBJtryl!b}&3=_Wwz* z1~qQDQ<~-7RmmH~T|CD-vGh2vJ#8j4r%p<6arO-H!QzXG=kekv?D1k!yz)rLX`>$W zam7>&{+6j4Rh`=UC#sBJByM}+ICe&N>8x}uQBAX|O|=QT?)4 zh7T5Rg^xT@yrk_3Z=?~fj0$xkQf~Jqsg!vqLelX zN+4?XP3zy$pLRRP(CNVQeWNxbMz9jQ|Iosg139)(wA4LL`~#p1jqdy{kkdln2IMsR zJwQ*egcD`=f;;XJYq=ntW=Wh(UmCxTAbQ_<04Z5Arrwr0Vl}{Tauc^N?NUl@{ z4Z4TVXAJ7(bI2fLGh=3=I`lbtJ>sqRvBeyQs-xzJ-b>1a3!pyx@Zmd=J3-^k9|9>! zF_PEV)@w{J=rNk3E|h3XP?)E~U5UVy$dA2&z!{5|a)QFg83r8heLh(d>QEoHq@SUf zhUT7djpPm(jcy+yK{4{{GUB9JdJ{c)IDy=T!CjVaBThQ)4GZj>#dhCnw`fe{VHqk0 zpBP1~4px|K+}~1|0v$1MrHs(DhPLkUIg$}UJSd&J3x}|J`@BTlKy|1H9kCi*?EQO} zxYyE4kt6R&S>lRUy2@K{Fx9Dy$w7G_WpoeGSh(q>Q@+Z#0QNo!(juOrWa#ZijK#sy)2K2De#8p7QF-Vm-s&@y_Z&{Uz zGVxPYMjfYvz4u$XDq^0t*vWkU&Y&rL4jOa}pU)ap&F5Z&(tJK+Pz|3$22JJjIfKOR z|K1=yDgC@b_;fk@+=jx%9h^+0G8%I-f$5cxDHayS@OyPA*{u^vV>r;z`~ptxqZir3 zZOB+7AvDxyLcoiRCudT{mQ>L8>LD%94t)p-MwE7Rytn#R`fq9WHp)m}FH<)ZDo^Bq zH!a9F&d3$!RPxQ~!P(UWS38D0f0&(qUW8!6 z&rj={V=OORw^|;BT)lHyVp5H|9H;{#!1b#3Fc^2RAh@Q$FU^Vj7H*_%4DHx5;W zXA8bDxG|UL^fqK~%&{vmVrSo^!qkYNiW7as!bWQ$*U#e?W@(|TU`z{-h*~JC zyt1K+5Z63oo2sKkJ8^cVwX>|@hfqgY5u=Ww2fH(}%w2{e|3W6ttw}q#x`SyDPVTqU zYTGGQWy>ZQ7$&PYx7uE!qskTJ%Alj<>A?R0EDOQR$QWs8k;6=CHN-6;?MTfW72ji- z!}}~>zr)#Z*U*Q@wd8J<&7r!#baN!1oS@^Za7Ui-gk3@YxDt9FC^sZdk!et;y0!xj zt1(h58+_UVl9od1l)(r2I0y&hxl`8Q21Orq!M0@Gg62hpLPHUUIU4VJyB-ICdcpN4 ze;7-zK0ha=6Lo%$mY1acQDcYZ2hOXCiBq8m?+c1OCuiPUY&juld;O4>=YqnVDrqX_ za-mhC32y8$pmPxyY-Lz0J)R-93XcxzYxgPaSf1C@Dwqh zu9O>rj3a{(k9EU0GeW9KLtA7!hQ+# zehb?I?>@z6BA`xErh)o)5T{n4X zdxPUAj*`*FNM>FUR)`(+)WQLP0(+2%3gS3525wl+{!E$wY6?ZrvnZAX3 z1AH7$N(A}StJ;baS6&jHh(AB49KSF8Y6_!syGxDBT@3$ASZ*(094{M<2(9eCvf-1A zHV{Wm%U?Y?YVgoUEjCJNk!CzSbVLY|HLSGXCFgWHNCYPPSr{KE=*I)rj|D(!8_d-} ze`e5M0e#G%p8&Z*msD{I7s=&d(nRU9+Az<<2%#E~EOMKb#U;fk?mVAC?!?Y&V~Sag z5y=z?D+l`>l!>9JXePgDn#QBv5e%*n;^cnSvD3HUldF{kVOL}k;OCQTVFns_`t;@S z;>zi-cD<}jqP{v0RmM>Z5rt;n1_??B6Y zybVEd#%bj(M|c}jGft~Oz4~L!^i(QIg$fd!q|EeTl)l;?dum&IYWugX=Z~kgh}Iqx0wkbv z^@7?eSgRRFEout{m3hCvy`On9372yIm-qAfk<5Db{j&Djd#}ANnhTDuePA6P-^6JJ z1tCV$qAr3rJDkzOVrht#XM7c&7jw}(U)VcSoKJ?Hhw!H~1r=OLW!-WvOi{ZSnqWS{ zEe*vo-0ilbh#Kql7ulHfFq_VOI+FgHC(mNeNQk$19;(!J3ijS8X2zg@aOfEa z85OLdreWgz>Y-!IW3e6$iqKLxUVR=dm8X!D#?Q&{CzRBklf`gFJg*Rknvm7G{v z4t+YP&Gre(@CG6LsM$h5RK^kl-t9hDyWaF9{7^}HQpkOtb?9zP-wK7WyNzY`nk4S@ z5QycDOy7zyw(PFXJE?n8mB@D_bIG;clPXoFUT?kBVy@#SyQmtt07YxtOEYj`lSV_TlVm6m23qeg@uv)=d&AQPl5pvB z23q4o+GUoxpy`43-OWh%=&=Uh9Ir?HtLa|a&d9YR-gkgb~o z$PAJYTL(A`92`&f^Tlqjf!?Plm3t(NXVg~eV*+_e#cII~DBR4eGD0605^fRx5+KXz z*8R?Mx>G@&rPIwEX zL~lT>hV~u`i?|n+x!)QUfw6bTclloR>tFrq?C_qfyP-3CN^nE{Cj5$MO$O3aLs)7x z`3!-xXc*4KLIw-7%h|_e=Q{anFu1yNZz+}&-Oa1MblGK>?fI)GAXC2qO#~VL3FQ8h z%X>G%T!tylt}VXGI37ED7XDj!mA)hC>FkUfa<02^(NfbWznF0S7N>m^X{?W35~in@ zS-bN(%|_g&5dD>=w8#*Wr8@P+xP{y&!!CaVc!+-;{M*dG9sHBnsIaFFW=P8e`tzXv ztkR#y^`}RFp3D8aN^k=XBe2DmVNlP>0Ax2MYc0o(4vDL`N8a$nAh6<4) z?_H1@O?b?3n9N{l=rIksA1^}+c%{yi#FVyNVni`Uw>$&~s1py}{2XORe020aE2e>{#%Kgu2F7)mIG;V$h@i#j z=#Jcc3JtbYd4=9bY2N&q8b(JS?k_U>Ol};hLoEoVs*09}5eYHC4wXgT(a~oH*3$Af z1*)o+*Yszz{&eWi{TOS#R_i#ArIKhc|CkUd?D7b*;==<)hDNbGxtUp+A&CodZ^p{8 z#N}niy+IO35lV|ON)jJRXg4s^BMDnGhM7h8nd%r}&@6<7T7e)PlrhYr1JGo2xJP^b0rKk_GmFb{^0SZ&ww*g; zJOWqVvbUZnkR{0+3#;`aDP-5S*5VYl4sR_M(LgroM&GUnPkkZ|2#@NaPbXXZ&?n~l z|1{)f36Lc(tAWm7Lkk5SB#YII7!Msd&xGkQFm9mPK$f|FyC1vGhekpato(tU#~^m4kc6U;R4>MB{y z*%CFW!Tr3k2|Y7mq~x0$R~ z_Wq!zI9G>LL$fQGib73=I>7PG68*DAI0xGQ45zLxIb4>I4d{K>D)QgSt-Xf*!%3^3nl+8*iASt`%}=K(J)Qp_p=9W z;y|mOSID$Lf3FWT`*|e^wjU~i*Q8Bq1WnR#j5OvHuPQX_kY+z+m_TiQn@0XGwE3{s zKh@^LcIv7l=#<7e)IZMZ8v%C2`7tA&J69$muL!3mmk78Lpfq>lfnf@{ipXF%b+Y87 zpz_9x9g9h_Q=H(e7*s>}>Ml*%q5eCI2+K5|2=oPLOfaAWnPs!f$;e5eG{WXo#RnJ#$lgEMPu0(Pr{1beqho2%Eda<}UeP$^C?KxyPf{ zwkk+5IoPWQUb)nUBW;p*;5|BQ9i|QquPUdZ?(oL~HQs?^U_ZLlkAwXO@_6`q2GA*H zY^MVCFms{6bv~5#p42KdHdOB`tvt^wK8XCIAme3U0v$Jck5!U}8Qr%ZKLq z5WVrz{n&?o<3sCxDCQ222(6dLO~om`ttE0jwD$X|r@&i#uMI%SyTRSL!tECm@$?H3`~Fzy&LFQyEQzgI@a zTsOMZ=A%ao^~KMJ9mGk?uqS1ZufjSqhdT7dGMvTDV^4uEV3h%p$kG9fn?KBW6tc>^ z=p;-Q>`|Oe@voakp9}OC1I2;fvmJqWm0xDuI$Mq3C2wgV#O$+9tQMQ5ZAOf`c6Zc$ zx6wt*oP#MA|h3A5ER` zE-zvC9PX^VoUQRD44$t1S}@$Xvn-+m!jz%?;4lx2rpt)H8Scs{W#P^pB6>%?P2X_ZClFV=bycA4`HzS9yer4s$ukK;2csnzb>G8cv+RDa zYivSYp};*A1|JDP z-`M_|bI0Q(jdyo*RnFrDt+D!}#>|&XBb?eR(eWFW-k{@DJtW0RN*sGc`Bb{>LRHbm8WI*l4r?2X&tpR9BEFkT(UbW z$JI5YZmc{#`w%6#tIz0AL8rNiyHV&|*(pSJRuatzsrgIg*>=(-_cpYgE3QhYGB~a@ zQraQ7wDr|sWzaNuTxsi@1ouQrw?(6t!gS>BnrLd${%C4yKAJiBBh$=+nA6JxpNat`w& zmQyHj6Mwx&A&E|lC#hlvEY)cWVYpFwFmx$~1US}l&3gR~`OVYC5(BWS%?EHtXpwv! z2p{bsvrxXG4`<~?Wm?Z#9n%PC{nl`x$w1y(@Rq`OLP%Ev_X1Cwoym^le3gDHT<)~V z*mif|8#i4)$KtG7T{2SZXqvNfGM}UP86HdDTe*r}8v>J>a+Ka==JRb98AYKB=&U%p;oP^Km0v1j z!BsNGd1kayv>iK{iKZ745WxmU;f~LieShU#N|3CAR#pTR3y5-^#Lcn#2v{Xy zh1o=TuQ^kkmFIt&Ki7V`gugd_x-`OCI4zRmOc+UBTX||c`9Y}V7_n<>COa!n6S-maNPfb}ofn4PEfXgsmQ8CJNzoLT)tijF zd19Kd&Ns(K&U?{mU&8>om}y@5O62T6G5noxmhsU=nSbZ^smR$I8qVIul6fb3c4zqP zY`C?nG~D_@@Rm=9GnbY^UT-<0p>FrgKAwy z72!-n+4;^bpAENmR)kyoF1)3>p>=IpL+eM*EvKsAt?OI!{Ou?UckBp7My!pb4CRWX zLUp-INRaPZ7pmKDfJo~60#TDP7eh6!E>~ShlRs!04d^(V_#}Ar%xS($5+QYNXJhbv zR#0W4o@cH_j_4Nt({8M+$$reNY>O1)TNxyQ$t6sXMS$8XIYI5+i-RAP8|fD< zVri~IQu-a-T%F!3%sJ^4pto46p}?g;?-)q3wtqFyO@5fzfp+M0e1F@--UrlcAnjE4 z9shA4dve|2$9fF9X8SZ(0U3=W9b?}L3f(uVGpCAk3YjhHo`$96#Dn*Wq37wV34754 zhRrkh;pbtj3bim6dZN_0n9O5o<7;LdP6o2$py$?$L5fgdir<5qfp(dm-s*?70eNS1 zrk=BAfdOgnuhw3@3^ToruAlpn**0`#Zk-Tu+UE&aPy%$lfl8-4?bjG6SmCr^2E-va zk$JS0O2X-YHBf}ua5!D!exux3@r_Y#{G|5vS`62Poyb#Z)L1U&*>>`@WM8?{z8&<| zai9k0i?OEd$l2Ht0Jq{&YUyD+vFikaIlH@r`U2S;9ZVwG+x{v5MO~L@+I>NQ7C7yz zi2p}Lage$uxxeh@E8TTx45N38hUI&bJ$v&V)w}e>^4cn`L-<^@1}4}|@MmR&P-1^` zoSU}Hakgxm{xnoL134 zejla@VB?GnA~R>4(_E#W+U7C(`7EbaJ2<)!C?teOymt|Fog-&;{eprl&3gpM3LL!ahiSXFVcK{eHEg_x zfozVoe(cF0o{e1!WMl6EvU&AxZo~A~hBdMrZP?X7Htauub{b0c8=&_|t2^$&ueUGi zdOMq|rRiq^W&nFqRjj*<+fP2`U6gn&f)YXt5T9LNV#xzHyO>0r%w_j9dTOt@jX;01 zHM(44<(OkGQWn-=K700F;*q++Q-S-k&lNvw{&s5vsG&y>eOM)!hChy~Z2&Xx0eBH$ zb_!r80J|wrFWS&^`HHRL;$Lp<4GqGys^>WEp$WV3eU!Ynsassx^;pQ~Q+!qkSZn$% zh_jx4-oxmQ%nQ%lTmQ14gOqpAAg#b z^XG<6XL&4r-B|Nj zpL}aBqqsd`g?Z)P#HrfBfHcUcgXhi!Xl{y2Lf%=qm!7{@~JfnQp`IWHK3G5?K zBwK+idEyzjMg%J}6Q|oRIiLBXGkH6sGR|00%ESo7egWo+C-*3HUBulI$y^~>eq5le zkB|V+$kgM*q>q&A_{OtT)$`1fbut$rZ{&3RJ>U#3a{7zT%Dc^Yp57fqq3zx9>AS+2 z>q|&I%aC@QsO$)z-plE|t%gPhGLuS9@75L}9gW~>&DHZ0DZ@nKk)>QY_4sR@b@DaS zltU9XstH=}GOKij8Z@iuiy*mEG2t`)a1&(z(1c~CmRRN!rVvj*k4ne-&2y@F&!6?C zQ?+JdCUgwAv5_d-I9kxHI#&~#C-ww>Um^BhQz#Ct&Y>T+ld&L!TtzRg2=OF$MWPE{ z))fo8LL@rNZw4PVevZcAdNK)VshYey3VEBm(Da(gOqiE>N|NU+zqx#z>z6^gT@>O} zt!-3MrtX=z6}n;;H5cbU+aGZ9*B0mBZu4Wjp^zVgTUT6LoL@um9{H;Me3bn>Dq~m7 zcv4N>Vfs;Sh2Rt%!qULZou&bNC7xs~3bxp1J+B4JmOs;=*TQX~L=>yEh8s+2Hb1jI5K{Ch`3DrWT`>{HlynRWL_mDU znG}qJHT?7-JXkgFKE7UXsxVdNp&MOBOUA=CXV%LqQZJgDly{B#AiHD+>Bv7-^Z2qJ zre>3HmL35qYSxR&g+dh{R3wXFSG-8-=@0Se*5zcu``Z7QG_*Rug(%rw&<%mB2Ki2_#Wch^|2X~q(Y_V!+S8E z4}F=nLs(*{q`Lu=XMHZ{4E?;191+)&*dI*HoHQZ4XJ7kzlXXgFe3=t}0jAaDOyx0A zC%&s48-4Lt!C_BLq$blKRs#oZWO4$YRi#4q-lZL3zd_lPi#c2SMQmcAiG#iRI z;}zLux?F%}NAvQc1Lp>C`gXwQG$Yp5nD}}-g-7g~auNXpan>J2^7J8oC zu!e1`pBIsyiQpWY06;(WW@u?cv-yE~`x}Hdg!`CWO+;UT@@pX#5q5@Egq+VWa|h(hHbi!`H(I*w%$+qVPPMV7^@}R?LPEFAL{lYNrTyR$3V<2BsCKY z$!>#%^uBG|Cv`*Hs;NM>1+l_udhS?=T|-&HiyAkS3OaGP8w%596?viV=2G%Hz>Sr& zq4POI`lorMf1$akfNR@j>!FJQA-Zs18A~mEPJ2Mb-EBnj_?&4x5SsJl;Vv`J4ZO@4 z-+`cnXS>_+yo|9_SS~Znt>*7sZk$=0NrYXk4O$gFS_rEJJw>%9`ddL1`cAilW!>LRp*bXGdq^QlIao{c9^)w}+XoRKh>plZ@vENcMTZ;l6g z=6=!~L7oRH-h}XfILko0xH~T5t1uVd zR&M9QY)#I9yW=whhx=(h&E3)JH)sgGyW{&B(@w^mbDFt7K0kH zk~X2aGn2R01e&qVY(-_f!~@fmp1c0MQJ-%)IhIEWBaewj@zp8UXCNDH=^*XF{^-X@ zOzHu8gx2W8HC-C}iw)x<4sFaR7yW=SJP3u(Ll-x-ETl3T z>$l-YZWSX0kLTgamE@^!nv?x4Fz@WdwbUi|l@|5$)-i53gS|ibMi8c9vRnPc)MDGy>Qxh~dga}r z&rn3}(&XOJEvF6~Bro$v$v1{ELS)WWsU7Xh$(-Cb?7(XJl5Z^T>>ZZu9!WJAeqM)_ z*Ev)pub66RjJG=%Lr*KW_EJP3xTpT_&ayQ;Lh(eOnL0ko-oXefrHN;NrlR~*2t(i& z)u&j-9owHE?0l~q+flhQTti;`#qp@hkGY}E-U~-8J;s>Xve+ZVQ8S;sWDAx3m+U2L zgzJ{`_~l~nisLBmb7t90_n`$oq|y9>SvD{FVW%@epEWroR%r9;mHhK2Y_%UIbg;2! zu>o61qTBXitQE+X@>3uB4Uk>99YA*BJ_%G~TJSEAeM(~qf5{jm(nyq|;q&$LQ%S{N=0ZuKdT&20K!t+0OCVlN!!%^Jt#OVOcKT^M3s<=g!?UU#5Pa zTH)CnKu^={Mlc137a;Bmj0$%pg19T}4ktf6-dTD& zCB&PaLS`|gY({1=>~4#yBf7jUN74<{8=fj_%*0F9HI#5CYA9Wh%}R-;knlm^LVbnw zu~KD7#Y$3oE(tDpBm3>59FoSd=1LEeeqBRQwS*S@Is3(;Jd>5DzdfWVp^DN4Z)e99 zrK$if_NzOf{L;{JlJ&^e6LE7V|=Zdm2o=?T{3tq|oS5ZDWQYh4*ewuV@RxlO& z$jh^TT|+*<;DzkBNsCEtGqm6G>rEQLYl=#hnqHy2(nFP})*P(N{R`F<%KRhkD6~|ko#OE3UZvHkK=pO#I80cR9E;i78 zK6JkiJ>WwR0)3Nz!N5a)*uy~5=EoZne^p~J@Hl^Mc^y8q#)o=*=qVr>XAK56^Y>N* zJ;Ps{cRSDm6ZS_xY=;lM=0mblV{^O(w2*(nz%KqSGSJ`ndz*puWM3h9O-Xwg2iv_7 z*~IRP)UTF|N2gu|XBrHi1&h_H=f~IroE1DPW=44i1JO*EkV365a4-l<500Q&X?997 zqM;UhEi9J_vrzWA<7`4FXU_kNHlr|`A2-V2N0H3cY)SSO!)h<=61XM6XeI4QWJXOv z4QIt#;CLo9Ih@S1E6oIr;!T^_mA)h7j|aEP39KcZk3i(?F7U|kIcaT6rE_r5!1FCT z#v9ptL<7B~;`$a*b)}DmOonu9QPIFA>%=UGw~ie3+VKzoYPmxY~2;`_3sG<6g z#P=OQ^=)b077;uQ$amEXQwxU8Fb~M?3J(F^4c3;vyu!Mg>LyvDakjhUQsExlF1EqXunGb2NvaxpqDJ@Dxewg;Eb`y3Vf4^;@ z`}u2gJm5pxt8AF|Dhp|^QjK=6N*hRfm5uEHT57`9_+dRhq`k_f(_UpE?N#65UofD( z$~BPoD)j{wn9Hz|VpQ^b5T2-mtQE61qUE*u2$BLY4t8OVEERFvTbTs-9O#9hAX*+l zl5$#ub9cAoKIU@#a#r*u|6s7GWt`its|VTZ+%OswNFQ)v<)_L;V)97<%QVRDXAbc% z7IKG6G*|Rjw<(9Mf|nmBC1r!=(dN>{OV3_irX*`ZRXs}g1~81z)GPcpm)m4}@=EnI zA=dehT@JBywAEa>9ws7M`I8=rS(x+B&deNA!L z?)%i{>K;aBR@g;Sg7ARK33hfz#gz=8pD@v#@hL8?mf$r%2O4S{GKtGz2 znNl~H&6LbgbC#>l<=FLi+I0EO_fUQHhFYxmQy!IF8*z8(Ci-b2?F7TWVR+}3xf#u% zY&%brc6UPzLE5>_id|GuXQvS7YY4okx{BnwVV(Pf`E}&nP2i2aWaTZ;Y5P3oYBVF} zYOALLxpBigTsP%NyXHFi9JtxYsK^BYdN6SLW^t+A!@p~XEJtfT61=u@hO^=ojG(2& z1ZjG%5i>WzY4DerWBfjD;%F3Pew&_ztzxPU?gGUkFoh;+x3YmGJ# zs6uK4yoWikGjt$kR!8p*W`;bbQ-MoyBiI8|Uw$6vq(+Cq=17Di!1;s8j>U$-4-Py1X8* z=-`FXPD(sIWvrnnFA$f&=6ofh`%dcDd_|B1-=*%L19z;?3VJ_MzuCFdB_5k06lM5E z3r+Gi(`Q5RZXlqDf3!+fHJ`1H7F9)Sxgxwc!`dgxDkHqt4OG82gAVK_0%C0Ep7r-n% z)_s#j)qvrtMtAX8XGJ!FNqUySG?oF%S6heE&E(#)MdwEApLCYq&nFTBTANmOn9g*C z-M^Vx5}}=~_Sb}~I}^dZaW@~UMkmfZg|}~Q8IEqk-L#HY%Qwzg&?Di#(uin!^-Bn6 zC#s)hSyJuLTO3T5yKPHM(qLzPhh%V*y(LbYm>*t&xo77r$I@gt6~bcr7fWos#Kd!1 z|0I7vybj?-@o*qQ$CeH#qj}-rc$L1nw-gKLsmSQO>S>;t`-^vSB){U@I>NYbiuROV zM5=_B>f9VJ)&mPaC5O}62LGltD7xjZ1&m{iwR#x%mUCiFcEF{ZGIIjUqIt-~b)gCQ zSnvgmn$^XEd$ky=#D7F!y(@Q_nC3MkuB=~XW~zDEoQd6`FW`)+Y0cEksL#iO+f9ym zaKD5#l`mHz%VU{KO7v1wTpBHKmg%qqt*xxL4RPA!#aR>OEWHpYVP}{*L;jv?p_#Y1 zY)OQX?v=9P?PE#S*z`xN^f2`}LqK-a-IAzYFZWkPmm-9?%FDZG&_Be+fc_1q~J$ z^Pv+G_=t?v_uPVlP?wXuk61#_^Fq3vyA1b1Cyb=PtP z??NLEHeUEy)_4W?$C7WOXZ@PFxgv_u`rgH%`rg|{ppeS5UDUbw*~z72PM(q)gY~~I<6h|}TGdrn<%jdi zY#pGki@CPpjIZtRMzcs`L6qE-8WLpt)Lw0lIvRkL^vWNAU-DrWhDQF}gRThSvzcF? zzD-O;jxqGD<&8mW;?dldUfDNaYRk3j=?K>wH2N^>E#eV7*&^DkUO>N`c3Ja@yO)eD zP(;kei#gx+fe_5?vh}Zv99;r^*r*X{c`vK$gOqQvM*lQ>D#!mDE2}J>`UO!QHyS$C z*!1)OLlBJ|JUtKM*@dLUilcMKJY_KviRyJ)kkwC$ew3G%`dbd(IN!=nC7o2$J4`M; zoQ0DgK^nTuj70k>!L-pJBw44!S-Kk9{SL6 zc=}L!Q2J1MQ2J2XPajI54_yoI#bUCPk<3r5`U7ahScajoy2sYfaGa;%7-6X?!|`@j z<{HdM)B-Sm2~lCj@A*V^cdUAo(2mS)^p^fgx!GAc45wsfxra+w6;ZvnY-KoOP=-0n4~9>JmqWaXI}$qm_9)8T1M7k+TBH9$eivR-<*;Fg6kF zNdz~sTh_6mViMI^c^v*ye^UZ|tB@w{t?moSzS4!$BkoHIif_rW==W^ToHS|Bd7%Uy zaoWWhwNDPrh=`mr^o`iFO9L#;c5&Px33_3%w_%ske1WJ~+Q zQ!)81Fm2Uy*apA7LE4M$f7<&))TBPHL>;}w6{YYB(2@M08uQX%WA^JNM7d{8; z?~uXa>a!i6f$22_ga-$w*TXI0w0~gwAqwA|?GH}HV6WQY)L8cq=P-s7g`^z)t`iTq ze@u%zW5yJpCH|nQN0c*QP>C-s47z%DkoaIB9t=2Ge5eqwo*pFskV3qAe31B|w;e~Q z?fHOcu{J6r^>^E2|F;Uu5C3Q|MBuXopJz8L!Ek>2`uVetJpb2?uwvnITz?KdaFKbg{U(L+lJOZ9Gw=1$?{#&Kv$Tz)b9aV4!MjTSSSMYMPh@2n}F_s00#ppKlXUOZMsha zec!}(mKDM_0sYv7y#i#pLBAeZsP_q=YfQZx{IHjSW|^>efNaSpqpUjJwBX+ILf(gf zzGTup?uTs#vRtEQfh;HKL!diN3j(AT|2-H80e#m%WkCOrfkpw{WuS5(ap!}9F+krl z&{!bdK!bskfW)y68m;pm7^sr4e=|@O&<_nX4oLj`pphv0k%7h&_7elu0o`Yy^MQV9 zpa!6SH&6uVX9kJ^=>;GdNC5rZhRIxb(TOJFHk3ccyg^!Hhz0g+do@zOVcxk?hpdm4 z-5ff1YYx*oqp>RZ`dM@Z9x&46+f|7$>b(9P=AgWugCHbz;XM zJ7Hpus1w$_Kf~qgyE7=AZ@%bvjR6= zQ%PqjhvcCwWVpiWn6yocQ8nyl8!@qMOhJ3~-h7;p6nDrBj@JzjQHxNmwQq{kuFG5j zJ&%{HF;<5abQpQ#*1ovY{yz@PCkwEL&o>!kE(hil`~2|v>YR4b=0WYO{D=8I-#omv zZ-Udl4^lBGv&3KzsMIcVGg4u*VYTl2iqrmYB(={7{;PuVY>;rr_js;X8iU-Go{Xo5 zdV~F>2c;*Y#BR#-s{daU?`G|%Cs+KRE2{GUNKs3^0CJX?wpDdc9><9Xt5zb525P5jpj>24+)nWZAKmk$e zhwEY%#Wl$Ac%#iY^TzX{oud9Z$qb<;Z>C~+>8b5#OovA29DoR2SRh-61Xh1;NiLB%4cI`tjgwSFy`dLm#=y#RUin} z47nMwm^E#8A2HlQ18JCv?p|Y9zR$PSHkZh_=WQhdee8}@Rxlvi;v{g6Q9kS27Hc-K z`tFvC@Bzlzw2nh=^HA?aneSLX=(z>K=#7kmsqUgjJvCCNLK*Fg@hJ3LUB7E!*^Q5; zj}E7Y?ODh9HsAap6d9&sg|Ql5z#m$WyG#4Rcj>&{7wiLHj4&%2eJzlzci}%8$Uf51 zYY!5G$cFt7Ap3ClI#8|2;qNYMBc{F`aZt8IAzIn+|=~*pk`2 z@Xxt(WGjChmKksRq{-6&$@kJ94a8=CNtqj3-k)WMJ0;|-;H6X^yDlm3+)M)b% zVvfyOF$Hpd$=E_z_zxm^vCO<0pEVY9-42E$R`2%kGmo>U4xzcq$b_aEC3M<;2R-aZ z)}&JF_?U^oY_@sbcUt$I>a;J=_BN=TQz8@2blT2h*biGo>%KmxJ*ZS(evYvAFl=hb zok=mxryRBjonkpS>vgjIQ$;0}t0dk{3;IcCsHg+glZtjyTM~~hPo}3>$3a*Wj5SRe z7hIpd^SYGQ#rz@bB1=D?-#w+Kq- zBk7yQ<$e&$n=tdSOm=erf@Fg!ZCu1=j#PIdnY!o`URmMl%__hvi*mBRl`KStcUD_` z_Gd;m;_s0OUkx;Wa?oUXy`mSe1bx)W1+kyWExscv*Y9%+EjS&eaZ`JTl#HfUg{wPa z>AO1Ukh@tGzo2&|cn@B^8~AM9H?Dbf>%MxYeTdM|?aJzvslO3VB3IK(0Sa<=6(FQz z3>a}ypdR%FcbJ~z9{_v8nNjD|WAOCOAM%kI)vlcBJFiW#%Voy=L0@v(@~;U3;7+VV zH~BZ|r8D^A;d_1hUuOw|yPRG+O;E50_C@;6nZQn@Gre>+z~Qk5gl7;BMAJcNqn{bh_ zlVi>!<5}#?$9n&m6NMh@Ro40k%Z=DQrJ}X@Ut*bC#_Lfs{YV`}6-GIM;YtYw=@BC` zfi0!^!pMZLRo*ti9cCy|(`E?UI8n54>-nKT%keC#O0$pz7}^$DI(}k0^wW5LO``tQ zh0ny@j@*|IO^b7%J51aOhmNyHDUY`^i}M|YXIyy4RY@-hXS&oeI zT1Xq7g>pc4tM2omVIYnTI|0a^c_f8pc^?z}F!9sudFk&!_U1Gk)U|mp0`^}SaUVL(hgJjG92c?e+wVSfjD*o1xLhm9Tv2{K{F0ojvX6b!i|N>_`nherF-97ytd(FA?>#G85%0*Yn6 zg*@R4#k~E0xNdH(`N!)fg+#;QuQ`zkM^p}qWyuca{7|>0BP%9SzdLnFewC!nv98yh zUzeIv8cTME>?`^R?b+P58^l*BzF>r}zPjsr^4KZ+PaoRrL+12XeD&_<5*2RT^-M)C z843hxfTpgwaqIpt=rStDPlZ+QjliIM+_-nDP^%<-vv*V9XzDq%W^ijCH|}2^m`_ZF z!`D~W(o(4FV@3mc&f(KfXdcqq_j$B2y$0G$=NvxMS6a%=b#E}QtDt;bMKkSW%=V#s zd}y-|iTQ2Qeb$G(gL*;h8Vh&9FqacCN&2)oN`wiQO{`Ehq~-HWyH>V(v9irJ=hMQl@!zzb>yvrTORv*dHZhI1+5{Xd9x8h7`^Q0@*iA7>9) z6%bnVViQbOC;2pa8d~!soVG5YiK+9?#M2{Qfn!Vd=OMPummEk} zimSfM6y1F40q9zkD0>4aLKCx1q93Ml$MiSu4QstG!B&(0F zr+|UC{<(zk%Ds!91b0{N@^c$y-F^oXS(~?n%&IOKv!nKS$7EEpfmy}15&1>Z^hgVYwg`2wCI|})n$bMV9vbNR* zTAr0qw)VY33KRVVvuh-e>JVn_FU+oG+Bsv;sl^^u2CH{xCk#2@j(Uic4k;~fgRw#? za8r1dWGy8zRM*emsB?GG?pdu9Dq4;*HwJ`8G`mFZsxR?BFAs{!BPM9%<`08hO?WM$>1uzl~j~zZgkT z35ld0Bb9guzu~ueZ0&lF(*XCN*ZFZLyok1YR4BrgD>jNV@g0?l2wrN5GWZ$=AL=~+ zb(3-pC-b%RQ3`e9PRu0q0y=Vvb7!Lx7^9^HHWB*y?sJsx&uD`=*nXeM3umHxFW7_h zwX^gQ`Yb8}d6_0L`I!=5olP2j=!zZD&?h@I-2KKfs)~$deDV;+GK$kcX5M~GGzR2M zWX7LRR1}v%NT;bF_sMYb3kSO~6sMu6-9_1p)^P63Lu4;bWA3Sa*!e~dB2G6O&ilL5 z-XNe2scNbF^AhyGTYl$A6n)n^?GHiI;mEd}!rkgW=slt)1q0R0;xscKAFwcCV%5IQ zEQDR&h!F{rGGLKX*ue3>`FM5HX*-F+{k3jq$XQuLJ0Z=j&bOBgoVa2Z!J&q$I1LPm zhSu&@r|o~zB<^V4k@|JcQdzLmc(whE(x+xZkB5W3u^>I-$*(cEHw9;;)%cM$td z>9TPzizh#X*_Yo%?5)_>5l>{ql)rw~qTNHtfUlS)*c z`@gq>D4|w6jvXC_+t4tYQ|lcVGq;rFM%U(1rq4XgEY|K0*Z+M{)VhdLMmBJJKu7x6 ze51@mF(RKVK>{J5v3taLw;RuB|HDDe0T2tf7IuHq27Ox#+ot7UP?-B zxRxc3a5R!+I_pga>M}RWOM!lB!mb8dXTomx(`k`CWx{mewdusZv85Qb0h4zZVOvc) z-QZt_JcI(`N80=DXdrugJqhSplTJKF?JoeZ?z#L5N4pG+y=2ik7J?gg?Xuk~Z^ zB#kt0LV-RYdn}6ZZK0$O{n>|30aGp4;p;#)-EVy8dbTnf_9l>sbSQ8t_i_6`Q0qez z{5$#-AltVu0$J|FTp;_9kO8uJ@A07@1KFNG2xRj<0`#)!}Bf$mS5gz~*=h z=p~cm49-Zl&C`Kwo3944^)3bajOoYk{Mc?FTi&xkw!9rcmXDJ2WBdHrP#M0POl|%5 zEL{u6THgyXu^Jxj5Mo%E(NkfnF8uCVLt_$Vg~S_U2i=PdiWv((0n-!=^$~T zyS`yB6N+Ikbs3gqq01(?&~2MWCxk-RFZ8N zlVzDaYAtzdIf3z}chzX?%}NGmq?;w{fKi?8WH4}mlGS$S&Jx0)VcTUSN1Qe}m`c3` z(62AHyPk9}5G3OU>js=R&>pe8O>xv4cCRbRT%1Qo1!gYqd6FEJc$WOvtfFy=%$VQt zgKpLRl^yzZH|mHi970C7pn28EhK)*Ut4WZTVY#{e*3405A*J`=x!r` zZAJk{DL&D(LrPqA#=A}J+xVZl?VGhPu@SqyMf)yh^*V7w4KH9AS{_%TCUT{HCxU-K zxL633H2c!F(!;h_b{ zq+royEyV@3RnURZom7YiVp*xY2E(_2wm?*EO2}6c3BJ=9+$U)S^f*iptRyBz@8~0c z>AH;n&6dHyxl#paRhK=fYi;NnRq0xG@GDO)ngCvR?Jle>s>T!BGmo={2>(_6aO##t z8E>IfOLenA)|usQAZvhd2$O%NS!~AvebPXe0sYu4yK})jOUtAZV4*94ECss;$WpL> z2D0?Ga0xE>b(;@;A9xL(O-Njd+q^U58B~uGPINa1Ke-pE zB7BeO6GgY}Rns`C%r4X?wU-KWU;h(P%M0Xnz$IOY!%pNQQ;NyZ$}RmF-O?WzTpo@$ z6{J%8%d#WGNG#Mjufkk@lbt~|q(T!>QNTICaC#`$=ayr=OQ6L12qmcbeXs0+m+F?P z0cF~ov{zs{8t9f(MZnw#co(!=gExe3hiR!9Nq>gSqz#%T=;>r#w}-gHXdPn=G$jO7 zSQ9y(U^qA0G^Ku;i$dw6b^IRc;#Dk-(!^SwpM`)$=VxJPkzDLmT_2}a_Rtmq(k0PK zFW5!YPMAgi43I_tUjSM3{{xVHb`ihWE|{@k(`lv@^SEoENrc(Mopj%SYQnA-))`3Z z&K8mt+O1|$-UDQhV2=XX1KR6A_JF3{z{ZYXDcabH{_<=DI>D53GmveSOf1=hlJr{* z7L>^l9r6`+pK5ICi}bs3(~F8Ws-yWe8`ThiA{F9Y5gDG_MWIMO?~+P=N~}$@RjI8xsIMTn(jkGVt-B;r1gq+fVh(V~@>{nNA@|n?B%hk16zQmv# z6f!#*`_g-uOl1e_5EJ^tSpCZjI}PD4G$9ep#)EGa)Z=Pe?vAjJsG+qlMPOT2Xd8Km zPYH8WnLVe$7{O=!qV=yh89jg)5tlV2;+^=`aBve`385)miM`moz7;i3eh~WD9IJj0 zzjT-}{}3~jvCKG=Dp9@lVk~1Ps$Xo(jQVcA!|lnOq%|-=u_y-scG~9$Ao37HO#-=yKovo_h zj^sku#ojatg~F&dHuXfR-$#D*EJXe93}gRrWobP4%%Iu=jS~EqDpqcYDJxzuwPtKk z8)s?47xa$i$}U1HJ=NYUTbmkr5#-euw%w{}Xxm-O# z&$j{2VNE$7+Jix7JV^G+d~MEHLDQ1?3g>odV`ZkGe264y z=y)di;#mDIPc8Z1h;uhB*?CI9=pe68uHTXG#F)t^2 z3cBmp0LWt5kAWAllp znfT?8n^&#h(?5%s&jZ;UlEC~pm^?C&13Jz?yMaDtu=_ZOd9|snVS15}pTW}mDA&0D z7NIq#L@-uwCc@MN?iGZoMQGY`H19Rj3j6t0T|(G0)cdJSdqgY6X@4-wnJbJI!65Wq zq`Q`IcyFxfuSLRr#&q2g3pK;c@KRPnW+^hpF-6(qwNIp-4y0P8?OLC^%37C%(Ym%1-}woHsB`C>{t9A zMI`~;#dXYao(pdVz}(Msak<^NDJ*ooDNf+wbAk3YSFaEo(X!RC`n8M37DNPbu{)_G zHOesV>(?&aH4uxvVTYQw(hyz3H2nW?-ODJcXv!Dbu7#9 zf@4-h+_GZgmK76Ef4_rH#w|NW1pP0xM~k9NC2{+jt(766WS!x0Rz@3YcZ(CS3n;uw zS1d6DdiiztN8HzYDGtLYFEs~aX#`mfOO=~V6!Rw>w<^%ZaNmiz@0er>cW<00fVN{) zrz)4A5Qmo8JRFk~MPIBRrOO2KAXS58+Ph&`@N6iSpApk#C!_k@E&j1TR`7Lg!uP5v zC&gU6%svd*KfUI1*ZgPJF zmqP(r6tIvBWX0h&09m3VrDY50>CY05q2#mBXdgPkhd${;{cISK5Sv5hsVy|!hpzUa z>wQR~%{E<|4~cbe!~WfeWTnj#F_Z|LiY z-HOhxQu=hAFCbFGLaB4VG^+l^=5yT1NT7B_To%sL!avN(mbDBs&B_fiKk2JS6{wUs zqYe$j6CqnT9jX+&VuCvv*2K`H75X%@5O#Q>WrBL+bUqSbjH)6;VS!=g!VJZ4?V1;;cR)lE)`WWfZ(n% z_h|Q7+w-rQA5whoz!Zhz+h1yd9G|Q$JOXpeY~ejN`Ar|rf$Q40 z&c8PNC_BgE=25liK4ZM{{raB8)3`%mMQ?r#UfKLfeiSzI7Jrtg9-=;lQNH_k`=$FCJ>%nYwB_tlqR%lobt>Y-|luYqP^{pKkZ=d!Eu5hm8;% z(~mhTUZ$Mwn5PW>2?LY`3NcXFEr|=;u1Y#~rs;MV$nH`G-HiOL^9YFbg7e7TkB%?n z{y?iOX>(mE1Jt`lHy|Ub>n5c=5bR7eb-=utRF-@-7+j5tk*@6Sq_OKlCCGR#`~BxB z20psv?^_q9g00wNNPY8UIYthr;GRt^38xxJ$X7$D5hhJF1e2!dkgcIUDSd^7*SSff z#o(GIq)iGp86m19sis9Hm=-Q<&~+Ql5TiSQ9Dj{_*R@24GYyE|^rTJrwpU$u8iDD% zlz+><;D)rx%oHp_>_gI>N$G;0OgF`Okxya6S78-u_wpo_zcDtEIfEp`-YB8M7qm=c zhR=W)WBH8Za zPTLa%F3F$FUnlcbC1^re;_kK&Ib((0$IUM&+B_~YVS0Iy8=2`C0oV{Z3%5V3xAo#e z#?-fMN51Fu)xo`kI;mT5p&iAYY@0N;Os_l5V~lT|LO;zAPZz`T%BdoK&0QX;JR4-q^fToC&|X*p=-W5 z=FS@nX^T}q9Zv2qX*pTgevw}#hwBpqx6JJlA(-v@~dTeR+L zZUwS#Zte%FGbpV!{8_fKU|d0VEXShy1>M0$ywrO$phzlGIT_}u4hex?{(;aq&N*7_9t?Zd0~Ao0Ur$}D^YwB* zf>yX!!B({kLkpQv!u4Sh6UAx!+DH>Iqtt2J4rrua8=R&8 z0jwKT=KPxaz0R^7?EB&R55IYV3|k!&emqdF@4rQyDX%NIEE;@`-&?Sb+K5`{Gu}p{ z!8ntG;^}Ca3UfE3LmUrY#vR{MFeRuY0sM-Y*{6me)Q=di#xkoHAg^Z^b0gCjYj~6U zk8;{&tff%Gfbrua*qsiVi5L)p`NQLBumy?tMHO)8Pg8)ia!(`$^E2n@P0VROia=+jY+rb4BV$xo5idB|!JrgmV$4U| zdZ+#G!x^IgR*qNua}1W@JmT)XE4J=z5nN~KUn$QWDY@x&KoNIpNRNtbkMe;5W7^!X z=iP?3-7U4XTch|b0ZW-?UiSz8twu=dqoiKpTQAT1lhGu;5sb zsfWU1X)}J=J>aobU-)#fnrr>WMaUwVl(PFbwTd0b=8%TyYGuM5TZt{>xBgmaKY?1~ z$wg%Wr~PPVvz6Ip?SGF7X_nS-Cyg=d`d)x={cdMzGeB)#bStD*&Y`d($(jRkzgP(P z%tPRQaT)}Lc}=A6fqZxB?jfxX2g3a~|BtM$H}2H3-JK9ZjcO(|ocH1Ozm$1x6%i%s zWHoQMLEDy3F{^j1C0{J_hq;u)7Ft;6`E_#;H_I$8t)Ex6@XhRfBvRsgOyY%=k%aXg zxV(@)-qgq%T+A7=Bfk!dpkpTRypo!dSN4~(qA}h)_Uy~&A$qjmS^7L}TlMQ-{pweH zUgzCAyyYF?U;?h-H{n~hKT0f5zGie!H1*zELw$F3Xu8p$sW+O>LiiD=#Cs~g2%fRV zPAN3Y8*Z(!%ru^C zzgmV<$p{+a+!RHRL!xcFn@2?IuB{BWFjzfogPbp92%h)0rz7d9qrz^qBJN&> z1$v&f3AdMK)pG;&Q1Xn*aI_5-cilayHh@D4XGMuwF?^0~nXj~4iA>%)sPEH&Gt8=+~gbHatwdN zr7a`pOt>`EGK9y;uMCYPJ25$kVcM5-|HR?_YE$PKw35S+yLry?NS&%HEog(TNrlng zqOvz~wd%=alQPQR1cvZ+C#xIY;za7gB`w42E-h^dMN(f0QU^K&)Pc$TGiairu41zK zyn>6|F*`)}5BciJ5nM~00deja4ix9@v(de5tQ%wO%98U(1zW~z3weVw+$}})kWF(0 z|8x)K|BLWh^hMf32VT$qp0tOnl;Z9o38OOKeYfx&rn10aQ|Px!Idz32Xx3w>RhQh_ zt=D%jErIZsUi`G<^8)rkYGTRtohHx=!4UZM-TeW%G6wI32Gl8NVKj9m_CHrMS|~f* zojb{ut8Lq$iDXcWIqV z8j-uyTk03Tukq_{Y{4GoijBFC8MP*XKagP*WPjEYeSjOuhX^z@^IruZOp3+BNXcmEF*w#338Vr%rHxa2mT6x!Rx*O*>3Hg~fv zBs92?q|Lams1Q@2S9pJcPYf#XR3Fhi`MHbS(2lIktFjQAgZW8iWbmxIp#CXSRMGNY zx@WD8W#z^N2N}x?ZTxC^_9p}#hR)q`_~@C3j~0jUFomB$w3KikWZF3dncI4{{P1}s zS9X{p{*vK8nqQ}Unuuy=uM zDIfY_67T|MiVy054#HJdJ{Is5Bmnt922(C zhnD)#_kHN6KJ*}vt+xXxWAZ-fhrI&y9TQf{mSxi&2ejOTo$QC53$)aPo#%&L4Af@A zrUO}K+I2woskULdOr^nucH`v{P6x?XhoRYDzoCekJ4wvkZM}w_JGC5cE)w}JO3JsL zgL`+0ha-uB`E9E}-kB{6=Q|=PV;eu&Tb7=x3(ETTj>UgTPbzQkSWrEP>>ZrDDMtEL zU2)z7utmNI&ndWKcY|E_;`JQ`bF%i18BEQPED-{m7%ktaW2TxDsXRv~$l7q{j|-tDjo-%_Cu~>XoUEo!vAu=1w1r zNL9IE5A&2;U|luiYwlRX0G>Lw7it!WmDHQPHCA#ftU^k#`So64nWoJ^c6M(EvU8OI z3Y+vEk=`h!@L9x=mZRC zPUea9NG9Lm@R=Z@mXqJ`xUnl1jMcB6ce)00ReSkFMiXAi4u-LM^_E^v({&RiSyWgAWKkgnG{vBTxb-%6pzzv7 zCiX=?R*kTEg%^z`R_2^6GS>Of44`^L@LPbwqzwhW1!NuCe;;U~3HzZR_H&@~Opf0H zO)!x3pUOpU=6WVd5-wKg3ie5EKEc>={$An(glW%xEgf;fVwTWPh2>z`hj z!+rw1#VouB*I1zL8?u-=3eC$}@3( z9ZoPzZrFAeH1E!D6B}zBxR~q)&UD*P_ssPAm4oDf^w#~M+4%q_hOd&Ts?sMylD~AfF@aWpW!}Z49_4e+~?eJ zdJQcxpT$DzzDY-8txm^2VPgojQL`@#EeO0W14ne#6+MKdJMfzb{@15Lrp%(u-K!z7$6q0%m_=xJjZ-XC2w8F8X2gx zSwTp`-HA>Z5)(*$Z|O@QATK6-H~Hh~t9m6(5l`Q+Bc7hOJ)XXGb7T4j5^j$pe$tqp z*AWlmDlco8k_GNq-2Ge3%{97vq@p)v&hjS$suspX=X3?IfuovwrE zf#dlQA?Tb$jrHf+j@mrC5ZhaL74r~qQ9F3S8O^?=KQ;Q(pg+@k$puZ!-&Toib=ZA= zz;Jr<2Kh)^h2i=Am3^;5x`K%O8*@HQTg)M2+l~p5yDOYKCBL5UO!k#8{0mAcBs0?A z0C1?InJbTO{D0YdANVM%EB`-X28j^+B#MgGew((jjfN^Vw#6N7XJCReGGkG(hVrM_ zxO{PIyR<@!HDEAAGd>xmTU~Y6Zf$?|yLQ(tZntY`Ywb(|B!EhQs;E_??b^in2me7( zFu(Wb-sgE{68;GG&;Gu@*ZPt?XYO;K`{$f<&pr3tbI)zuIK^GuUNtQfZ(p=vT4v>R zwJjc6zhFw{p6QnXr&d+Rp^7326uXa=8=dvfc_3kmX-Sy7T z@(a*gk6aKR*A>$Zg}24q+9#}})CHOQr`|Q1>RNUm>0Ez3g{h7B*Iaxtjy=0WxfRa} z8rSXSS3Fx+XEp&(HqU2Ajm!VMf)CuDSnY)1AUP6|vlN`a)xO$eih!ZZb8!63d=f8q16u>Pm7Oab(D8m;Pw= zKKV?8Hu*@4Gm026r}is8H=$h)X)+l2$)RQY&e4=?tu`}(taHX^>5b*ynLt*QeF?}4 zI=N&_GNSD2;B6*&t1AgUZr&O<4dW0cwa>=sPGl~az!jdyQdPk$w*QGwLd%QiS9?_z zBGK)tonE!8Cl<+FdDtaz*l|oG|Bd&p*bTC;`DQM(A(H>*Yn&lKd7H#(3U_*N_Sx(r zeR4z-HJ40!*LEV06w`Nl6-$u`W}iu)@uSA0Z_uNY=)cA5sX!L5p9HEin41^8y&`z~ zO(1Ju`F9{|7n4oRmZGg6Tgp>GzPNkAc&?V?en;3owq?+8J{t-vdd2whak-QRL^r<; z+xL&MyoJWbp7 zLhO{O74`VO@x{suG@d)P<1o~j!JNYnn9Z|*1?GB7xfCwbnlekKWXkQ14L8MVaFujo z4D+z2NzYo+J^*B`Yu39pD9!Ul4R>R^9c8Ms2$y`Y2rp{Me;Mj=Uf48_ozY)ILo_VGxM5R(&6QEnKJU6FLH4Oecw=zo8D2I zE-6j-q5GU@id4k^`KAmixIEr=S@pt!3ZgpEOR7unAX9iDS1^-h5D#b`ti-ut5_f+) ze`4XnIdZeR-A72^M{hf&dlJ&c7oQ8olEJvraryZPw9U%RNkCPG@}B|v11uRX`D-A{ zD1QTF8D$C3M@+tN1HEGMNsDky+CK--XQ}5rXdN#39MH=qUjtB|fxZf4WwTKqi8ZO% z6FXpm3f?5_kx$D4B~ArqAQs?DW&*-Z0rFbAALH6>m3+xc4}!t~arca)~LLzolLUS^0m)KK3mU=|J@4JAHZNKPv` z++dc?^?g#{Adg2E&r_V;?O@_#^*KqsTCrB0Bd}RfR0fGWi>9Z6JZ0-*@74|Bqz{}- z*as(^A5qv56MJVLzQqx6u$XbxksSrbZSc@U=ZYCOD#q0X9R^E(A{23;g33XWSa&#z zFwUa&74fcN)dJR5tW~#-x-bt;od9|)r=9_1`ED|h<-0@xJqKhFDpQf=JFUJwZrc}` z_9|}~-rCJ=@_P32X zg%&kIj2%k)h|UGp94xZVK)HOSDwaHI%y8Nsknr?z7XUvs7nB%&oaB#UZ6S&ZY#~;$ zeMn$|-_13?$d)N<>6#Uvp8~Sta}JOdpO*qz@hMfviqAG6%f>eWSvLM|0G&ZqQ6oOT z4rJN*Y9K2 zt*gF_A4XCZD0gh8zFEZcDYw49t>oQER~3-1s+e>qi*!{7BOQl8&VYE)3Yh>|F2fP- z4L!6ek+~tKhkJt=l$jg4`860{iNPf$>2wYX`>Z zK$gulFf5zL14t%*OM&-80n6s61hl}2gX~N2J5eP2R@&K=8EQUX!YDvg7}^0kk`SqTczPVx2jNF^vtej$KYB2m++YpoqPS z5d{-sdDH9#t^;*a)D8@CE?bw{(qUuV6LrS}Sy2}O8f(PWG$1RajAo}gD$F!?P~}d# zoF}73Ds${lh*}LsL`8>bcfPXX>vu+}%PiY&6gs08TCFaTxwx14p@O!|NJ*iK;!NH! zfSpCZ8d9NL3MIu0ISDvuY)r{W&z0r!S(U%)#k~VxI*ZR2e?h0WXIh;TnUxq~Te(<$ zJjqm`nv`djDVVQ0UePd6RjAOs)K)LMKUA&qM|~p4<#xnvWZ8He(UhW-xkcxjzFDRJ zUJ#pdS#8+Jm?<|s$fv{{OcSd`HZg93zw#(H2THhFT5k@$!Kvz50cup9zAiKv-0M1U z;mvEX&0!k+0KqtWB3qUm<2U#leuD=_p%)ja!J0s&|1yE1!(WZO7&d|a2i^OXSwnn* zOgRIMW35n7i7JYuvav-TaK*sU(Gl7UOvSd?K1#7pjg?3!6m(+zq6^YF8qc14jjByx zt@XK0sEQw$%PP%j27@l0SvVM*jpVS);)ca$zYB|fz!v_;^4NzUSzJ7}1d`z#yn}hX zm**hQzJ8eu67IzXc2oMruv>kf@opGCHvY0L=iY!q%N3}J=F?J|$5YMhGm8s!JI|~7 zfSiaLcO~x2SK}3C!UfIk{0RNF;udSFH*@_Jke#{C3m|ReS$~sdfv)bb(-F_qZ%6pi%XF_CA2iZ+F+Jn8ci^&m ze0ArJV4K*`R`yWb`rg|59i{c#xe@PJRVJzQ39iJVHZ#VLHiOy-G!F8NfTRV%P=u|7;QC8*te}pW;oN#-6 ztYXzhU=2$;*(71)3NF$>VD+HT7$u@ep{Zxf{#UCg#8{WNXkkweS#7@R8NK`k3RAIf z?E0;luZib!sKzd7T7jafGX%zvRgj1*5{w@2ZjwA)Dus0h2_*$#IA2vRL<%l$rYxR| zBt5Zg4QjqEsZCdurU#j3jb&@8EL)3IfQq|HmaV0}1%--0KNggw);v&V%>xtIG?eVD zQtzXlDxzRC93Z|J!<%ZWH7D+Td<4h9HPKZ0D>Voy40}c{*$z(ROH0uxkX@!pPqDho zSAgs??dw2xnYIkbF4GE&vmcOVrNCJfKhbDA+8?qb{)<2(ZCn3C`~QE^{^N&0dr$l2 z9x3gdYLVW{&^Lmnc<5II*3J1w|HZl)cb6>G5Ll>T;+t5^PpQV9!E+(&bd6DK+q9Nv zYuUW489rrn&W9mczMFBR0a`FU%fdNd!;%`LPhxq-!nrW8aH?V@hZkB4Cztxl!YRwM ziBM;xlQ%vw738a$HIQ5>1BrI}I<+Zb2j8`4^bJ9y|A)5wrL7f-MYJupWAA@^r)Wl6$RyYdiv20cgwfClQ% zQ5d=dTjGKCUkHOcRGfW2u(Mp|#={10{$#u^n!AV#mhyLE`z zwbE$6*!{mjE?MR%$R+G${?5_9TINb4o#i&v3=heCO4wW=HaFrfj;4S{z7p6HkcdkX zsx$bvNNWXd7U;xqwuXOq$1+pzEZY1~RQSyF9RKb$nwtscWW?)V`_Z`wm}ob&6Z;Ft z6jnGUqe{!0xD8&9x$ld+b;L__KSd~Ng>}?y=AO>oH@Y@#!}3cN$#J35c60B7?}Wt- z^Ko}wtPt}AN3Ddyl{~M&e#)NIO3;>;U?!2UFOvPf+NdiE$T`5hw_O8|X@A|$1?@m5 zo4Nm=fUM4_9ZwsV=_f!oF4M1oY+NRJP}#Ul(iw{fuDx3C-B$$Mu5pkRK~rHxV79-B z@Oa4E-#J=YB!3UQBG@bee1H`})1P@ofW|RmMX;F=&i(>G!u2n#_n&6yUk^2{wl9}+ zOV|I=3ihiNScL7P6&y?>J_^n>>qc~fC5s9Q!Jt`B9)?1YEGPtjB5mMsG-6MiL<`nj ze;j?XVx(FF&lm^fEM*}r&n>2&2l~HAH@1x~%t0ALJmX_zMIe(v*o0_2OqV7rO0{~h z;;+I9<&GU;;ICHP--9GA5+vD!|OD3Hd;p77_TkC)U#ODJ}10k(!@Ye$4n&lv{dB0+r@Y3Xfy6O6Z#?2S@Z~GTAiG z^Crcy4R_-&sANbg4v6ot7+-gC0|R29ls z<2{Y0!S4y)?+Wi(<~>VzvW=Qy+-8`x+cqb3)1P%6(5$9c2@zY>~oNd7JRRC<}p;fT3Xwgrkgj_b%C=^$KceyBJ3wG?Fo2ktcD9DyR zNtEqKmO~XPlhk*=S5YHj45N3sk9vLBN4Ut2qgL5{x+}F$_r*?)LMucPKvsw}09hd- z3SDOCax0J(BJ}g(&j)w#nBg!?tcv-}Jz_jLhgR?IF!%GYk>T8^FpeAoz417noTqSB zN{vQF_hiGjPyyi89LMNRXBu-B5l)TaKy3p|a%zsMAWv*fjK9v$j*9X~xxKo*jd!D~ zlzIyCfP9mH7r+jS2!c^&u6NU$`LUsk8SW2z2O#Suj@zr7$!k!iyov11CV@k!%3Swk zEW4aAiBaNF`D>AubNGPuNoU%9kVT1856bQGC2?CaTYkORu!_Jrrp%$vq0KSw%h{N8 zAGAHvf<>}o4gcV@`@O~69Y&z|bAWJI#C<}tv3k#C0x0ZaTuur0-25V-SIwvqKUzo; z94vHO0NoWp>ww-cUpxZzCSxsJGKy;CBRsl9o*KHFC0r5#vM2Jd0P-e}6)&ntxZ4c5 zV8r3BZbzJWvzr`d=G5@Z@uS||j<2`G1A}jy_<#R{Z^c>_-Z_gumi7L!11sXm6f;xP zSTlQjV~sN>3W7!t3~}WcGGYRM4`WP>e}%#I4}k0#^Y<5Up1r4f0vE!p>4WucrM11q zg0OXxqfzj~DDUfC0`4KUb&_1nFDKGhxvtPzdHIQE+^xKnrv~E627p*LHbhVz=lbdV za9b0U(29S-J=K%pf!MFUKx=fBVlV039p2}h^3&=bVCR(kt8*sp6s8~xptV?lxdtHC zvbS{E(QDd{A+8`?Q*!$*F6rtXsEPgjGJbLGcYUNk=6r5L%kEDsJIZA9avTw_-B2Ie zfDlh*KS|b-*e^9xuHxj%nh&-PTrkyH-F}_YTk@aS)t`TBw9E1D4~BYL-YQ)-#++># z7!!+ZqwHecsszJ2f2 zmmOyH4CD`CZd(B&Z^})CA zz4{4W6aB4aU z$#s;(#Ouzf-GbE?^IoHxTUWWeb=HF%qOrHW+B`OY<;q)D*)k50EhtJO6xRasQz&(M z`5!t^u{RGZc4W4oSdBbW?9Ic9efU7dn%O+4ePp(vSdA!C>}|t}-F%>8?-{@P={L2Qj{D1ZfP%Hu^b6KSf|e;Lxb46N56`!6!G3u#TA{r5LV3g98%(xS2+o2| z`$P`0bhxwGmyQ&wF=ym~OF9+nPXj|(oP{Zv6jAvuJ+FEbrC$sn$ z)}RXLBaR}I(>Xui)w+sTL%EX5gnK^U{Ug8Dx8BU(vS{0{6j!M2ySMRoL09YTJVK>i zt#|M&8C3~%r&20Qhq_wt0$N-8gOZ`+R7@g!%e^GT)694xrTikwC=#)+IkBes??GO zW5)Sqeu)SEwzys+y<%(VF-@tj+sO)hDKNwu8U-x%zhsTX3jY0qW6t;1lRihV$=x6* z9eN{9%f~$-SH`Igv2o4{={zpMW!**)IWaH(<>pk`_H^tXJ={H{J2elgRJ}HmW*zBU^y_IV;-x??cb)aHsgz%Hw!J>Zsl2&$ z)mTYFQ{QiR|MKh3oF4uSnD3oAFM7Ekub_KcS24>Utj%77X!j8l7K%3(P+Ur@!Ey?Od58w91ZY<4O!I|e z@7>e3A9Uee5PaJqb>+68E4Tec5PZiWwd#(bRd>)TBC2WvjJ2!_!{P0Ie`~mqQk>9Bsy>)39>%D)Em~(LP$^li}VzTH*s><>(&s zij*Ed6mviLhp@%Q@0|I{yDBis~!uV4I6{lXO0#uUH9PkF;n zd1GYpcbeigy&JsV?-zfkU;G-s`1}3B2K~YY{ggd^%AS$M-(`x=`NgmGi@(b+KIa#| z)-SAtnbowugcYA@RM@15VPKZK&AYI92QPN}ML%c&aTF|6X1;*Ncl-5p`}I8N*HiA- zQ)bFi@vv*T`9VGR5R1FnW6}2PJ(OdDfS-c_v&3nCWB)RQnCk_Z5(to{VFCm_G7um# zp;!STdF06;Mp~1RJw;_jO%X*2lim7eUnK3fL<*eW(pAB+OQ}F-&24kqcke`^r>d_& zsxKS}wd5i;%UkvEq~Yik9DghshKJnhZb)dDTf*WSGKu~fAQ zlpgz)kPy#&WhKjmGM?>qTdDmDnH}eItC;k(XCW1FJ0e|8A?^_ll(RTK;I%!mp^Z|` zdQi@`)o1Gm>$%=2tEevZ*|~2qneEM9ty_uWkxnA>#NEwKnoHBsBi>C%L&ciaMRs39 zn>yqK>VxjXo`qiaAW>E-1+(yK=qXYko>Jmk5{uM_=cNe+`WYsL%A0Q~n$))OdSCU- zshoKW^0D%sTO@4vubHi*jcTk@vrWpRZQJbMt4UUMw2d*%h)14W#>F?CU|1(>^5E6EFa+w z3>PV82W~GipZ01(OrVsBq1(^V^4tB&O2geh(})p2v(!kjtCTx5hW?YW$zgIWhaycM zlBi)4OOik6RaXp|wU~?xAKt$>eGe+xNQs(WCB@|s#3@4epz_qHZ<5eZg^Yh134Iyz zsSFV<@psnTcBg%ids&1ciRUs2VTtE0N<7N?Q2{(fP-(&18wcUW$3iIo0 zY$j`{A=&Pq0Qfs9HFl3h@;-+KtMYny>b_!a(&13(KZKz%FuDmZx1awK6qa+ND%n!xcncuID=~%a{GCYPJY~ek{>5o z5$t+tl(E*>EzGR8rHXbiwSC17<{aZNrPIYWCi{ngtn1Wh=0$t?+XsO5(zOu5ic3oN z7)ZW&?-=OT;H~2O+qc_-w~D%Mzty#E_U(m0_S;*6x9ftpTY|R=q-ej51KDq90NHQ9 z6TIyV-fj-w9*v%1znubPzdawwe*5j+8hKy!h{8tAWqDh#v?$hPXc0n`^jpGC{EZ~s1kjzzVy zX$=AN?*XK^glrnp(ijFD8Kc4_Gl3vF&@v$C4YUe~4gu*RtfLL|AP|irO}BPwYb0D! zhQ=n#R=DK-K<_tD2Iw_D377mGP}ub2AA$N!nsm}@P1?T!-D;rwfZjB39{_sCKwUs@ z8)!4oD+YQN=y?O3POvSzcc8nNIWNG^Thl374shQ{HN`N7*OgSU4DZ~rxT`#|va zmEi5p;O&th#g_b6K(^#B(DD;ZZGQu#kr6KW2O#_QzTj9=pCE81klT*80dH=!4crNk>@{*J;AJ<6!>hpT&A+Q_ z!DVE&JMPA_S3wm}*<~_Nd{fyPRI=R2s_NZtoX0qcy0njv@YgWM7C-6jKzWg&f)EVE z&+|esP>u<_Koo{2mmFg~KjfK@3?|k>^oyM-Zhyk{ev{d>_MLu$V~@ch6Y^U}5%bYR znxL4ixMcuYx1A)Ab=$cd$hvA|fV8e;=m1%l0{H{lw*`0R;-0_d-dx>G9$W^51N_0j z0TbCGp1!+-&ciIJu)Sd7X|P?5CK~J zrTdeIr^y@xX`pCk7CNNnI1g>7kM1>fmGw0L__rnZ4fynI821Q z1D#w$v6|Oad;-T$)hSoByY=)PLRYL6lI&DEw-d}q>rgdck#p5pD4tE1a=Vebywu}l z&KE+?87;eqmQNDpCz}gIiG1Bna;lz7(eaiv@wz}$TyCm{)B9I~^0@nl*stmIHSVs0 z|C2uBYf)X1RlqNWDo&*eQl&+uu;`UQ#+o@@kP3TTWHZ?u1Ps@w4^>E!DH#YXvM;>$6vyHHJXgy%u?G-udo%Cb% z?prPIj7Aq^zft$h#kq%c@fo~Lf#^6WiW=-0WEu47O!Xw#1)<{;Am+XiCss7^De&k~ zgg|#&v<;(XqLd5K4T%z=#hmsYTBlkS%3@(W(&w~0)X9KL1p_f|LnTV9o&mjPs#f36 zQFaWs&vIqD^(ANJ*IBuw8k^7*vtK+bxQ;u8S}CugnPy!>^ED8g;lm6^yX{a)W>~7N z%@0n9wN0xqPz6w>fy#i6X8mK|a+e2?-X3cpy*;kJZNV|#oz$_eX=N0B6wmTxB7R|g z+xf@G)=!&Iwjh>SeqyX``AOV6Nr=yt=0H(>+q4r1m@ut;XAdz}1RWJ~$G5L|4YnmL z{KiCGcm9PkrN1v$H@SGu<=A~vj!S00amvWl{K$l9 z6YATRSA&a_lX0ZvurAmibT3)gop!stm+EftW;jIHj9pvVmTCKZ6&FW=_YcT_N~HK- z0?Lx^BfuYwxm}i2A2N{Mf7n1G)kh5P;oq1H?Xrv$%bpvKnXsp+#%?YyuO03$i4kSy zr%z50s2&0(>b7wAX<2<;_~v9}chm3OV`UtU?dq`vi?>Y+K_YBFy4VVi;#tu)trVbZ z8X7Z_dsAVaOq2+^__OzJAmHjcuQI^8FLq&M$X2=KCw! z&Ob`evbOWz*T00t8;YT~COHe}UbL-n$@xI2ia?L>*ZN$(96)kWvvXM?!qwj)KL59w zs<#KwOF;Ki{OFQncw^t{0*gCLzB&B0rO5LV6_wh)0rc1A?aJWo_ke5*%E8EPvtIaj zCPQ1wuYhbRLqPT|4wM(!LlBx`ioFNz*ww)~d7R?VDcxy?{099)5Q8HQL9FpqpP2iq zT$bxK_H`tPn#Qjqst=oOh=hTA1_HZVo@pE(-BBgCwf~%>%L; z&{u)1pb7VmY^Yy1eO3w`A?XRB+O)X3hoR82?=KT(+P@}VV7XK^O zs?#QHEcoTyh4@}cW%3(Eq@#Lvl+fmAm?=_!qWWWt6jZ}MTcB_79aER%s@H)^Y{0*! z)kAbHN=5EtnVYNE(l?a59FIsB_ktq=6svcT-vmEcy$R#6^sF8HPVt=@>a2dqS^bE2 z7J?!kBrR~sM&+rmdnpkroZgUUiZ)=kRj3>Qi})$MH0m2_@ZV>LCvPl4N5p`p)JAHb|E{ z7zU%?I1z8)#mCC7lgxg;0$Wbq2Id-#t>E)SV}43o(u!9g=j4H6T=P&_n% zvMgHQ+JWDJ)BXXeK$gAmuQyz08HO*q`69H^aA0Vo$AcbM!HTUvk^aL+szJK=4xTzs zE!Gr~gs!8D(1nXieP)`sMjJkqSndr^xSBGscp%ol!{3*U;2uM>?I9PPC$eb`Ky!`k zng?W;;dKm=e=uo(6F@Rz*|ab6M*qSk`2hO==AjuYljWu4Nn+%Nk;7WDAc$ECYEg<- zy1VWr_o<)bIEHALqay=;WN^Mf|CB07MX@iMnPH7Ys}7G#a7PApFV0bMdj-#0p>M{n5vsx1Lq(6ltTZb!yX?Oh2Bqp2Md@|Ct{BqrP<#xtclDXT^9M9!QO{#Hwx^^S+zlsYnA>;M)sH0_7gwK|4S(va(k1UtWy5a@cZeNsbg}_Kl5V&< zvxx48t67H`OVIIdbPo(t+H{^xwT#85H!;cWONThJStO<KUgxB)p=mdG5DSvZ(<%d1l?>KYP_u|26wIIjwaqI=ANspm0YfQK0&xQ1tx zJDy+=pAVD*6C6I>)6ji5xkYRDHPQI{G+$UYbWXvvcao4@Q3|>DL*H`fn@`quioSD^ z!iK}$4hZgU9n$jPoK#~^(p{UZ&8I@djXQPFBuKJ3HE~}n6gsFmP3TgK>TppKy#8Yd$jcwiF@^$nz zLTj!c>K@9I<(dKd1{FCWc+O3{ac=rCe^=xcxH-0_4A{+wwzl+^ZrROsW4Z(U6?_BD zz~AvnCg&t9>vM8XB(v3R^h%NcOa`li3ip1Fjg ziER9U6+w@B5{5Ch(eeuYN8ByuYWF9_EHk)98qsy-pae~{?d%Cil>94f-Ef`IKlRsA z$~jt+I5+*LX?UsHu|_k`f>j4^`jLLqUo`z6-gG-2|NQO$GIgJGJb!Hahw`yC7>T^= zfezmOF@F1X!SYDd|E1cmh>0umKjQCUa7)v&kV$R)in*@16F$EFVx2MbcztMd|Md)AGyBo6vgX}4IoID$ zJ6rOc?A}QLp!)2zvi%Xs^wO8VMV&N9XGaKO^ZJ0}>tMw44fsXGV&*=eF#dl3J+ysA zUMuXN`9~hS`N-g)`AtiT=~Lh^CXfkCAR>-8iPZTVR%RvLEpEHf0QM!`r$!QQ<1peK#_azC)R;8rZ(qq0*jy;bWqq1G{qcMNe2@9>YA^TM zIxD4R4U`#t(pPpgBxIYe9ErJs(F;}?TIX`qS^&J0 za2>^Q8Oy%Vpf{dcx~!+n?-^+}DUP*3y6&1#NojK|n|f8P5ML7!cvakG^t=?SeL2$S z?sYyl$f(D7!-DkWY5t1TeK=_srG=r+fvN_)Gg*$JAVywsZqB!rPtZ_7Q7kB)AM>#0 zF&mRD8mAYfKqwniB-r$^r)j>o0^H5{-DQ7#E3V`$=zW`aZlNTvFQ=hIuWR~vcH&pS zomSb2#zzVYbWwM>5557!TsfFIO=xj9`-6Me7Mhl9e3UYip~omT(Kvk%x09wCyZR`y zr1a`N@z5?ylE|A*`$EQ+SvexoMMcEZPEOe`U$SQPkG?vuo;xphy_A1zoJaA?JMKLe z0@wDXx&9Z&ES6chi{L=>wO*Ou;a8Dg9vLKyCF1xXECD3mfm*J9J0LcPqub=!8Z|r8vP9U4_5_HNp zjYV$>kac8h_0mEmA7-^`^F0?pKR{=*X%`}(Ep!8r{q{RRJ1H+z@vS?byHJ_}^?C4dG^DYJm|MW|$Jknbm$o9q{j>~dM?>l{F_P!(rm zEYuS~m$FQ-Y5xIaH=Nc7(D}GL*|#?b&?5nKVuk;?2A#E&T0s7X`F7%U6?6MLs|TM^d_N= zj4BLhGgOu-5Gh!NC1!H1u{pMz@`|>lRI$DAQ5L8wevN!7#oW3&^3vN@yaecM(^v7C zwS%q-peTVp*GwY!fqO&<+(hGRKQD=DcJf0e($snCMKtISH!SZ;j8-n))ly|Ut$xZ` zKu4lxNI3ZYJWghbv3_SWA^9Cd2ab}rK-A7G@?YAgmujh^YRb}TJBsU=*U>s4JD|P> zWV`(LK$czZ2C|)x%I^EFRNSF%OT528G}FRdH+!E>zmfG6Nh5dCVWWDNRHyc21dD z9es_8jwOi_PvPne)%yYO=VjGZ`gyW`E+{yyIhPQg;nX3{r!?$wYIJ~QPF{yqavZOo z8g;&qdyO|XNTBlUe$APLyBct6L!=T#rNdYep?vB)kbtH|Aj$i(t^+hl~Q zJ2h3e)mc5YD&e|!(wtOdF3IJ^<{ihhrp9rOO1R(AD?W)ir*}HH=A?I<90Q}xBYxKZ zvz-jfYEq3Y-2m{1>-GX<{^K|Njc3g3%zyOo!+hYjC_U1*d{MF83%4=1MFnMCy>882 zb+q?s%>7Nq)zu{+_m^zt&1EpHoE-!*p> zdXBFTgl)ebMH!ky68=Ib{z5#b20H2-Lo>xlTg~y*9xK~qJS`u%7vUAM$@hZfL)eSI za1)!VtH`KuXkY9HC^?OPN1zPYZPgDSBj^XDS2eN+7e*n7GOuO22wUBNHyuqZ& zPSj$c6p&T)beFCCZo(xp(6<`s{{(M!*1+aF6{yX;y%oro7ri8QvA+dthRSYul}<2N zf}?q)&>;;JB_;il1K-WdTSjN-;MhRNdl)XWw#3i++iK@V?exkgHAjauZp0QEHzJC07Yd;)mHoA{j2ur8M&s$-2T;;|nWmk(R|CW!L>(MYJ2z@t>R#$Ht&x{XEOWX_&8*gE1NX#gooslVS9PlKdZBus@o;@F zsfp}KZT`TwzR;#A0~b==QN`6A^+%U!af4~wxlwgkLt3^0ztGK|Qx(`hFal=&>09*Y z?d45X5N2SU$G##@%zcE;8U$l4ibog~?X%^ZS|n^nh#7APxZbcp?A$4;@mpg;Vn?)< zz{&9}7C692EyT{=%~-UC+NT-C65_0hnMD&)*^dLMP(oq4J9%;wnN#zy#GB_6)tFDm{(yXt z+GtRs5u5O1c)U9|>4pMbn@(-GL9`5pn}~T4!w;Y%#U^_;d|k4oFO+1)CY}cVA}flt zAlgDh)^mh6+9$F&vl1_YRQ)iCJNS`!(R=fT-k6j(D6w=&2en^QZQMD6{_z<~Qus#x zR)%lHkVT&5{Z0*s5?hCsenfI8{P%`j$1lO#yS#d6Lum8R=0wX2r7^M2RZl?)7NY*7 zuFLB?FQkKZd})1b$Cp-4c2vRB@l13=A~T~Rkx7*4T8xX$rI9OM93&I$dUxFrEP5OF z%ZR(%a3$i|CaW%$b&BIKV;C-7CGSdJ-X_0Fx2xVcJ)dsek#=9!@-fPb%Z$c(1(d%v z$Ir#pGvo&UafU8}V?Gb|;L0e=D6`4@e}z*aye8_U{N{%^Q87l%lspe=7Hd?E}a6xlrFbt_UXSUH^_bM!{kPgAVkn1yFIumo~v`)<~(i=K$ z$PC88MKxN_G)W#Q-)^tm8q-(1!Y$e?#PL%v-p*8 zedbJBxq5A^7N4u9b-8Tyilv`PWzP}4In?r1j-AvXBh{P+bg(&H$j4VyC@ylFtOPB~J&kUu1!7$v+ODp99%adVp*T-U-q=sA+|%Eqam8Br@S9<1Dh>WpwTs7YhjB>@=Q|POloM zaHr2PSs8v?2D9bonqum5?$zaF%(yu)W!2@;?$l~!pI?+cY_i7_mK`%KYssCRR+?#% zg6_8H<9u%@(_)5OnSSVou1;r!|IEw+^J<^FD-~B z=Hl6M-0Q)6T`vFJsLXf5ut4TJ<@}{RQxiCTo1XLB;H-Al_ZZ9jSpHeo%G0ajnU*~y z#WSvU|CM-pSH>*^mMT$YJ73<_qEhwWz}T)9m978W7WF1%x=7?M{hteUge*c^)<$P{ zew6o?&HgHYl0bGC{B@9aa{%29WLfVWAj`JnsLwK?oUSZXaKxP%Osw5};l^ep-2S-x z^ELe76hW%-Ybp1tvbcLegFEYrMB~>ghM z|cxSOUg72Bz@ts!EkHhK#$m51c_%zJZA(G*uHgE*{A>sg(D}YI8%~ z1LKujzsHeFAK~K)=g<^9Q0ueRpG`TdpT=MRB8j{Sv^y1=OP`+E^<*l89;qucmRzFN zj8+BdSmd`(_WAMPsq?(-ng2=ekY=mb$7_EVT&8()-+jsI4Rb-`E(gU zR_5sLl9ktzSdt8N4E36peV)SLT2qSOzPS54uG@G%-T2~p+3>$;lAWB)av5Yce64;= zBHoL-Fx0L2Cw#5h9a*rd^~t5-$TLk}Wy%sYTlz~EU!*@D(;wmU^W-?v?Yw>05Hw1{ z1%kSKB28|6@~Zbmo)MY525LDRGVoDKtICEy8`*Bib9`+l)Ttz!3OkY<f-JhUls78c`g9+`@CI4$dy(S3M?vhLKF zRR?#0P`KZ}C= zdD-zd6!c5n$lpn`E})AXnf+=`N`*78LplWOg8O1`lW10B&O8OP)cWAQ*q)I&caXSu zWKPx%{dlC(=w)YWJEqE~QMofoZX7Lxf!wgNQeF3Zg{>xd98E#()fW~2^&@TA?C{TpZdK-R!C*Al8 zE3r|rkiveRpPl$GC|5UlT>Y&guAVD~uGOE>obnj>5?RI?wnq33%yidtkPXg`i?QPp zKQUO=5odGF&%l}7FF!PJ8m#@XIJ_N$xlJi2#cMlbl0IZM3FDNJuLz3ON$bSo9MXZa z!%fTZk4|SlzbBc0VU#!5Ch>ZAAL0IxQRipNZ&9aKiGJ{-p`W|*dZlHi7{Ud=48?+9 zhE%~XX!Jtql3y@Y&hUgxI`VMS*nv99sXBRRTf%KlhBioE2kUuLEfn2!@@}nWL6`#HRw2vW?lqv2LHoWPq;>SHq4*Tn=@nLeHf_FVu(L8G1M% zY$Ff(ie!x zAJrd;oSDV)>s)vJF!A+i=ynw33Pa<=m0mcpd&28C5XlO!jX*=)pJSTwgjY5^Jr(Kx z=8^vf<|Sl zi4(P=%ZM$d_S#e{wu00?n`%XtNwo<*gq?1>In}rkMsTt+$0DI{@wXD{ANj3~GFtivZPL!swYlSwXLj8vOB(UB|hn_Fu=&L2F6rjd%^sfNm=ud*7 z5_gl9t)m6jyC}tlNPb3s1&dp>Q)@JXw;z^nHR=59*|z$|d@5UhtvBjIgs9NgX(Kn6 zjlV(XV4}hN{WmxVi{p#u?w!SR_iLKFbM7wKzxFjLSg#Ef&D}fT{%`to_nDvNhMRER z&Vl1=Umtqdo4a>1cYo8)-Hh|qJI$=UlCE)jKkYt?ktLlyd+LH!G3RGv3W()k|LM7} zAHfXNHE<%|HOTn431D7F!QAl$Eqjq1m>otXTh@k?I{5H2BYk{Cn3yD@%;Xd^c~s7M z(pI#xl`c0-NPWmhm$V0(6P{kw9@R7|9eOMs+Kk*bI7Cnht>%1@XxRQE$*4EVJcM&FXHY1LjC1>_YWe|QKc#+Il>q@+W?ONR!Mp-%K2iN4pJ=gY^&r0pP1oEjpCbo{2&nfb^9;wTcI`uXw? zFL35Py1@BDhyRirx~2>k=QwpgIY#*zC;>sRZwX~y2LGK(t-uknDuqOBUqEve&SSDU zAg6_JRhoOQBrHDw#)^eyUfm=^O)?uRO@_KW9A(E}CnOk*@FWw+Sf8q0k4s^)c0)RZ z(YrsKK*fWhCSZz9XUj9#dtz?9Vh^S<=?F{#uO*yQbFU$^!2pV0<&+nvxbaatl-y17 zCX&6o3#RPQr*G`<%^Pm~6T?4IN%+#C?%gDjdalt&lZ_9hYPTd=Jf~}WuuLDRre?=C z(_Ch}6Q{W0QD#!QFuYHz_L#DsGKkVJP817R++AKp#+ngRA9~pgl-SUNW@r&Onxl)8 z)1h|)72+4fE9_4rR*k?-0Wdrb7oMN3HexdnyDm3ySg9)kjF>&J;9YMt z$}(c3NFYQlGTE28_*Iz|(_&BJ8olxit8MHYn9tky+11i(X7xF6{s^&aQ;Wv&dz8Ix za7?Q4<+S^Jy0#x%^{7MTvwsOaE7A*#=f*$Vx>kCTk^6N!VJ1Xuxan`q&CnZ?wGXjW@&qDc4~Fst zB1Q_GVbz#tyr)CkwDXcZ(_}T{9gSS0D>F*J!kH;yaC&rR3K}vC1&z|jlaZZGV+PKW zmVcHvSRYK)Zb)LNO4oKHY0mHlYohjH2I~nFP?2HMLKD*WIOEZ57Mo`LD7ry6D>D{l z2BpO-v+s%yn>8!QLh>+xukHk+&$m;Wy_rD$@kgJuonyswnj8;j(3M4=aoQK_L#yii zcMZH{G+{pj&(m*TpNc*Hbm#OP#ad5}fu_|q_r3(1Ja!z62}axc_cq#&8K&(p)MAj8 z0m?*r$Ybk!(9~C@u*Vy_Q%!qyGacopHBBjE>769V(?=#OUSOFj8u+D7t5h;~l?;lz zo`^+$<7DMim1=A^0@YXL40pOH{FV#SZodq>HR6V3c2QZPaXSW5q;I_TImW<0rE$ba zyVzttC}mSqsa=nP&5Cg?OB+Iq%h@BwK%#puD#vNSu~S98bz50%vjhBa95YHX(zEy| z4APjPV{Cj^#s-;XzZe( znfme|pS^;ak`3E#>bI9tDy-{VwqazKtE1WYiDkotS17+;Xe>q#rXKJB4jyg#eg8PJ zE?7k=2mSBsw9a}s+y-R5*}H+Zh2_KkG*GMA+>uYjIs-k*8=H1J!o+^@YoIVT&``-k z0rX@5^#{;iAp6DXxNh4oeh74Z+8RPIzm{sY#k1etz!a^ zt>Z&LwvG>@EZaI3&<^|UH-PN7D}d~`Ss?rE-vilizeDZz+dHsDuOmHN@*EP_QsD$* zfLdq~&~FSC76UzEprt^rv)oa{=V>tL_yfGO8+^ucg zF13H&Mp+5=cZ!Bp=l>z?I>Rjq+(k1DWyKg;@uHjw@OfB+$HU#jBYWM;hpEQZjvY}Xh1d2B|Etg`>mbzGfUO?DyQ`b4J&RG&{k10JF6`1K9Y7f zGhzQ52`ExSZa*G1ET`D?8FWrt|E)1gM&mXzFvh9THE-R?mbb!9-@sIv&VFHUYz;$` zCTvPZwglqS7phT&YCcHyg=&77)KKuC;#?zzY7T+2t?B!ctYZfzrXw#b`xsRtgHFYO zbDe74uMFDS^!sG!g=FZr$(C0TxTir2>8C;x4o}+os{t)}cMC`JmVa2z_LDeyx8w-$ zG-~mY7_Bp<2(wW-kGHPrzv?z58dp~5_}J{;yq}?MwrR9B@FE+U-5S|O0d6)C*8uJ? zo96&`RrdDhT@ENG01lyVeBA+S*7Q?c;*_?q9HmswraD&9Pnele{P2Jj*JF{|LikZUDf48ZHSTJc z+Tfd~vGaickLy*+-H>Q`8;oCNs6KnIEE2vZ!nyo-Y7#C;TmXPCxD>zg>t1)h$Zb}0 zK{1i{s(2|YZdO92E8kb1$iG0i%=VjAwsT*P^Rv9Oy2q6B2@1*gk6H0-$vZ=(p)L6r zh|)NI(jQ&ynSY*QKXo|8zB>krIxdyU>wG%0$!Wh8s-+^EmVL1p+w4^w05gYGmycv( z!hT;uV96N-f;}G9Q@UmOjn3(>4jVdB9@l!jw$2Ql@EP@?M~G=9DK8d#NT%SQpk9c@ z{)H#}w9lAMWWO3tV@YuzMXCcWhw9~F>FP)9Cnf!>cqa$gDa_48q zw<SCX>3;nlK}K3nM$Nk$oN``$Tkl z%<|LNrPUZeU<*c$Z(2dQn2GUV+^7Nmcrx^2GW3ikz|S?t&p_uB0TgsUumr{3-CB4W zYNXshDBX;70cPmytq})GF@s;gCxvo9HUX1J>yyjB<&S@cf72wh?bv4+=Eq`~v2wk{ zZ>wYAbSrT2{6BsB*T>kj_ltd43qIJVat9X4i zeaB2+hDkpy9=E%lrrQ1Rsr<%97IS`mXs=;ayBs+klJt*3PZOqw&_@t?204lByzsE; z=OLya!=?d$K1bV=?xTi9YajJoQ<;l=7WG%cPQ{$D`(r>&KC|c^6HtOaW@2L1lg936 z#u%BCH5p~@Z*CcxGsdhyR{W&)ng905%F%zV<%&7=sDYF?HAy!UwU5HD#~6MszYcyq z-bEOWXlZ;2QF z@d*C>)VuSi)Q>_jVuA3D!`X9^*mEJ1u23|eClXVfiPZGjah1o9O&1=F7mK{5-T2r& z@R}PQn<)hjXJTO!~%q=33+HvNgVTThnfQ0gO>diZFmxYUS~& z1&V)OI)w+QmNH3qb`*JcWJ|dmTY^nn0%X%x06lE#RU`nrR#zl|51JO-0c6+evP0PQ`(7ZsR{y&) z-&*ibK(;)GWrDRJ=voz<_Aww^$0Q(I$5}wOjwwL4j_E+Qj)J}7c@{PH+gE|?w|jx? zw?|;Pu-`gB_S-m+ZQphvdx|y;4?kt7PzLn0fy#lNF_1XC*FfWeo;A<}pyv#96437q zR0Z^V1K}!L!*DSIkpQyZ`BUQuTAr7uX}5K@)UI;D&2*N@uUXF<6cckSy=yu_p2s&3 z!t`3UejbKNR$ytb;XNXN@6vr;1on6v$QvrnZG^dKF1NC9&^NJ zQMU{SPR-k_JEPWza7G|qI6(In=OK7CM}9Q7u0zZ%uEd?ZjB&&OWoBcW{sT_UWFl2mc@qO1ei3^{5(4vy44_CDkUUgN!+{ICws4 z6-4F4q7G0atSAOh<6|-R2|12V!tMV_Hh!ux#i&^dSa~GR;)NGYeLdz9HsGy9>(=Fs zs}N{IIAqO;Mdl2JulcO|dhHHcq|S{EdWAP~7j5)4Bhx#X$tS4=1czp)N=GXi&RjXP z&Uo6t)pWPl1lotcIzjAJBfXsWu&VuvSLv@M?D{W)>r<%=*V^+AG22_UIg9d!J z(14-N$abea!~_GL@#}}ySy&{2c%^96;so)&b z@n=WqOCbE!I{ER1e5gzK-X6#ZXEoY%Xg%R%*{pNJcgW=}mI=4B9af{@K=VO)++%b4 zqr(@yv{M_|li4N{2NAc_P$WZABJ!Hk{x$SFNT*J6osroniSm~)?)-)O`Af8SZKyPp zMN_CohK{z~X`VLll#W!GDU~YMkgl_hIrA)>ZB#cjLU!=vzBuRFKL{{7$0(=$34XZU zE1qRe@s73Ox}hL&8d!vDm7m$?%85}tgo8})0%y_h8D??oB3lu|<$~nWB&#@{7wFF{ zInLrK`z3B=`4XNOS8!F!dz{Rxf{5xu`HG;!$TE)A0Nqn_B?vXANyh_efH*vZvZVv9|)J+1Z4f|rODaZ;xQmA zl68Tdg*FCI63xS=>7HNU`2@RiZu}@*QeXEZ5uCYqYuA(V7%#)*-ll@@sBY##w5!I6UFpWA zu5g0uLWo0llTO=UR8Q6JrX@6uL#DWK4Rxin)z_ijG2$x5SDUMno=)s~GTE{h>&8D* z6ia>%mwH|=*>bZDE=vIZ&DnbFnHvR3&S2FB6NxhAI51)Sp@9ylgnHjGyPh5*_TMV^sLp zluH*PdoewKCLMWd*;z^VZG2rmLzAyfy6b34D1iq|vUY1Sv?Wo?F+D`mEH0vT8d#lH z%7o0`AO$@i3%!&y-fS`ry^2hbUt*aejZJ`co9T<9R#mX~AS8#_b&Z9d(#~HMUG{M9 zQNU0m8Ci=VQftR=G0z&JeGLGjB{)9HDcl%g{A;_ZWRdZe`e4cQ#*?0z-Z=A_a3b== zHP^60XG1WNe>R+`-9|IZ@GEBnFU=8Cf5i^HSP1399%4bFc1s()EmIG#NugSQD)~be zx^26z9~TJ4`crv<*&;PV?Vr`A&|q??lZI8K%kPSygC35hZ+jt;qUx+>A2gFTe zXCJiLc+>iV0e$cDgN44TBVJe4m87~-)Xxjxlm_Tr$-jzua9O8yWi$woy@8$K!gpe; zWSM@?(s#4irLNSUisMF92$xpIDheNt*N5Zv+f;bL1b*vJ#XJzYp7XxLsy#_xpH%p| zN?%tMs;%bttZJw|NlfXq9tqyzhUKFNE+f`dvKEPsuVUzJc2}mt76yMfrDwwrP$MIv zm=_KiKU7z42>(k%_&!Vcazpr2#lSi@X9#~UfWqA24s2uFC)u8X0q`$lf^uI=*X~M% z233j(mu#GKd^njs`}kzzna3w0uRAw=)^J2;vT*?Cxqu^{G-InXDQD{1_33O{c1Sp( z{8bsN*#G;HIZGYB4m?#P;eb3tcvKPfktnH84<~;`5{mozz(i%K2v*167 zItp)KsB<)csF4jzH!DH7FeEK8nw2oU@oYxt9Lblrotw6jl5jf{jc+0r16tfbYRZKc zQ=ml`w~~0Y2(K}=Z6v#)MY((%=)@GA%{3z`isY%(pNjL0m^l*qBqVkC0|p_1!7?9J z>cjIG9UW#EnT(W?IxMIFJG#2 zXJ%$c8Lndc!k_4IAg(wsd$vD`hpP$2R3(8wfuNnvjZ>JHlbP9EZ1m;cWai54>CBZZ z^$4B3KApK5dOU1r>UN_;azNLd%#5?@Y6kHI9Xs7PC(pLS_+_WH-uzruX{DHs_| z#ha@ALn?drclDA3AhGP1xpk*IS&PrQo##2klnQOub~Catk^KflGCOSKPh_Xym_Ho_ zV7(mSAVVs9QdT9cDhSPZDUl2sqT+<8Kh>v7;gbf9H(Z3}Xf-QdN`{80*nmGIl*2F$ z31vwzFXXJ-+>cU`CzxNZNf0L+^yNyCq%wC`0R7JgDI3RPEMO=&@uiV%Mk@ zVQCFU0BF3Kss6w4CRen6JfMUC$umeKk17$o{{vt+?LHyh^`=VTq`L{`V6{~a!Eq!+POE8ooM(a6?)3{ P=;5BoZr)3xi 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%0D^%vtLEKxmosv+Rs>|1o%?zwD{nLHEahF>lwE zPyf(+)Z@3k@l3ZRqwYBL*@9|F+X#z4w{13y*v8 z$mG1uFCJ|@?AiKY@u;*vPMN*-)!WCNd3gO*s}78K^N$5_@1B3wz6X*#!>&5(_oc-n zE*w1lp4zv3`Kum&xqtYgxMXAB?=K|05D^7nh z;o+XW^Nzcq+y0Rges{t8h}M|(f6aUPu{XTcgqse!~s**^m^#F-~Z*^ zw>-Pw>Uy+#bl4@2fBah3e{D#)f8`CIeLXPtf!*QWCvG0{aB2L($bznqU%58x=#}fz z|F)>@@2`CHRFCsM|N6~uzpMUt*2{~oYN+o070+>UUNm-o$0+( zAMg+S>ySaKMh(9DrSDHacksoDk7eCHXYR7g&c1HYzqUM3y7ATe?xVLqI4R5UKXKOT zn|2hIUf#vGB;$pZy}ae0M&5Mjn=YBj(`Mdz+~J!y+*e%l=wEX(ez?3SyQ$lwyH>3B zRKL-?e(>en zAG!0K!z1S2_}*WpoHy^1i355zA6Wa%85JX6+x^sEZ;LIjyngf1jpy9-#3NICef8AZ zmo^s7Z`-}--@ZZ1b|tUb{;y%D4xE|pJMiwGXIxk?e`x07$6pGlo}XU2=C#B9?y9?D zO88BWUG{yT|39Wje>*3kI^mZ6w_mZm^Hud5&${a2QK?(b%}cy~l>hMUBbKJ7Tz>V= zqBrj=TlmS#U;hwx>7o^LFWKMi*-O;}4>g}~QS;LuTz}WKr=`Cef7Z6m!!Kzo_}9(8 zX{S6H$W6ItW6VoS!p!gXm{qG!{3f|iV!zqf^nSKw=ojhJTXt_dht=p1{{@m}4K~JCf#{M7DuN>KZ@MRmW z?Y#cO*W2=rJE8A~oh~_)@@kiDA4M1BHQyEe+6jSIE~`EB>eZ)29=Y_!^oPpk_MCg) z-v&Lf>dt}pCa=8d_=m<_AE?Qxz5d4fPoDDr*X8$Z{rrN{_H=o$SGVupKWYA>SN?VE z#Jg@-*}O64nKKWxtUEF0=H-t)`BjgakJO?SCtUEyhbk%$EWh}cQJ-9#_{J%7{@mm1 z3Gc6d>x7FRZocoE9n~kFHRhu#&-$kBeS1fJary2slaH=TeIoMi;W4x8?|h`^>t&;w zzq>W@{Y8OULo!pVF5Gj+rAM>>)5q789lLGv+11M*I_KGatG0UgfBQm@3u+hMwb@_4 ze#Y60PT06&a{oz{XMVfxnUn{={IG87U24wE=6|1dYx8xt{XOlzjC;a%-nez?CntA) z;*+++doQludGBvu_~2si!pyIdm)yK9?cuuA@2dCqn47x#z>%cirF=7^*J>a|FOQ{BG1DkzccmT$_MXwZ2B!HjK65c74P2Au%vZT%_~>@{;B(J^WFK~ z+ASrI-QAWjqyO7SPJ5%}%LTU|zh}nmEho;|TH(n$-W*>Q@$uzq*Ikd9UsFyt-+bhy zKYY3V-solDWt9K(!E-KrX6}dGum9}))a&1zSiML6qpzFx`P3iF$~XSk%ykdEc+T7F ztKM$=e(jL>S3kbX{C@c2JNLgiI^A!6GiScL^^~rcbiJ#laCYMM?49QCPu~8-cgFi4 zhnrt>etY42(;v%P6ZZA0wA#J3f4bW6d!CB>!}!@>l^H(cw~5D(|9PwTt{`v0G#>5cWm9TbHw-e9=ha~yeHF=>Las0`s}+09(@0I-#kBS*w^u|&AaI0x8HdyeQn)G zd-iQxa@?|ysviH%DJMU*-QchCZk@k;-P+gxusmh|DKA9quADn^>wqgS_dXE+`5UKu zM%+{Jdgrzu{<++nw&vm|#`Re6(k*k3*4BUj+4b@Hi@H7X>6hJ_zTbKIk^C#8cYdCK za-SOmrGM&n&gN;8zdJtrUuT`3J>ZFBkVZWKx z_3_*9e>-FP=?~O>JtC#yhkrc!U*~4#Tg_S_5GYxzCP7+!lFY8lg58h8rS#M>3s0vUd#7)WxrfA6ytcgX>s+* zmi=R|j|)?M)HMHrtXcIzi!1C}4fnVGJ!AM-CVDDwNqxn;6n5>r@!Mni!j?Vg-rmV& zwn;h9V8^@W6>1lfTh3+W_KNIe>!{y8^e$8M{hYA@!99i*L;MaU^{x}#imM{`?w3?i z3UThuW!uscbHDkvOJm~)KheHj9eXb>S|7A)`n+ojlY{MgXJ0s5s?`@gFKvshkVEN3gH_sQTXNZKkh`sXp zWPSYHMs4ev>fKH2^yOs2^jmla)W>~e4}Y;VnAwq;ab^ASLT=q>-!slSZsETym{?Nl zbLadc4lW_yCujVHs|@;hHMT|y2#Sw)l_=@$KgIpkLfrTDvGH?eM)Y}!+;5%d&ne#| z75FHjZC_T({lOJUzu({UQ=i=4FmroEIo~Dw-OjuH?9dZ@ENW9-DVOep{#1 z5ED}UYQ{$gUvY)*w|})R`rke@`0=?@jnW6c(;iD^nmX^6+rQ|8uAKPqw3e?DGWyN; zdNY(}?eep-e0}Aqh(SWxO@q?XU+jI&do}hsxCq{vFxOQ~_GXI1{1qoeyL>P6+|%6> zYJAnDX;XrL(mk$7{pPN~JtAE#<2(G74TY!8IAzbp=e}$DiMy;xyN^!UqozCI-117_ z!TkF8Ws8ej#z&nUcyXj+cZd3)zN>5Q@Xs&SlS`}nJt1Koci*#XLL6H4Dv9D}d?(MC zq|n~H=}Byts%PJVx|r1_cPGx{&aZWEIA+-unqPD2*x`@dUnS10{A7Or_J^ve261;P z7v+W;U+>lF-uG4VQ+!uJjN)IdNrNx$-!_v zdnJ2IzK=P0*z$+tj|p*WHZGW5)Hw7yLKb3!{?D&90<`Si^Pb7mg*jedLSo=x5qP3~>>$~WSl7Ju-$blyi>BwnWW z>Z7N+ME|~N8n|vAzskGsqRr>dJ%4`LUlvy9Ziwb=etI!kGqE)_VuS6u#67+5b50(s z_z~79*B(60?p3AZe$ydd4pZ^BRj)1!PHVgO&Y7dNVY;r1@33?jDHIED0R!sGq5!r+RpDi^o0NHOpd+5{|h%N!`@m zspXuv)Cl~^zAb4pXa9+YeQ#ijO&9u*=q5? zN|QH*bGPR%?cL- zFZykXw#|4aTvq>Ackk-&b*YK#*7^7a28o!?t|&hG)BL*_@4e>WWB0-iT)nvBTFZ{g zcQ3Dsd;Vgx6fOQy|AMc~q~_L|@?@j3?q6}1rs+!>8#mvbF|{+aWKyJ2h0Q@rs}$?| z#P|+>dFzeQ$&w4c-g4>NIDdu2AE{d?R?ICj@wBg3_@YE!-b0Vlj#+y+8~E9Ze|=aj z)N_Q7tNNf}%A4CS56hj>-cKA453g;n5n8j*Se!fWwa4RiMkr?=!gXWkAn?=+|dvaPr*e`e@h2E}ocQTd_(w zezv51w0r!4T|p~ktd1SLA$)^7yn#=AYyRX_rEKQgdJW9|X4Kj_dF{zl`<&7`gV*t1 zbGE0C(EQNqruZ={vZn|ADc%)Ws1{o7zGF|#+sT3{Gw#NUZII0~i!>`-W`9^UNaM$a z*2)(*&-|)ZFyc&+np;`c)j08Nov)^u!$Tom?Rh79xP|+kTeT|t=iNB%&9820{p#;> z_oTmbHT9+M%_)}4=@3qsHtqV7*ViRmO9G#!@M+z>pH%sBk=mc|^-rIt7mR;%E=OcW z-W=n!t0#89 zn^aH;9hAeR%(9{oyH&g2z}f{htR;q#NIt7)$6&%`}?g zhTfbUt@q^4%uHGNA=vov!uuy$R=Hd;I=gJ9^U851{gX3VzZ;)_dbqIpthe#{8_yR@ z@_4e$5Ym_xl=wV1*b|_m&BiaetiXTJbSL162D9OSaGrO z-)SAMmuV2?b4W=!I&NARvG@D%I8LYgU95Hw7c!9pBxn`+jveJzOr`*ro3A9F#tn36Dkuw z@^_q4b@S96lIK>v_h4++l&Z{{iN~gyG%Vlqbf0_9rD?yL);^iH>Z?!d?VOWcZpTfF z7StQP-gs%;!G(s7Qp+AUzPvH;Q}V#RRPH~$?mXptzq)E!S~)Jyo@Y?V3eubx!EJka zz*V}Zx8j)D50*@cte@+jW@+(rx-%2}cGoMmJMm4CH=2D`?@?*%qWLWMO?n*)tG=<@ zY%Ko#q^wY;{F{DZg5ctl1sXd;Pb&2$he=0R?D`Q~X?vMFXZ5p74%a0^O8DkmtGu4R z+9GiG>=w&K?^7R7>ki*j=C*x9v(J^|56!+kvg#i5SIW1-#9O3h?l*xMhcATgdh0Yd zwlgPnZ0YVnU5}c;kNcB~`k!0Y#&%wRCV5gpz5UyIcXkWHf4PUBd;N-5xuu={jYePl zyjQ-e(+TG-={;7Ewop~)ppo6n=Q)>o$347}pjY!yT7a)wzm0cGn0;3K(GYQ+%C5b{ z`6t%C&)b(bDN}#`yr<3s;ibg+q`c{m>F<_P-sg+I&PxiBk|ECjZY!rLw7MNpy^!G}L-;9u>`e{A7=Twuj7nb`(^ zI^+0+x~k6J=C9Bsjz`0owGGpjI0=e>E4%o4b-?unS|^u$Z0GYk5T{kspOGWF?IByu zp+LP``I94$_zlD_I;ib<((@Pp;5IGSzMR(&8lnTea`vsO9qYCGL!E>MkH((RbZPf} zuRhFilRrB7$k%h35p0gS{0bt6=5ahrkM%$Kai%!?wUtIWdt(n8M_zQF;w<$<^0TcL zZ&LHkALph$FIC?Enrj#DX5GBcDN151-Fr>a|IA&^D{^kdSD~qizgv>d-Fc+3rz1Obf3Uuc#E}CuVQKBvy z;aIeyXT?nANxYw~y2+FlaDL8ZJNLA;?PuJ@Kl1k{v}{*!-?qK==IqcO^`_l+Kc?iE z7xC3h5-_>fpOeYWzt_`G$4~H{y?Xk}nI8t8*zWc`QGWJGdZds|cd@16-X*fU9Whz* z!FziT=-FG25z-^d(<;3fxg}j}W3yBD7E7;ekNgDH zpY|{1IFfds64M?x)q8rY+jB>xA9LxM~_TCzf@68#HQzFOmQvWr4_v95}fzX@|+o}@iy4$)Gn0P$96L#_2a&q z9R(4w_jYTf9oc>BP@LPTlD5KWJHM{t`LgodKdH zW@=s)#|5}Q%?-QipWqy4uUwNkez(yqjY&&?+21L#cDG%>bEt07v^!G!OF!DQl}-$D z9ejS{kcPxKqm}nJR%W^z?@?;uALI|Pj9$6_QD&iE$e)WF+}?C?mUW)?O5?4L+AKQR z-G28@vl7Q0ipeE6?}v;tESMtk{P5#hI`1u7_+Cn?)wK|>`?Yy zp!TEY@#Kh4@i|}5ce4i(`={0Ns5i%i#7X0(IhvGRzoiU5IkhRe7b@%!f0>J8gRoZa zKzaNQ*G)%=>v7rX5BvtWG;f=2eeK+la6yf@{x%utm>zg0PWAG+>W6|yqg%fZh}m~L zHO-YTjLSOuw>bW5-nPK%hhV;vS>6{OS}K3FKgxBsZQE_FNxavubITt6rg!C%Lf(Nu zHNjoKZy#8zX}sRLNTNQdj#D<+EL_l~oA57<+@Tn8+8)7K5E0WWvgLy&Zl>)L^ntmm~SwgDOp{Z`#?un?R3Qb{XP>5 zzGd;*dt0arPPG(PoL`|}v@72)#G_Das~ZU)8v?J>u22`t?0=xn)io4#evX_jfqIDG9zy zygrSCqaxAr-gx4AgYB1QawltNJu#mU^BM8{L_%}+o{pfcYV9-Yymzu*5cAE8d;Z#z zem@k}-H@F#g-^Sw>degvRs0b?5~m{-GhEN}R7QIB^NW?2dv!GN9-q2AWa8z8y0^>U zcq>`BA7wjpay#*QRC09omx-xsmVcBU-l$HI&j+`2aPvq@HjKF_{^dPB?mSsL@(7N}^sKj9OY|3qQ@f=itTWqg94HI}<8-2QE#krh8 zg+uFj8U`=8#O^n+InE*BZ8~?r#%D`U@$NC3r#+t0WXbieqksAb*O#K~+b()XOIw-y zgl-7$EPZ&ic)Hc8KN-fx+X7$bJia4c>dfZAXjU zt~YD%>{%fE!g}nzp)OUS>2CKk9ORtx{q7R|Ke5Lz#WQ3_R)6U@pEXPGuOZ$aD($>6 z^~9=gHbS+V5<(WQX(&7Nv)D-Mq~45cTm@QR1Xo;(Na!wlXaCgvN%YW{0lsaqicPKE ziF|Ln*(SP7N{`4Tu7|qEmdTi=tlhUETrDrmUhx!hy_3muzI>DYZSFEx82zjy!OQ+TlKhXjnI@S zvHfYsE0^)a6$li5N-;{(_*wpzC{MdXp`>1}b<9rFHV>&|Zgx>EV+w1#viL*|DrU=W z&HmvsDA42>nJsU#c-o)r-{CTMwk0?pTj4bjx3lo(47a+#$yR>tdW8?Pi29lwX%cJQ zpDFJyb??X63xBJXYw6`Uj;KarJX|}~_-OUh^dUL36rGHMgB4BB6@F(1&rh{|C%Z8g0mpIcT7Z9(DuS{N7b*hF%)TjCSW3$p-d)=IaS-mdfLyT^xYu|PKV4!=p zhHG7m^UfxdFeMGv(q%2ge961N%W`Jns<2esCriWD(uX@FOxqy zK6zU5NatSvB%{d-E2`4e_&Qf|}m4g<82| zf^uK@Z9A*AA?w|7^E8SS4Hc35 z)fJ8xzgzt#!J&QOrtI^?^Nz)N<~M8A1ONJ0zIT@H&*s=T7+u*o;bzlp*D>9D7k$55 znzJf+(0a@0=W40EcG8_}vlQjGKXP{%uTMOmal`aMk?`}dhYia_+N*jF6bXq)cLiCw z{%*>uIkSV$;bF*m?x%Tg+s+?7neby)^nTf$T$xvwHk@9#R7;1id8Re-`M`C7&g#6~ zH|L1opWHRUWN%GC*ZoCf2TfNHpLcw$wd=p&@8~O?;+f5A>|H{9-f@+4uV+BmynTJa z{4pidlU5V+>s406BD*&QVroBDPYd|8VM46F=L4H_8$AcRXFS~GCZRjW##aB@w=J8e zt*sJND%!E0n15|6g1grY-qdRFy%ENd5FE|o>&krkZjY(0r_y0=iH6T{HE%CyTu+w2 zmmQfYyKu(u-5O22p+U)c^>$JV`An`Y)iLn6>C-YjxyE$x$D+?0n+}vDZ~fi3XpB|m z0-;&*57rUyCmkoTmJR$#ZkvBm;(oZ){1?RgJ!eC|N$Y1E<7r%)Z~rU1s?79irLwlt z;jKBVWX&qNgvPK*q+1FK{T}DKwJV&*#`^hSjK+KY-csQy)`6MR`8p=Zcb^vx4*D1> z_3FFMBK^og;`%}<*XOv|MGfu#O{;xxi)MZ_*7>q1#QnuS|J~&aWcG$0^PS_tvJ*QT zyn51LE`YPa;M2@mfw&TPyoc z>~I*X5OLhNbl{k8cvxMd&h5#u%L44zH!EB%aj|%Ir9R@#&GAv+qs|4TZL__weX(BK z4y)PnE|Yd|xPQf7REuqJyj)JY%-cuvdJnaHzOlq9c;%phmg`g>(Nj3=Gg_V%)mm;a2toUL;8`!^;K?+-&ZJoXFq zHFm39K0Yz^n#EoA5bizNC54JI`jfrNZ&i&sIQg5X!_L+6T(x}*KBX_Ztm*$Q$&bfk z!JveD+KS_fp~UBp*Ltp6tb5cd5%QR|q+Gi&gZTWf`&5ABOSX#-%-+5#Z!=x-f-83R z!W&x4^}DxeDHhwmlb_%;)pdOJNhPJ$(7{`EEKmC+=zfJr-Dd>WtblZG6e&X|{SN5jkm-}&r*8ApF&s!^1 zq%Sv=y`y;ZI8TB z8ZpPGem)R*Rq$KyOx3;^Z=QgUqHFRed9gS$e$|{Sf0V4q)A#UFeqHsh0^98xKW|TX z{LnzOy*hZKwrE7x{_4$@Qx{45SYO%f&(UwU==Iq$?WsqnOgg_~cIK=T297;x&3DgP zJl~+xJ)=Tlz1gR(yZrAs_G_J(U*uR4ow?D->BS_G?pZ-6ca=Dv>b~NbEq(qlf4_qA zMB_Y%9ALk}&+60D>zrdxu>F4Xa_ALViC#X6_ROZ#5L>dU?V-afr$V;INw@!rOh%8&4TsSjm4M11}^*>^*v zR>g|uL-7w!-7TGvLVW%?_kN?qajhRc#OLGV(oIBVp0p)N8J+D(8q42aqSZR|<$3;@ z&3M4sit3)PSPLHfVD{*O-*DS@_PvBIJufNKD&WqpN`Cz>L{y%(8rhC)sq@?c5&hFXl zDCFf}p>XzCU65wqk-~D5E3-nDo-^|IO?&F7K7pGrY3~|$$G-R8tLzJmf3Fo#h=`S3 zZD)}kmD>`2PV>vh)6q+o`OPb?X{B=gT zPl#?qyOLOl9RIjU8$99~*Ys7jS~a=%_dhC#d0t&Qp>cZ2y5eu`qI*71I&3tl@!-h{Y~&nt!V8()ML z&7v(D2(4dHD26kw^3@{1w|i6ft6}jcXxWc%8QOXnd(1f(%fHM{fE|lTD)h+ zw7=O4j%_^|_gBZ~PI2p#HM1YawH9bLY#EAh&Ip`TaA&jqjnDVX8tQkKC0tJvzGZH` zdg|7cK>xBI?|Wl!a9{UR<;nPaVM~hK6ah=UluPg2kCj#L5fGU=-f;cHX)|Z2cjY+< zk1LEH_a!l+xM9)8)N#pSzM5V&-m$p{7IqF^N*#Z<_~zZ#y^<5u1gt+RWTd9E%nIZW zYUh6GH2HDOG~m5Po~PK_Np@d2)vt0Jf1DI%y8X-9&+Tsl>%)c$d}r+1y1ZLCGx^oH z1>Ivl%+PvgqRex1qm!J5$oGW_antsPu#soqXfxGc)Ixz90tJ4O-aDyewJ3JqzznB<)@s6~K+RHNQ^rMZ5xy$Gt}69JeuZ4EK*7+Fn-QF6V*MZ1#`t+IXf024*fy7sUG2@XXXfj(QWPb| z6zb~jz5I0Pfom2+Z#BOO%-=WW;NlRuS(z^_4}PzAcbdQB(4Q>pyyUqTUypq;Hdtbb zucbh0{I$+^hjSj7I5`^i6-vGnXu5Xjp1i)TfA8xb&DwwSuj;;A#bfYlqj|5+Mozc< zD{ZQSkL@%5n5Fk{-b<9K?=-68wiM18{CQA#LC@J!lOH^pv0k&;@B5)c(H+qjZ1MsM zKg~aBzI^FaC*|!M>P26d_q07>x82WvyzGAV!(|zD?$TaAH?P@JtTp*bi4?a^w0zT8 z^NMq3S%NbQh~t0rq8S#yrXBt3Hd~IT&s{{Y(|Uq~@`mP|jrV6R_u*8`k?GKE(6!c` z>GoystOX1Iy!?5h_D51vK;yKb4nCon$|iH3b2EK>=SEHNUhdc|q;tDy$0XIhJ2O|+ zp2=SJXZ4R`zZx?7r$%26PPuNs$!~pZ7^P@9CvV-=^58FAilV zJoMMNEYK0jUv86eJ}o$BXU$ke6^`?&vrcyMFHW?rkv{TK)-Zv`&gO3YLan^W2?8ol z6{pD8G!&Y(+I#GOY(LM#!YqB;{wO!?-zR2H@yt0hZRmOJ*rK|Yx}NdtWPb(;USWS* zp+C`b-KiZlxx#hNCd4%V-nSxj;YyP+;kkDnUsl?5s^L0S{j>EIlB3`?vO}f1)`SRVy<*^<%$HuGn9h=#;RGUXcwtPo*%=~OCj^oDy z^?fCHtp*R8UA;U|<>6IaT{pYMOL*(Gllwnqwk1xe9%7I4!#fL zDYX&;_{|1(w&QSn2@fN7@IQ7ocvlzjA1hO*^D`xd--Lh*)WEWa@5BTtMZi~4 z(6=RqiDD2{G}5u{82*t`7VoZ}Rj`EN#UB5kC<}ZS1Q7VUFBGW;&tz%j4|t|aBPyU9 z-qVN=>=^K%$~g(1@zcl)@JyFRgh2E7!Gm%wf`n@%afSqZJBQLlLIS#tBJf_i{NSg& zDDnUhSz1;G(R9IT-$vAMm4axKHIu?!ddJ`6kC4zLCt z!J4l3v4e8CVHfxXy-`{4_mSDz;6)wu=kMBZo^pj@7dOKN6WG~e!5aQDijSQbs4^Sa zf(!iZHMoFZv>ufOf3uIB4fa1=WPHZ{pj^4w1%CN?lnW-Xv%z}8ggwF1ODNZM?3%!E z!JkU|zg)zxBJwg^@Hk@!zr8)2u&S{O6a!P?@&;$|Fl{|jDB%(K5g{M0nK|*IVh!%Iym0g*}zakB}c#0 zx;tF*$dL(u(~h0Z3HafXJ6-w{QzHOgVP^wh;zI3;`)B}mAT*3D2mV$QI~&-Ms2-U` zx!}j3Mr+_5#@N|50Sx=Mp#0turUw3o6g%4*u!e4SmF?L~jWE)2)3+;{A3 z?O09?4lZSO!vE+Wc;_y5wq;-q_uv{K>rKpZ z;ICw{v%&ciwySiCiUm_M9cc!@5Z?o~v=q7Yn3@?#^8<_~So@6)C;FM1nMjii*Whve z((A)ajX2UMgEg%4lPVK10AbBW?o$b*(EtLNHKSy`6;mULG)q8`BG~#8{Rh;3bUCw- z=D)|G6w+9La^Mkeb5R~lDx=GhMw(Y(4PPnvJN6&ra5mEHz?wL9+560LWRNBo6aw3B zUsL>)seyZ(o$WNJ51fT#{>}u_(e;r-ng_U?suV78q8+UPLkg6W4BYU{;rz|7o~cnl znk2Y}8Y$j8OwAmm0cNCeJQy0l)XYU1*psjp4<;3ZQ~2omz`exI_TS@q9@3lyb%yo% ze(jVgvz+-z1Mg}Fk2IsT>UicKIey@r#?ICR%7HUuT~fnFW;t*Kf^z|=COoQt#ps=7 zYE+O0-1GeGpTliZn;T8pN?qXe{eyYSfVC2*`rxt-dw6O-zkC(o6&z5XV|0 z%Jq$@S%5UF!9WEAkfokE?Fmz(fiySa8az&Dt`lc!7Q$EAtUwmj#Q$vv2QGL*I|k9& zgsluPY#i$(ECg`4i#yg*>(L|c}a19;`<7&Z$+UP7Wd_jF80EU|P0q{G! zqcz${a}Z$IKO3ap9b#&9kfsi3;Jk6K;`Tp|Q(dId1Um~J@3;0UTxXV}hcrfDa)xKJ z!>3OkU~2S{CI}o{P}9(5Q^(XSL7GsI1?TzSSe9S7Wj|0zl@Lu9?|fXqlMn9m>OfGc?1No53lUp{Eu^i3DUrxgynE_RQ==lT8cE{ zpi%J1H$C$C7&8kTx?rEevluLARep;PQ)7lS#5kPpVF(5tRF6ECmm!TFuJhTZ^j}Pk zInqb~4IDrB4?W^#YL+9-f42*C2dJ|-Cn!jKT_xlmkxgc`1W+l=*2Llz3fOF^C5}6unqye3R+J5jo-#_LJ zFcd($rhswC2eyj4w}RqEXW1aleSp#NY%g5R)Yu};E>I4v^L^v(Uzr*(O@OTRpd8qT z7LkEqfRD}srw5=}1TgHM(@)uMFg2@@2L8rB)TB(&0EhJGavYH66j*~QvHHUzLC25Q zI3mqCFyP^Fnq~dEim7oznr^U$ZFg}J{KuRCuMFAQq`(?3C3dGhnB}YmuduW2MhbAv z)=}Zl)Hox}EUe+Jv^>t#xF8KI2UMH&krnliutO!lmR(Ru8&k6mY0%67wq9u8-OJQ? zB25`sgQ8g5O}j#wn)OKI45|P%=4a}(n3@epQvudc(^XMh%G7uv4V)7ufUTjGvyU(} z-bgbWXyACh{j304XSxcD(x`&2g|V zq`=lp=Yv<78ZcZymI<)Jefnm9N)uB9F28{0F<8SoKU(+>T)vIY3Pc)o9D^;hzFA;s zkJbbs4Lr8sD>?Jo{xR1D{|}lFq?rxYU?{SNEZ$sUW^F_oWw-{9? zTaX6+zAM=EtS{!TYnfT$NYjQj51fa`q-g?K{9sFXsf!#_6M-~vrh@yzu!UcY*{&T(1MiOoHPLg&f|KXyI`2f9Szrxc zsjK_`kFmN7Y2clirh=_ANoDhy_eK@KqCvb%=e19GBx{=rV(UK1Y5b8H-9oUu}EVH zCWN_QtKZ5ghpCA}8W*sJ%ZDJNuS^Y^o!E-N>u|rbe<-$MYU1H5q(-3Og>ck5Eajra!G@rqm8$2S`9|9dV zx*RaAgF0)0iA)k~<)6&j$kZevjRmm6u~FK0@E`jNOrxM2f1u$4Tj!+*k21?iMjAz2 zPKD3nw@gh6(!l$T!K|~nKeLz`FnmFl0GOl}gRMXp|9>1ia5fm8=fMzSDg52?k2{htV3)RFG8(G$LSY!=T)0rX~|)$i!B#2 zHDDSAnmr&09v61=OYE5%FpUBYywB8Ruyrh_791h4W+TT&KGI}^0S4!2o5H{U*k5On zCIqbE^2Xpw3$vU8@XEhFwH}#u4r$>0%n7y>T0Fs@OkPPGc}ix=D)KpBMltOaEvYC4s&Lf11_yVo&Q?{PSqpY_3!Jt z5~SG;n#&8e>QY^rnOWD6<{Mmthp1iFKaQR2NFxNwfo;3LHTfU=s}yOX;Tk+P1}$}A zX5B!VGq^s%PwPR!;0bN4!gmeqZ18V-upH&$=m4e$Tv`E*5zxT;9K4);kEywdG@L*K z$Km#znoms4Eu>is*5J@!omws&&(u^PjTG2fP~#=mWXaT2B8?Z&j00Pqw>q+!nku9z z2K9mEY+J7Php7SG3fcva2_OSM1#8v8)Kvcunmb4X=M6X?HXKa-$NW?CKWOd_XMu9y zzHqeE2PRmvk;i*2(x5XY*xLT==s%7fuzO&;{%&~cwXLaQwdItqqFM&2hDw? z`S1EXKpGoRJltQW!asE}vmPRi7trv4Ei=&!L#CzyY5u!ikC5gESi^BB83^wHIl5io z)Cl_Lzw6wHG;q8__rK?{CrI<(^Vrk>p`2&`Lpe=I0~2AL7U(8{0Y182V7dYAf`1{0 zW8Ub+4JW1soMwO~2Cl(FyJk0-AV-(eiZpQMgnj6JArMS{qczWwW(UA?t65)Q&{UNxWSxz6)z&iuM^GfR`g*8k~KhnTE3@U-G z#ldVhnVPRi1MkEITb#mGZN}7mLmGJZIAyT4M(8=XxES3(-;riHSc7V_-lU5gGBpE8 zvjME(zIYHA|Btr+KpJ?b&k0~_-uAQq81p}ohPd;ei+B~-b))Muh&06g1=Br`|KpnE z7t#=Scsp7h^^dXf8)@Ku@8EGd-QgHGWJhO#Q$83Q@P0*nV2gED51e2}Yle^p-h~LZ zUHjd+Ag1Oo(!iqwX02QI>XVBjY_hdt^9`7qNk}sU z*FZD#>nSjUfG4#6nT#}&fWlX*1+uc38Udua173&A&-T|Rhc)n-9vDl*i#XcjES4pM zIMaxA5V$kaGJj9H%b%u!uWeBK~eBm|m@FpAI!qRkWHTlU zNpb)aEs`9^#Em59FG zCML!tF~!7$B=(prA;|_zj7YKt69baOV`4~>Q<#{M1l*(?Ez3z#hlx2!+Avv0l0i)L zNx}gy2f<=NlF67@l0*^{Z;~it;!BbxnD~&y1`{umfSbsp#hD~wm~13TBqnP~l7>kL zNzP#sN|I7c!bnn&$y}1W!o;5>y_f`$(ix^2}V=|K@YM9I* zi2)|l5itTckr*xooWDtp4c1I0i3=veBniM|3Q6{0B1)2YOoT|1fr$u7axf7f$z@Cg zNm7N$B$7P9WHKVg9wAHMJ@#Nr6iLl1tWhG#CrtcE@(UAXl1zYaHPJ$xE2lAt9D^)i z5EBMj$so=Q;=>@DX(Y%;-@|i*--sFp`55}S>0k?r4rO{&$8wOd&AX^yZ0E1*P$OQ(u!yqph3^MYb=kT2ccrVP*=rD*WgREi@7Y6ZVkj)GdiOD8%jAb)4R~e+5 zK^`;6O9p}8J|LFiwhu4}J9^7HtQyu#WRPhLBEul645CLP0pMm)A?t>7Hj`~%OVb38 z5JixhZCG=kB!@A%N0PIc+#$(jOzKEdi^&6$v}00Bl0TT-C5b5fxCbmXB$iMyk}SsLB1tSTxk{3?n3R%aBPQ2KasZQ?B+0|1j3jq3DIrM%Cf7;QfyoV$e8r@k zB)ssWH?TY<$sA0INn(acBT0NPc}9{$m|P&qRZO0c=3(-IB*vJ$ zC&^k&K9OVxCfy{-!sIL<@Lf5JbqSL+l2l=mN|MKz941K{CRrr;j>$=qOb{4u#VL}^ zz$B9-^DxOEi7qDDB(cQg97)_UIZl#2m>eU?DNIg~m(a!IlqlNgd5!z7O+Wtf~H z$pcKHNz#c)EJ@IxltG>MlSBl5a155yB$@e9$mh6SeZj$W8B$6blnCu`)Atq5Isl#LsNxCrEMG`Ji)Cd+QsNryLh+@Jb$sA0^ zlEeU$aU}7;go`A^ce6Q2l7TgBB)NjgU$Q<`n6Q(Y7EH#Fqz97$;2Iuv6Tn|g;qsj% za+vgz#1fMqB-xC~7m^&pq@N^tm<*Dn9+RIW>Br<7NybkbuFr3h%)#UrNh~q>OcEbV zzLF#olOB?sz@(2P*D?7+lE;_~k)#U~capG!zbp?gaKEoz>$cuIIK-PGa7&P`S-&~J zpSXYq<&0sud2H|*cEB}3@Fg}u{DUcgH0yl)hu`2MD|D>`H-V)@kofp}QUJNYjcwh0 z1CRxm3`xM|QN-7O_y-IqO|VDENKJr$81WQq02!4P4DRbpiC}$#LxM)7OD$WjMrd5X z1{VvE1q9hZ5ctI%w73#PNqPP-fgjf(m&WjO_-Q;Qssw@6KpGV#j3fx6OvFnPM2XPM zCJ9lr9D~RZM470eEJ=uXX@V#bWDY@;iKfaEM3vA;kpyg@MFFf)D^y{fH?hG_+F9Vp z1wEz&(>H+!BuJyA0=6P(1ZKt12y9pUNP;>wiAG>=9HkMMb#f#@dnbP+QC$e0!G)?1 z(LdIJq8bt%&vGEh0>b4;5GB~H7r|$LD*-_*Re_p^-~q{SZ@_`z1A2oZu+Gw88m0(L z|4bt)fW(7okJ7-N_u?2yU=^2hjwI@Uz`t`)F4(I{Gy;2-4}6wQYLtlKOA?}?=--y2 zR;b|N%+dw!;XO!n5Ukg5j}fCqg&^d3hT35ltRY!BMFa;(}gh#g5_E8t=a z9>}Faq^}}~I+3ME5G8_G5rk+u_=^Tn4y-*~R)fcI$;6nqCkSzHv$PpRlO#k97cmIz z-rZl#3X3u&Tp*5N`bdNA6Paf2yVXz%xjwmcoC{K@!x`cu;4Opq7e( zbdsQ!-lY-P(nQd!lm@mGejAA*u%)J8ZlMTl#YGx{EmgsFMl~eQ4y22mC5(X+!y8qAvMbgqE5^k`UD|e z79@c^1{X{47~X@#2!|I_h@ia#HNGSv5WIY%YrF_T6vNs`5OR)MOAt~MLJ+bQp$rnn zAaeh&n?fa9{kT5m?YzTr$-^6GsxVSE-VT zUJU?l*HDn4a?n17M+r$#BRoeEv@c$dBxpdnf?g$EsD`IU z612Y_(g;+4qY>Ei({K%k+XZ_J&TM4K=n8EQm?iwcD^x4s(FO_Cic2F2YK1JwA~mQL zl_LpiMHt8;HK-NJIBU2*aP~ABNyz<9y3js74|K3KR1N20Le&sf0csFIS@0}P64YaG zrlAPjf-?j~VE`)A%-ezGti;>5R(MD8b*ZF+$S{T7`sOh za`fIIh!QbP)Dc7(?n}5l01tY}wFDtczDp3YlQ)OiI!H91ilWJQt&`6CF^sIAmsdWlO#mZWh5bb ztb`zBov#x_6^=}}+yD=hMb0hd1R-4?8KjFOL@PcJglIbYHM-$e5dHIsq3I@wk{YN` z0tbt=7m(qj0G7-SjyOnAIjV4n&7l!^Ost_17=MUHVE+DV=u+Akk0_!{lw{*CF;M?O(fb0XWP;KuA&mf`NJ_FR5 zBCwnlGy>ZmMI*57`6CHx`x_d8ZJ!F-MV5@(?nEQ7?Oiki+rAXEi*muXXVM64`v8r= zIxog8MeS120O&VAixmrAfo)%=vJe!M0J0!~8bCln@JvJ!RTU8bkWPTBmrj6-AEb|P zfh;9D0bOP}f-G0j04|Y9RDHm^exR8T>P(aa2um6jm2$xYER#+^ zw;mfy(|~sU8c9?%08ypa2bA12ZlnuNcJJu~lq||k(|~eh$I}Stu@E`|ZRh5pX+V!H z8cEdQh=R*@@IZSI?ozbC_cMr)v({FEkn>?UK~zB_(6WUf===rI8C^87(>T094z4P z;ll)J(EE!=Gy;1Awi~*JHSmc0Hj-#S@_J;+@E~B#1P;mtn+oSciom9((FojO?`Q!30K8y#;Tkt>{7><^mV2ud*ekYPab}&d3LC8- zxdFTm338#&;>y9iK@tr(65zj%r3f5iUf@`!2n^E%M_hz(PuVJQYsE+OQa0A2=#vKH>T_=0k2V;9n}MrKW+Wra8w=x-piEU*h{ zXj#IvEM+6tN0iGQyO4&K1wXT6XM-=p8tNGi2ve?2*o8E-EKyok(}`nCDAxh(LK<2Y z{6uWH4`J5JvufUy>m+s|4J~ULEvrG&+k$dk!!D$uWr>mP0voLOZy$nO$v%9DT}VUA znoi4#@_ZvqxjL~6X=qvS+HUw)1z@`rU44E~u3y-NG_))@`?IqVW8>CWoe?#h3_m0Q z3)0ZC#E}b*Lzv|icljKZC5K%|L(7t&Wz9PwZAQ6tu?uNvS(3;l2y(y%%OO`!-Gl5y zTkJv_TGlLDmW^xZPs$aHT}VUAl0q&K+%DcpzTlr3gNX_)2e1oiXj#&_Qq^)@)jqPP1<;<*LChq@iWW(6Y)dG?i1X4(vi2S{D2yf*SK6tmxjQm#VmLK<4uJX%(6?5b+Y zRgYarL(77nPEyCR>VQ=(u=*e--7D z!7iksWvS4zQk7T>D3>92Aq_1{6}iA^9W5tLH-BA6?k_j&LK<3@8ZE23`H?#1iohHcMY+yl7t+wOG?0s!qc(<$t4Wesx3CLo zXjuzsS;{_1MU<-*yO4&KwFtSSK%3y)yFt|IH0An=T}VUAT1?9tyIet^a!nKm1%U-= zXjz(MyI@x9E$>*$B`*#=;5rg&XjxjctQUOZ`zV*8I5M%2hL)v`T*Nr+I=S^1<#NU@ zq@iW$(6a2;eMzNU;n;;Vv@Bg(*2}0{<0w}Wb|DQdOOKZ2>K(O-aus10($KQ>k&76I z7DI>3XOm;24!e+smbHYI)e^aQCFN?vE~KGl8IbK_frWkClt4K$YXG~DhL&YW%ksL{ z_nC4{l7J4Gw0AF`?@|Daq!*o8E-td+DZ)~ufclBIxA^UJIb|DQd%ZZi+Zq`&lxlUpi($KQj zAQ#+U?BEf;DgPAZD#I?Mp=GV5WwCq9rc$mJ>_Qq^mNRk@efVqk4nfNG9lMZ*mgPdr z8tPm%B5N|7$iad%v@BQTf@1?Nza~CTlPCL75xbCvmgPpvg4b-6%M`nihL+`yTm~Qq z_TjpyP-n{Jfn7*L%krRQmC8-JLAiEg7t+wO)*%_s@sukIyO4&Kw^ZBSrS%3+zG~TGj?ymWOK88p`z@yO4&K<%L}0xDO5a;_E0E zpEST=K^j_?H!bTR*R#`*-nd=hkE&^35I|he$)q3ZrF-jbqEE zT+-NuG_OX$M+?%>vbG?XDtHxauq0k* z`#X|ZYp@GxXj$R3tb&FZGs+c&T}VUA+Df`$Wp)f0UtCFMMPe7y(6Y9XE;x$@zpsp< zT&dWFG_vfRYpzoA^baOZ;sX=qsq$VH5K0TJ{2luH7;kcO6Zkd~FE zl&MX*)UXR_XjzA7S>0vj+bP#l>_Qq^)?r#!UWCP1%H@PzNJGmyLb_nP|JbGn>5^k3 z5WA3umX%1l;MfoiYd%N0c4HUP(6W+{OB^_$EAY)pd&+eLyO4&Kl}yWuO1-2+xpJ`! zX=qs~$OSLyU{;LfH*?B$4ZDzrmX%7&+Nt$tE9I)kE~KGlr6CtF4mb0yTtT^BV;9oU zveIc;hs)B|Qm(Jqg*3FR4CErlq3^RZw<*^+InY$FAPp_+C@t%nW`;cF62mT}p=D*# zvb=)ZVkp;q>_Qq^)-hVvK+*MEl*<6SkcO6ZoR;DNRva*qD+;C^HD!*mTRVBy#4(vi2TGk0#mUvd=Maq?oT}VUAI*DAwHQR#B=YA?= zRsnV)4K3>wElWd()kV2(V;9oUvT|tcnsuRDNR7;Tj$KGY%gUu?!Oz(!S3h_Qq^RuL^LQPYHta=pPWq@iUM zBNuUexk)eCqfYLxpV);ow5$uXtjz6~*HbQGh2haBAq_3- z5-p2smbMw?T8UjqL(961T*TN2I`XE0as^@6|KsdTz-_GBKfIAj#-b4FBo#%Ohsr$9 zGD{rCIs0&OCTB3u5rsmjNGXyA8bpyHp(GSZlBp6>5v4TuU(d6iwVwC4_dfcr|9f3u z-`;Ee?sc!V-t`W9pS?HEfa@)Awf!sedZlIy#Tjs|_7shLPrZgK>-jl+O(@QQYmKMq zs`qsFW`&jdP$usju3_;WrYgQIi>Znkh0oPh^eNgMR-Aer<6lcJ-jw!mlk*nB_ zrYDsuTh$bqjWgg{53ck9<3+~ zm+e<=r&4=_;taU9Fy)S~^rQQVD0N&Y&VcJZa2@LS`Cz5~6pAz8dY>t}R#Fdle|GVE zN|mT)ip<6taBT(GjRkJaRq6(zI0LQ^m~#8;m$ydcD0RC~oB`K1a9uNScwePD3&k05 zeds9~!As>AJl5OquOy*31Fr3!qS;v0xo9b+MhV3kaP43!&JaZPUvTwur5+ZFGvL|@ zuFD!7{6eYch2jjjK4QwPjhW-GYN6D6p*RDskHM8be(pM@J{5{H;M&EM+h4~&ot~)F z_d;<7T)V;b^zo#Rl*)grnIN-q23((jtIv|V19MnbD9(Uu54Z*&U;nzgstd&#aDD1s z)R*w(9oqHsYooPLoB`Kfa4mh|yDX&=gyIaiK4Z!qUn9me=%Umpp*RDsecSZ?0fa@SrZq2`x?~})sDlZggz;y^*E2iBSuT*`ZI0LT3Ou03GZN6>e zlhl?#& zsz7z>btuFca2*F%^Za{iDOFY|&VcI#xSCggWvo)S3B?(3ealpw=?BfmgHP7@SE-gl zaRyu`!L{?y;6Ie=D->tI^&L|s#P#YIzi&}$s8E~%*Z1Hmao@yKN=+4tGvN9GT(fKU zDW%j?LU9IMr@+-I`I2Kwy&)85z;zm2(>`iGN2zT>aRyvJf~#HaRTn9BL@3UH>x_4q zX$;+U$sNU-`ZfQHP@DnRS#UjY{DJ&R6{3&Sn~gKz`iUub-&=RVrva+GP@DnR&*19x z`sf1ca$g_f47koQ<&LkEV-HtUs+G7n1Fm1dwQ=6P=}Pq#iZkH)m8m#0W?J)OdvB_u zRHjgz0oQqOZF(@Fky2BH;taTcW2%I>s%AIbr__9*I0LTV!F6)du>DHCDimkH^#`~X z^{x80Qd@-L47mOT*IQR-ZdPi)P@DnRU*HNCIlNY>(?W3uTz`Y>WX_6VN)@0la+r-X z;QEIt_dWo9Hnpo?^JRqM47mOU*SW8jHBriag_twoGC#6pKHnQ>`ax^sjqv8jm1-|8 z&VVZ)Q$>WzzCXQ=QprMb23+}>a%-bZ;Xi*@YNAk_0apQVC4Q3euTl$y;taUx-&-k= zFF1#H`8j+`D9(VZAh>!jP3o`I9-%k`u8Wy+=Z)tI zRUBN)DjzPb)F(o523#eW3eI64KZhrU;taSh2N%tuQlZ**ZEyx$S1{$)VOBWx6{W5c ziZkFU39ht@mep74R-rfpu2M|7>sRN)@4T#3E1@_8t}DTH`h&TtO7$0tGvK<4DYw5S zp8j*9Qp1Ge47f^zYt|qA?pNv|p*RDsGT@@)OR49D;taUTg6r+a4kRhHK`73Ei@vFD zS1;|+XWlP=w2@yMp9#eoaM7=X=$fC}Z)!fJP6@>saM5oPnSZIuc<4O;&-wHllqx`9 z4m2BQz*PZUa~>>GNvU!|aRyx1Fy;2wkhgZNR*Jq!N*iaubuGBcy;P;JQtgG}47lQ$ za>p0FXMU%j!$hGt11|d4({v8$J#(eT2*nw2Rb zeDO$2rD_Ys8F1C~6t(*C&t-3K=;yGjP@Dl*El<&zt!JA_^OZ^!iZkG<&6GPIcCI&b zhEh|6;taUzfNST(5-XK@MkvmJt1eSaRyxVz%~D|LgSVCOeoHP zt3Fe1e_c1Eby20x3dI?4H2_!ow5pdYRiwV@wAnZVuG_)&_M*MlD|M4loB`Jz;HuTQ zZ!@Ku3B?(3-N}?YzUVbkqF)>RgyIai8iMPVaJRKeaJ2>3 zo%^0xq0|zgI0LSBOu2K^tPTZ=E45K5&VZ{uxYpIVs{xM43B@}1C z)dgI;8h%_@sdS+@1FpNkm38^5Ka`p-6lcKI)l)R?8+P`&p}JoiF9^jMaCP$(&3vi9 z63lPvxKHV95Q;P4>durqAKsT(Y+Zd%?GcJI;OYUc&O_e#S*bHZaRyvHnR3VSroQK@ zC{^SR8mqbPQU+YTz}5cAYNM38St!nct2a|+Op7!dW%@l~E+^47mD&YvdPQJ1MnDD9(WE9&jz5_)R;dHVVZVaPjs4}gQcZ>842)}_9~ZfLwOf~>R3D)@1Fl4H_1d(vky1m2 z;taTwn4)z^+pr2BR&VX+@ByJX1FkT*_KxcOwNeX(;taTwnR3VS>{su7x{Y_O6pAz8 z8U(K0O;6pU)OMjb1FpeL(VC|%qsp8y&Asa@p*RDs6mZ>exZi4}eiw=};JTNoIOC!H z)$O&edz32C&=i@CGvFEmuE{4l_f@KjP@Dl*svj4*w$;8YpHk)qlQ+(QD-B$we_uRM zslGyS23+Y(1@~7gKZiL&aRyu&;0lc^|C~}Yh2jjjGX1z{2!nfGHNJ&+EfI<{;2H|9 zqt!;AQfiY>oB>xBQ*p*ab9nvOQcIOOEEH$Jl?|@PcMn;h)L%kz23$FQT;wXgwQ6^z zu5M(C%*GjT<$|l|iwg!SRbMF1fNPj{QLCvdHr(CP&tXrYI0LTX;G)m>DwQJ?XTUXr zsq)4{CHufacz{70!#LU9IM6T!8u&hQgTJth=qz%_{} zcfWB{`hbQ?tq_Vc;JOc7Q{F0@snkb8aRywI!A0NyQtCUQI0LRJ;5t(CxmT6CxQW>r zX5$RF?q@1^KJ4VzM#Uz?m~T%}23%9YMb|H-8Z}`k#2Ii+^AsgM-8-#dNAKz*6lcKo zfTw6h(R=1f4Ht?t;Chg$I71Ni$e&k^SL#urI0LTf;A;I){6MAN5Q;P4n!%KNtvBiW z6~&bLL@3UHYbLn1mphuH)LEf81Fnada_jKrq)QJdRibH#H_m|TVQ|fT@7e82-6j-g zz%>h8^tS+|Itj%YaLoqShH5o>E0rb`XTUXwsp@tBq0TeQZtCFI#tfl21FlEFwRKyQ z=1MISiZkGPlquR@w0*IBQ?q8?wOuIAfNL(edjC9Qo>GT|;taSR^DbJ4)vHf0q||Al zI0LT7!S(r@b%raIuNikc#2Iis0j^o`lSV65N+`~NYaX~hc|7-sQa1_38F0-9*P($& zCn|NjP@DnRli=F>LDu6+brgy-;99_x`(9h!Yo?niaIY%|2*nw2Jq4}`U7qQyRJKr@ z0oT(^xnudY>DfOjb-z%Y0oOus&AV#mQKif>;f*ukdWI=?EH@fkFRw)Td9k9YQKqoPop0oPJ+O*{BwDW&QQ#TjtDz!bf% z%xC_Wu<7rwyLeYep*RDs7s0i>=iNh;3Jb*Sor{ zP$s4?q&%a`sQs;%@47grn%Do@eacQ0UN?qQ<&LL;O^*XplCRBV|scJ%T23#wc za>sJhZ;xH6R9m4q1Fko~HE%%49ZH3T;taS}!nk_glF?A9i9&G(T&uvf`?os_DfN_4 zoB`LH;QDU=fY+2-BNS)A^%l6!yi$LYQhSBs47gS^<<7m|zSC~IQfGzY47k>S>zez^ z{H9dVmUb_523&75<@Q&@D~1HdRYfSyfNL$dip*PfiMm<}#Tjs|0~f9h^TL!j&VXw@ zxbA&q$xZ4SD->tIwZXfn*%sycPQ2G2U-N|G47lC_*O-)-A5rQJp*RDsjZC@M4)k}u zT<_W;6lcKoF1YA77L@v0D9(Uu6S#Iac&~W8cbylCGvL|`F8a-CrAoE3GtU`tZ2=dJ zE62O43&k05y$7z{L&`Q*s)JCR0oVKBqW2GndDkGJI0LS&;G*9mP-?7DoB`JdQLf?M zHAg7UfNLAL=sQ_Ty(|=G!1W=xYK)&&ubOvl7K$_A+77N|sdtW5>X1;J0oM+2(b~xH zu3v@X47hfJt7iRi!;~uC+O7@Gfa@cs+%=_tmENx_b(2t>0oTXin)>>df0b$~6lcJ- z3tVfq+%Z(CzCv*ZT)V-w^NYP#DU~Y}XTbHz1zZmc#Tjtz0oTI2A6%)f7lq;sxIVpr zYqL`p#TjsY#*{nHAO57u$4Z?SiZkHa2d*!&DxOp7@-}vDa0XnT zGZj1^X8Lt_i%^^a*M4yQJ9N%8rJ4!F8E}08uAwJydcK@@^%jaV;5q=VMf+-wQz}&` z&VcJ+lq=4=#tX$6a2)~{o#&N$R4C4X>o8Nazi6wtKL4BLz3T;`I0LRD;CijowslHv z5Q;P4`Vz+VdeZvOuJx`xLU9IMUxDk}^(}8u>N}x01Fo-OTxAP1ZhDP(@jn!4M#~v+ z9R=410}s|ws&rePq7Y}m^$k;Zn(6}Pe;uEg{fSc5gyIaij)7}zT)tbCY9$nBz;&Fd z`r@ka;X_T7iWiDA;5q@W8xM~UD>XtW&VcJ%rrfbyY1;G|O3fCEGvGQ2u8Zb9uv)2? zgyIaizVj5#a?jpddsguKYqLfvae!(^#dhXlEKS8)v|EnkhGjL$>WGuhgwVaRyvJg6roukG!o^JE1rOt}{$s zYP%9T`_mPz%lbJ?7K$_AIt#9)ldid3sgXi)23$We>dlHPSud)o!hfa`Zp(dwPMWz1%!$_vFAaQ)#a zYIpt7U%n~jUA2Vb47mRE6uJH_{!mq=+6u)PaQ(%UyQb8;=c$*k@UH$saRyv}gKP1r z?t_&YCKPAD^^d1$Tz3@Tk(2ISGlk*|xc>DNjf>9nN-Y+OGvK1rMS*;Ah9GK5j{-?b ztrm(i;L698`~KH$mu%aq)Wa_0>?_bPQG;>1;bTDjHRy=$FNoB>x+a4jrRe~nUygyIai zih-+I?|)8j^{&5#;taTogX_@=7Y|jcct_K5vvCGo^shGB&l1xdPWtP^#XGz!PAJZR z>vC`{Os`ZysXK+@47jcUSBoWm6F&B?UP5sOTqVI(aQx>*lo}}%XTVj8DR-@0GWV_@ zm6|UUXTWtOxVj&E`d6ja3&k05T?MXT6aSv1)R#hW23)1VHDKfMTa_x%iFa3sGvF%2 zlsiYQF21d^Qa1|48E};aSGnS4rYO}`D9(WEYH*#L`|v8IQib9SxXOWRsoO2te@UZUFAC4 z{lyt@#rbi$bJT}^%{LN?GvK-oTy&07DqbkgfU6=?ai%NeqI1+X?;0-@XTWtmxab_E z)MBAH1FlNoqI1*--u1pvoB`Jj;G%PsQU`?M47hG&%Kbfs&QUwP>qntD11|d41ogXS zbdFN0SQop$I0LTAOa-qgd%UZvP@Dl*6>!o1QmVaBoB`L(Oa=GXZtqGFiZkH41zfbh zl$tISXTVhzT(rM-dDk+bI0LR~;M)4uJtvfUM<~vK>sF@R{>pzx!JVIY*KVOW1FqY^ zMfbf*ofe8S;HnO;$ydGi$0qN(>@K^PIRma5;F>aa@pnp96N)q7qJMAR{##>od=+Wh zW$700>MRszz*P%e>0dloQ>hH0I0LTQOu75RS|Va$f+LS#?eJB)Xz*V2A5@!C)gAn~bn^H%F;taSNfa_$} zV_TFuClqJEbvsj)jEDBuH_Hb%-0bJDP*+oAHqL7uND9(VZA-Fcr_@|Fj1BK!YxEe9#j<4<~KmGP??;0-@XTa4MT(@35{Vk=Q z5sEY5Y69aL(s})gjo!6UD9(VZDY$kOeEhUhM}^`HxSBEL&b|F_jxVsmy9#!ry%h>^ z23*a-b#r{35Ln4&M=qGvI0uu0Ly6oukwNp*RDs4&Yj`Zu_wH-u0_coB>xya4ov; zi#19W?QZ9gGvMmPlsg}m9N6GzrLGr>GvMkBu2;8?xJjuygyIaix-jMTSErPjA*H$r z#Tjtj1+J!}u6|ajAwqEmTwR%pGsC8H)N_0PuK13h!~2Bd47j?1>+r@YZIyaXD9(VZ zJ5%m+MCW_;N&e2ewg|-;aPz=4_o${`KgyIai`hlz8=j*yEbyH6}^PB-!|EO{O;9Z@C;taUr!S%(f zA6HjugixFT*8opZZ|FOZ%e?Cup*RDs1W%aCyemm4&VVZgTqpNzKd01ap*RDs zd;Pe~gV4WM%zt00*+Ov!TtmPWcVp>^O1&r)XTX)plsnHCY_OoCQtt}I8E~b6t6QaT z9i{dQ#Tjs=Ge!H$JP6g9Re7CKXNBSnxH7;sH8i}DQiXb(hRntpaAh(TdtBEE#Tjr7 z1y_&m2OFxZfl!`}JT&Y$DU_*tp@gyIairh)69n_8?>>M5Z( z1Fi?abzAS5jg@*!D9(WELGPkHQ?cCY?hE|d*ew)iz%?CQ!%kjut5V+y#TjtTV5+w4 zue0MvhLy_Sm;9j+XTUWRT-#2Te@LnFLU9IM5BYJK2ch`|x;(B_U71>5N zmFglCXTUX!DY~Z6_IKCqp+$ZU?-hzO;F=AtBCj8wuGA!w##6{o$Y)Gnbo1FpH?>b!UJqe`6;iZkGPj45|~ z(eLUjb=f^Mub~iU!1Xw|zFPNnIi+qAiZkGP!n>%|9wTP#d&bXU3!yjzu6f`pef;{5 zlu8wfGvJ!fRC(hu4?+{K>A6LzM}*=GxSj;p@phBOE45B2&VXwHQ*I9bERr)^sbfNM z23${ptHF=+E>@~oKbj%){S(T7>uILk^{eux-JSEJlQuPe1eD9(Uu5mRms={ve=n||U#W}x z+d1S6xSsRlqC|;szdDQk999>KGvHbRF8X(hm1-*#XTbG5xO%*`d(&+1N)U=O;93f< zZf#rDR4PX(&VcI$PtmyO_3}gBb-z%Y0oRM3G7mxxKD*~?r4|Uq8F0PiDd(EyU9Stp z8F0PqDRR;G0+iY+6lcJ-%u~+wuy-94iZkF^?kRH7xRm-yD9(WE6{ct%(w6d7-*yjp z*Cp|`lr!LZ6WgdibW{x_b)M}wP1Fluz`fB@ERh0Tn zD9(WEO{Uy=qxhQYXOuc86lcKo7Pzv$*m{vtR}8RwnKR&8?Ol|(I_ueW5BjxHT`10g zYYn()Z79`QD9(WEZKm8D{!w*syi#dGaRyv#!L{SJIZrD!Qz*`WYaLVWJl}KPA0w1n zE)-|LwH{pm&V2GCrFII%8E|c2%I&YXE8e?FsZ&C623+reYv(7ww^yoYLWnocfNLXD z?)X}`qG>0kstLszaJ>tz9@n0`N~w-QaRywQyepsS&67V)dE-^THqwOR47fIfi_TF> zJt!1sz_o=bw>H8>re3Sm^Fnb3T zxbmIrcTim;gyIaic6f?LKH-{zr(g4H<1wK)1FoH(G7m!ZT2HBELU9IMA2H?DM#WFc z#VPf!P@DnR$KdL+V8i=LeJ&Jdz_klp4^8?YNvR)&;taTUgR5`+-W!yR&VcI^ zrs!Cv?bPzggO~a_tRNI;z_kZlKYzD+fKrWx;taSxWh%~i@|pilnDF;~)4XedP@DnR zUT}r4$!e(7WT7|%uFsfq`)hC7%B@N*6^b+9+6S(EA6B_hsU1Rb23(&r75p2=i+)^Z zh2jjj_JgZek>4sSRVK+ykl8o`t}mE!j1bO`S7*%N+k=$8E_p0 z*JEYxUaQnYLU9IMhro4U&#C*AdQ&LQfa|cQXxwy<{gR)wIe)EgZlmXXQ;2O61=Z;F4WdaD)o_2oB`JfaQ(Ty=5Le6r!1X=2Zdr808Ku&N;taTc0M|uhkN>OGLqc%| zT&KYGZiz0tm3l=e&VcJQQ*mad%!5$V=Jhrz^^s7V0oRYsO{|4r%*fZsFl` zy=$FNoB`K)aMAY=l{z96XTbHFcTo?^e=@F;QuzjR2SS_y*YDsu{^AecD0PESoB`J# zOu6HWzK5t(TcJ1uu0O$bV8B(Klu8qdGvNA*DL027cCU79j-SKXLU9IMe}n6~Cyy>t z>LsB#1FnC(%RC5mDtNStQk#V047mOU*QVdz+M(1zp*RDs&_(7b&gbTE=g^hql=@XD z&VVZ)Q$JueaP(Ua4<|;taShW6IrcY+E()??=7s(tB+e zI0LT2;Ho$xD9(VZD7e1Zz2{M-`U=Gva211bwO#Sv zi%)phFrhdDuHxW&^rfG!P-?bNoB>w}rh@l}k9*h4LU9IMmxF89=;`g0dQT|Mfa?mT z;>?br>(`?N3#2~fU5AC@47f^y>+ieXOjPPup*RDsQcStEL323HyNV96YlAc3x)NNq zhnM(9scJ%T23%J$6`aGd-qk@U&VZ{lxEj3BWP?)uh2jjj$}mOuy|jI^YtrpwyemT} z&VZ{dxau`{`>;|IgyIaiuJ$h4Ullf8`s--#nk5uxz*P=he_r$XS)~>W#Tjsw_bxiy zv^(@@TcuVB#Tjr_09U>d@fDTYCKPADbq!PQ9=p`uA%~SZBot@BbuGC1{d@gnrOpb) z8F0lh<*r|+=3M%uQUz0KABIAl0oQflS|488QK_;*aRyu!!BzU)!)=tRCKPADbv?L# zT;K0@rJ4%G8E{o%s*>qFt&Kwa?g9`P&!Yc-N;waRywsfGeTzj+>PFUMS9ht146O`gQDwDz_Z)u6$`` zsAl5~xT=9G?#R3nN|h0cGvK;4%5~VgZWW3%;JOW5FSai7rcy11;taT|Gv&^`bE@8Q z=4tIRRdh_&%FJtQlo_847h4~7p;v4zxw&QFTCpsp*RDsTHwlf`tSs$-V%y4 z;Hn+vI__P2h2jjj>O{GeIwuroz*U#2OL+~Lf75kF<28r8>xy(+%o%Xi1J{vP3O}J# z4WT##uKH1~FTJa?P@Dl*18~in-DR0l=|XV^T(^6Q#<1 z23*aUa_6Y2%@fZR_pTN~aRyw?!BuSb9|M%STPV(es|8c;KC0-ld+xd1yE26047gf? zi~dbXr5+TDGvI3F$3-h@=Bv|}EA^aEoB>yBa81n`+*GNJLU9IMZJ2UvgZ@oPr49Mj&#z}1^6_uApMVn3W$DnlsFfU6I<-aA_{O{p0|aRyv> zGgZRO1kFafuD5Ma>P4YA1FpW{8hFq8y-K|=6lcJ74^y>`hqkh{7xpOOkL9C6aRyxd z!1dRaJ9aBoFw3^Z8F2My%H3oC`)tbZ2mSuKQ7F!UD;`|*ZxblhOeoHPYk+sr9KKNN z&P1j93B?(3C4lStzX~>0YLrl%0oOpL-2S59gjecup*RDsL~yP9eA-t^trUtg;7al? zn&m?)$KQCu&*5&NI0LRQxSH--e@3YvgyIail9_UAzWS&}C6&53+wNt~fNK!AiueC% zvr-j>;taS3Gv)51=FQ#|7*`{qI0LQ}a1D9*L??CKEfioB`KRaQ$9r?<%G4 z6pAz8%3`XrX^~!kUDaSh;!(fm?-7bK;K~Nq_K96OC^bqb&VVb&kBdgouHa2eiunEY zxKNw{S1!2d_h6M;DHLbGHH;~DeEs~+9QVzwN}U#pGvFHG$3<)7 zhYjzHQ>sWVjWrbF47f&uYtJ=piYaxoP@DnRD5m1LP19=YvhQE!=dg`XoB`KpaNYA} z&HI#!7m73B8slBOHbTV{3VT*L0oN*_I0LR}Fs`L7^PN)H9-%k`t_Q$X zb=KteN}UyoGvIm<#TRJo1Fm`Cn*Yy{CzRSR6lcISpD8zo?Yq5M z?|wgrzX`<|a6JjGrmsBPT`BVus=RRqTnm^gV`}L<->cu5AxfE_YvqkI;Cc#N)3R<& zQfiP;oB`Lv3i11ZH3|txSnH* z_7`pQ_spnQ(BE$i5sEY5S^_Tm8@*EZ3&k05Js;%?dDk;SaRyvVqg+a@6^b+9dLhbn ziFfT4iZkGP5nKnpUo}aoUxeZexL%5KUFuz>M%$U?47gqfSIh6O?W9ygp*RDsWlXv2 z*Q`TnyDs*wuuz-<*K%;tZy;?iMc(z2P@DnRtKfPu?YF&3eIyiT!1Y>` zE1!3nKfLqC8F0NGR{8E~y+DtLSq z@Z*XXiZkF^1+J3kb4w~URw&MZ>&>Wf<@c`nLU9IMZ-HxDk*?n;^`=mq0oQ6z(JWUk zao?xs{T%KViZkF^<0-m2%v$^0$4Z?SiZkGP8^%TdX3($RRer49%bWq%T5uiNRr*e) znhM1kaIIsC?g41KzGd^pXS^#c6lcJ-9$fTqjw|)3P@DnR2BzqJ0Gf@$XWGwHYLif$ z0oOa=%Kzbs(@Om$6lcJ-k*PRw9o?|(pi&jbnPRhX23+rgE34^(5lVFxiZkHa#FV=( zpN@O2mr|32;taSpgX?s$22GWELnzLGYYS8Eej~HjoK;Gh4?Xe58F0M^uEYCB9#QJb z@s{EYxZY>V-5=iDuS#8|S_#D&aBT%wrxuO3C^cLt&VcI!rraF<@M!xAO1&TyXTY@$ zT$Rf#e@ChPLU9IMA9{*LzOYo4^xyoNzifh?4bFgTyQgUN-cn=j7^UtIiZkHa!Bh)F z5OrA{1x9wG&*87IoUH)YC$723#L8<>qkffgj#eYPV3F0oTXiDl=(WA*C*w zXgX~+&VXwdQ||uo+RysVIqT=Jo=}_t*KTk<|9;Y9rFsj+8E}2Vlv{_@kMAC%)Ci$C z1Fk*by5q$ISxU_piZkH)6kL-we|JEsbwY6lTzkParbBvrr49?l8E}2Zl-pnXn$Os- zRA`c&dCq`qAGk`*?owB&ib8P)T%UuhUDaAwE7d|M&VXw_xIP_UdgyIai4uR{$w+DVu z>X=ZR0oP%s-2Un|^qPH26}->xFV2AL2)O!R|NWOr-5?Za!1bl4sNKn{u72tdKZh-a z;taUH@)VtI==V~T8Y&cL!1Xm#ZVpd(*mh2-1wwHKTt~rGWAmQbN^KL0GvNA$DL04o zdnro&DimkHbqrivKiu0|sp}`(ndc0+jx*)f;qGyBpZwj=VHcq|1FjR``Y}A@Yo*2s z#TjsY%M`ueo6r33l2Q4Z{^DIP3&k05odnm+L$|C`>O-M81FrA9tAKIs9e(5~rM?x4 zGvN9jT&;gf-J;Z`Q|uga23$Wd<@Q%Xy)gxqsw@;|z;y~-w_g_DT&XrfaRywcnR5GU zRsE7(|MGJql_SY4i4GrRE658E~Cp%H8*dzI*MaRyxHm~#7TZ?n>uD3vM{XTbFf zxQa47kpN>)x*}o}tutLU9IMzcE$cOcu@I zO<4&Ol`1;b&LL;O^*gw7%Z*;AR865c1Fk=qa&vfp;k)W6)k`SOfa_0iRb8+sU8%7` zaRyv}G3Dm)aIwRc&iOf9EEH$J^*6Z6)LL9#sVzcr23-FzRo+fkXk^a0&8NNV8=*J@ zu7AO`_L=W@DRtR2+ZboSMGY6oSKU<8{yKA{z*S1!CKPADMK9m=-~M?0ho?#^)l(?W zfGa;!Zh!S^w=PAgu|jbMTm`_jc4D`AN ze&B7TItaxXa1{bq%@KFkQz}g;&VcJOrf40KtIhD?*DLjqP@Dl*VQ_u5dh+c`y($!E zz*U4PI=;wt>bsuPmD(i~XTVhyTpg#E+oIH2p*RDsVobSp*ylj2LP}lnpwXL+GvF!? zuHJLczNu6#p*RDs5`J9N>hx=$ee!R=4!aA*8E{<=F8X}{rE-Mg47jdf%B{m8b8}88 z^@vcM0ar8aa23)1VwddNsC6%ft6lcIy#*d5IeYjAWeM#QcQz*`Wt1P%S zOg~UgsbNBK23%J&<@VPdmk-#l)LfxB1Fmx5ntsvNAC-DjD9(VZydM`GUtJSsEK+Kp zP@Dl*1#rDHdO=a8eiMo_yc5dK2!-4kH$RtjF(qz|m|wuiNzHb9@fvP9j#H8UNj4On z2{;qFbzru9I?B8+<3|z6m~RpoiZ;&hqeZ5~Tok1pDl$Kq!JD+4m6VW^U`yh-<&ySE zXwdkT2DD=^zXu@{W%7q^4N%uHRY<5xRi56e)a5g6F=ddd$Q11d+RClkVE*e|RfVDq zQr9z8gcB#hTJhNo6P*XG*F<$t+V+-IoMMS_$k&tM)Nh zL)Yg;hN6u!*ykIVy3AIGDjq4;RjG|aQ3k0SnWA+=+u$Bg?^5cJP?SOHCZ^mgg{t2- z{!OX;581XTV|#szDd}Q%H?0plKaEVuE-2|r8PlL<5-Hqt3cRwjrM<~i5RgJ0Q(!xQZF;K5&cCK4GiJ-x zxn;M)XZ7v$i)+QauQSUImohl68cbawvypS%Ev9|zHfEtHgH%nXiVL;(vPS0b`;NLt zD9RvJi>YElO*vlW8>PkzMH$=Dv!;aByPie2m=ZdxYsr_U#2f^H^J@Ot_B?OTtE8%E zN@%{dq@gLHcC@6YDQRL#>^uk8b8YDJC-Jnd+(@SwiZ;sNNb4}=j)HwxmN0{M)KZ}+ zgH&CnXgstnd%EiyrM3x08Kmkl<@S5!Uj`pi>by{tL8?AeC9Ep+*VHMylqxmH7E=bP z228otGIahu|0;F6P?SOHcBagt++Uuy9LQw{( zJDGATvqFg~>y&y;D9Rw!kSVvn4ptdGP^nLaq6|`vm~wMiVC(v?l=?*|${^L4smo%ag;M1nvBi`@stHrBhj%~Hpqo<7grW>mO__2%Jn-4*{z@eYMH!@;F-1oRZM&cD z^O{l*3Pl;DnuBZ1Wi`K5YKc&kL8=8)ZuM^MxOBHt+l8VGQZ1QsJ#3Y)%3VsG5Q;KL zwPMQ6VN$DM0V@BacC?g1sx?z?^}as-odN2)UMR{S)rKk8!)tc6s;g8-p(uk?Tc+s! zVBOrBA1oAQkZQ-2J5qKp%L&ZLe6pY_A8J5?bl@J}P*()1TXMvzqhewHqB{{#68N zhcal7XX-ZT^Y{-()l}*Yp(umY0H)lv>ES;Qn*+kl>KUOZgH!@j&BWC)`%^QMjw=0x zEv5`o1DUEJ)aO6GoTF54p(tZpnr})5n5^D)zhg?Cfs$jUWFwSZI?p^cr*5UHnvysu zG5-`;D31Cfr1_;@Q^NORzT_EGGT}=1+R7A%R+y5FQ1U62Toufmr;^galB?&N*J$9n zl}gMBMD6XV#JuR!l2lW2kMxB~&AS<qe!< z3Pl;D?q%wBp>F==vB^rkDHLUp8Un7YvJcf&>aD1%f6Q+1?=1wOvGl2T`dq6|`*Oqu`i z*8QzzfwRpmPuWt+AT^Y!Dnk8zL#GUNH5ZC9NM$i)y2V@5#+A1#HAN`OAeGIOS$w>0 z?)>A|N_`*{Wsu4Ns_NpRaY~hY+O|a*q;i4!dHzc$l}Z>zJe)S2dw1gVZFZ+&w^#{+F5^?x=1;Q3k2|n5rtS2Uau~ zpwweRQ3k2WOt~{#|CfdZ?oRg$MH!@~Fy+osS1-SNle$VSvR$AIQui}eUwU}UpXJ&q z)lMkNAT^b#dO~HCu4GPEZZ;+gMH!@~F?F3#e-E$qkWz08MH!?XV5*u>aVUHh-Q&Xi53q={E9%8Dq^ziMcpKGO5Y4h5LHp(FNFjMBm8*gv*F8P2`orR(d zQnQ$9E7YrnziFY=142;-so6}m7OLaM%%w`bD->mrn!{8>p}wBiCGfu1A3{+EsYjSH zi;uS(QyvMN*=jAZrIbPHQKsDLT~)o)ecHn`p(umYT&CPQY(MnXElMpBiZVz&##D9b z;m*P@eXZ2@LQw{($C+|#V`q(qQgo01+Vw9K>L?UtkXi)P zm}AfWq*OnlD1+2upe~(OFkY!Np(umYb3i@YcjG~&#tKClq?Q1+{My#$z;f$nrcjhY z>Up5{)!X)qQcnp*8Kjm1Rc&VDjY=&SiZV#O0Mv+|Qf4W&UMR{S^&(J{kN)_VQagpB z3{o!vb@!*=Cn|MFD9Rx9GEfIjwft16Q$kS&sbxUTeC_EsmHJyK${@8IsPj4N%xfjL zzly$S4+Y8~^$Jj*Y^a~6R0W|ZgVd`)eL3apKa{E_6lIWl4XD*)w-!>Wp-_}T>UE$N zR_S$2sg6QX2B{T5UG?I}-ze2jD9Rx922c&AWPYhsnoyKMY9&w&t0f2a*I1z_gVZXZ z%3OQoQgzJ~iZV#O2~_8cciy4YQ$kS&skeZ-=AW5Um0B(oWsq78)c*U&HB)N6P?SMx z4Nzr9-7`+9okCFtskea|w(8hSr49*28Kl+%Rqp<*ol2b&iZV#818UrLSvM*5w@{Qp zYCTZde=HcQRMD60@kJS=HUKqY-UoqKb`^x83{vkfWflZ)CpWy>UR~9Mq6|_Sf!ckz z%(qIl6pAuPy~~ulR#yC=ac`yi2}K#CHi2uxjxQD|l_nHrklGBcSxpZPQ)-G(ltF3> zxE8c}{avNz3Pl;D-UHWP-xqmMspUdZ2C4Ufsu}KmRH^ksQ3k24K)o@iUTdXx3Pl;D zJ^*TNu_gB_bx0`6Ahivs*Z%x#zfz}!q6|_W0(I4q2R>HnZ=ooI)OMhDt_*$-r0C0b zby5bY9Y7t}AKy`36@;P;Qagbf`S*d(m8vEbWsv#^sKbxlxL&D-LQw{(kAWJqVo_zK zItoP@q;>&y@z4YLl`A>ap!UoI47kopX$mWdMs_r2?dq6|{|fGYpz z{7miPPN67+)aO8*XkBoSQip`13{v}w@q6|`pfogSCZ}T>) zyQ^#|6lIV)0@NR4&pxSC51}Z7)R#crTw?E!N`-}@3{qbKRWdg#aPG|&iZV!j4OGIk zo`E~_DMC>OsiQzWHhN5k_HeFHltJnnpiWGg`j1jegrW>m$AB8q;f_5@trChdNF4`i zRIhG<_x;`ziZV!@0BS>{hTGJ&S18IL^(|06>-HO<)G?tbgVaf&R?Vz1M5$kdq6|{s z0o7+*qIqM(t;2%L?eRq!q`n90o*Gxbr__}~Q3k0WfcoN}wt>5p8-${a_1BRS>I1fO zirXn+I~V$+Si8xN358kmiVYOYX}LFx=p zk8eg)Mc;ONumr=KLho3Vz~`U)ewp@ zNSysN}+%b|^JoD9Rx9D^Lr6UKu#LpBIWUNSz1jx>r72tFE0w zQ3k2sfLiioN?WDQ2}K#Ceh2Eis}klbRqj$;}R%E1uo#3Th@9Dl;u7 z4jz(Sw>Ag<;FfpYX4CrLj)ut28JH43JS!z99G^2NA%1vD&fxg0)NrsoGks8eVn$kK zRyaF5B_lmPH9Rbw8Vn?7WF>~OmFZcD8A;*n zCXH(}HkDp^ZzeUJ6>id`L6ZhCuweqBWWoFY7rzCo3T{JSrn4iC4WT&(6)v%*e`#uCNDyDNjjAA0&s7wv(7U zFeTBoA<@KyoV483RI{8SD$-JN5(kG1F@XpHf1`Sla!JX zpJgV8F;|d1Bqb9H!Wqf(d{k06IUzSS#~kYEgK`E(mL{cS=g?6dY8}q$mY5X|r}s)p zGBN+OO*m!H;2e71H6cAIBdsSL#-R=w2}!L|Qo}9it6AL=hJ~Y^bPtcn3AN3p@|GiV z!s&Fnp;lrRbV^7I_cEuejNBX(=GNP$B@D72e$+K#xE41}Pf62ft;~FP45wvejl?qQ zL2g!{4GP*ZnvU64%|wn2^+-=O!?D7aBWN*1J#L!a+??}F|I@juc}8kRmVeedDT;jGk@bS!Ib)>3Y2f_A~q zHceUcjLeZC?j#M@4ut=!5qi{egoHA((h|&$BD8x(m(Jbo!{%8Tnf6iB)Xc#Nkxx^@ z#?1^@cTC705_sArD{KyfoRrK|=}EIx^BN%`*IaTE(rvD5I6GxjIQY0zr{J^Z3F*TU zvTaGnl+3h*OnK76tP*ooVt1?5l+2#tteliYGo!wwO-5GAsEqU+SJpKnCm|=?yq7d@ zpSh>JBfF=h%M9?-w&}x6qc+Y3X8(@NHV)}8mo+zrtc2`ftXUQvDe30Q8eqGIGgA}H z;Y9}wcaiCAecr{io0Ag`E<%X}mZb}s<40$`Sw>cpnF?3Nl$dG%G)qVvGAJt}H$BM~ zw#Z5t-X&#(x!iLT{%KEr-XX=DdweZD3sg2w$x3unK(Kut6(Gv(E1%-RK(uQ((VTVY zr0Q+HC|1l=#z;n}G@(nKIx5SZ_5eL}rv!PdM@b;iJa=H&tU2CGUBl^SnjP6TTOM@{ zoI11;!odhsgnDF}@3e*;2G3}y=4>E!ZtZsq=SYb;f6{H47W6U~w2&Jo4KDDwXYh$R z{Wh7C-%$?a|-BW0wGFuuvf~g)GoQ%gF7ae8-NiZ^CTnFKklBD zke;1tc44xquqPOLL?@&0h??}!w9`Dp9H9Kf&QUEY=K<8t9cUx87`r57nX8}Kr`e{g zWqQKE)Nm^*8JL@#Y<6^3YKxTY=tAB9CJ|V<_^d@Z(_G6T;Ffk)Dl9t_a`V`VF9~!> zHih;iM6*Imi$al0(@cOl6ePjBg$6=p_FC(UsFyghz_X?~ISFRLWu*qnnwu9Y=H#f| z2-Jn*<5SWyFnUN#qsb&GWa(kYQk2lhURJlvb%rc8AIX)vZ$K3j43ltxpkZ5i;Q!)m| zC+DX7o@Zo+)8kzxIWaZE+yK}SCey8)dzh7FZad`3pl}Z0uH1|^$vw^vhljYwIduOi zEWb#UC%Nf?mfQ`cd5xH6ULFohwu6vpWNo(8@~gm9vwP!{%^4v+&EAYfl+vymXs$`w z_7;@l`pAOG=4LTaHYg=Ij|OYh{f~+mviKTx18s9h$p^)G_@p>SqjHx`gOQMqVQ^Ab zd`?Dus`8hhKGx8GM@;pOQJ)yyD__Jj_&Q4H{^hB|6#M zU&hnDAl+c5jzm7s=Hqh)^C8GnmZt?$7mz`2RBFn=_@pqs{St4_aPfo8dn)F>+FbS6 zccDZ)y`~OlC8s6~$}1dQE?1$b#?v!wYtoNs&A|su_G%qpmwanz!2Q z`ZaIZ(F-^`6Ikd@c=4kK=BA`3#Sb=j6lvxan9bT9VctHG=cAaA80OnLwpy~GIPy4kghd;uMjA6*^_r5!%2YJMrjGVw&>L{ADVWt zxngsC83VmZX-`q+CO?lV5X-xoes;~u$}#IMUU6D%wik)?3O|SLyQB%Kf?k;SDtIB% z0G&ow17+#Op}BptbL|#!d^+7@+A_E7`AyS6nc3+%8AHNuH&IM>tAzN3%ZoHCl@E>h zq@-*(#}3Vq_klz7C~W52bdes~bBArmzEN!EB=~foxfkN@`L~gSPfcHfPt7~N!KXC6 z=4j&Enm`+-$ymko4t0z)&q{P7^yV_8W1O4qO^uyg`#zbL43D>Oj3*D{9{Z>8tQI_r z&*T@&)Sii(y{(rPJ2^Bkdc!+72Q(^Q<}B_4o}NmtuLDzK_pNJz&)x3Oa9znv2+JX8 zTC;nS7k*?@GWq7B??{?5?kK%Q8Z2zlynFDeoWff4;6nNPfqOHb%HlKm9jN$pdRvO; z2utG4T_&FwTya)PlDTh)jwcUHi&1J`SPaZHFY@Rw3warao7cFeHa#Fx!8d{V~nbXy063u=4jFyR-o(hIp=G54>!{LNe2 zW~NvaKiI!r7bTCC(QY`i929v9{53psY`%G)h;H28sF<^CMrKs^!fBZ~Bje4Byg|YH z88fyZ6y2oGRNxNX&IqkqeyM8qi@nkY%CpQJL{>uZO>TO_Bk=Z1e0=L}ZOkP)HJrt7 zE1MT>+2O=o^Y_4!=1)#^B~8r87?KhWRmx2to|2wase`%O;rHJ{mFWGbgkV8rq^r5a zMy9wdaj>}&t5j3jKr*t_W^2XFMwUi)fZy|v?13$`&DPLngW0I!s166yfgao9$ZpVE zULEc0+sMuYtD?FTthAFI=vc5aYL0@HmJCc)u+oyXbsB<|mdvBll65Xb=201Idfb~u zvF69u#hf5t8*_$yZOke1wK3<&*T$SAUmJ6ld~K}3%HNY>jn!2N7W~VS#GxoUCVzB_ z4!a6Bm_R$O%8evOm8I%bicw{$m{pdln>Q7+%2M_6reapfRG9Y~`SfJp^p$CdD2#~e zpW-6ofeJTkuBAYgo3$8KZq{N{xmk-*l}Gp5xN~VFVk)etR;3tKRur=;uR(cJ?N|-w z(LMPiWgb)LYOS(Hji`oQz;^cn0coM;f3=WzAYuUShT_r+FN-TQon?P`n)>0(}l z4&FBv(WSs&bR&8dtclbF>tq^z7lL(`)A6L??rPV~*%0R7p3rO{kTQ=20uG zuHIN|9<>qO^?&}3=&P1nnYN}iwv(}HEThLsBonJ9qGNQah&;4ynFQs0X8uGkT@Msk zfAva%BHLLgl4*=i)d&^^b#xoRZGtmU8Vm}X`EWMwZzWFtz0(_}w%0h7re z!;tHMxFLmQR$S8#2Xa_ubG2gRu*~La$H-w>a1i|Ykl+|>0VsnRF$PnzlY%KIvTeCp z55}-ea_(rL&#_3y%!SAvT3jYMnImWq$|MIpmJ=P61*bzlGZUPXKxuTCKT#8%w#89# z{=iLC+Lqc5%Nk*4Fdbbk1GIA!m6tgSl-s<_QJ~yTN_4r+%i4*`N0-~YoCl)v(dAK- z6a4s5)Eq&jRRyO6s^RR*J%MUV2PX)sWswBt6{>^XhR;U@yNnf9D60;utSn}grR2;O zi;7t#gOj<5g}K8H>x7e8!8)0dn03MF=xRS47MuuIWSf^>xkA`auFxiBdAUNHj3~58 zSy-5iD2(o;`P5o;H>uDzDm%nBs@bUG7@gHLbXVJkzG*tD*tT8QuEWTlL={I5Q9gC@*qB_*I^klDTMmMl zb-~GZpZp5WyDzf>IShO$90$HsI%D_0FO_aYl-jH;p@?i`sm;m)ipWNm+N|8MMPwsO zZC3VvL^iTCIAQY1(BOQzBHN_wDpv?I;0kS0c8)8w$%sOml!0P0qR=K~n3#+xv`HBx zCL;=MQWiTVBMO641Rt0UP83$y#^of1Rdy<3R#{3;RKq9yN6PFfzT=h{B@QQMC$xBYQfw8-|O%Y%dEw*mQMq`|=kN^RqERt%Ke z&PSKSDa{>Z(XRPIcm)OJ$N z(SdTSh%Sc-iOS1V1j-{jL*LSg>WeLm73~=_Yf2--@_nS>LZDu_;;3P|il}kAil~9Q z3fSpEN9-;|kH9vR=NM=*{K?esE(=Lr9-{#=u5fso#kTJSkQt7r8HeH~oD2wHK_)6EmT_r;{u5p3wjs*oj^npabg`tD_b!R$I56ZDFr) zjLFWh`-_idBd0a$Pn{Ht{&S}* zjrfyiuvl8A`$yvGn{sklf}-eH;E%Aj$ANsHE*f;-;)~Y!8ks)+P?z+|*U9w6th1cG zM~}_LuCtuIBaY3*uCtu|d|7NRcAe$w#vFqkU+g-|)w=)}yUud;FTlmF3+z1n5^!MO zMN|la-@TN0M4?36W!(~U zfcfB)tb>Sme`8b#(k=4q(bA*na=RC6REn-~$3%3EWoqTg#Hz7OojjRXHI}KDCljm2 zGWGLhV%0=V8h?d6YRYV>gx%>baBhR5=$OB&2;}tEEKsN?)`-IBHUrBikPR-LKrwx# zT?Q3dYG=({S|TfC5kyxAQ6n!RxOFFMrwUoFc^F%&&s(w!Qx;% z@;yurYhf_Tp9HW!OAs7jwdMIH)=*;*O3BL~JWHDqSEV z2kwO;ww0O}ir7{z7_qI?`tMdQ7_qI?{_j>U7_qI?`R`UP7>U}==IdLq6YZ?%r58&h!7qAFvfc}%&d1NG2=`-z7d?5_z2s{nIj!LDj4_E*bo z`>xYkjy>0Mn|IyU@|c|o_BJ>WhXw0{4P5A#EMR~a4*suA27eqQxTi1FIxrU&{YQ`S zY!`IOFJutFLz{7`RH;Otos2A9ITc?nD73nj(?;A<}#wn_DSyV?5l=IE{{q}$~|3d zGLK42*0q<{*km4+maKOnGLK4_9{J@S{$U!J9H;;!@XIwo1j{34#Q$`Z+hu+_0yPmM z3e?zDm=w-t{nf5x=emQx{o>6Bk*F z(-v84S$DpOthH=jwU%`g8k^0l*0OFgW3zeH;zWh*Psrg6xx$F4am5jH;)){%5Bf5J7^@2i0!xAO?iZHU*-{l4%sfp_+>rlQ{E|@{Je9x zH}cNm?#Vlc`z!BUjKR{YO*~Io+?E5782LMbFe}lu2*>)hL2Mvq;)0D}$IZXH06%CL zb%Kqm$Ni8O?~cmoddufsZ}*?SX650}yWaBt1eyn*cfIBPwJQ%k?|RF-moIsZKks_j zd3Ig-Uyp=+A6W+=y_WUAFbNpeL_xOIMEwoQC^$M{hwQGoB#6%7vWcCs?YJ{k?2K*a z!kMT+$**Td4aJp555Uz#ciYuOch=QJchS{Y#$6+5fUd?ev1%;yf9$<`U{uw$KYqdt z5FvOHMZx+Y)=@+8k&pxuqs^R|bCNU3Ofm`xh!R2`K;@CbL_rZkLvBeAW3jfi{q=!f z_3FKCFZyjuQLE+wgor}K7nXVjs}&j_SQJ6U{61^%GiPS@oXJe@@At>=kKe#d)>-?r z*Is+?wfA28an6afm&7=BA#nu|_q5QsB8U%(ixhdfETv~YPc$y7U3i=TipXY3?75?H zafP6`Xl%AiPex^rvW$x+1SLd+d(WR>M= zIIh?R7tiCkX*RfcUQ8y;N5{rwBEm62Y_7ncj7krcHGv{G5loMqO$0M;A{ftCwE;73 zA{Z8A17_SrFg?sRQ4PjT1jjz=HZf9MXkz5p2jV71jtfnU9Q)YZ#K>`>iIG|3H6N~< z7&$I9F)}?8Hu4DG#K>`>F_9zBz{P`iVE0)jgJCV=veC$cYC-Uu-vDGDR z6DA_L&<+Zwja2i2!8X~9gxF;@5@wg(NSIxgBVm#5f*M*x=}1_-l95Lk$17-Yg+wgA zkbuSKcs}qUVT;f4iF}UdE@L7-k}E$ z26637SAoln2J#|E5*S-XId}c8X6iZ`nk2BkFLTIdZ5Sb7jtD#*uk8d@xB=M7n$0%=BlR3oU+(le% zaFdG-jEM@(Xp~?W_Du5lf)c`FYcg3(-og??h4K<43#BE5CMrzNOHWjlaTCGOr>Q4K zi3y8|XqG6ck)$0)gLuZwX)iDAXdus5l0Y64C!S**GBIkhP&2MM-Lp>?x7yfBHsi+i zg$d~<2{q%!^@a&?lZ2XaxlJc2;({ch(aMQD(cXM8eY8r&fW#NFN-E5Hg+fw6QAAXT z__Bp)~MFVZpz#0jAkA+>tNKjm~ zWUso26Oa^?C@SWq7v_605+&JS;sxQf=&d>%{vV~vB7&EQsQ~{kv^Ww=O_EATk$wWE*O5*HGX?Hyq!YpHt<#TSrobJNe<6kRBbX_0x8+|*A^iyPMw@7C&g<})W)wD5sLBend zGpo#ljxz~ChK(It2rk1aU>i+&=?sV9GOXfDDq}cAe1VE@|A{Zogix-4)uknb^DHC} z=kfUz2nCrWe)8~m<+0e1{2fK{IT;=*WNUb^kjLS{LWYM2bIDfjhXec_8^|+ z6d*IJR>2G>D(cDDqvA7{`1-K;oY{oO3y4i5w%+4RBpHb3%QEw1FfJ=4j7#GOtYMeK zOG^oh&t`NKirnQDm%+qfu8dVg1`EW0)ce_j7rR?R3*6ZG_8}Zo^Z{4CgySIhMzA2mTZiu`tyKd3a6${OGbJisV z;SItmF{_$F5_I>v>+(IS+w0L(ttzOyTbJLy951IVFJ40LD=#k&t!Zg;M}Q?YwUxer zSFdnmgK|YPx)3X9YLyzSbgx`!F#_(YpsH6WmDO&%t+Ko%R9@V?qNQoM+boTxQy0g+ zoxP5(;kH<>2wpsODG#q(V#Xj2Lx5vy9&iVA)l;FX(0f&DOAFpI+|+2PP^#7He$7|y zcQ34OEH7qnwYCC1iaVgzRM&a}ULH*E^~IZ07ljtDih?w^&r{(GR@73CaZ0tkn0LqJ z#Y>kgTM~+7<}MzwZejhZ$m@$EEIh($rTMn{y1N>e;2cmah%q=MQW+k%&lm9fY80-P z`ReELV$#o2tVH!GL0_P zH*L#NdMj79wvbrUN<8kMFX-`B`xG~w$|)~y!CRRl1rmiR?pjZEZBVH&i=9j3r@|~$ z(5=>126WBib1z>3N$8B4AgggnLrj9GA#aUG^#|2R4e>ooytEa9Xk%>ElDJF?CsX6{ z7jUbnZ;#@w;KC4{Ok$B+YF@IE-dnxmPV@DzrnxmXwS-KQtmE&lHVdM(wo3H}0-h>& zXa#g%TE7wBFM2dXP;DiwbWguRnCVs)*{QEtmxmxh+KEL~&YL*U)^OIjAMSl)z}uGcS$ z?>+3J$Mzle2rmD8u zZDtj{l22D}vdXE(9jvYLR|l%AdCgKFs)f3mi0Nu>txER=t7~fA1?2@(%L|Ii3rflh z3Z|8p;zh9K#VeLCU1On310GLJrMKE+T3uWh$hwVyM^!5-qefX?ybLdvUJ>niJYILD z?)Oz!2TarDRhx*ba94RN)u2Z)TRYnqSX$qJJPIOf-4!(z9^G48>&`DPW!7YN(w5>u zca^48)CQCaH?!&TVrGFtVO4p9N|l1#S#}rn&(tg-$Y9VLtkTtL*!N8}Gs=tWo3VI< zGFO$EQIyB+)zq3Azo*hfEo^GW>$}T~F9Mdf32po-Xbmu($}w7`fF<{-J~M#=dJ!Z(q;oSHQt(PjrHRz zn&}0-QQ-l9Q1g1w;Zj!=mrdyJ3DyLIXzOeUS=sbm>?<#8vEq6v+%>hDrd0&YZUyGF zigwmu8r4U^1U@d^h~(xpv{>X&i|Ob25;KL%?hip*5{ z6vgkYF|*6Otny;DX;s6@B`t7yqEO9UqXep|)tUsl# z6pyF2HpaJz8_EK1z1F9~xNF?yF0WedQiC@s7~X2UTKP0f%=GFCwaQoRt&V~!J+T14 zyT%*Tlqxtgq8Llav>LUxy4r^lvmg*+1y8T>`f97S8ncRG`xq2tRYj%8@2~c{D{5~F zz|LH1P2p75f7GqSqhRpP^O#XUb=Oo^RaE%ld&GDqS@>9~S)L6BNEj{+IcwmKSm?rv+G@2z)hj7m{y8ynyo$TZqt$v*ywT>) z7xKs{wlzsC|dT@3~UUIogFPJq|v4tN6SZY#a+*~(2dzM9JNLNuCyQmGN4 zs^~D#*+C{(HQEVJtqk}v=GD0GgpU^YN~fT} zN<;Iy^@@rLt-3;w+L2|k%(9AS<3-`2CN!~yXp_in9o%V4fa-DARAG>TiMzEq!P*(K zZqmq{%8L{K6_gj{TOUZ^E?z^_wTnALWsaO2)U$d*N3-J+Gak$XwwYN;IF{*qM@p%#w9xn7hPEQ^qn z0eAK;K79aV6*`o7X!`5-7ft-`r9-m6!x6p|USx?Fo^%n^DIO@5lM9MO77g zpt9PJ&antLD_Evjq-nL4UT=j5eAGsiU+b@|Qfq4ok0XW_A1$LA?Klvu^}4M_&-^Xk z=z0HUIv&(-Suu+$RgYis`q0%C;pBak4>w8kD;{+0MU9Qoq08%m?@$4c9c|xAiKgR` zPBbPFn)X=&)oQoD1|ESgP$fpByEmGs<7;hbz}d&<)}=9S9}@JdN=;1wzL=F@MLqg5 z#0Zh2kJ#3{7`94n92`h!UE|88 zs0j310ku-`skId;M8s+Y3DK%SzAJ;lpilKx|F1<h z#ER5)G&@Z-wJc`k!rwuUc_c3#_*Zw(m;h0wG3Adedf>MCgK#2Q_KKG=Z=8ApIMd5v zxC>hsttu~F*+hlRDj`~Xh)q)vow^4qo#N)Erbc>Nq#4z8KzOWZCSq0BR25Su&2I|u zu4q}aa>=5_un|nfd^KNYRxrutTqD%FvxlWAt$FQI}VR}5ZpT?sFiRgy+NIO1@TdJ%~z?8|ut z`uqVH`l=8z*HB&z_jAdj<fnVc~kpb5ySV?p13M_!6=nv{wMdm7G z`_W7W-0(oXUO!eAlZqI=LqKn~N(0_%jJy}GY-$MAFJBa$#i z->k(num+2Q5k2F_z$L7Z__|nh45YElkBJ;=!-_|b0cSox8_>uvZLV*?oQ`+M7}z6T zx3|V!;a4&L&|^kk_CQ`NO4P4Hr@%Y^g>dq*r;lGNs)qSSMP+rZqQ(p$aZzb4m@i9E zbohFaRMkohzglHwB^IGAoy}*KQ$>8Yb;(MyV!m$`lP2=224M4*RTVZ7>zC46B{Exo z2Zr+cg)vpBx~nQZ!CD>tt(BnHye)!K;vEI=CQ!xD2{Aq7iUJkzD6B{sz>cP$pWG3^>YMbf%9X1yNk zB~=yGy0@wZW*4y^(Fa+%qzUVftWvBjs+hH7$n~h+7!xofMmzxXc2Y_+>Q7?4ulCn^ zJe63IkEV!KeawbKcqo!htSwKNSd3@MT(fl!85O3OK3M{I*ENuFomabmS z?WJx33rf*4j_tj;quS8AunCi?SVssg+oNh)wWh?_Lu|~(rVx5Obh|vRl_a`7f1pCw zE2;umx3+vZ!Mm+kiQXWxKeA%scOc4=07LTX@NfN|hyWWj5;nUBD;~_EM$^zUV6}L7 z-hy-<`UdN|luz@m>xD&) zQ=1B+;SD8I^Gl`{Sm6yNNU*Tjx^B!bnp%)w61|>UT;J3*EqXnzplEtM>CN;jY!viq zETK4@@USlFIm`FWXWqTm{wF=KQ($?Se#$fTo}DBLisktgimj#Pc&T6 zx4C3`etltMG`xO#VdM0ue$5T>_17%uk40tn;cDkc|X#B$I%n&Sjg$y1OzK|7+ z6+WHpIwpOgpIIoh^My@Q8yf1TTK&L6o;^!`gJ2g8LcKN!_1G}g%Fn8%hE}Y5uE7?` zirbe^3aghbbMx$3zY)8&81XQ(bgfVeZV$79&AKD=j7c;S9Qn(OGN1L5HZUvLOrAPZ z4xjdZma4lON33(gDN5H)_k8{q(pWN)=0ui?#{JFPEQr>MGH#Q0GKfwPf zFxSuLxRFV4|D7R8%YnIQ0mtFeHr*>mNYWL+_!n{8CbB}?~H#NP$X zQ&f=noQ1Dleh*|y(z%Ny>Ae*UCjBr8u5y$l-Q6llJ$G~5g-LLfkAbxu6Zy4EcP|1@ zu8Sb}Upw662tejm4+twyYui#4`6sK*ukl}pNhM$;^oqks% zylz7b2&5hE-@xCT2JUj;&iP(yd2Oh->A?Nz2OK*Uf9%q&L_z#!vn2g9%yFn5Tig#3 zFzQ}O`pFiKOIE+tFt~^BLtFYO$7LsxHxl-8?*p*YUvb=|B)HeW@Bg(V{dz0MQFmaM zk1nSqy$j4Ek8oVF_WJ?yk^d;#8yOBh=i_T9Zvo2X6fkrCi@~I1@=zqwyTGjc4aXt- zw(>S1-A91A>c2S-;%#x|;7>C#9BGf6j=mx`+SUqfG>a>dXl4(mET1OF8DtYN&K%}y|qJL0JwqQ4=?Ws zf=B#8lKzG-eb8KN>ti?gg@2T!)A-USS^J=Fe%y8jv3~6I`@ax+J8&ca#9=U7+jPmC zt_J3yi9>U-#gV-6J0$79@ug2Pc~qaT1M`-NOIB}`?)$*}=qZv0J@K{6$3pOT0&~UF zgi2m6q~CSGylUdc;@VCg>F0Syl6?5mCz*a!Pcwj-mjM|SWua1;Mbl9HFpO$fURm~|;|lQ97O2$*M{XX28UOBaH7nHY|=&&M7VYzM%B z9*#;jzMTQ?c3>9oFehtjWpK)9c{@9hv1n_@; zl4Byjb~qRE@kAQ9df;CDJR*tzwUbvcLXwJ4r^fvS@|wStB=;GPMKs%dP&LdnF%hYD z>F!5?m41!!U<3r?lg#cb5mp1tPfQ%4?c~w8x)qpw8aVMuhNJHBI$%CEamn)Gg@8;a zm&F9)$1dF$0jb8|I$<=&CbNUdXgI~d%pb>b$?V`ikxu5>snZPr@+5Fy%N(0*{BR>U zAI9I3!*R*-y8()C1ZL!U9G9#{Eti#$x9A%g(wi4^T(W-SiE)y2 z-X$5*t|=VnP9pC~D6U2nO2j53a+Uw3xC`xSta5GdD)P6A21JzI2(D-1G87e3Gzt4VGwku!xF|%vijHx+;39Iqw?zq=7@;1$?p&_W51m`zmtIph&UU0 zw*zyhh_k7Wp8)fyh_jK`3(S5IXCv=JV9tm*8+jL&XGmA#OP^%*OYK85F${>GWc4u@ zxTX~HsC~2p^O%UU(Qg+pFN-*v{C*6~kchL9cQFQ$$uyAQlPte9U#K)O42Yj(`K<+R zUJ7|sertdUi#Qwoegn*(M4XUclJ^=g$3&csywOUAbS}R1NtRz~Zw0_8BF;u$9Wb|x zI6*&>*9pweMVyViKLOJ#;skkAA4g0KNcKrqAIE_EEQLHOzjHmXdwl6*m5Ysj8ZbAC zI6*&>w*r`U5oaUsAz*$d;%wyY1?FuLXCvq_z_f}uoBFsP zn5`mCkVobBEHE#LI2(C`z;y&Sj#6Pql*i35xh9!)jWcB+1 za1W;;uRBe7{lLAJLLQC3C(@KRx(fafzVxx|K*%r2D*#3laW>`G0L%&zC&;7v4FmHl z5oaUs8DRQEoFI?v?>!R(l6{iZ#~I+xsvbVSRKHi67*kx*`n?vovNYt)O;cVyaLZE2 zqjd%&O?eLh_ize%RDRuQ%6k*I_fp6sdvW-A8K)}03BX-uVu!Oo1(;bP&c@ro1nK8(lkm`BD8|Zel>PPqOkW1x`yLkNTH} zH07-T?(Q_?{X9*1j{^5(3VCFI`_q*7HgJO}#+N>po!Z!Q88DS1PG}z& zK}HiW8$_Iqysg0eM#Ks7D8K!{yeZ;r6q?-^iT5pg#9eFDrG5hv(J<#*vt8PXJd=`&pY`hb}w;skkQFRM%p z6NsN=`Tag{_opH6Nnmz~IGgm#4v&Q zNtWL=z;&dMNA2TbV4fFoHu-%Em}4SN(2w#vdM5T=@TJdi`7H)U5pjY%vgbMz!vx|d zS$^*Xu04f3D!+$-`J;%l$?q$`ye;Ac{V2a@fEhO{b$+J+GhM_9@<_i~CI%$?B+Ks- z;9Ap=cRw(Xi8!15?gHjz5hv(J`TZD}ArWUI@8X-Wo{cYkEISb7k^NPg7zV^ovivpx zw<3i+nooy;c~ZpL=(iu3Ln2PlkMesOn6qXJ`LL09B`}2|PLN0Wz0t&gWS?aDT?X8m z6!P*Q;Q?TtH*ut8GI{;Lyp}>9>30Gcc~0v5UJXpCh!gTl^)VZmyG5K$`TZQ2M@5_< zkLsfrm{&xcjl55QIV0k1{UT1#kL0}%%$Fk0M&1SUGNjA#rH@rEHuAi{%ocGr@>+q}AmVJ~ zZ3X7{BF;wM%fP%P;%wx735xAXy>NbpbS=L0vC7%TUIM_(6>);Skp0~W z%=bl{jl4&Jc~Zm)^4yTO-^74qpJeqb*JVf-;!7VZAA&q8zfu#!fcQx!PXR8FLLSxc z?ZC8)IGg-F1kCS5oS+|--(Fx2i8vd1r-2!{Aa#B(Gcl?1I|aDuDdds8%t}+<65v`> z$fNdqf12{P0{5E~@~A%g)0B4vxDQjv^F!X)dW;|V(uaPN*-Jez%S>D{`y>4f6GQUo zlT6;jz->z*kL>xSH08Yp+>sRWsJ|Zq=E8-7UD?=QDKMId6YQDfH2||-#M#LE6)^uP z;skkAetp2aE#hqCodM>o1|c7UJhJC2fhiMlHuB~I(7W4w)E`?32u15SWZ6o)7v>mfx|!OfYf7<+m6ZpNO;3ZxJx7M4X`CRnX@?V4f9mHu4Su^S+3) zkvFm#>xuZ%$I6F|yjo!9i8w(X)yEoOIz^m~yvKm~y@(U!QGL7&%zGlvMxJ94{8)VH zW937TNBUh2%nc&WM&3MN7Ku1P9*rLzCWg|bPcnPC54c~Yke7@2&j52s#M$U~8kmub zQ|I?GUae_Ruzqf(;Sj5@L8}}XTH{wg5;p}-j zFqI4w-m}2;i#S1EK6HQI#ITIuCt3TLa69&s@ug3){8D`= zz|0bHHu|jsX1$0L^rQOt6)?XOaW?Yy0`rE56XcaZ-e)ETB>N=G@6}5&pT?Iy!{v82 zFt>|18~r+g`H6@V^rQU#9++McXCv6B<(Jm~ zZUm-P#M$U~KQLQGoS+}&_gP?G5^*;227&op#0m09zw?%(-teW5l@A+vvw>+4ae}<- zA!CDyVFK}!to)t@u0Mr5s*m^6l;>E1@e*J9Sosk2qx@bC%#9+>Cci6yxm&~u@~A$3 z4$OawI2(C=z`P>j1bKOo_lb!C$v(--?}8Sr*WpW_Wcj7?^8!<6;s~8g-V$J1Q^=$K z>V9Az6LB{A-383cB2LI}F64a-jQm|8A2#x?2BuWR3Gzt4*}&W`;%ww~0`n6QC&**{ z3oyMR&PLu5U_KOaf;_Unu`97YgfD%DtB+D(G!vJseo0;fFy9w(Hu^mZ%#$Kc(2w%F zADFjAoQ=FQz?`*8s5e0#&8M$4F(BC|nf+Z0Tv-ZvRKIh9StjCa^fQ2YK*S09QGWjj z%q|gUBkym(d@SNt#^0Yu_w9`f@iJkV#ShD`4ep#YaTC(SU6dy7(ll{bq=}o7CN4is zTydJX>+Em~SFMVaJNoaQ~$sk8pRUiCdcn z?gq%)kbq0nuMD{7(!gB--03uM3UHHJMSBh=X#^Q8gMhyz^TCfAOV+Xf4E&-+LwS!OqZUsbtnxSt*gA729Cz_<7wci zTN{6O>T;oW?oINCS5% za1+<2F24(aD@_x3QyMsWzRK-s;3yyemIjXe`$y8iQUBMKfJ?M{O7|Q0q%N1mz?CH6 z66I0-KA3<@w3l4q_N9TN=bn9(1}*?x?m96aiTV`)w=4mds9!N~zfJ>3<@ZV&xXXb1 zBn{j-z>Qxo<|9!*njc(|fJd%t(!f!F z)t!J#%rE)(yAyDU`K9NEyq9{Tbj7vr-}Phnz(1u#66!Tt~U)F zwYRgjkhih1T`>JV0C|&+Jg$IjWE8wItl9Zd9 zd##GM^33wj^!q&5eKRoQX75cizZuW0^{ez!rx{?^FU4y_mg8L_%kkEU>x8#6+#p;> z-p-Iqy}~E>-ivQg%AkjwN$PdC*5A6aehprG9r@F;as|DH}9s&x%3wKWlQeD>qTMs_hci!sC)H_42 z?Adzz2MdfZj8BdtP*TJ0Pn7mkXWu#cnW2ZIp~39-Q}Q#?udf|?>hF`M56S*F8Oj*Y z!>oSTm2QkfS0w4($8tORLydAas}>}XryB!u_BiTT^swKRe?rc_m=cjEtFC;&azQuC z%U`GKpgivY==bG$@5*^S@?^iu4LD0g9>25MC$H-|A?NsAxn`2Lx>|H2j)wbY{4fXalGIi(JZ_c*Apn3QKg9mCft zp~M#J#z>y&qq!Yj@Jf?C-gdKSn9fHIj-FR7^*JT!Ij_SF^l7f<`n z#l7@=K%Q4xdEnF)7DcN*ocAkGX1@7(A*4pJ-ZlCyoeexqM`x}1V0 zw;YuxuRf^Clihppqwi4VyuI?|;3m+IH|z4c0lk|FW!>dERR0;G7=Bksp5&HFvqNVq zLtT1%SDsqdz4rK^Lo)_^hLYzG!yqW<8T2zZ6S?y>96)aMaMq7>$AM;5UaszOBJXSW zWXgFb5GVJ9Jmc7e}XW0Y>FuEi=0 zNtGu_YN-^;9_rSIddQTNvi`Ln4mxz>3&l9U{fjZJxyVo#@=7(=gP%F*Ip+4Akgw`; z96e?r{q`?%L&5eh&I(n_*`vsO+~}-wZxg})PX0hou-ROP&# z)KY^a_EmX&59^qCn=>l%V6M*_Gxub59B4g9H!5;<2MiD?&s9%l4vwX!OT|peAUbM% z&T(J+Zl|yP;|#gu{jZ0H(2`JS_qmbN6Agl>z+Bdl0sw%%6W-?*@eb59`UuX&l5Aw;a3)aTYV4Jh0o>WFe7% z!iM(f#xWQXTK8o4t|$<8hV#^{SC*U@t3GD%LqIA<$IT59MwC2=?X$C z*dZ;*>z#ja&0&B4?4mVE^&uEg{1_Q#AE1#1208m=gw6dX7O;`ouspjz61Lg( zV-jozZecWcoMy8o%5ZYF1B22Y1nR~ca&~n#@AqhcqQPJXQw^P;ob5&LiyjUMu#OMG z8(m!#JboYbc6-=J7IDLV$p&~ik21AkXB%L3R0I+^8e>qHPU!|vS&X9cdY5%Tb3u`} z?vz?Vd6>(Exq?Y;0L5dx4vM=b$3cx{F)-L+Xqq_d=GnaCQfBMn$1~A4p@6%9K-aYc z{nq1f&=5z`3jyz-LeY)C=$$iNi~YtCy%P{xIn*6&~;z z`w@(Gt{VqAqT^6#q5Ry~A=aNfhlr9nC-_<)>TQ-MsYrjjV`En+@A|sdaq@H38Q^oY zXOpvhXtzGp2adjBh{UdaWpKRSuv@=@F68!)P!68m&JuKrClzC#*=2gbNa> z*q5=ftM%ijDcPqaDO=)#bptLCQ%E;XaWxwbMmXWDNsQ&NI1PJs$NvAH_b-+K95>aK zMWx7`J=Jv)wVxK|FJL?jvI705oV_|*&d&cQIe0ZYP> z^11T;Mvo4=F|F)hEIKMQrefg%uB4rYDm3g0U1sbVUdPwtbbJ=wna-#tZy(L3Y@dGwA>Cg%%xPEH`J?W` zSbkvA%8vVF_0>qjA+dq*`V7axq1}*Nc6{yAexuQ~0JPo^X^a(Ux0AVAOc$T=lEdsp z5{fd=u+-%wEK&a!9`AfP70o3=@ z^$;5$d0~a%I7qoDr(EPw7T|IjmiDSq^Ob5;oI-obgU8Qm6f_@dn0|TWD!0C5r&>ai zW_ro^k-V`~7*;c!E|ZJIqWt(e*%hf14ed8G6+Qxvl@aCH>t+r=j)NF};+hOKLa14cr7p~hZh=85{J630R6 zrEIE#k2m&(6wP2_A=?*(9nQXR90!x}?PMhKnAbx-n45RftmbJU2@5)J=*B+tdcVB= zAn%Db9txfP6glgrtiddkU_H6t*v(?d+k15*%)E@k7a51VNpeSg#=IbTlzdi3eq^08 zpFGJrOvxDX#VL?}Df5AD28AbvpgX4JsR4YQQWJh3XI|54EA-z$UBqzrS)qThc;s1~ z%|a*O_be875~%YTZ!&(f7;mb@D+47nUWLW0wQ#psJi7bu9EPKFJo>)Rl}^W$|W!;_~KOyhWhC#c(Sv-UFasLHRqSr$JrKLU)4d zW4up69b(iN7}Cp(Iv3P`Fx;h}ZblBAQl7=T0Ti!a)#BX)DxbyZ0LAlmFQ`Js`?0-V4-`+$1L}Il`!1+*MyVM8yW8h7Vmyg zGa2vK7Vp17&1Sr(EZ*y&ZehF=7LQs9Pa_8uPnWFbHinyQ@u*A|FrH%Zsz5a`-Yknp zm}bUXX7TO-wS@6DTD&cwmNMS2EFRU=3dVcV;yn#&CFAX~c&~wKWxTg69?h?KO`inC zYkC~|7GA$IK&@sm=78e4Yy@>Te-^J!|5Uz0^1q}WDE=+_ehH~5dURuDSskPS8uXp~|)dupJ zI{fIJYh9}qxfW{xjjk3yy!yp{uon0mzVvlw`izhD?)RL!@e++xK?-s6(MUBOVRLw` z@PLYCi!O-5yq|{i{K{~V%hx{Sls9*P8wgi^?GqU`5ZHkR~=p0M|m7*a(A`DLt5!A&UN2W zj1h|QS9#l8isNmwJ|G)YlmcsB;xleKg(~P(9NqqgE>GAw7IO<_2-ULPnZ3zb3K44A zp0x*+plO6`E7?6>&zeGS3-B zbd}Q#aVjv3u=8xyaSG)@x=-nL>{824t-S<7yKt>yt(^f5D~6UerF%+`T6TE-6llj* z8h2+$ipYl=W@X_oqqU{YUt+E9n1b<;%F3;T*JS7hR$ldn{d(CxIeZlh>DI%yW$N9B zojSb5DW90-qZ)m&o)@!)!Y(YQbb3$eoen)bFI#W_D5Ld_W8@>WpTd&*K@efRGE&1Y z>8Oeap+440I8TH2Iu?11S($#UqM*{)P5_f#9nM;>cOP+>NKCXN6=|HJnkP@mA9iO3 zjJN&anv1q*oxxLquzR9n-1t=>?1N#yt_<}koxyh%!*`I(yi-5wYah&LeN8v(Mm69y zzQI!C#Sor95oew4mNM(_NHjYZRl@Wr7gNKgY2z`+nX_3ae&-O z7U-z_3QRIR$4;_AZh!@bgX|9`iOQehT)S;>yk_i9s3Mw~wC_UI^i9;;d)Wj|?#QR* zI&5K(Z4I7lTO9i%wT9i92+1uvas|7A^<_dsR3fI`j(#4Z7=cVI*nuC&qJ_zz-=LnA ze0-YNV(}GyZ%6;SD*^^qvW)@N=%>x8-6Mwd@J%C-yG&GL#-^$vU;D9))}uZnU@f%q zrB`3)ZHUJ^cIqi$wCK?DsOL9$A0IOUkaO=~!%ZP5KHQMgPW_5g`Z0dVy>?2!#P9nI z_YkO=jQ3mo^1bILE#9-BXtmlY?Xf~%0!8~GPU#=`<*xrv(J_r;@*V`m(|r*XPxr7z zeFcgp2To}WoG>2x9Z;7rUMad(F2xIqOIZVohkg$fA71H@2B&^uQGW!*<(&;Zcqlt| zpvv1bl&5I>qHhFJk#OE%{hbr#=gz_zkD+X=zt{GoPK<8dz!`;J#pt^HFi_Wbwa!7z z8#Avpm?;=(sg~C+!3a$aNDLx zZqySt*@-)K~|{nP~ZYSK<;1kM0`*D~TyvqZg&CT-HrHS9|cIfN@!Ok^(m) zN6LrQv|@DgLgyEipN=A2Y9|7S!zO2H&5!kI6-E3=ds{EXiLFFhv=No}NL1@Wp zer#7n^D0YoURu2rooy^$ZpM|(xD=7%kL}_G$RzYCZAT6(ZKtuZXu>BU88Z!TpU{rA zKclPHJp+eYatph#NkYzK=LmT_7Bh$XH+HQVMRp$gm{z{?*;v)l6&giLpq*oJ_$GH= zZys_;ChEinCE7fVuiZ(vg=qq6?w^gbC^`?t_tcmkI2&}1X6&JZCsnzAY}*)oxl*1y z-UX*NR}BZtX^$!whZWXgv(u0D!kI27_2O#jS)nZ2?d;Ag>skBBphKk-Cf;0M!wVQ7 z$bL`Dh3ARlJDe zR6}8*X4y(=RJA$(f@%kS4ZYa-Y|{;I9_fbdzdhNQUW~v_g1RTyXY}BrDw}2;o?Nan zZP4FwQG2PhZbJJSr?f6dZ(oxuh2TrC$&*5kCo+1cqBi;N7&l1Ag*nUs3^8s? z>_JpLoNK@F1@`W7LImeAa+GYo9Y*{2dN}+bvdwB7IBe7xcBz=H%*3+fCbppl-vW+a zBen{2v|P2b=@I*NwlA<1d9Rz_&%t>1d0H(>t{R_+UC6oO)t34W7SrNw5n& ztdHxla?p{!PSLa_@{KqlmF~`0%Y5oug8R@wyhZ&6Z%$L z>6lP%+nS6qq4QAt&h{RsFYL_3b_Vjf_VvN6_8!OJ==PowgClTkq~R}S_WUs}*ifID zsP6a@>G`L?;jA4&R`vgGI_9c+O!;CX@E$oAFI~%@+=&EU#W{RycEF)aj*q>7{x> zdqi_!X6G|r+gSgKBC?ZtJHw#R6lXgDm5flJi3{*#kSq(nGO>jG^wf z>u@fHww>9zne!;QY)hY^o;Er*Gvx)uRl`b#&)^Hqm~fH;YKfK|I@g>lnfg>I#Z9*5(7J*@k zhINN^+U7oO3u;X2(|$~&s=uKdUi=i_&>prO>U;Sp`fRSh>C3~J6YXJ*I3j_;$xDkY8xN)YbBCE6FA~J-tQ1)C|+8yb{ zRuwF=v%=X|kqNzE9q7@mnWNr-!xXr5>YWvNJQn&=T;!^y)OX%Xw~`kQ(Y(*HpTa}b zlFZhHb~Rk{{#VW}4a#G(Y?e{1$RhYs+UnfuGy{pc^;mqCsLBiZ)3zRgawGoJzm`shFJ7`A)i+ zIW?31+&UHYT$5*Le~zi4PN!^WU7f1zG_;-glWAys@CSP^fx{k*m{ZM4)7n^Fk^p6B zCl1wN8(zX@r<{$d)$x<#mob3$;oK>e`Q~5HphyNBla?tVFu;iRby<>}$A=j?&m4I$ zy`!;7?l?fzY}8<$$xZ>|KqH-grUQ-q^x~|;@?`BeP88SEo{KDC8Hntf*W}KVrS5EPH$Ko&1xshw|8zW~K2*0e{$<=ut}5T|IuOeW!ENB%i353Vp@kFEms z1`BNhB{Ru%Y=}>eX~N8@^PvZq=LYp0(`pfZxmKTodW}h$2A7FTE(b-Y`<>EKP~3y= zw?h94il=r0)Io+jWAU7skr-!#>Sn2(XYpJXRRF4w#r-y@oeWoP@s@!KupF6p6fAXR z(`^M4X@xr%$4Y5daR?_$b>lRq1+?OYdj#Z?3uw$^gKWvf*3Wzm$DgLzBsO5Vf$PRm zz2l^OFHQd7qG54v3#MS>OE7sek7gF(S}hS~e*Ti!sh_{ZnnCfo-_4P^-xZO_v6H`; z$b9y9r8)bX7(oluztKjwxt^SXnV%0%Cp?(4-SXxe;kfDzuVDRN?|x@QBu7~Agf~K~ zPr5E^N0rV?Xxf{v)3VW0bi0^KDf4@M$T2sd3sI~&R?)HpgtRst>%^M}^JYUT_u}7- zGo~Kq%#KYNOa|?T!83ARglG7kR)A* zr;}GmolYjUArAGOK{4X7=UK>1B!D@@VY)E(Q|h23CR%6iVQ3}z?3zwLSlR%YU&kU1 z=%Di`7IynV=H`Ml1?*$P4A%nXf--^g!wU%6V4#SSTJ(es`ACI?ZqO;>?UqspvMSR@mJ&tX9k(omb4@G#up2GQ8}VTCnf{#%qjq z5uKE$Sk}02t%a3tCG2~|%o3KQH@mtZ+v?k~)Jb8~$Ky|3Z#I5;?@o^>_ymeLB{~(m z4_~Jg!0)GwH_PHRg8H2C=w=&^YXhY-^L`u@?>%W1;ca~R7{U9v8Nl>29-The&nQ|p zJ1w!=@w9DSX|os z=W*`>#rr)KMLTiUjM>;J3@>&43{!17TpTctDVX6JZ^G#1jpGr!@W5_1YnGH94?--B z-K@l!{~l=5jaS$u&52({U+8ZLJfb{9lUKi?ZDN~-iu^p*fS%v$?|j6y00CZk`^*fd zylnu4nlX~*$8NCUdwq_bgJuWkk5=X94>0H`6~|w1mAAc&RmNsV&(EgpF*=@rDoC>S zAYx&k>2GY$VE*wy$A@x9CWKXmvmOP+TmfgRaz|1BWcLv(NEi9YBON~6jSiF>zLnw# z+A@6|Ga@*jW~0zy{bctz{5&(`n>b22GvhMjh3+GnisJ=12BBGH-A_^5ke~0r=Q6!v z*5hGk2bG`xGoPai3*PF84D3>kzz%k^;^-O#M0*^kME#B~AA|%PFHnQn^c6LnO=r*| zs5x|wg3XLV1L$0r)j2=AuVOqBkoqdf{lY2Bx!85PY7ZbP+7Lizo2;&kim#~1S_7)_ z#|HtWBS2VY-?mS0Fn6RV|BH=L_-&yBydgSEyci?NYL1X)c_UslU zj42WCWc)aYKz&f?LY!-jcsOVg7$m6sQ*Nu9cN<2Mp7?7%;6z6;EM3In>4_eEvQQ0* zj;A@3l*%?{1jjeG1U0>9m0qf0^% z&GP$3QbRpV0dS_EI(mP)Z{PI8Sj*GH8(nP-K?~yO@@Be5N0wpQC_v7}y;Z(!J>1Ez za@=jWi||1?N5{O;_k^6|eh}APxPAiH1Gw(O^e3^d;ZM`uw8}FPlhce5JBDz91#|ScJ`6@rAHJm7)2WVeGCr7I z#=N*$=~Qz#*kWD;q;pI>@InUsI-dCr#{4Rtc>!a75zm~+5Q zM6-=t+zgA3H%KF)Tb_)84-5=R`K%Sfk;fum=g5m-@p=PmwsOu$G-I^Y_~pED)TH@> z-pD+Vy!TT}FDE{`Cx{lOJ4fc?Ql-V?4>aRb`CgjY>&AH$gZ4XGAlhgARfl7+nvq|T zkI)9vAI4vxm_LVWc5h=g2=Wqm7a`~2R1BOJdHHT7T#>67(>t9LnCq6~9E(9cG?wm_ z-px7c*i5?RuDeei3n94*-3Y5vFPB-Z{Ibx9V@4B+m;`P1IgtK zIuzqLPN_}6{Rx;nVZUbrR^L#XSbf73o-LuFDA|oLvE^xI6~{k(?R`!h{lJ|hyV-0> zoe*7=n_w==6;s*Wg9X5Gxgd^R1`mymG*FlZBq|mmfrz*>-^qHkjiI2MWAT@ zkjdseE;jhw1Rh_*sRwl>PKkMMO$ z&sw}a7IgqrA9CuH-T`H<4zauTur#!IB5vHHWuX>qD)zZEfs@zM=o|cgXm)(Zyo=K4dVl374EX0v;C+2(Gbi)Ehf9}9QE+~Aj>J77FHdo=4K;gQy|)o3?ckKxN1 zs!^K-&xRxxp`XLSR{7qS5MMPaalG+>yglT)3=Vk6^-cV)bzR!Lg$_MprMnnA`kK7$ z#Vy{j^8%c^EV<~u){E7WwfAMTp0AdK?i99nYGhSu|t(1wiGvysq-5v`+<&;~~cTH&ngYl8>iQ0HMD%*sG@ zT}1_vUsjnVhc873UpNHsI@f?cZ^_|*pyZ7Ke>l98%2(cobANqwtWh&w@jLb)wMMqN zr#KEk14Ig4>|f0Y}f853@stI^2SP|x6BF*|5PQBNe%T_{pon7ayl&5))#Xri5?;4uZ= z*;?6a7*)|bBRm(8^4RTxDyYSDUT~BueWE?#>_*q0~c{6*$0oK@x6k`_w zaI6(}QK*M+98q%1*R81EyM|i7p_WW-JV3%+sdRmx19@#;BKcod&04Avv!ff4d+yevskdOXa z=OQPvTA8JER$k<5*r|1{$c!KTeGRov8v1>mm65$X<1@6A);4l8TENcLN>@1Ldp9Bh zpHYi7)K*yDTZ(~YjL7Mw?2R{2i!(;itxTP043rU{QHeo}Hgn*vpuOSTB6iD0`#YCj z;6xrSz@Qu15aM#@VW$hnE$_gjd3`n?ST8sVRrqe#1*f#KJDqFqXAL<qi#NK`oesTx~15gm@Yw9{U})6zygX7jisP? z?^a<^brwZ^B%kMnE$Y8Oy^gO_T7$CTL*wJ1_~7@nMO}>nj1ODOLA}aiJOnCc6C$oJ zUF!M-Q?)MOV!KdnH1^}}#0Z4G(r29VcWTem*yA_e;iFKldCRK5v-O9OzEq<@N&B3Y zVBtyAvB26-s8Th)Hoo>xd8c`cKU_4yD?jHf!ut7=$PIe9(^lCuithY24>Oo|e;?3| zd!9FWQ0Ipj+puVngL}O{H}Ca64i+}wKlg`OXWzU9;bX83uUw~Q4z*scx1S!_`oW+# z=C<7hS=M3D5upiwO8un|Qt1?*u;M8>`;<{=li^wbjf3eXKf`OOqN+Il_>}}ZPIE#WZayhf#9ak6;}9h`!&t#Ir|lUL~AD0+er zU&1F0U$}1q^$z$>iEi5a8>9At;;nKV)>3%8y8#q$i|Z^Nt-hRrwK}Drg6iW^K=Iz- zKP-xlZ*g89DBgPC2epgEAfE`%;!?T;=Vmpov37&#~FLf$mMwM8%3rh`19WeeK*ii z=Jg)LB+KtUeNNkv(QW<5qcI_h;_+AsqDZw(BPmh60bKxkUQmvguz$)b-*JKtf|Y$O zZ$6jy8nKk>4p-n5A8w7dZfK#EVC*+ytI^zI46-do+#PQ<54`|H*8JdSy;g z3**#77DYR;oJULloT8f=IrV`>WuOo^kJjrrMZ1`sqTA5;^yu55%-zlQ59Xk6&V&eb z$aFLU2TWH){9E>{wAe?gDP;pR*(9eu7g1C>z@8SDk7uW`NhrB612|n0eSjLACmbQg zBh&CWF?2}0Ux1_1f-#TIDz)#N(@T?LMv!N~?eYSPnqpD39>znz3+f|$*)x>*jAk{R z&6M;0feE|*IJ|PqQ1|M6{4qE{VkY~EywQ!C#eHM)#_2?0Iz;`9yW$Y#K?K??y|GHs>%OEcQv8BH7ArL={Plfv|Hq8GUF(ur;s z#2#`)SA*C}=Vy_xh(wmH$cTyfh|JmygI|fW$aEB$w$fQrlaL5cfh>J+wDAIKpm@y2 z`Gp6_Tc@)#w1}FQY?d@I7(pw|PrxCLVFr!_Mo{!@v&EBaQ;b z!S>VTts{Ly-GiBa$KLkSV?x*YjGObYkMj#deIW}bHV%c!++}&r!NFo&s4qAJjzc~? zw~L%;k32^`n28(G4h~K{A=mv6J&gzt6zeKPfu8{TFiOAdBdlozb{R(lW&7pL593e~ z>YTQ;;Vn^t%X!#U;gNCZEUXRDttd3{rB(IE0iYX39>m`h^0#oW&fK>s1w0pQ?gx}E z9%m;sYuj z%s3a#%PB1fbsnQapm>Z9i%NbD2IpUV4Mz*nUB8LDNR9pIopBN-lb?hc>UNiuw0=h3 z8uqs^0lF^stY#lOiy3yx{)Xeea7~7}<1*!--{`^vH7=wTN6c^Oc_45R$8KWh9@&cj z@v!q+f5RSM*|B>r_f0|MEG%KXtWN=WBXnl?vt#jrvVHepQ|EQGlnmdLm&xUflgAFN z_^{c>4z18_eC$YzceisCd`WhOWf8=3zg?S(+cd?w`_)n>*-{Mj2BET1Uft za6b3LjstXS13OD2tKIBA2i!T!JOET7vySM)p5O|=W7oqMlk%$Z4>$#Qa8txdXU2fJ zx#<@4>2$=_T{7J)2rwfBRk<;K|1b(k$6$jHa7=2ZTytO9qAl_~q=Z7&UVJNBBkjy_^F%-nC@H}DX$-0@*(joyGeK(Q`@iLz@k z9ZSX$GXAU?D%2J{5J{c#k#4;1YdC{5;5bTSiVKe~(Q&eQ%HHVCKc3vRiDu*TsE7O~ zyK4|@BGlds2sK3SjDPPOmM=6_}(=iFB7@wehTh&L$Am>p} zN-cuwlQUL8Yu@|)z@nZ4#aqju#iOGabp8w81=<06Nt4)Z}9JlsqezGmnebebS418FI zIiKD4YjzXN3|`Dd%8xP|p9YHCxEs_XjCZp|EwCu+UU-b>EZ$#1?ZS7s0;7$La4|p< z-BNVg_y?M4LW$As04S}Y(77rO=ATW2Be`F2$TC|$Rm%Rd)~SSV8B)srfxEk8|8AwM zN0t2pfrcKf97V2amMMzl^`3g2{;!o%Zlr0{zVtMax3Sg~UruDzkbZ#4}~G%-5Rd{yB|vY)l+OptTy#G^HMmQ5K5Im~;EhDoomzx1>9hQ(3i*@#Zb*2N-zMj^l&{za`JvlM$QW8a zT(!t^n9MBkyS-ne1JeAVKHsvkL|r_8Oo!JBZM1m*0m?R;F$Zn`zfe*9;Un=C#d8%? zQA3yi-^9IteALyI|Nl;A2tx>YPar~2#Hg_bgFu1SU~HR#8JW>UQE^E$V74Ho)ooD{ zLBZ>w; zCdaR%Z+g4wG8MNmKL6$*ee||3Xmn&Ior?n0SkRZE1F{zMKv>Y*ytZN{txp7o;vUc9Nw`Bq)cX-WoA=NvRi6S!mf_J+FNTIkGFjtAVT@WQkvpe*oIg zKj*pqFipq}wt(cFlDr$Af0V((%Y6M`nR(wtTEtAAsz}S`>j0Wcjd{VVOh& zeF1h>GUrft4>B`GR>&R`l8S_?riWGzUy-*(6JvWS5lmektlD#1o*8GE*Q@rpKWuG} zrXt0ui;8h(PE4(Fc*BGHqgIB~0T(vRJgiw7nSRXJ#)?JDl=AqlcC$qCc03RrjXyFi zUNXWy5?Nf!DYI0OU}zU3wLo?;@|UG(k|Wu~uGW4j+T=2omX(T(;DXMDq#|cxL9>-u zYLYVRH|${#%tvQ?nSB@SZP zG|s{)8%Tf4k)2`rtXOK4LXb6PmsKLZol&*Ry?Y{A$3r{r4co%djz&`NX}MV!OZ^GQ zDxWi1Wsm0VSnBDj9yfhEDMV5?2dh55ZCoT(l-gUHN`xvNVb5w$>Xle(G)LR3o>?)t zVkdiJ-Ji$#2|wr5(r7p+7^!$7mcj|hBaw1s+SXP?cRu6`*L>~>wdNVKzpRBb>$dd zEg#%`QlzST1;!OG!6H#%J%qd-PhS*@r!HqgCjrBl)MTX!H#Q8R;>EB@oC=hbyQrx| z`Cwi~YABa#rLH@iNJqlmgUo|@*;2`AzGtAHNPVb-Yn3Ysjl5W!S{aH>JA3(u5OY`m zmx_^|7wQwL<0%YCz7nbUWLo9QQ!sChr@A$0H^$R-WUz1qZn55Yu#weh zWsH-RR2KURST8VbG6~9PF5+#Q0Ipm1%QUUn-SWVu~Njq@7vCgS0cY)x|^6WO+2XIEXg>9^PbJ z_;G?f`E`oXR+Aj}={Gmibk8td<}=cJWX_b{8R_w%Sn4C}8{lW^*=gsjxK(^9kw?s{ zf>p2FHa?olWptnpE2w>1-pA3@$+Wy!)y@^6h;4gQA{E-7?XIXvT?DmVv5IY`c|KB+ z&m!Npy|ibrCBPUv(5-i=nhwEPERL8Yd{lH}*R2dkbdlRRI~wl3_ZaY#}x z*V5(BNQT6l#lb~;2>zR|MpB0`wLX}7FP3^aeQB>u17s8-UCSLi1$>DwC)ZuCB@g2B zIIbUY$6Zi{5u$l>7Nc~=di;|<>+wYTGE{wS(TY}cp9+e)9_e@=iKJ)b8Y6MU>+1L2 z+g{-xJMv?XL|WQ0e>#S(Zsl3net#1HQ*ynrq3=Jl(0%Huh3+$#-^ZEM=R<-pBR7%z z-nIJg*v;R+e7#$KL7CjigcI{$;OJ?hYX6FAmhO@C6*=0}uaT~+HIxXn#RB`y0-$fI z#rHtEnv;RA2DNr#RTl3_XdnCcMrur?FDjQGfIw?)vZ*bUp4l5oPG*Ib{6_G5W`z(* z-cp>{HC-;To!aC@rHSN4B_A54e>{?$9!jLAS0+t$RY#Mbk0oy$pGZ!h6xlUh<|);+ z$s4PgHFUH{MzuRxQw%abC9Ns#t%RL}&RgpyCaf#2WH^`LT*=Z^tE8@Ix-m!Q8)IwI z7Zn?+IJ2&aB&AF&VK1?&b@_W}qid{}Uxwt!mJ-OKm9f)_I@yLLh z$8nsb&B9tbC%=u+)RMzSr?4I5)RH4oFQ}nJwFionA@4$&Q{go!4IbfI*?Qb$lG>y5 zmx0HtYJ)4kUX!XVtwrc+7f+5&3$H9;8;&WCSO%%J)<$T4eR{fJav~WCO$)6UoD6Y$$&?q!Ler4s6`#c0 z-Yo4NwQI&FjIAsGTVLHncp`5c{78<#{;j08;w^X0C|;@SEy{2!mX4LcG0Q0VD4HbY z0=$7Cx34tRnhS3KiU>Ai=G{HW2qaT>CuauNpd^nyD#uFE)T_oZ?&IpXi;WhdlAhau z1|pM;tr5+ZUZpTM(=5DbQSw=41}iPNhZ|@U(3u9hk?*q%w32W8_BlVS+Ydv-7upq( z?gEi1r?(>zDgNGvHy6XPcD6=xnghwp!k%J}tv#clwerK9cnZPbA?XQb2rzF!Y@g5Q~(?Pme!+zj%d|xH~o~65rRd$sm$x@;AvsY zvApJ4JWtHS%zxD2wgaI6M?dzscWmOV!iPX>Vkoc;LY7L)2Hr#~_8>6~i3fIoR+%q? zL)%^>T9;gXLN(W2z0g8Icg>H<8$h5`-yWGviU_^6rRGv;s8HOJb z_Y!n_og9&PsTn;jNkuE5vn@B~KKM#x-<$kws|~cyNEe)v2;gArv5V5ha5OqCOzEZ- zDfRv4M9pP}6$R(>?))5|r+1%EFiBkQO zM4NFEfli{Bm&A*nA12CnqO>lI$+OObtzB;tD=JCsL0eNBy z?bTd{{+hs!n!qlUD6@*tslr=9>Z;~mSn&Y{Kl&GEEyC{?e9i8vU%1? ziZK!d;@jxOM7PkWz&`3^>FMdZoJiFR%kR_(Y?KN{eTJT$E-k;o(vQbS^HqH^HPH5I zI3Sm7)g^5QN-T6rpo6wr&^#o9^9kB>_k*dn?q5pu2^sA#x4kgN-~QImDIK#n`-QU^ zeL1OggaG!Gp3sd+Pt>M9s+s>Ldc{cU7(;I)^#|6hXJD*Vz=;o}lvU^Fa8!$phRX{X zhgx;~$M{Q=@FaC+G?~Y|(NvPaH5+`hBU~am7zKNCel+>TDXm=((%^NNP2C=yz0C9O zBMUOklaNKmR+p`^0Jcvt_RaX;9clR_r+I9A{(6&NXlGpXc^+jXc(LoM!srv7+L9B40rY9)yQWvh_@1a zC#ph}RVh~&C{IC?vzooZ?km~zTIM3vD-Js`6^|tger{-@Xq*3l2_ArK?9*h28M5!_ zyXGAkofjr>3F)p0%iRO3tRBc`Qjwd8OhPm$WYT})tN>esw13;^bRbHtPzG}M@v9S0 zYN%$@Rd+PeX^{EViHw4OuGRQwj(jCjZe}gb!b07Fj#isIFPfahB>scjL9#0Umwc#| zNHh2kI`Tg~-9Xt;ch->E7ow?;S@^gyyPwX&7WkpE`*^KiDcK14RoVRj-M3}X+;wmB zSc7|xhm~s0eA@aBck5$1^H-ERlM%mYaOTu(Q6O_nwrCJ7`gs$B6Sez@?Y$Vni=*a6 zUgkwKu+2P&bd=WJdW4w7c@OTgeSZ$7BpemgfeY?mFgbe99e+sU7I!Qu0^U07_i|U9 z|DJd3|L^7W#CW{f);})f-R@Ow9x`?wJ~D{?ks;pNJtWl)YhV>xqxHthwc<}K5v3Gi z1%16Vkh#fedRGTS>?77f>&+29`#4UIi!yHmEF{eS7hUxR2Jydhf3}NluuO}FBm(Mw z?Uc@rb5TPYaTZUz!(ck<8?$Jy!+(fpZ!0@|ErF}mEm>xo-f1qxTW$t7ws^HJFs0Ru zw~T!{o092^YE@>7)HXyN2T_aD`9!rqtUTg@CQJ(IDF*rvzArbB4Bjjx0ryf9CJD_#D}Zbd{yxwPtg3>Jyo$)Xe$bI2 zn@yuSv)}5?x$AhZ`K^&(I?erNY(N)FR=l%=w!n-UB2xZQ4FxpwmiD>Vmz5C8EO;>D zPWVJaQix|XZkpXuXW;x@-dpnA)fZ7Ij64wu{(Ga-ZmMazQPwAP$#o=19x%Du ztq&d1CQlHe(_e`e@4W_>t zB=yPc7em~wZ<-hCoc%lIHoA_vcyD`F$84qinU4E7tc!lSd)dDEnAbP=s&77;)i>3# zg+D;IW;l(icOu%a-Zm7rqFP-2Yk)wvB%Q@@zv2slm~SnBtBq!a7Vb=as@ zG(prcO*v5ZVAe8!U;Mf~g;QS0))KIl9IYt0AlEg%52m|YqvLY%SPsi9XSqCYYqTO) z_D?{;aq#~c{yA%XPKN?27$`d}gJH6UKHcP4&jo1>9VWP5-pTj5S8>>XLiD8waG~s95GAO7fdsB3{*X@|qIW(UK=TbxUqjekPOK zx;c(ezMaa_mT50JCk!u<_e33dP&sH^V`Ybl67>rHz5EYejjhUQh zQB45r?S-E6cLLi1HI8Vu3LexTsOXm#6y+s@4j58N)-fhG67nk}K1EYUs@mOjbI8v1 zv&+id&0MBRTuFn6xm*ny&kCtDle+gLrBaB;HR`j#r2ov@BiNWh)#gsli=lSTP4~n%IYSH{6ICE0MnPup#JMH*K9>h$DtV zck4ymv4tSMd3uQ?$yXr?;e+I-{!NJ1V?zmH~tr#Ej`=4Y9Hii#@kFY-qu~%=kh*G)-d&?G53hpqa=Kgv>G@^Q?3I*^{nNQE=((> zbs5=Btj?^_*UU<{gQ+6F+h9_?QU^`rgg1 z6Q8ACm{Js^8o%QZ?-4S)4)Ci^^dmjP6tYFudc_wq^dg<$K!!D}j;4pn;2Y35rUMOtm#({~CxodmOQ^Pa7d(T~~ z+emn~lXpAawQ|A2?WqhMMrf;3ah`%x4Uk9C-0%`FU)1wUZuw(W@!L~gfJN6o3<-Mo zgmcwelr%B^097q35De>{qIC5v;LGVH<*%!ZubZ+rbWp^H%38tVWt(EXrnhZy@(F-C zEtTr`@brQBb8p#pVgfOu@c1jUDIz>7TxjYhb+Z4(O4Z(pyo1CKxOZ(;w$@0i%FBA& zN~r!;wSnzWr}h{s&u%`8-|cGcQn=8Zjd89!$4n(8Fz-m$K3*uR{F8TkC4-XI!*-Z} zSA>bLx_AD&@IT$K8K1YA-fK!n(z}^ouj(}R_|QY%^%81O6KK!@w0UZ~^Y(Q&^v`%r z+Bz#D)!*sOW2Pk3mB&W)kPed=ufvv8DK)aNWugjA%~{@qT>palB)@M%Qb65Hw21bl zXGGkq9{f$qP-g0^CW)Xu;;5#%e#OWXU`KW->M3}p04DRVnF2ryz~Y`OJE01PV;Ty*pTGs?0A z$4;w0cGrLOA!hVk)DV|KqE6z7gcwgek=_QKH%EQr;F@JmwCXi?{Q_Z0SJOjM09Jkh zuu=|y6@36!n-#Ke1=P=h%_81sq;R*~O6DReVZ9qaMOuNG^;yPOfFj$aTzO_G$K5~b z`JM@{tU$}jkv$gqIFMa&4kD6WaefcTt}`F@dYw3>yUy(#y{Kz1#wLsVg6 z1fAVJ^gNI~>wgP6qk8l9W@fXO%^GzoRZ(pA`x<~QG;d||@~C+m;oD;9mZ)haUMrBL zcZ6pf@1H~1_ZW=5KsHxhK)D9vWJFL)r4q=#odaYs?gWyFanO0ykJkfa)6j7ri@OWR zhW#6BCL6X7$cC+8DQUyL4P?{!g%1s8W-Bsz83SZX{v#l}Cg0>kF93N5M?DK$X~wnc zZMnGyRb)>J75GQZ`G*K`y1va9gQe70_W_~`lfe#!(K1@HGH!JV0Kn%Jk~8tv=_LXU z1Mf<9+yyoo&?-Dwr+v}54~}2gQJ7g}X{natu=w6Mu7xwwxk;bML(pQ1Bxd8uu~PTg zoJjkjOyiw^?ZhRes6DP}Kb?Rt7*00<*>-m)kZmzP_QNtB?6NLYPQAqzF!nV^#@U0S$7T`Caq4U`sVnO;kLDc%!y!Yae|Rj;;p_pzXO1_4$(fVbWo{b7e+kC` znnp~U8*eI{Hg{Ij7`Y5s^LzRa9leF4Hhw3@msMXHza@f`oNMye3^N*&b2k~vRL@Ss zqYQ(@C_TGHcdh~@g?s-PTUC2^#boNn4s)$usoI249^+{yTKbi-ExxO4a~!U!=eB}f zu~y;8;JK9hdih=+oZO1x#(Z`IgP~OIc22l%aW}VOeRfGlvbL4ushQhm3HKj#*ereJ zexAt;il|usI5w=qlt%P?yvUX!(j=%uLFQQO%tjk6#ZXQQkL^#z4o-_5STWK^N=E-{ zmTo0&IhM2hwaAt{nxaSHFF=iFp=v3198}rM43KbR7PhvokBc3pVg|t9wv(3@@0vMPn`!9KYrdR|o-O+2K!hmCYbv9Gj;32P2Mp5}2Gha)7m7d* zCUBXZYW8uPPUo(lKywX2v!~@Mg=qn^A&qacra>)7hctiQ1P&7JG-YA-w80T}Il(nA z^7Md5Kl8ma(3zZ5*^4pUbIVgLD=Qs$wd^nA^Jk7Ba!uuAp;S&WMc6_cpa2(iok+yG(k7oyc#d0gD3ani zTC-O|^t1iWKLoWsqKQTDaNjzf$ z9k6aX97bR+p`Uyf?}XLD{*EXG}qp6;nvT z6Q5LNSt8VI;#k4yYd~RBW4HTZwlr9?RhMM@9J&3iQXTx@CkWJYwx;u2-vP}`L zj>J{uMqMGv?(90g?pa2~@Vjx5{k^Zw{xbcT@Sj)mYcj2-xmaYAr(+4eZVi$!8=Dd1 z1(gkuHU{J3lQTOgC+D#9v5-UN8=j+Ax?8u=weoR#T0NOvo3~{7yhxTowex!z$d?x$ zxv~kFR<))D(0#Uy-w#3sQEt-)_ZI35jq^F)AOYNvh zJzkr7GV)sozDVnvAcOFr;k!?AMWQyu4qRz(AIq_sf~6w&&Y8% zkAQ0&F*L4UnO@MT=PryTb1)Gn5nN^dLJ6cV$t49(nJoJGt6nRGetz(OO`oFzaAh`z zGwic8Vu!`g0xX3TS{F@qaD^eF_13~DZUZ)7Sg;UV=4C4A)=P4usgD*?i?i0PwyV!+ zHTa}m^E?exrusaq$(#PpT=LmquEy>99wpn9(=2g)BBVqJyRu39jx0Zz}OpnxeaRraasIU)mf_5XOXGLqWWr5l=W?v|eB3lxfdkE`<& zf#>aBif?%AZoV!@Dpq&%5={E$$nb4RfQBA)%bBS)mfUZuThrXK>JN70HeJDYPSd2m z9%KK``KQ3f&V8U8ETp= zlH_4G9giPo|E(gOA%PvYbvcPT6ZZ@3OpDl12x6&6k`p?FMR zA9TqAuzK~|ZgLHP$l5VrfD#(&eIzM(Pz5)6#=eWfwSqs03>fmf&(nJfYYnn^Ian{z z0PYlrLcEbpm+`7epe#J^5G`thrd~Ox@E6Z3vr7;7Qg#@5&cEe4TWKtGY zo4nbVcudKgq#@Fm(pXcLGyD|j1)t^CUz-9%`cgQfUs>4q$kfX@1EuuWHL++2BIDal zsm7avO!CQ3P_tG8K4-tGpiPxytr_|^VvkD$wBTrHf=^!JPNiIUxNEkvX054ue0gEl z>kJVbG

>u1{RIuaGNAYAf2j0^5#7yU#cMif)xZP?`T4?&7lB<1K!^b4AAODM4I#GL7%MCFO{f?3W>F@+sh9g{D*M=q} zqp;#|m_`?Q!$Ux*xo&4+BJj8sp1~O6uhKkjB~r)ivJHV8NuBwo)Lnh=5iV{uQgzqE zfJ*DLm@=8mv$%HgP^xrOSI5m-kFSi=U^aO#ZsqHWpYwI~eSFQohp+2a@%2mD&B{E@ z*D}s+Uqr3iU4bDGw95_MUp1AdpmQx_u7%bDJz@0k4*}^usGxHf&sHPe=0jaTRs-Av zbb+C=kd=d_d>7D_ChR9Z^h+SS9Nq3iZ~KtkB-^+0bum8?s)`pZ4{+gVJjIL}%xSOI z*`aXF{Hx@ED4MzmkIo;(P|pm(sZ)xZNxRREr*dOl7l)`<9EfpxDaHk>(qtB5Cm!i# zUJd3bn7IgL=Fm=eb&HyOCepA(Dz`5l5m@jZTNzyQ#Lb*E+$Y~r$;(+Hvmlgs ztDC^9_L(GD+U3UQ@99O73Fau0lt~bY4n_LsUUt@sAVhjuDQqLfm4mQfzd0bGP5I<} z*REh0nZcqwS{4$(8G&V|6KUBP%D8e=j5BtixrtP}MDBt_AUB>2mf>*_#lkMPXfR6U zFfIYe7AxSs{RYFai}0%Z1m1Mbb+=tHH@+`1|A_=S&zsT5?(0W%@=5HRk%_A zQj%PPS)_?u`24it@F~EJw+11IoYRB-zWX!$*KUiDK~4^dRc$1QUL}Mg{A=+P-fDJc z)OUv2yEy`y8Y*{k@N)*_3-USS!0+zp(0%6g8g4FDi3^YvZgErEgk?-o z41Le_9HX`jZh0%j&Av3j-Odku37@+wwlQiewE-!aSQXUv?o6zfqhp%CYH|Y$C-1fmw~Y&*JsL4ijgTW9 z^NA(vL(vp1`1$2UpN%^I5sR#B(+zF5Jwh!blr5!9a{*tAa`H+b8E3vjcLzw!-Mnvr zP}}#1^6KN|!K$OnhcUQBQ_n}Mo?QNu?un^CbXTZvmd9{AliG%(r$|-D$`NaJFLMD_ zP{1}7FVvkonH69c-u>3DB2OqK%v}QUbd9cL@Q%6g`oe0nld89q+%R64(RL^T?m1w$ znbhT#y^%?m&CcuOsTE!8BsnlpNP2n>P{Zh;TIBSd(a~rsE=<;pM);vE8XWgQ_J|YL zJ%Qx%dMdpJvB1Dx?lCReSfA*(mN?_R}Guby4iVvB>idls_F zoL0kdj|{7LS=G7|_bo*ftb4D!$en2DEM);!XY>(9Pd8O!G#{<@j0XFEHh!9I(Yi^WwH_t4QQRcrB=5BS}t#b;i_N2DC zHM;0aXQkYUJ?>grBOO+Dar3` z6>YH!4xna_guF*US?VPT?tZ>!r%noMW-7cVje2x8~(o)sy@@AHiC@=JBe1Zp|J* za@$(fNtxPI)S5%4w0A?9pdF_46jO(D7jiPb-2_mkZ)O5s(-|{fJZ{wxPq-6a1#hQ< zp3~PMa~UsOd_ktRGRv&yd$z3M8Qio1fqAmBko=Q ztXf&4LDHSD!@cWn^O)otXRWY1yE>?)XYC7liLb%lHB)^QK)c(BFo-6+>8n9Xa=%ch zw~9T?ir7}U4SO<(+5%D;#2D&BY62`lKU&&slE(T^mC?=JY4jTzw3pW~lvL_*l17+n zg_UZUiJLLTH1t#lE<2Ww!iWi^rLOsHh@`eh+?hK9I2O&#ylc$7TfimYyn8J09BsR> zw&D|aO%1!eI;wIX8P`!2wPl^;IADG=9f9Xgo@HR9c_!5^bD~v17$M0qtvy{P*Oc0Q zw}vm{fIdK&4?44euAqj4P94zGChP{FR}G|t{iDpnU>bcdX5umO#p%R}kUJp}zQt`G z#sglKCPa#<$ug8s;}Zo_T7MzMYbF1a#4fQ%Z>*&wV@tgK%aHz}N3hNn)?3 zM;Qjh(>E9<#M3ty-%`+2(am&o1OE1JE>;qSNa~gFMwM8f7Bo zC=y2Zif3}?MczYs6tC!FM#v&kEgESWnid?hB)M{`0v$C)sJ^ECt9}`N>_gRm(=rXQ z5$5i5S3gZ~G*yqwsz@+SG1*F6URDyTYF|01g&W@oBixROrS_+8E{j&}^}`Zn5q#d& zmqe@Dm;3Q>RI@*ISt;j^{jfwStEgQL_3KoxIu>lc3N7}eNLBl7d5~p$f*G)~YVU1% zk>o{XsgJ7KR{%{fN$s!NBj}>i)IMTVN2(sVjngR?jR8AewM+2yvZ_Z`D6FJvn|`Mw zT#|3`AROtPJ_$!7^COeAbT?CBB5+ap!eqqEc$ENo)$493K;y1mg9NL<=`@Fn%H!8{ zn&{Q2=JP|J4vi}`KSR8KgAmV3b&;EKcQHw8RdfJI1m?ab)a}nl+;|rr)so*p!t8R> zqu~f^!AR;|yG+vI3N-pw_i(`&_l|#pV>~nNthgbbs$!dA)diJfo3HIf817v8HyCbQ zp1cBDoh#<2wk^CzGS=Y9yTM>(GQR^a7h3%mOk=SnnNI%uNTIU@hvOf)O_L%mulGc5 z|G0-ln$9%Iv@U%NI~`mQB}c6b zbpOikWhBmOje$d^x70F?Jmc*!)6S{)MaXFqd?p$FM?-tX(|t77yuEA(>}rGWD<6th zJf`*iuj2D}!~+33{`l^Hm9d75B)DM+$eJg7;D_P+!(DwEqoCcN4M_|-z*{=I5mRXM z$U1c!anVgL4gb)b!J}sp*n~eD+&d#B>5x<1y9i2(Tg`+$F204YS)2H3T*nuOviRm$ z0`gIBzcVN3{li}`z=HlAbYJ0{L$@?HFJZQ_)ABBNZ7G{Cn1=V(rex@kh&0KZDd32M zMh#}!(i^8R?me4G?J@P2i4;#?`UxWkvCso>2*E}*F}ijHDJ}1(JYk>zi)UpcQ9^Nk zhrRM6dWwWWs(WK;F&e7p$XkQa1HZ)h^-A|(ND^0y_wWs4nDRbYI>IfNO>=`WFxO!I zMt2CzgZyLRJnjczmzF_Wd;E+UvW(wfU@r2BQ*n&HVR>ZekH}y`~F!j!^P9`>Y;)_eCM%_7P zKZ`Op;2Q$tcS!TkF&qHSP?+OK4UfC!Jy;}j@WL%OCjic+QOI&r`6KopwEF@46d8Dx|-U zqF~fs?I2z_L&YPsyf{Cf0AV! z?z-hK#X%$Wm$<+qxcs(6suM>*A>4Gw(;O0Od6Ro;%svbk*!;abiAx(@$HZF4j9XWI z1Qu2wv4>LpK$;i&dlRFm`V;$-3CqJO5?qbWwy2u3^{rv!U;2J>wc@mFLhvDY7da~m z-i1q8UN3(Y=57bqRFdi$uJCLtI#XTmD$taZeS>zT5@ul-Q^K?3E-VR%H zRA2kji;4UDr7>b51Dn1HRHGYF+USxBri=PLQ?sMGlRC2LzlbKb6Y44i+QFksFLNgz zTUsMTBHO-B+=0oN6kk?cQnVH!;wV#1y*WM@!EY!U^*1 z(doX{o%rEW9K2Ij$$lruTlW`9;qcOND#~9Ho$=&DvfD1oW`r|kVuI)^HgkhvR3!Ce zwCV+SeUypB8>4GeLo|%9`T0>}*3U328=V8D@n0Q=@YVNGlV%JqUx0myjP)f$1FSE* z&jPEhPXT1=RstktciI<>^2Q!(43Ac-eiZ0SR9Dd4>0qH_e%Nl_SR?X30$F48a~Rib z*!LNRER}_fx)!&^hcpt~uqS-zWIBQkyUd4H`OpJC)Cy!NOUy%Oyu2)oa^)5z6a2s(WU3Cg69df@ql+J8j5G+&_kf`WFsd}< zQC-|(FU6?l__^^G|E4j+U_U@69n0itorPFwEPdhdOe1*Nn5EJv5E;i$W9hMCl!;TDtuf*p!l`WSotrm<(o69ue{{mQ~5ku%)n981xBywshR#4Tma%9C$ z)KLiiJ6T4I$7mJ>r^FLhS!V558ri~KSBxNBeoFvL4U=dh<>$#W0Xk0JFgI4-a+beB z1eyDuovJMe?93?JbJ;9OVbX5YSeCRY>)>wg_d2g8d6Qx6B3%#1T0j?)RCCS4ymqNl zG8UXbR?OM$he;H)VKR@l_L!{jSTcp_7ktw%+zD^#6rZ-IB&&oO3d76BxD(%T?;K1R z0!*-skuO|b!Z@(qz4L8o0_~6_R0;`9cb0yR5u;P1rrYqeS;m=3`Y}QeF+!sNna2#r z*7C$RI80W)(;Rcv(5}-;imHKp9>*p*j#h{4Y_6{3MBR;(IB0oeh1PDQ)bKlcE_)^A zWD?1leAYLz-(6RBI|FOk?XaY>UHUV5%DH;CJMp<22XV4>Nfns;72j>>A-nV!NgGPJ z?q!cg{i&HyCJbHvAGElT`7o=qje#Ry}sa(aFC8fcE2CXug*0H=*8x^?DdVDa}P0^SPq1 zwPyaa2^MBwN~E?SE+8r7F8^FD{>vq=dQCb|oQejbDW>$c+(gwQ%ij@3Fd8UGq1?o) zRR>PrWr%05!Ob{w!V3UC2JCeB2aE^cF$66lc{{r4dDc3?6XWUYjRvl;V}HDLm4 z0yv|pcCxHYU|E=}T#)WLPH&EEZy;V|7uk{BaptvtLaG$nQCoMwo!H@i7i;{cVT@43 zRb=i5Fyf-Iq6r@5;2xy5#2O2J0NQW#06FMcbLdV<53?#?||_VE|~M{p%bv2BS*bH6yg zapS#vjM61ih99qDZh~0(Oik4jO`M(&{sThA8r*_J*Mt+wa(i(NYX9%bBrQbRkzX5b zF``b2rM44z#4zt^0?IMJB|t-!23(VS|KOe6m#E#CbAH~nXX=&mtF($2+#;{@b0Y!m z`MFDg?DShil6Dtcj{B;43eprD=PL%f63FgT%Y#y_eVckwm$pwLAiMiwRR;mK^O9GW zPI)1bysl@;+ll0@hiE>v$@vHHXHc8GZa>DXwaF!&#);Fd9WgEtamQV}E-{~*k#T{l z*}1yqNcC-_(?Mz4WK`Yf^Nh>Xy9Y_@*qB;hwut0YZ0$1avh*~|QB6g43=x%ybntc= z=T1@xryHYX!9W|`ZnL)}K(c1#R202C7@5{k##MOZR8Bc&pa{l$2)~T!tIIk8q_^kc z-ZGsMRB9)YGrj&{*?pN1Gcpo#f7v~mkh3yz9w=Lt2{~6G-Ff%a&|4?fl5sh(t|m)I z6RF)8+9lc!wUV>ZgERqT-+Uq>o&Ksn6Wm$ENP>f);crDQGWLhRk=H1W`QO&?W*bWfe=?X)TX}J zJ%zhDPWyFef$w%)$5N;4?mnd^S^01&T;kf0-p3N@OG8p4v>h0P(?BTC35k3GGX^@j zhM9EId0YU4FkwavG~96evVvPe&3Vjrt!DL01Db=1|U~)A~mjNm(uh_JLvfIAF zR)1tG2YToT*zsnz@l|sLKWG0!i(OzA_OmsFF=g_!gLN@>7I<5@l>eVa%R-D?!3b^{ zx%h)41T@z0I`*Ec3d)xMm&U71&S>`4%3cL7oa{L5O*<678qU{MQwK%WNI;m`R}Z%M=N zC~_L9Pe)to^ib6!lOf+tKX&`1=Z$X+Z5o2+wHLyFJE}DU*|F@~Kvw(+(AZBl>id&` z>`C0Sf$XW)X+TyuxgN;g4zk9FwBuyy9VKDi;)8cz79Vy*T;fAoq}Z`Bp3<=l9b#aF zY$X#aizFJRZKjh&G^UTJuhV5qoVlY8r56K7^%e~*GlGC|X~t%4lr(vnp6k}p;NH_C zvgNo1##5qJgJCX)MtN4v+ZXlt4MjFJgMeD9_@7sBm6{%{&fbZ3m=3j{clGSSND?i2 zz(^G~4lB%i%MOrh!tXcPCN^7U)^b+9FdER8uxV6>21p7fu5W9gABPh`5zziZ9TCiI zj@yt4*x6=0{4_l0-gOCVaM#53t&}sKF5G$hjRx!u!j)Y!k|Q}k;@)Z#zrHh@b!<& zkS_WCfsPsR`>%EO_oq5$#PcsJ?eA~O`OTJ&)=VN#vh_>WZp7*ImG{)9dXP|-%fiPU zck3p`@WseRoQqw>&C}e(f|P@GToYJ26MWy44|rP41L8^TDjj%OW~&Vb{~bzF<31_e zd=P-BPt!;X~7I*F6lIks7+o=l?@s<^C?$H9MU?J
jLK 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

>uBP7ruuWX=bAJVyTrt6tNPLW4IK>`i(>O=L? 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 UV>D;bn+tQN=9He~-y$jw*WM?;)6X zHD|Ezyd6B>;*bzjUqmkf)1f(o-h7z5G^hNP{96UHR&xfuT`+q!XV5zVGvH^+4};#t zFvB&c^rSrU9>b{Vu)SR+U^6yQUlbSQ=4c1 ze5L)yJjMa}2=X@rH_k$@*HZ6JxFuEer2ah#vr%&ffA_!~)SMyzYJN_Cz#*ZSF9y9P zm}@ns^klre8D^fxRhn3@_Ii)A{c?Zm1%^CDgz|{Ui`JwcrJchtrqd9|K2h3E>DLt|8E|}$- zGw7{_*`zt8C+%&o$8hR|p!RkE?udonpqJb{sit=hT)oE@>w&?(>n!zBaAPd==3444 zfV;;+?{Q1LHEf z+YGZ)bEHp6AZ=O4INGO(@L9Y{Ly5^MLdQWuBbqbl4f-Yfwj2_I z{FVN6l*c$AA3^?J2bZa$C;2xWX0hfB_B{r(MsoMnwoI&q6OwFs6{gwG?y~kAZ z_j0(=RrJK)ah7_s;TBfWlm2C;rQS<$uT{~L`f}1zZ{V+ZUcn(DsJ=*h8v&EooS{5s z!z|RCp?p`utk#@CZyU^R%_%*x?Pr($L~{nc@h~$rr}9tyUE(p4u7sfc zTLt%26}@YTzr#}R^u74YA)%tb9^-&~1lbpX%U017e`mtnr8z_Xt%7+jHE<~ly{VRZcfu{HqUWsNEcG_RZL`ojXsLGsuJ*Oc z`PW2_4e=N+`vU9B7`X9O^rU?6wA8yFZeH$5mPnu7TN5MNj4jufQC&&^rlp`u@uPie3XuM01Ax8xJ#6bB6L*0<%(c2E7e1 zTQsNiq`vHjsr|j{N2UBb6XraR3o2i!&!b_onlsop6K1~VlzpQ25X@@L8T7Wn?ADyp zlm7ImFb7n*8T2lIxm0roy);aR<_voCVeZnLL2s4EV5$>>+Q(YBO;z-y{_TZ1t~rB! z=e*AT6^DeN@{MrsI+#V8Gw3}Evs!Zof49NBsyTz+F<}l?wol6U0+^wiGw5YuIy7gn zZ@$MM?S!E6xEF4D6+J1BwJ&i-sLb6%^CE@!_3s2(v$kK1ZJh?40;=2 zwrI|vw;$%H<_vmg{*nHaqmsW;zN2CCnltFlhFPdNgMBMuR%_0nw+&{u<_vmAg*l}B zFz8(XbE)Q(UOoP%VWxXrrSWJU%%UoKGQK?uvsrTn`}V=SsX1kz=neQ2?Ttf1#r6g> zPIF36>R&I+J(@Gv_c+Ycnp1jW-%gmLnltE~`6l&`LqgFHr6=}{hDmGApw|U6PjgC7 z>hm&~)gD)=eAmG|XQB5R%rVUw>^u8^_`NQNgdl&Vf4&x`Lvseb`7n2BPWdbS=_;7@ znltF_hS{e%r6=X_F3h0A$`6Cyr7)v3r}U&e#=>-K&Y*W6%nHpZJ+W^+%vQ}A^bWur z(VWtg{2TPYuCJUrA!z)qhr8TkE0u2srb}}M`|g2Rra5Kb2rPOU=78o5dZ8nf8;67- z`y~G^g}Fv^2E7iLshU&viQZi>%Qa`vTMM&Eb4pLjW3R_>>V%;3I0ARlLT~V&DK`!Y z#e6Z?mw_3lIc49qX!OFY)to_Z7tCJGDLu)*6EFjgR=4kBnBkf;=;dK1YR+KaBAEL$ zr}X4`#cGe?)Coc5u^w)76+LuvDsIfLF-kE!PGD{%X(=t+Nn z3g+B*s{1B{V*#vr}V_W4IWd?-(7HftLRC8bpmG4vFiR_3NuP` z%08*jV_~Lh&fxD|Fb`@@=}CKg3TBVTRhkbSfH_h{Px5cjU#QO<5-RnlF_@g@lzrlF zH_V-yGx+-m%#)g%H+53)B*zrzqlV9|9#gpL^jC_zjGNnhTqH77apK=wKCa2fy$9}? z1t)rcv*1pLJ7vL1y0ypMvf$JSCVz!H!;(AOlKYSa_g>Pi_i_Gw7Jo1CasGT3Pp`1# zMp$r?FIQV~5ese@dd)u0@2}K@1wPL2uhi$yS#XknpSR%TdGg&p&Tn5W+)^Lsw@=FV zD?ZMzC;7b6$NBZdzHj+Bzn-M~T?O}uk#vvwIKRKrF8}W1{CbjqHUFpkE5Dv_11&ho=d&%i55s-Lg8Lxc zXbVm}X!mh`f5pDBKF;j#1Pe~)O1aMF+OvgCGKaFWljT5`X&;G};! z=;QqLK|15QNqMZbw|5!EzC)_a$PUhJseVpG98TV`c zrt6KbZsn6$Ia8h4}S#UBQMJza}_c;qr`j-h7oRsez3r_Oy4j<>wKgr?6 z7Mzstmn=A0FD&(O{_+s+>lR!C+`n3I(og=>f|LEk-&k!N-~B$$oG<@l!AUzhZoxVI>ECrd_4^_1+-3_->hmuwI4QS1 zKF;j#Z!I`!ZwD+mDUUz-IKRK5_ZJ`Mw@=#TyFSjZC*@IhO1v%w({mx|U(WS$X1$?4 z&TpTjJHmn!f3LCNWL_8baen(muieM_?UNiCXTeFi-Qwf?>5AU1KF*wOw*@El`Ja89 zKV9J#T5!^D+-=D{V8O{a{dEgY#?^0Ga8h5^_&9(5N%^j|;Kbh_`Z$07N%=l+!HK^= zx8Nk*Us`bD$M1Zc-(M-;H+-Dm56Qnj`#8Uz`0*DX=hqYa{_f-adXjGKKdSdHQV$0D zICHum@NxchWn4Jl$NBYS9eSAsCmvkq-#!GXcYxAMsuP3=An~& zdN8RNCd!K)Dl8UGz0V;1>D#AE>6JpH&YyqMK0@!Q&Plx=WWmXP&bb!c$Ki%saI!wS z$%4BSuE&Ctdi6~UPU^u^KF(iX_V|;AGx8%Yuu+E%0&vc62e^Mjz+5PsXGD7F;9T zz%#4+EBo!kEx3=tjkDlH?{gNM9wa)=^CsoQ#(@T5yu?91Bjy)q5?tVQ}BF;9B5b@^Sw5EAzS! zy&{JaKH0$em~mbt~$56eHX*s>*M_PeFE+&3r^baA1yd3w~u~M z+viVrINUf3E)TcF$NBR`#;rX*&Y!Mu?^2&XT*?k{fTyO}6B^EV-GM+-ys3o+UTml3QrW zEwbe9vgGcy#gx|X1%9HrcD2A&!`c! zMmOwdAwNWMAvPoH>+7#bBva8FvSYI?v1^93T|X{9X6%r@7u&OmT(m8D{g8U;R^H-R z#xW+;Pkv1hN?g-9sdL_>JGy5~F8rB0Z_dnVQ+j(k$6Y_XY54HY$+ykuo?5s$XY$O> z1*1lEj+xdyZBoy)&Uv%uOr6%a^2N)%@*mr%wIt zOS{7lp1`2=(yiCu5FMBP;^CJ_GX3Sb1KO4zO@Dd8;FbsGo}UO`(%TS8KX6C=JBe_e zJhcrieKUN?+&x$RCVa_)?c9z$!$*2GANiGhbS&XxYQsc6yBqR+-r3O975-=fU3S-?WVrDF z$KGUk+unaf!;L#QUf?+SPBeVe^PC)rhPRzu1M)n`^MbtfPBMJceolVPt+#FnH~xyh zzg~kA9bDaZ;D&d?H~lQ!_*4FD3pXAXp+nA1IeRJGxRo0(aG_H)UJ&Y?aK|Ck5B}bb z^*1MNF8(RpxKqww1bXA0aOWW>0;%uuBYnp3D@PMP&$7N*zs3DE;*)m92GIHbi9Vn7QiP87IaElf0PIq zMg%xcI`%l~z}qCPKZMVD;qCBQse|(6k2uhEn2ePyeLEVi8?;L(=K z%<#6&RF{rDB2kDf_r17syAZ!~*ZBz4jonp`1;3Wl?5+k*a|8IGTD=fHXA8P+L&A*H z5y=hs#|!DZf7+0~dt2itejC33m3RN~56Xac!zYc8Pp2g{I<2a)vtce*9%@)jwsUfS zgY=c0+|#g%lW^mvhPBS$^$nZ(n_jx9L3*C_()A5T<@*=6N-K|!|I95fNbf!4TS)Y)dcgZI~Xuf~rj} zI~g91KcBvPYktBD@)*)}`9{v3BLiwf_Y}{bE}oHobkN#<;VWw9jpjUtWBuk0l{4&* z*4=)F0G!6^=GP40EZ4C%dX9UY)7Uw3o#H<{TB=_o41e-eKU!Yrrw2%G)>8+ENp{vr z{cHTIR~`QrZv1(;@wM=_7jFn}`wbPeQ+l60Qq9AiM+6eTaJF;1ILsl9*{PFh@~yLl zkB--zY~eaRQpeu#6^KeYPBx5wA-nW7Muk0i8(kV1(Dp#<5wN5llq-uOQ(J*~!tghvO>sNvrx>ZIFyRD}E?^ z<7T3_;{VUWx9kp|v(+)9DSXb)ILS6Nrb&g&IBRUfolbqDA&6ryQ2#?$JB>iTPI0O} zBjOF$kGnBCE_!47fz<>4@sEFy4cna=@%e8-?HnJ|%CYe&1c zo@wOo(kK;x9Bq=s2jRu&rO|Votc?zEvziU!I{&SV8C$6|RHK{rhZ~QCFG(&dTwcR9`sR1J=Jb>AVbF1{ zlDfmdBh|Kf0PTy~N7swwVd+0NyH%5F7w(i6>r@`7pYxr*xl_g#d}|PP2c_dw*bb@M zeEI$W%tVe^M&m02Qj8=@$H>hGq*vqH)P@MR>b^gkui?gBg7f{Rmjn@y@jyoA?UW5= zKT$3ZcF~lE&V0$qcT6Z%0TO&k zCJty(2Y_XI;|#wqqd;?&jAsTWvArUZ(fpTWl2dGsyv!>+-(N5H()G#h^KLppmHDMu z@}jszS`5~IWs)Oa{7OE4D_2hNArqFL%9X#%2h+Tclf;#3+Hs06zYRD3g7dmBh`A`d zfDfd96B&kj+cGhUW+jy?d{!s*lQMQ|Bek_rN}%MvH)q;R99n`?-p_~Y&T!mrlA0U7 z=>`#e-mRW)1-PArDd|FSa{Jd5spsZ?ano^}SH|mQd+oJ&*#J9Vxcg(;kXbXA37WI#o?QNkFWfZDVx)3ILF0u=Sq%A=i{ij5jr1sDtCC1^wDk_-;{<&Y-dV3 zK{AP1x>LU5wNuEQyQK2-<>&GtuG4c+v`9IyXiteoMOa60nKeo6HjZAlZ znJVRT)|VvjqD#+|Rl<9me(G6STY5d#h6m!@PJ}mnDaPOMhKHlhp9doRageTPc=n0W3%$+VGIksUm3o^G=bJLxU$~2N$ zXbTh9*6oFz+eW7KORwMVz~H$<3U3bIH38ca)r{`*a;&ZjzRcY-7$~#)2rHY87s&Ten3v6JLk*m{mEenMyfl z=|nOE(o6r!3Cj)cEOVy9TplBR3t7Oml~TL;yGrK4{9QeozY_IQK`!CSTA2p(_nE=Y z-=RkqUUb`qOw?Xo_~F|=#NS;D|3B*92ENX!%J)ynu>{C?PP9tzl^LTR#}p7U6febA zN!oMD2|Z~GO>IKcQf)zIC|ae3Dy0U~w2e;>cK*T)j5yO7@yY;m>5K?C;+Vd-yoMK{ zSYBF0Ef%!$TBMNs{jK#p`<$c!ah&_P_uo(RoVDNgUVHDg*IIk+z2Cj0uIc+D^66R6 zv5r5&?~Z-dO(#9aOxwcW15EIa2LN^m*rE?CVS7L99zXY|PuO_L5hQsbede9}jslG_ z%C;-#cPyzkq-Q>C4VA)ZE=s0`E&Q1#r4L{aHSLgkz<870>9&V}CFeuk7p2?8JF&bi zPM;{&jviY|mQ?cPi;onwnYDvTOWCp^J!==SiAKPz9g2abgzO2E?xJG@5l!zT>W01r zFBRQ+K+c!sd|XaZX6gxZjn6h5QfhRtYQl<8I_p&j(D3cAOWIH05>oE7ol{ z#h^ao!>DxaS5n7~08dy|0DeO)Y$ewUA~qA|eVhWx#A<@i;_L)sA-5SjvxO$Ic6PD= z)?J%jtw9G~8Xi<4hI|K1twe)`T0&s}4rv8FdgjJ`M_07MbD=q;NuRLQdvseax+%Mk z+)eRF#WH`Q{%wvXGq>g*fNV5sIUecLUJa!w9Z&MduMc`e->vD{eQMNA*{jJ)3AKi9 zk#ACag6D3JD@;s;4IE5H8)GcSYqB?z6ktX61~vB9E3^M>ziYDB^J~%aV+ZolFVpXD zqJB^2d!9>QaUwKPZkF`sXrSli^c6?qLycaDcBW^)3~+$uS~&ZyJ}|hxOoLn&-mMxg zl9Eu~t)bO%U9|97kc0_HV=nREAN#*3|HX-PslmOBUQJ?&J}Kh^inT0TG=G&2b3@d& zB&xhbWsvBDSGo@E70qSH3!%qqsB}QO88v;L4?WbW;`Yl+S-cSZp@5~+M=+BJx`%|B zo3d-k3m3(p-JLZMNg_Z2DHiU9^sxuJWb(#ByidpyzCWThn{w5U<-If@Sj>n4q8#5!qSlkFm=HG)>f!EvL~ znKd?|Xj8dlwE$Z4m|Cbw42FK8&l4bB%s)*cq>XZMBX3hRSStYPQZI0~;u!kqrN`A( zD5e{Jr68CXemZ_FcmWL|2f>+J43qMGM)56tVYV@;wPlv>xW)R;`(semJFc{lavR7J z{e^NC#wk%;A6VjJQm09x#cW&Ln)bFVYo|AajweYCMy+zOPQ&A2!Riry z+RF76mWNgsf@Ekuq^?OzNP)yiB~&sa$kwK1pqWZbl+^0hzKn{}L2m$O7JJiBi{dT3 zwlAhd{OqR*$*3W58M&G=L{fD-?g%JH&ynwWddbJ|g>Eba*`l~i%=7h=%PyezByAEn z5Abde>;(MDzLVrwoL$JmB4}Cme3Bm^=(loqT3YGr>lPpd@v|`7N#$Ir3=oE~4}a@g zGO#sNou2e{nxaCXyAK|gUUMlqHm!Ir-Sb8GCDGl#;`coE zw>0g6ApfsGfEg>MQjUcqs&%b(D}A7LGg4klPf#Dz-Lj?_GW;{K6x zWb>Tn&U4rVGFei_<}SA!PUag;Mmz?{1%<;I;_i1(fDQspHTklE*d>E50CEZP{{wOf z@-ZNnK3@q?8kMU1eFVrQ(vJnd)&R{5&_yBMRl!e+Sx@^#SRc>tt3dA8fDG$?p8#^d zox$(f;5WJ^kypnAs3|~a2I$iPS`wh&0J*e%))7f*3xT|}V=;d48hjkc{Z8aGl}pj5 z2dF(je;J^q0qPCV3qUSACqmi~0j)tJ9jVC#G&txnI6jkdDedf^R)Cm8uf z0AC)z4)i6NwcEv{01 z$Q8Dd2~2T3oG|yHL1KXF0RKxnlZruU5eb5j$9yv>z}SSj61F6bJk31pU|*nNpMc%5 zkcSqh4K>zg{2+|1u5D6yvrsIIrM!hmekSD&R7iOPtcmcrtfOrkB<3CEVjjY6!z29d zU|x$uAr8W2xu9q z&=O-q#ctO}%u0v!SF&5^5J^*&Mfgzgd(HX@Vd-qbFJ@43Y86iUmS;DJq0dwdjwSs1gO^S;KvFZ<6-Xt!=v}kR{1|C$*H%KL! z4PlJXSFL%(ju|$*_TgosA7OaMlSaZ}yW%b^I*Mjx$^* z$WO$Tp&fwOq|Pi?pSpA!`<_UrWVXOqbC=3GO{BBxnDpRv-E&A?8G|Mbnt-=Q)q7O+ zTHsX`?Llg_s-nbAs;V?YYkIBmfQgJZxUv!#8psL`&m<0Q21ww@;>TEu5s9WkZo1V3 zJO;p0VlB=tQze)L;7`(1#Ykby!QByJ#1clG0v0GXN=Ay5$i=8*7!W^H8}-A&s2>QT%V|%f*BpyL_dG0k9tBt441&d>$@Ugz~feRtRb7&%Kn$X!TIKc<>w$ z(PQ$xVQ!$z%&LJcswyj)eimjMz>-#Cnv!E0n%K6+2?m~V|C5DA&ajf1+E^p%WeRf4bd!CM9EeHKNrnVuTd&Q+=+ErG^=b5Wg*)j zR4np>8F%seNNd>Kr(IcQTIO8U(X=X=B~-!N!kVnI%CgzvDqWkwLu50bVpK(A#AP#t zOu(nfyHYl@cHnQa+0PVcvKiZkfcNPGMRh5yjlxYzyM%3oSSHihi)AtiakR{(Hl|y< zE7EB1p(0ghwt&Ah^kPU{SUXe{Q@AEyP+=UJ(ctm^>-3s$#}b-2agzR5N@%l#gmxmC zyEHZj$R)JNK`#3+;}tWq`gL zpnnH)8RzH0@Acq!bCA$}93-^A4AR*0AdQV;AJJu|1|ZLGPuOLAK0wtqi5xX5Kn(#p zH9%(s={^zIwsUi*BS7vSW5D# z-W&71=b+et5SUsglQv)DbPbBoLJ@E5K>F5Ovflto-+EJ47N4-8w`BhsfU;s4NEX|8 z-^(9+XtzF`zSVcwp+=_Rfp@_jwsITpGk5p4BmXnWE+05wLwwB=w*4$0 z88l8Wmayh*iDqY7q6@IayQsb;y0iiMH3=)|hADlv)v3+$xzEs^s#E#<8q*_Hr4#UL z4EhXE$)JTmJ|X@V$T!T_1Nqe04CI6GAs`=^PXoCK|5^w=iduT;`+z)D=3Cy$=Kw`k z8iM-_c2d;^>R>aLEq8F-yJMzbPZ!^ht6k>w^AN=wo^q@n+TmrhdAey$b`v=RtjKOu z5l9pp>~~GJkKZH@W?;P0!WJHzBXoJkZiLcZ0{SWKUQu2%^45-A=kFk8B7Wj-Jr9B( zOg#DZ{Zb{8(HKIpwjA%asBtXmf<0E^k>nM-#eT%uAlN>EOQrGiV3Lgr#5N=FLUNZ= zDW)Ru7s?qv#*i#3vs5DwaSzS$kRpC>ihwt=GCWphIS8=?98&2+Qdo>3t$1rhSi24> zw9;ePQV(hA(1ujDTsc&_hqlY=FtpZ*+xl4Zc9Ha(njYkK(f;zB2AZ*+&+K)4=C5UT zyWUcljQHf93gnYpX2L$DzXIeFc@>bGI%tOY1bs9>zYfqqfYMDR^4AI!lfUj~3+%#-h?;9+`;^StTEMUc z!RE&mE^Ne%%kgnF2^K4bO}dffbP7w^L8Z4xKaFt^5Mqg~9EO(g z7OncfOnH74=uK6a<8=Z0K!E-tK(g8Nx%SqSr#Hlta?w-BzQmz_572Ow=T{;0ttrp( zfdYIYKxN7^13#w#tAPG!3J~nmV3;!qy6yEku-FFz--4AA^Ta8{CMG3Yf*hr3gvG9r z6jXKU9d;ZFUo?Y+znX4!pEo5HNHZ0rLfoIRTE9~jV6|SgUq21!c_gg#?c!pYc7EvV znpXzkg|~5ha&}*|KY9(y@pL|YqI7#03Zc?iV--uU+)XN~*QVoMV_`9sS{r<1f3`usk6ZEh$ROrH`6T=CF^iRM_ohOfI%Fmv&w|7VszWvnC|UQKG&{qH-O-V77}5bmueQqA`9XmYmqfDsKtDo$9?w_h`9z^Xk1>B5Cc^ zlyW`)((B2rkmW?bs#;c^slNQFcgpx=w`z7DKEfvoX^=4tQs1lsjLu>4`6ltJpSb)r z7Yc<>>jXNRi7n2tkIEt#j;1abN!5KRVof3z8so_4f-bm67Y!E>-MPn0fSh~09LTxH z>w%nm{8ymw*beuPfm}#@50leH!;b*D@K>hIvqGr2LJuu-g)&L-w0|8!{}+(c=G#K( z_7M6+2>nffjtDfjOnqnJ=Q&H`8J8R4i3WSKV9bXN#{HiW(&LNm}>UprcWg79o)pU?Es9L|IK@25LZk=$-O z-lyJ@Z3H=mh>g?Cmt}RFZgnsA6TgJka7@$nBEl1;itKEb<#7Rvdl}zyT-{XCA5_Q( z^63-yeEGdgM)AAh%kNxL+nhe(RhNKLow4n)bZUVRe`JP;W)m$5+fIUO z17g^%;!1O95V6CpXYVx~6PCcz80fQ8ADNfg&eU(nR;+JFA3idb>3C6<*~K#dq9fq%)+tv=Y1Dnq<|Wt{c3rvM}^c zb5q~+-2JSgvE{B=G|t^k6z#y-?hacD6I9WgvKfYxpj)z|1<6oBBP=F5s9VP4G9KXL z0OA2owcj;nqGQpU_9mROh?7z0#z(rSjpoFlgGt&6k}Vs3 zDBUmJYVFxK633f_9g+v@DrvaOp8y+j893g*@W@z!Cb|jqa}w#LRI-1h2;i?dB9G8 z0TQC@WV^s&03{L=p+$wNT`FzzBoVMF(mc%<+rZhYO}(Puc7En2AUB%3l>YKfmt$Ev z9g;G}H(kVHI7{)bK+aM;2;>XvULapi&kYOVmw?>wso*E`Irlq`**QB*k+Zm?tE-SlZd2Js7uyu5m?8;&p&Bw)|L#e#OVQQSWC!2kkYF4>y78~|l zGj^9mvsVzY`ZzLxK(@PVq{7(>HjSx|8Pdwg>QKq+iDcwy-8ISUVHgZx7iAbno5{7^ zjNY~OCQE?UY&+E8o3&;wV#k?ZCV6?21$rJ_!=+9(Nub}BT4##F2~FR|4^Dy-xlE;- zT=oa1f3UJ`Oz=+#q18_&4Emi2WeGm$$qEKNLxICF=#@HNaCJc!*rw+-^K38YJo0yj z{Yya3uy+Ib?79KSXV>?DoMG<+a)$jSAfG=narOBlI_op!6d(^RgwVMmbYXy&gm^1M zyl;ijn*#Lx5N~UU_jm|>Hb4ghl!6X;O^*ihIW-UH4`O~<@0l!3*TV!S%&(um^7~7%zx-|!`+Fsmo=&z|qj6Qi{%(FN z_7?+mQ19$-Om&U@O-M1b{7?><0@yzsmIapV*~j`R8%g6m#RJPwjZ-*$j0YCSBg4?Z z1H(-Y=7DXz8xJfV>h1Hu=@agID;8KMdY>mlnPqZ54jyPTKCj6o4xKA7;3u&kBZ`@e z%6?FMvb?WNI2Gf2t%6h=V>xjXBoM=&xh`=TlWdH!{Oy)1vtAKfA?jm?^6nmN6bsra zd1Q609d9%i`J?nwl@U@b8Y@}km&t#wcz0uu&8n*o>o7d({KyJ?al$Hl_2OCo2XM%* zG18^q3g;+L({REPlRz-1Bb*7PlzgDxzhw}!jHisVu1vV)4cP4%hb7a$_QN6SubU-c z1;Y&1xyvfynq`M7#?OrYfPK8EtLkwf9XX2)E9ORi3JIs65}q-z@2ZXlXHp}EfLOs5 zh9->=LngpJqL?MzY4Q=G{fHH3BUmP6+h=_2=WECj!P4V83J8D3@SNzN263$<$Li|% zq!KaDEF(Lw1o>@OX}_QnGBmbId`LdJiKKnDmG3rr#>8}y#_mt-*KI>iJ@u$cZ8zC@v!zuaKLVTcN8&LPw0wERX)3p5)9O1 zl7wRmyLy2P6pG0b(@)#b>cKX3gww;8fg)PviDcUl{JM(k5D#BTMPqygRcmAu%8%wV zKVd3UQDb1k42dVOA~A==u-0KT6i=8z3~NFkV^)==FrlP_c~%0T-@|gQfoY9IfsJX^ z%~j5{eif?Xtm>IeK8F?nIn#PGkT0tb1NpLA9hlM4ff@aq;CDmtJ326^#{>DYdPDG& z(X#tZ3~c0#0DU$xV)f?20M%O=Rn@?IUwINp8?cp z`cE0j=~c4GS0wrsPZnqC|#DC6}h$<9-u9GQ_8OBca4>ejb$>@3%N zi$6rYyv2HI%SXB%L-87ZCO{Vhd0n}&V&Sf!}ZXRUTu$t;-H@->AzD3Xu)9!dOJ7p0(hjrFS;1{%K3^rMt2I zYVEzCpL03Uk*&R#!dQ&?o-Rh<_lLR;!P--dL;_vk*c?r3?0$7%@x_H`MyA=YmcDi3 zsC=pUFh*CO*3$G`xP!W$MU+I)d+^?_3tiH4Sv>1Xi{1OZLt;yBP3)r!rK^;1NTOwU zSyd?hb?87I+Rv46`>3Jv z^ajr9C-+5oox7VN3fw607Nw{NqF(5EHAi1*h;i2l{+4Ev;g)G?OxNYBx(65?zhQJ> zv8ZNXy_iv9UcpH;K^2@r3o0sT^@{GJ1J!@(KJ}hy;OeMxdh13mt-C9|^)4<>LXkP$ z*f$uoHc7v_(QfNK9@6eqwD$UO?tNd_627x*sB7P;tW zAiecD{vP0O7g|BWI1517GQP4&S0)Sjvd_nt0p!+Me1B)A@DK&|I?Xby`Ql{0$@lGGrePCem z`O%cxo*j!%N)nH1{?`$*D&|6BtLKQgo*~?TeSdM@+H`}H(b83-H_fKzkG3=Nh5CJR_`G_;($WZdGKXv%0StR>2y zf9j&zB}atXm^Xd2LUfiXV??&tdtFxc+qvi$c+GJN8*?$&9JdjUW~bLZee>pAbRYL8 z<2&{N{I|z#dPuXX43})HETI>9CXvWRD-%i7BF|rIlf{mS0rV@O22im=sU#_YX|8+x zLN3f+%Y_+hxfn?y5*O4ac`>Ap5;o3OiI*MN(S9aQHD>#&5lu^YP zWlU(BsE#EVyTcG%$GH&(X^Zv ziZq_e&dj98Ea?(fLdEk{=`okB#jA?FWYfJamW4hm{UG|XG zeaMHQ(?!E(>N968pL5mX3%!RF==ixzK`}BcheA{m6H^%L_97BVoHJ^;NE(StrA(hB zW%`tLd}gfWGrNn=w-*^-({STFeo^){&z(DGldQELG^TSU&~-H4?rV4-*My~iMJbUUP7ySvTrM97fmqQmL`V1Azk zQs1PiJ_qzq2CW71T1njbTl4!7&@~3>{O0!!`Weu-4B8h$b$^eCz8lCxKM3S$n?vXs zA@rOO`jrs6I)r`$sMbWje*?PBO8X(u-y3u%kmvjikeB;Bke53Gt-goW19|8eAP+qS z=$n>H3y|kG73g~Ny9nq8gT4&(&jzgw(BA`n-TZC<+GvoD@5%K;C^{j31326Ej0 z1JDmVEzs=-)zu^^CIWf94j_-W0LbJ0Gm!V&tw8^1X@3MHv)5GBJwR6*^Z?M`8T1H{ z%p_7(j{$whpjUym7&MB*A)5{Q5YR1*6thlc2V`{Rt!bs}$GL>CmKbb_+>W)v^~{g&diH?3t$)Jxshmj06yZ2DZV7q%uGEl-HlEK}0S#6r5sVAFMa5+`0sKHm`<$0)h z;+6R7F!F%cv9x?FRl+!Tf$W{xvPARa+4b5eL$BOID}r ze$-`&>Uw0@fdElj$8XYBUQEa|@(1s$<&mY47~j_d$nTH(sUeJTeY&pIx}?EZyEhjY zI50>it&L!@Lc(BVutf7^bsi!sv_yBeM2{6V>=`-W4ejj_Mhnq?E)z;$p&g6@FE1Q- zfI8NuQIMsnXj_^>7NlA6TF`kk?BVaXJSDJ4PYJvV@Y@?u81jp7*RY@89eco8Kfu%4 z(9bC7?v&3*1d%t7A@Jlvdh7lhh_X4ylLdB6^kqU` z)>Td!r5{jwBK_3T->vr@l>BE(ZW+Cz=pP~VPvOO%ovCyfQ*Irwz@Ov4ne4YdYd3FO zoljMi*OmTMCDms@FDtb4@%eN=pD*m@^QHZT?tL63eGGmfouR)oaersx{?1r`Q#->i zzrzk9>KgZY#(F(4!=&>*N=2t{dL~qc?+3MKL8xZ!g`mRDRcSt#x zz76Y+CdLt*dcvDd&B~OwDo$k22xPinOMUVCHX7|?V@^v6SdE+Ssz5Ha~Ry!jK*PVPf4ohm}YYf$N=~Wf1G8zO`64 zH6CQ$%Lj{fQ{P&wo0^DqlZO-Qrv4tWZmLUHgT*=#%?hzj&I++EPSV`He6UzI^{vIa zsTm*6-OC4ybyMG3teg6K#JadPmbb*Zc~mwRUDkyt=jeA`^xKx=?3#P8X@pQ`w>6ii zDKpkYu<7wMoyRm?WU-ND*4ZKvFEB2~X~|_SO1TuoxM8O{krEM$oSK-{yD7Yn8D37f zJ1%^GTsRy~YmC%r>VHa%8)af#bYG<;S1U;_AGu9X5a!lHoQu(AtDm{Xs+6y%mei+} z6>KK8^_q^6+}6qpH)e@w(PjGqn)scLBR`K%5Rw0=>fSv}bvJvLb)WY8C9!R9E{R30 zD=eQvRMHwAFX&NeH;zg%OY9|v&(o2z-j-bjtNQn1q3ef<(8b--@tt6s&IPAKWiN@z zE_;ol@E;lP`%eM70q9|q%x(pG)S&+WddeW#KvbD5au<-xXjSCkGTK={&bfC7NEb){ zjK5UX3pCAhehtWTu10F|oR0$XoU=eKap@{C3CpP}84tV6A{ou)nB_pXTIdx(&g*{z z$oc<&19FK_GMdXGlEPdL{5g=<^iPmkT%Py{kjsH50J$7E9mp~CS3q8?%Ya;_`X-Rq z<=a4BzZ*m7ogwtW5c*UI9f9QIX^#Z*wC@MbN)9V&v`=#-5o-o38Ak5xg2;zO_JX`fm{y!Adt&}V}M)^{8)fmfm{yk1adj> zYd|gsJ_O{rKOE`Gp>aTtdtJ8nL#zEfpno^$))4QPA>N21lXz($k9Q1^_uCjCmjiXE z-{rt2ARh;LARilN0J$7E4anudSwK1_nW|a<^prst$&V4rIdi!0%b(rLz|Ber z$|$*|d^#S5*kjVwTyWlGFWo43J2|#20-AI?{_}L`lI>1Z)7YPknZ$h_fcARMl)b91 zt})l|rvJ{zH;Hcrnq%$5zK)_Cc&zhnF)S=#mp@ElG)r%BjJaO>Wc;qzJ{gSq4&C-| zH;DPwW(3`??XW^*8)t0s_bbAkZe*RYUHC<^V#q9Ihpe4rf+sxm<--F#Qp z&4ViH+J)-Ydi*AFGkdH0fUA=!?NNEjxZ_u<{4Rj!3v}naDqi>_QhtqWt_k6ZxkvCn zUkH->0UV1G#|uib*pd*mr?4&Gl?1)EEx$SmcnlMgZFw23S{Bc4%ike5wpH4-Eq}KK zr916im>tSAYd%=ua9d6LgYr4vd?@BcxyE^ly8Lx!Zq;dL!X8sdlZUkHDuIr>@sK*N zN{)xH>wghIPeIh>88_`#k`6=tE3F;tslg;NIcOzY;@j5T4r3+Z5mi~i)pbEM#-2a z*F-aWP2=6g#Q??@8XlfIq1C1_gAOIR&2X4x0ZO7-jtT0A3MBQe?D@XwJKKT&{!MFvA!0^8a*T<+3Z_!^xNv5NU^Nk-if0m zxYCB0%uZ&2)OK+LQ<3_Q$qP!|NA=gEERoV18^28MzIYT#Pc*F_qHUY3#BZhVrqT2H z{cO5247ATOZ60oLar$)J3Tw2nMv*G1CCc5G>20SLUs=>zx;W*RSzT{TZqh$Vw|S>Z z^{JiL0Tpf&E4z9(&v`$P z^Hyh*zeE2DS-1N2E&J@>m7$azE=^ymm0T2Yzj#4iRWC$?_Ms^n(g3WVN8zhl8L zTriZ47}$ELDaDH3;YwX}xOgQ}bfL~5? z(P;I_{$RcQ5z_uo!^w$2-UCYJ>+49c{oUV#u@<)C8(yfuSRqrdJ`13|j7?Y+3XvIKCBBG;<`T}O60yd2RO0Or zg!a+g{~XGm35b&Ub_Jq>xe)UTl_&;7Qi@{a^J<}&H8&Yp!x#q{*<{Swu^B92umJSv zgC0#PW-m(2jlL*zqc2#Fc24hJn2jWVGa)lGtw+N7m4q_OXdgqc!}uCXB~G`;MG*DLRgIIfFdC#w&21rAV!R)m?P#dfE)>D067wLGmJNB z9?+i|5-tdS;-|cEx;JJ>r)+csJRk@x>^OuUn-t^h|?np`$D` zqwnNemMh(_CkC`#wrpJa4rFQDJ*```fr|LLE3xk0?y*4LZt-3YeFn%e@K-=L8V3G8 z_{lcZF@W`50WvY7`3D*NlKWaT)#~$6{0JJ3ao!uJTMg~btc$(5jfZfRhfvgE}gd;P7$S}dlI8Y{VuBDysy znfA#c-ykL7VX_&=Cb5i-^>|4&s4n65^3Tgw3oyFI9))ErFxca4i1Q$SvO34OT8O|E z@028kdsdYfOprXj!NH@F_brw;iTf*Rqg-hVTCq*Kw)76zu4M4+I}DRrUXnNhKUxPt z=4%6?VWG_X8f>IA*r>r$yNjCPnGCCjn1_JtUr&g5HjPAUsElxHG=h-?`V^Qv%skiM zcN>n}PbQud`RPDIiF^saf3i9KAdoYAzXiJ1{PL9LjNO?)&g`8R{Jt3c)&lwAsc(l+ z9cS_s_W?Nt(eU?p2SU6fnRXuU13(_{SRgNVdLb+uC#Vmt@}7d|tjSj6H0pC0fT+(1`}MJE9a^S7y81>` zXSY=ViH~3C2iIOZuqN9DpiyU2i6E>6`EqB8Jmc*|h!6wJk3&Lx7Kk-{0G z#&wAH=x{mzNqsCQy^rm~&3X2@I>UIZ9V?M&?$?9p(o<(!hy%SM`u=DqgZ2RA=@qRn z_GDDBKPO~&!ma@C4atq*al%6?AG7Rua8j>)l>mcIfgC zNpB=XjV3WyHI!>C!tt^QN7Aba<(QICj(XZ}-3aAq0=Djja?As^{)cRIkuy#oDW)vI zLu6w&zgBON4FRS=P~hd8`}mQ~lz8N-Kb&l6diaFe0_0>vCb~{G#QFR5of@FCfqa^m zuQ%zz&&h$*5S~K20v>M@kWb`?LcCvucrS-|e-ftoF#-B8kmvV5fIPp}5ZW0a5fCp! z1jJkPIFOTw*MZ6;0*Q2CmOED$XGcrNT3ZG3I2C1MN=Lb3j*73%f!)8WPOo_qrx-ArwvcPB;L%3wKG}LiY#9UFjK z-eS~TWd3U0@91YYq}U5LkdOYnIl6npp2MrR7v}Fsw(PdY*<*&|Et`KJ@hR1Q(!8pJ z&;0ue)%X5C?U(1Ye_X|UG#RC~;f@ykzN(uI(n}z$C7N5)96ej;-jqt~s$qt~`{Hag zA~Y-}rP62b@*LA=Kaf7V@4S}u@<;XYr|0Vfie}dqx}O`dU>TKt8czVsC$yA*g>w724> zt@Ld(4$Gx)J8EDf-$`#YW8BZqQ1d_^KhkV8#mEx*;>Jug*|u4f$F$4(z=XAO^F~_p zZrIn^)3>}`yJxH_dn-@e!U>QNf-yZ;nl!*~Aua&0iN1!Yj3aY?Ov6^0efOqn%l!_O z>?0u=9EIp%rj}I$Yp3+BJCpg~vj&~8*0V0FPCTKac!G6rK40%0Z;EqFvN@>_D&QfK z`+vC-{k%|ET$WA^80*P^0;634VKl#+u*Z;KcJ2?*51Qog4gQ-g>I}{UZ2% z7@FvQc_2@FHqZo%_nF{#A&?g9RF$qW@eNYl2X>mp(>AI1mX<18pyo-so-QU99v3AZ zs)FC4EzqqYbtBSs&731@X4|8g?T_Xr{-*OcuetkGmb`b8o0&Z=%r1%^)+)EOP%^$6 z8zDE=u}5@u6jO$e@i7YKvqh5Xl;!b0?ON4WvG2xj1Ks5-HL;Axwpi(g`#h2+k0oG( ztm`xz-9&tcQWe=_t%oxv6QyZ{bB=R{{dicQmai&)$LTko8T+F`P4y0z3(PhTi>FBM zaRlj=Su?fav9&RbiECZl$3Neyh=mK$+!?AVJ=BSLlG`2J--x6WxCgVYyK) z1lskP0$xg%aw)I$SvYf}n6@MfVk3O!gEdODjpmUI1ZIah=Zm-V3Fa^BQab!$__ zPj84){gis7)oDmbu3yzX^5FR6(rc=0H#?o6e_H6AX`yqbh0eLpqm6x_5V>kYoYGP; zNsIQ?#T2uwK9k%ry$}UjD?Ns|&Ute;oekEnVFsnD<^yTArmCbi?lnl7(5r5h z`N@dLp{D}$9&+_u-XEYb0U8^i2?3f6r1S2nst%wzMw#XVooIfTJNU~COEWVudbr)q z_?rkfBDH8Qbjhew1!=O!8lHy|ke39s*Nj*-uzA0S`KWvSV#1XWi}b9gkh%A!XXy%t zo#|OTb;6|~dSQ)=r1@h3-1Kzw-~KH7+4rt`ITwDD;I=6xFT zDex`wNRNE9o8GCXb=e+oH=jUIA`9<2~f8po1%|9KmpIt*FmyotSS zRjjj<#+A+(frB-?bjD$FpV!=5%Q_FBD2JWby|FrW6{}Lge`HH{Uu{eGf#S0NIrf2V z)uSnjm2TUlR4tJ4F|vCQIc8b&?eHN`oK2r3>U)kBf&Vm+?{7*Y^^`4W zcLI&H(4PQ3YJM8PN0{HM0n(uJc<%)Aw9-v^3MscebR3YUog6~jfIP)#fPQXeTmn>W zW%K}zHb~a4k6EZJ5d-$1=)KS-_xl!*FPgSM7HY5woYmacJc~8*0E$lb{C0vm_70g6 zaPxH|ioNG=FGhP<`ZC4dMSXhI2v%NJgG0D^Y_0k=nRuEOO}9Nd3svq1UMCws%m!L_ zThHg<0`p@{(Ry?~dPNG?&(`Fl->|A)k}CA(_eYazBh<<_@9531B@`paM*W;SN)qzP zx!xa1r^!#f|BU9Rl-jXj_hE(kI}4==vkM!3$xw}1EUa@LXZSGA_9v{_eO!s)a5Qr* zmg!jB^;aPXAX?;lFWb2---YYP#oh~7o4=itDDA!Z8h#3d-jr<;YP5IK2p|l9OgQMx zA0)=f1l(a}C&FhvnXrh{J=}dnFG!(r@{wZgm+a3)R|&bf=vzWHJ<_LV#&>i0cqF@% zg{x(5$$rBx_;fzeS~_{9wD(Wz^VnK0_n7=UMc4D8i;X?$H1@=}i*whRZyVnQ#>_0P zU{rYE4gWb}HqKqG&(2)$oK&uNCY^pRU9>Elqn~c#j}E%*AvSDv8x|GOZbIk1D&KBb zokg zYS4Pk=L|>cEK=02J^3s-I~8zb~-C-dy6Zv3`?CQR4-gP z8r{oE=sqcm+4G4;y@*#_nI+!w<#;HBax2Hh@s=uAb{UjK+sX;V%*p4n>-9YseOhK_ zSL^(ZQ%b2OMLA{_eY>hAadxh%m3vg#O(lw}>dWq|+{c&Q(nhTsS9VX3JJ&k@u9o?m z3*CJqC-+Xc>x^x=yR?X$#vE&!hy(O>ofhTS3(hD&F;MVyohF}SyzLk@n^a;C8>+qf?^&M(jP@gbNA+2<*ktHN=mGWX5QX1f1}#0W>R44>q3jVTIOT9 zRn%)0^_qwk&DWEvDcUOhsn^6%tqQ**ld4wudGQyDsFjG>da<)l=X>SNQ%3T-Y;QbqVVVq5Ai4^dA+;>`ERLB8~#`5x8Wy@|qYu3LmE zGK@QT{`M%pc3^vNk4W#JK&mjl@3K!ebFc{lv7xzo3%TXSP54^6=OWRLam&8OS8)-@6JW%u1+wplCft~tVOMD2e)l2sptZm zRMt~AsfsqKVzJJR{2lvNk%Kb5`+#kizA4iZf-7^7q)RsM81H3>_fE`9YZ4k}Vgh(3HsZPjwC*+v* z!sfCvbp!D}Lqyoxyf4UCgpB@c#LG|<&8(qQZ6W^6W}#J?vv@BlL4B$mX8=%d;}5GJy}P1 zJHvlxCBA9&@d4op<`xL)zMR;oYFkOm%LBiy0@pKZeSC|Q$GHBzh=%YQ*@`=SSp}Nu z+zKqqRYtO0WgN>j42u8wasAxl6Ts!m=^hPVpjXm8tqvVX_e^rMayJ*___=h?SVt@4 zxOFwdGf#-YW)j#;A-|N~0x12Ql4QiQ9#PaJz62ZWj*1 z?ZQF0T{s+WefZk2W%$}~tt1^jT#a;84BHCoVJVDyh*^Z;X6R(*^oicqLy}<)nan3Q z4{U+=OXbGzO|LoTWw(_$cN9!?uJ=1y7}(v?zS6kd_>Ji`>tE6d&+laL&qd!imOc6x zV<%-7VZ6I+AjF_zF_EyW4bIu(#x&{K~JRjT`p9zq)@? zDRnW6j&$$M?5w4nw{M{)>`bmT7HRA`u9nLH5o#o`H zN9+72TBBE#I@1ad+StND{q&koBT==MW*o$>vSq`sIREvjnwA0aVP_SPNT!xfzKXoq zcJ2`(D)tAXi3iY;H@1LbDC${_=#gtSM-#dG0S`I0M-%&lP23qA4@DCn z3yz)9L}ceUgU6zYPY1{DXd(~N#vxBf6Q2!^z0pK$+~bgEqlqsD$Nm=dDCwTFkltFy zzi`=%LUffH(TcrN>v2y^E2Sn+Eu~hXezztzM@lFo8Zqv68xDX!Jj!2{Fx)cpE(lznIplUITHMtV=(^GYo;NjKcfp*F;D2ZiFXbl zVaOW)-+~8O)VyJOexh02x5lCT`@e$l?#jU#lEAj%INiiL(@casFEIi!8})D{~so zQS0rt$|Kfvk)pLff-#5vUWH&FLE|hOZO}9qGu$;AmxK&=WpPQwa91NP72~c6WI6MC zymCkuyWn$m+mi9QyKFs1lGw$p?2<^aD-kJnB_hSH`XsW^G$l8dNB~r=>$F&E5eJW0 zt!iHZrMiN8tN9?Q4c8#y0$*o$21ynYH^lUqym4eg9@$|xW=G_tl2cOBM5q9<1?^Ok zZ|ZM)bAJPa-Xm%l1Phk?Vx;z19V(~P6qmVhz7zRo}o7 zm)~oZa2DjpHW1wuf!E!28wncF(aq5#=s0&)8YiH$mSHTm3H*2aFqE0JLiPmt^`I3M z<9bafOm?^BZ&!e!uvltc??D!`&%(M+qX>Na6pd{0-7e5lpt>B+)?iXYo-0Z@iX1&` z)&}r5_nKK28u#w+m%zc9Al{1V8I3{&q)Lbl}kDa~G!?u3hqZ)jL{xPjBeivHXKA!T^Kx^tk#21lD0&# z%|J_(*bD&0NrB>|RKQD!CJ$qvae9q;A8OEXdSpfj>n%~~j&9LJr zCTDB(aBH-+Rh>N9EIOJ8wk9SW6JwJOv;s1`m{wuZF*$Q+Aa)n9V>0O&KD0)mY&Dfb zC&SQL&J`vd!-fu*bw%Rb+H&61Q*|?wj>#1!9g{OdLK2gX-1t+{Yu?b7Nc4vp+{mWG zO?9-AtP`5~y_(-)Ejx6tk5u{%GSlncyr}t{bLMQCLF}tx6uF!d$gMh70J&Ai8X&jo z(5mE?8IJ+E-G)w#I7L04j`VmrAde?)k6V9~tvYn&i(7x}0`go$p*@#ID6FT@sdLX| zI*{jle(<{p$ZbQG0Xfx{A-6*^_;pA}yBzvtG42J*E;8)#?0N9EoK6zoc7_zjVtVwJi4 z*+%dL>uS4Yh53I~gQ0eGHmo+gWN&KsW`}#@tujBjJ7%eN3X%((O0{zscLN0^&GuYr z2~spi9d5q2cWR1hQK~(w_q~JU*+MTyW+R76x%k#cBZr8%P`p#}V@3Er3l+}rkYIZ5 zhZ!$Wg2@@oMhn{}H_A!L4IJRuuKk-gAj;RdAUu1A9fYHz^?2T4J5%HUxu5$A9xJk| z!3MxB*`)y5NzyrT3i_xrZ7EHAN3r)NJB!SXODxKMB#w0zcujUUaq?py0KU?WWEY~J zNEtx~NEm0!t4|U9?ak}#P!PU1W!K?bVAmRlTc83^HTj|p;K69@Ys*&f`LWN5D<6^9 zyN+kjt>@*_pL<#?oU|i4Cb##D(lJ-nD0%b@c*yD?9%91Fh3Xw}=NA{NH%u*MODF~5 z2Wu}cR^LyA=ZeH^DpC}eHelwy! z4Yc$xk}Gd497`U>V=a^1v2T@&=(FXr?C^ulJYGpr{W+bYpnkeAf_GxbxAt%a&}g5X9^mChqQDsjCi*XYD`K(1pF*Fm}J z%Pq~SnbfIxtW_#?Y_(2p!sSh_X)P_lgmZRZYw0Tmvo~R+KFJ^0oBK!^gS(TeE<5~b zKpoz#>rC|-2woSYHkWCCcftfD$6RBJ}$s&z3=XRaEnoJ?Calen|38snTyv3j&| zT%EPNoS9izjd4!rLJL`3onbt(A=rz;jI8?0GXsWkh29tZ{su@a2IO8Y| zXAC9bqp`}*7P^0f66^a=RB+;itkAthm7DT7U4{*lZ@~s zp3RxPX&$+|c=mN5Un;*7pnngL%;NnXkWg;VD)1@4GddxaciCO2t zIah=Zm-V1vvCf{iY@QR=`Sh4|KFaDeB*a zU~}k#Sv>psy2jbbIg+wfw1T@g6Ow1RUS-_!Tp;I`&jY#{tw5^k3qWfu^s7M5K}%un z!(VqMIJ6}|I#=PmU|oPTINeXj867$yKr$ZlL4Ov|EaMq!(}}vxSV%#7(f+2bYf6)TO3lJ7?3%aDgR3*h7l&8 z1H+yfs1H-*Oa`|r+%!d;W=pjEW|$a0ZT<#7pCbPZKZaRK^R zfTW)DPzjGdMLr8O-=@eHfMT(VgG3zrmnq`R_+;mz9Aa}nB{rA7Fe08e*x!zbw#Ih* zxn2*?n{^_GWzpLz`oPx2G!dzZ)$q4Cxm-v$t#jz8IR5|w0!ufG>PEPBwkMANN`Vcg zLUfOlD454PET^$1f;AT5g6D5VVMFW&1RxU~x+saM_^14!xvFhyVe_%Il&^^o!jQ+E zym(}fbMe@Hr(Hp~z31iSr-{>NE06cQ9;nz26vH|Yv-aY<;^*G$nhx|XmD#nc%kEwF z$iT+d>J81~A71vYeebXeg=%viu(fAk`LTsk0X^>{gT;*AFC8dsYd%lY;y|KBJYMjK5&fexyVZ@}~;uX)H zj%&ZXUL5Gt&jI-!%#VL?*)2s*-89nVdiIgu*LxJlo7lq{v@;BitBIoFB&KIu~t=syPTYt`I%4c4CyGqt1eXol>JSp=^~RG91gQI;AGo&mRl@ zGRHymtmFHZVG^~CcdS1-HYn}8biBcw$W2r)z4ZGsD*g4NDhhjG6Hao_N0<6m9&WJ@x8!gve{OBAs_ z!ph6LscLO`zcwpvxDGT)Xl7cv4y=5a@oIvd4*dYgY1nBjE$;V~0387>aX%@T9Fh&T zLt6s0D?nSJeNLP13((F0?FrC6Ag5e~X!DHbnP`2a&4Y?GT@PIn9mz$%dh3PUmT#GG z7kba}?_WB)*gJ18I|{pty-T^jBe`s~l$uHIRn;4d^Y>3HWiM{o@bqD9xi|_D zi+uSXJD@4Z(Ypg^L>|z5L$|QKRay<%7Zpm2Mv2i_RJi@d8~mRr;JlX7RNczji2{e5 zjCvJb*;AnU_diz{*y2PZ>|r6VJzwZu{;cG_7kZbYQV5p<0m|1eLl?w^ubZqZIV3K& zZ|q$zvh_*VgV^;!;X;z~#UDdbr+Swo%hoN2JZ(j6dk(Sf%jm&Eh3C^x>lc zniQZ92C8sefKCpOZqghi`-;_f0r+hkhL#LmLrF#}2B=UaM{nY1axHEm1NV; zW$mSCs9^0`kB4FDCC=8o8B2d?;81~daMGc&u0kug@(Pwd$+;qQxU2^SA1dow{=>?; zamfFDmcErKa3upSRi!h)&c1&J$faHpE0=mTeVnELYapKj+Bb4&Lx5hPQ++uc!60<# zr~thuKz|mX1|T2qrvtSaOMfO%d8dS>(v(u&U#eknH={7U=3o5o1_Z_Hzw z?S(!($jh&V1-LT1&V79U6CbvW8RiXz`8;O|&sILZKmRE4{g?-p{i37BKBr~#!{h-c zx|@~vIh}-mL)C~-_)ErU{$YmD*3!(Hmg8P(J??Q$+-=(qXdOH5by4%O6g;DbmFDPT zG%3Tz!n>K&xw?9I|6E5w(PMrbgiCTs$JBp9$t@ z!$IAOb+!6wtIO!8vu+gI0D?|7_p-WUaCFwz>DyLkYUECe!*#OxEyGV6Iey*;g|Lp& zaJLuLk~a6AFV`#?$r}IMJ|y-Aj_|Ub(XdfPzyTm?J=wjbx}|%=XgPPJ8+0&;2kA*G z;3;W;`PD`9S6T^jVIa`Snd^>w_}#4wz|tLV9ZCVZ-K*}51B!-h(ZNlNojc{w?S`t_ z&*e~_b)Pw??@8%VcN3?d+nwvqNZHqP`CqJ6=od$8Cq|Oh<2XA}o_G92@5qiqE#C3^ z^Ak};zxROur2HrI0-h7ztM9V+*80!rmhO$&=qL=g*L)nEG7A=+KGw#8?#~piKc?|9 z_GMkveL#@i(Y;@zB6_{`xPuAv5lyPcJoF>a)2*pfWQ3-71Tqs2R~EU$Q*Jx4_;6vm ze^Qh?Mf*flyrUmElryz<_cqoOT(xd$`1|8K@uh~pQ)+m>`_a|#_rz-WyUA>GqJkF+ z_wxq}iEbbLJ6dh=b?FW}B*y)X_=!`I${(9zwdR*$*sxQz>DR{~dD%s9x?Po>4L)`s|IZi; z@QB8!GJfnX|KoYJOSx`SEL}&b{SIw_)GZi^bfX|4fYLPFI=JA!t~jzr*M+~Acssr6 z8*D430}i)?lmDIjT(kJe_SW{-JJutsnMGR~ybZ=ujr!F^A ztZqiPNBo)#3d9^~n1~_NzzH%{;7mz5w5wV6-_=@Q>rV*Vek)G z*N|aYQ4|keP^-x7XXNzkh7D>V*w?MuK)$|}H#Ky}h5PLS@~w>5n6Ym8&`pWHsiDV0 z9XkCTNq*Ah)%o&%${^-4Y@|r7JIu8*Wv%Yu zz@bXrp`m4+Zjx~Ye^|j>4ih?D))k3iT!SuJ${BJPbgfKzBc&pw%v}E0ZlwHS`eMIe zTl!+3EYcV2oO!D1t3b|hehtWVGJg-`Z05fL`9!-jKzjo8$7+t}*<>kej(M$T25hDX zTOqdlvS@TFaR7ud4Ifpo1jT6(n7^a;x>Y@!=lS$6ZQtlzB* zAk=GeOcBQGP_k0CokpmqxJf)!(lCWyY?!eg_GnUV?*nvo|RhT_l{U`fY#? zqfgxL&wzGV=!pSp3J@cvrFZsdx~+a@OX-4tOh(WAFE@?tW7xPRufP)4GmyUG8>CZD zbG^ZL3(*$~yfd<`wfCZoUXHO>WAfYl(U{gpa5r-0!7ue71$WcDf}4GZ{NcFg;XWGp zBSt=p(JQo4H;q)K>-4I_luV&}fMN9pjrs8+J}m?H1}&V}LzN11e+mPw^%U~KkvpZH zOewT@N?dC0l(^X9DRH^EQwA5zpm<+8Q$yiRne>TwaRmOml%Busl4^g;h<@OB$BpR| zH^>LB$Zr6hd2{;2e)+)5WoC$Tv52kTOP_c@j`#65sYc=Q~{OZSaoZ( z2LOH+yYXW5yv)XDz1$*mk`>zYZ;tM1j$S(T>wU_*MS?137+hh#cCxm9>TN8EfPL>x3()I|l;{P>Zd3)7=8gzu-1VkqU^!PVWAO~S z5R{}(yhV`VGOF!w871?#FpQQD*0Nt-ub0CU#=cAQXv+$ z`$2BBW6HYXu_c-cQgIzBVo{=A)^#|4s!tu6<8S`sS(L74pcHCRVpp^XR0yBTuCg zOj&+>mV8%vc^$}p-_eH_L@SnjF=;^t_L+Jo?bz2*h|Z+C4=jP_4%J;esZf1pX7MLf zFPZ4EM}-pEYo=OgQM2k=&9FqGR?&ktO3L*D5?VTSQ+TJOrcM)>o_Bc&p$KWX-L4T= zV7mhAPR{C^%ck_hNx^6CrC)SruSeHX#vKIZgp_>OI!BwwNz;x`-UQi|-nwySdh4A$ zMSVbzK7*kR{2>y)%qw8uedZr3dgG$VuZTdzbr6shxXl^?^&z)sP8~V*`SpXKIeNJnfNYiHo_=~WUW{QkiU_&;%{vN@L3|S%OXZ( zUH2u0@;~ zuyHfu$Q1Pxw1D+_1Xcr?i@(Cq&n&HNh5%lC5nXUbs#rP;!^RT}sn$|^>f&=0-jr!6 zv8tcA;o|9v!o!hgz#*Q9gSjGb5B5v+A?= z0B|ult|JL{t5GTJP@Zfh7-XN#`-}~GMuf-U&*q(xv-_N}WSZi67k?WQkNr4y@E2ml zdqgm#agohT?_c%5rMy?`S&&iK#dC^tnFKKkQ*4C)7^?BR`U>W$CQ+R%*ghnLuDjd57p*Q8CHJZkkw;Q?!|JNa$r<*luK zdhnjRA8|fF4l`;^J%mf^LET(g!=f_1Q@+jVQF@I>Cg8AESbY!y%U|#c5tgeHzCQ`+ zkU9KZJT_SwrnTyj0uWKay@(GnvYg2+X5Xlbx@sL{AFhkR9$J&wOkYNc|` zOg_dQdSC^3c_!kEUWswzV^zzvasWehnymeU-}yXYbF9$B7|7l))Uc9>qukI|cRZ}# z*-zojrKIe-i;rnq@!aC$)i~Sw)+8fJJmnY_u;pG&qN?F@QxHRlLIn#7`*}el1--3z znn|sT0w9ue&zZaFFBvy}q20#3(+m{Y40dgVza-h$f5$_w2-Hk?`Cqryq2WEtIdIt8nxvfyTeze%}%b(p&c`Z?U z4a60O7+M;WL>S%liW^9b`NHpi2kl!YVzcmtM!yD?se_{d%bRr!@Yi-|K8rfZ)?wUi>II|nanLc z9OceMl4Vj6oDRz9+a|w3|G}IN4J!~f(t~5=~p{TA$G+y+cut)Xz znN?Ym&O8=y*jPNdgrto;Zva`asKN}*uoiLyufc{5UBz2Q@o&_E3e*}^evaIEJ;aa@ zW12D_V^Tk*imL)Fk2H9?c3jj#uqj_qOjFtgLT9yAMJ*JA=V`X2w{9_Xt8$=*X9TxE zAnCBJTflR>2%=pptJHTXDdqJwC(A`}DX#FNg;T`0{o(Z1=k$VdA4d_|f6kJqThBOf zMp)fKF7_qLBMh$Ab?H%?ZII0)(YbH@|dS*sh* z7n!U87uf~#xK=kg#>^onj+XBr^YtrsEPh|tC#x18MKdO+(kJF`x%jAb-8)T-!OOOV z=qlT>;ATK1`>YAcJ<~Wo0R_AxIhX)^OLFncO}52=&vo%#h3sF5QN-s;yW0?8jh#9J zSYap4l+#+GD3^8oN23YW-aCoyh3SV_6JbFb&O6!`TyqbZNQ@}&%Ez}j5tclOq42h>6*6LHda=n z*e*1-oq-v+2PO~%bfQtS4O+U`Heygzs(}P#dNUTctxKP^yX>yEZfm#p*{xEawwn+n zL0b)?7W}C3qm_tStX8pA^Zfqjbaf^6u*6hc5 zU&c5^5R1iz5AiC5Nr`mKWPTwP|GrDUs@QB71 zGQ*5Idi~^MsKq8aa)hEJj~nC)aZ5VtBP-fe5RdgXJgZ76iEQ?0@8Tn^s0MWQGFMpX zRvxjzGorMCw?kt8krK1_9kf0^UO zh`e^gDAVDC2UJ#)9i$L;-3EgV^tvT$(sI-E!6N@8l%N>Oiwh~y9`~+K!4gXxtzOo$ z2lQJ_z**p?&4!BRV?gJEX}thB3ASZYzMrsXc-woc3u$^LUi&5?FK8z*ZET(A`Hu$x zZM`|5K~31&aiqrc`{JkEE%T*U!7+X#x#`_*2x>WMQI|Jlg6)GOunEkTqS(}XtjK2A zUCobx;O~xqxf>&>^%W}T8OnLO+ze_EB=bHxa0Q4UIL|s!Mts5&$ZI~Xt)$ibPGC=h z{|D`tZ1ELR=w-ns`j+3%&Tkc)G(SJaW~S!X-G1irSFjv64m!-mQvq!m3O==9ar>2tVw?K}j- zwPWm%ZZEWMpY77o(H?g_$*xVNi^kVDNK}3(TB(jBV2DIq$3eY?a0^{m5!j~Is^u!( zI&av!^>ra=E$drbrGxC+Bf)mzz6vHfyx>h;Fx7#|WU;U#aOJfHm+l8hL?eyJIwFwNrZBZtP>kIxVcB$;)6^y8QmMKcLYMRNVEGmE6wZAaHE26~WS5($>b%W_ zwr=FlvJSF2>hHo{jrfm@@cJOoF$R4G$Zh2FS(z?u5XfzF(~@hCbxx05UUB=F-qX8# zz1CDq{n&PVXR~YW=P7tQ|cQd7Oa6ri)G+Uwj}o%08oAry7$ zo|=aGdsaP1SrqL>+TY7hW2F5!e)5s_c;}VL$TdfGUYU+uQ>w3E@6hqYo^YaS^SBox`1*zv>tG4RJwIta#&habzgwj{vMJFTwV=n)z zB52cfXNyzT!KJT88Cmwc)sD9$uy$&<^iCiqhrQ_&?{6PJ+>P6w`g@nZB=JS}@b+{e zgPHI4TzzkRjc8EmCaVKk!Z_YF1c;(Qfi9~K#8JF*bqZZ_Lht*5_R~Wll{~Ax7?Y;6 zz2a>()$%2>`gzSThct)~zSaGwc)L#gMX&f(DIOQr>MsG+{O1vZRFeN@wuCsc4K*M` zO^_4}pm}4m>qef=@{5)W$z|cDn%xv2ok)@XIexcTftf+jz5V>B@Ju2UgCoqYjIa3_ zwEF6gefp9`v%Df)Ry82AkxC#0>=SSkbU-)39sJ+S|J&P-Lws>mU#5f6i0qrtd0=e3 z>r0f=d0@wDtY z%>kxa6XR==KxuzQWww}{Xi=vUu==XRoQ3n}#n-;y(rv{dMso7h;i-?3;))Na{K*XE z%*k17byV1!xaUu;UX_T>$j(DX_adKO@v2z1;=rNp+eu`peT*4G-~YT-Q(gE+5fdpN zoE&>I8&&8Hez_4KOaSQoib@QP0)?f0@6{j>!0xbnXkVontp;BW{x%zv27h)-5cC5W zF_BVW+hGE)+f0H|I5n0MU#A=DaN*sD58uX&3}PG>OiKGi8dJ(1wjt|Z*fMnoo;bYD z-^Jo<5*h^m+Pvq#>~;PUWcmf1_k-r9{*M|`uF;CW=`lDxg(Rs=rV!NkJb6T}7){Dh zB{w}mEOgF9Eae7|z+cA^>{9IR29L=2<|cm8v;;iG^vCqKd74s_xiWci{8PJuqx|l? zIDW|^Dv<9A6<#Xs;`m$pR3hPHap@ZiD)fT7!;)2-D@Qe`WR*znr*pjiy5{5Tbz1<0 z{Nm#H=eJ!Pzic-I@LPkW4_cv*Yo5g5%&YIc>@TwZIr$M$j4H(bOx0B65_sxYqUA%W z!o1{NZJLl)OxU4a88>$vWec;syK0HSCso_9ypg5~v(hf^uE~V=WxDvQ^Ma&}FUPNC zPxfUtE37yte9vIF_Nq;3A>;NN0qZS*mcL7>?}E~eh;2m~xtiua_ZABs_6-t`B|j2K z$M;mCnSi*dgYI%6CK@)Pec=)pX2Q{&#i=AJMyG+7fS62HXItkbUE8^l9j$;sordQd zrhmRIzHT>d7^#Cr*aY{hTlRZ%#F*6ZAUbvwPk+6G$Q zAh>!58$L6fKT^pXm!>*b9Unu{UDhdCf6?)h=e95Ne6DKFMeHjrV?0qufh!Xid+}>t zlE!=5D?(!k$EI@U?wr@YEG;5c6g!BZV!}YrxzJwX#LJPPYOJ436lNqwnv?aDOTly! zT}KWEJrLg0jrWTEAWu^U)-RYilH{4UN%HQIBq~|saBwNdjU*9md$=UWD@oS>%8~0y zz&OOaZW0iTMd?U9WGpg&>{!fLWP`CJ7`9oBHb2&Ln;O6C_*ZB^A$5sOEVE^CDZ=+# z_!*@J$56}E#Gw}8ChmWrvD2)v-sqXrXte~DfBqdS_x|XSYE$KFI_UMG^>17s^lsQp`jOQ)@oiH5)2LLF-X_&QTdG-DpRqr- zul^T4@q4_q4XypO{~aAwxU-Jwgj(~dz_ClU@gxbF`T$2=;j22oveVCLiLZP1DA8Mi zDL^;6Txm6Qe%>oi#>(XBBS4JP?$FU2nr*r1>G6s9y04Q9%<#l6>Sn-;6WOfk@i8tp z9>&4ROy`*ilr9#NisLgkeO015zU~8bXQ~-tyR^m0XVC*0(dA;3{Pdm}*hqZsb1Kho z-jnFOIyNr8R!C~+)d^H=?grvq@lyWX-m(L27$p>Muxma(!I^Rw`u`l$(lY+>o2Tkk&P^f=c~it9i3=aLX$qsbb?8U6p?B zNW4Equb)wfu2ysqkiI@zh~7XVEMLn4V+2xbt!hnI?6wPbX7%!K4!wMYM$3?`p+|s) zj;`H3y369ZxGw)YP|)3X>S*SET2OH(qBAy4lPh!BxglwVlA+;Y+@_+gFAZl%tT(*?I%O~At!f&yNQnxEccY9>udD- zmGduKzlT|>KOFKXv(%+ifjbWz!CM6i)b2z%(AMrY*C~1%wWw03#*Xe(IG1cjZAhdI zXtw3h63bOAoa83&XPil;^XKj6uZ}n5qgAQ((O79(6q2qQvp#xs`7U&!V_j%Cg)X#$ z(2C1yOOyAvLl;nS=K;EKG8Dx0nThz?X@trn98u1yGtM6Wp7v_6hhlf7Q zP<0;QfPR+%+sqX}|D{0--aQySXgxz?OQXi2dFZgM(XgHE+JESH`O(!3(ciL}SL1Le z`bCWuFeVLxD+E^x4#$Z)!hyQ|pn*D_fszelbPZ#q@hRbv8ll4u%+7FN_Mz-#$2-_p zxd$ka?$mG}TZbzY47@QVzq%f@D!1mG`bClI_?llHkPCqU3(EL!W|s}Okv56V#h~?@RRxf{WNYid-!vn#o zhX2WtL%dYGHcRQjX*P@6#cq+41DkmE%Hd{x;u@}T=3O&Ve!jK#3~x>Om1|}cD%X`y zX}SVM)2%rc|6}A(&i74y;Np$0KU(8QPNOe3UQAa~jI=uNG!qp}S^0bg%3k|w4;Q`f z7!B`hQ{ur)6c)uX$zzJ;IK*Z++17wDS~ll zib6J`99kl!b~B;OnPhWu+lQkuElaA8R3rPIl3~bDiDN}b$ zeHE{-jfL-vKFCg=-x6PU29PF!UZ0cC6{jSp4)cJ?5e4IJ%$dIG!yx)H8K2snE7o++ z!KX&7q2ietoo5bmS4v|6+5P7(32DSD9n{FuzNjxIOA&E;o{EkU{f}jUA zp+O*dPCdVO5d(NSU(v|-f!+;59*qb=KhB_W%+3i0eItZk2Ks04m1rbNzFQ2ESJPV! zIswR8|H_x-w=GQHF6?7K|7Kz7Fic)0zh_}1UL|Gt^dA=19;RCZbf<-F2*ds!Xq>h0 zUxDtj*nbaW-^<2%lCNlFdI)_gggys!o5fxZ^c{n)1^Tu@*8#m`qRig_xl-N&a;{_b zFqRAZERZW@1&}M{8X#B7Iv`hyY^y~gL?iEmYw#Uwa|2M)!ma>1)1bfPQg^XUKrXfm z$i+Sq#*T}XVow8dvF8A}yq#g}_rh4cHRNKCgva7ao(AOdMvrC|tiSz0PTF@V&-?z! z#`JqYF6^vI91&UA^*}Bx3md-I!qx)0u*nnfqHkg60=cjc#!Jx0L+F%5$qxNIAeU}= z2+gi4#Wn)%u=36aa;xcnAeUp|F(v44La5@{NaQD$<6S^5$8kW;ivImT_gn0gFg87r z)oC+xE|4p^k2JSg*h4@MSdJ(7>&p8FM$D~)P9$s&`VNpRtD=#+!?0h4VN((9jkj0{ z232M>(gNhly9LOV(uVAFx5Zus3~kN#4D_q^29O ztOUHC&jRFUD)uFrTAsM}3X3=8{2{S5+i;uDJ1M*%TGO^ysgTL!_(0hbp(<|JxXt;5 zjrN9qSEl?|a)paJ_`jb28U@1{`+IWGrH(jCAqa?C>xO$&5$hOX}F`-qe&=5#l)=`uW0-KfgM2+Q-!Yl=${SyVOb<^O@q^ox@5>ve?j zf>R}iYf|za2Fb^*_KHn>*V#Af6Y{Lzs3Fbk&(hHtJ{^FW;JuQq;B}UZZeyhTp)ZeC zwU{d&ouH~oL7D@k3F7uzoJp6|Oqzog+LHENi9 zf53awt$CeOk;(7twp(&qM+MeLK=!h z^KdPk_Kqz~QqjSEFaqD}}Gi?uOnT4Cc;e#nZlSFml`r9-q3|=FP6*Ay4YOPu7 z4_wUS@r`e!{8*~uo^<`r%RZO&&j&^P$%sT44z=8riqkF0x1atq2<6HfFHW88y#nQr zf3zShcO&elQXq}Bgt;3LWh*dM$c_1J%8#TflDOv_SbnRP#L{eMZ<_`}l$fLgOXF)V zVb{2x@(i&Nive?ho=%~sX9PW+Mo$ZFyO(;pjXota(?2~WzOIKmT!Lz8x`eCSi82sh zbZDBH!A&AQuDg=7{)RO=5pjM$jAVRv-N9oFHhDlp)?zu+Hpur2W%d_sO3)%(>Qr3= z!9#Hzoh6LYe;6k8Su_3I!!c!>S&@6Vl3(1RUX~38JGbnSwvgfnyT6VBhq%oBnfz`X z^@c(q=@pQ)01(fIV>2t#Dkw=o%kLfDo~pm1X8D(g{)s#1ZQ9R)fB{HZ`|mq^`&+FD zTs(DYL?Sq_{X^TouGD^eF;4AY7qs6C+h3{n$HMmarRuMx{UHA}Ekn8*T_++VydkE) zPCZ!3C?2H~Y?^ES*AiL;!3?DQ$J`|R14XE?l^fH3?|f#H3AiuDz}*M+SkYaacvSts zWq;M6#lCC+@feB{rT#|$PF`Z?`neMlu#$Ld^9{>Jd+)PHx0XLX+?%Suux9x!uC=>?;6@s}J{=n#X)rBdvppKL_+N%rQ|0e%?E1HBtX^I6{4ekh z@gd_$B|$S8)KuA^8fA4y<;UEBrccNZZ-ucO_=pxi87@lM=(@(<7c}-pH@pwB27hmh zHy+etw*VyJY48_=%&-%ah(Jo?>;F99Cj73Ag?YTDsC2?BJqkPLG5&K3>Er9(ZUS=t z`5VLXW-tLKXaba{g{2+8C^KeBBlr zlJ!>@W|HxLk{V|HMR&~SsiuaC2M`7A((`BQs)dHk@GEx(Xb4QF=sLqgcw49-p4B?Z zjdqE(ey;%d>O7?>Nbft|t2c6XO%zlqXp$hyFj>$kSj!^1gqvAze(rQI&*K`s%yV|M6gkJzT%0Z4~0~!p-Q76-Z9Idf1gf0%D_j7o;SiJ<{DBO<%ISN~zXNhPPK5$@Vdnt3uvfyc_ds{Muzvt@ z>3$rB&5f19mI1kRZ-!y-g~oPa=K#6>-V5Z~_d1X(?|7&hm+mitT-eMInhf>i=+M6a zay0BIAv8UN(jn9kLT882Ux(1L5LyvJ*M!je5V{HI8k^N`0J&NHK9F-)up4Nnjp<`R zy9^oxdcdG(fPQAsUZ4jJdLHN@gZ2YGY>+6|YTO-^tf{7UH~0q-hRWc>EYb9&seBe8 zAc=SVHEY!C>k$p*`8_(radVyOI5QGi@v0}O(z*$xK#M$b=92hYIZjG-tQ_;#@wKn9 z9RSC+$JdIP4p>3xlMal2EWY+(Koe!5WPVRqcl(6+9W%ywoZQ1bXHHr1Vz#v>hZJjC zV#RU689lP4hbFMTc{kT?UT?T3Gi_pQ#cM`KJC}ttHCNnFvzaQsCY`oq=Tj9GTYJ#u zz>X2p5e!}0Gp)M>w&;%|#id>Rzv)8`Ll$KYYEI)hkWxyNlq(q73v?Gw8mf*&iEe(v zaL=K3a_dP>_t>k2Nx?eIeQ>U!nPfl!4f=$_OXtc-sQDST>}O#w+*Wfdtq|pXJHMp^ z@PY&sx9k-o2$XUDlj&g`QIeT-`A5Chg^3ITw$}deW<>nP!vHAAc$36h&sOZ5xjqUa zeSsycpE+sy8n=EV-kn4vSv#uXof!x8Rcf?}m$x07R!ll{-mr9*u!ysLfZPz0?8KT0VFYn$SKb}lom?AwKqltrsU-2zJ{LwpNK#HQNh<3bXSiCG4~*VFx>w6%A)@cB9pXXt+@?XQJ86>eb11M*14W0-0bD??4;|EMJ)A-5~Uw+2u~KIeaSGq04ju2ZA4op-~&$!y~B zyf)WHsV-b^`?li#T;a2u{nNCBGWCOBIHvxz6%%Nm*V$8x447w1UgX7PaOkrNl@*0W z6~R*~WxOi&r^HVhA43{9iV;;72RCZG@b?im)_gCA0}3R0)tzq*x5LC5Z`4RR6{6CE zM0KgoYnDdZuV$UCr&p2oOAnU;TIBN+ax|*L(l+t+ti0Pq5YmVoq~yn-oBx1^&c*cUVONrtW&Ce zbUCUieM8wwKQu{DRaw^#m&U3p>z&r@;i@WI%ZDZjsw!K-hf8BsRol52@47^nNO1PW zyDs31cZ)w8;a}=M!FD1I6~8Dg85Rt$3`NBgY$z^h%$|Ipq1cqqRqV6wlX zLj3f`1YG3Qz~@C%Ti4$L?@8Q`r)diALz1ftW;Wb zR>!MvK}~dx>L*ihbl>riL+Dxgff`FisxJ!V)$vJK>`{4X&vtI(zuuC42_!1#|7bJa zfvE?R)Q)#=II{`n5A3NrT%gnjmn*tu4pY$GpQ(3P!G<_GiOh|#9&EhqCw~1Rs_R=T zoIrG2>W8&J{@3-*tGp=} z^y5|BKm4ShK90@oB?>7vQ8Ljdvrv>`9v!PSg;#o_3#q!Hdq;hrG4y}<4zsS_Ocu-C zp?dUh=zopMaLLdYgYQuIh!C=n%8k^~IP__fq&i;jh_8{wwn}%~U{(uWz5CT0c0$f? z?vE9|x|uo@dQ9P~!kkhazm2Xq@-Fxxk$sc+sNf^2kMUC<;B##JD_bF=J9|19jTDBf zI{aFD7!TzbJsxW}6JqqSX3<}(;t~I}OHAED&?Px|1ub+#+%<;{Yj$%Ly-AuCoUU{j>R^XJO%%7;h)f;G&%3Ljrpdnd0{7KqrmR2cm=<9!~0?m4A zbqB@mLq%&dzyHmVG{d#jl3*8cpm6r^ZtxxHlVa)m!T5%4kPhxt;4A=32V0+%^Do+r zjH`27Etc9kA5!&3QN=er3`ZO1Y-DHk1@R#!_ zDcn1qqMbfM<)ZCwuG#N^+iC_K;NAlp5jB82AX=Ke)UO-|+EdH1a&}v`bsLh; z`1bAJa$bt=2fj~E!sI^1+!SGOU?1iy1uqzQibUVxlpeV$B5py?J~?%<8-d4tdIOh= zpmFCcrHBWd^P5LN?5LH;gXP&wp5^3(Nv=B*_88AjLgXKA55FJc_Yr=l<4^uX)H+UN zv2}csU*^evC+l}kYx=|0tjP87nOO{pUCd_(zq$J>>C)5uXVJ)kT`jKb`$PkTuLdjR$@4$tFRriY9_lM9kT+ADuD`9WphE3ZlX4rmB1 z)H#+hH=Bc$A&)b3B)^w3o_W%IEH(YkDkg9!j$0LS<36eBmmsfuEd!O{7YRQ#wEh>$ zru+j$ZB_lahcbsK&G@9t?<7t0W8{>tm}b4FlXyxwK19mI(}JesyJ^XZm2)&Ya1xtK`VPMgU%`Z~{Zi-ip@_@h$&TDvr0A$g)p=ey8%@%Z9@Pn;y-Pd)DG+ zKIxsjy)fP+cvPA2B-6B&QXU~+{t0Ea1iw+-Z~1ICFMl}L!mCYQ?pbmt#)y+YF1@HD z?@IZ{R2l(^TdWSIaX%%>CD5}fVVlxF=89GZ5^I=ulSabP{L{_>Ui3tLJWErToEWpA z)u6(tsg$>%CHHFskQb+k=0VHl53^b>66a2wYz~vMLV(Pr9j`~OpQiX0^M#<2T26VJ8+Iq~c= zASa%E04NYS0?A(mg&~65W6)73^9~x60D97(ERa(Z{#pn<7ec9bm16%kgq{wei&6S@ z?YlCBeg^azn}sP5LK=r?WEq>!`Gnep;;xIm7lm9mlDmOi*b&T%6OR6Q2-N|(`Aq`3 z*`EXC=JG5crx<$)&?DBPHlRlhY6p7EAgzJN4O#{CbAvj7o-jxP?Y#y`mG~)x27rEP z(1Sov8zfcTXAF7_=obbJ0zGTcGeAQI+4EOPWE|4XEV-~lv{_wjoLuxO9lFQ!QBHPO zaQdoz$83jlL?lW?EyNIKGY(H`poSWae&$zXZFMOiAaBP&*=9vzN`(<}60crf=eFc| zz3*c)xJmjjkXuBj0l7u=F(9{yW&ycHlw2sM^qtSw@ni_bt4?x(11;1e_gD+Nz{O?f z=@l+Pff1q&oy_){TG0(H62-{bmc%anI%*vW$T1^262evk}e&G=mSV=$a7iR)+`5r>h@$jcWhHNi4z zZ}9wwZCO}=WKB+TEisdX*L)({nO)6ylJ7dc8~IN1-NJXHB;9QUv`Ez57A(d8=gQ~t zl9D{}|1Vwo6HiIJ7Q$LM8kd58+`_0eBpVb-{@e~IqUuPS?y7T`_6zIqymoD|u`LjH z;&{yMp&Xmvjkn=F9 zsAqRUuCL3O4|W|mP&a~C793m(_`jmizyTI6mgE7;Whn5NlRuj=5%-g3g+8!Y@+Ap# z>7JU+!SAL~XBY|)5uN?mm(i6Ad*9FB7fqRA29P_;76Sc?ol*Y_=p~E&=P>r)fo`@~ zy&m<7#Y%(6<$V{>YZmtIFia@hH!O!#B7SSJE5g`yK(|`#Pl4XF*oVT{UjqHB#Y#Ei zVM9%1;JU{kDJ?u@&1bIsQi@Z}E4DLGPia z3d`{UAeUnrkSlLV2we)~?&7O}++ExS;&^#NfzYb%s1^TANCWA-NOnC&VQO2RGpRZ<= zy)rAOwH;(&EM(jSB9b&49kfbpJkaQrjsa%q-6%uxgUZ({{0#D+*SeReZ*m`bEiCHM z?juiv_pF`Cm1F0d;Fatn%97&NN!Yw&=iYui2iei=YEg+LACjk2Sh)|$X(RU^9HX_z z5-m00X@L*Pe

g2Eip} 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Ξ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

IEkgIFpNdHf{`Z>jG$_&hiE#<%`5ZqMWhG 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

v& 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

aE{46`KX3 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%0DcZ+wmu)*@U7u4wdFhVWM=M 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%0A_Y0V#ZGLyJ1{Nz-QqKx?bSn-E^KSD! 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

&_l_m65qt)0W~w%gJQWrwvU7ea=u6^ch3(T$rCj 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⩔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ƒ-^hF{SmZh@V(~o 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 z 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

Xrk6yvA|GkAGKzz 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

A{?@~Z?jJtR6uX(5}=q&u=%iQI%v^J%$QbwRZ5! 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

3koylY; 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
>V9(u7)@cU$~>*f$>l6$nxAyN<*K`r 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

_f)m;2J(Eqq6 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%0D;F&xdznp3bMIf=U0#yW9T(K9x;=(@UD4RQ#st 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½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

DYiZx+h4Qj9~BqBr(q6%6r; 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

l`9_h!9cC9;|O!PV=%E{#AX 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 #endif @@ -199,6 +200,7 @@ Vector3 NearestPointOnLine(Vector3 p1, float numer,denom; const float EPS = 0.001; + Vector3 zeroV; p13.x = p1.x - p3.x; p13.y = p1.y - p3.y; @@ -207,12 +209,12 @@ Vector3 NearestPointOnLine(Vector3 p1, p43.y = p4.y - p3.y; p43.z = p4.z - p3.z; if (fabs(p43.x) < EPS && fabs(p43.y) < EPS && fabs(p43.z) < EPS) - return(Vector3){}; + return zeroV; p21.x = p2.x - p1.x; p21.y = p2.y - p1.y; p21.z = p2.z - p1.z; if (fabs(p21.x) < EPS && fabs(p21.y) < EPS && fabs(p21.z) < EPS) - return(Vector3){}; + return zeroV; d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z; d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z; @@ -222,7 +224,7 @@ Vector3 NearestPointOnLine(Vector3 p1, denom = d2121 * d4343 - d4321 * d4321; if (fabs(denom) < EPS) - return (Vector3){}; + return zeroV; numer = d1343 * d4321 - d1321 * d4343; mua = numer / denom; @@ -278,7 +280,7 @@ int GuiFloatValueBox(Rectangle bounds, const char *text, float *value, float min // Update control //-------------------------------------------------------------------- - if ((state != STATE_DISABLED) && !guiLocked && !guiSliderDragging) + if ((state != STATE_DISABLED) && !guiLocked) { Vector2 mousePoint = GetMousePosition(); @@ -586,12 +588,28 @@ void add_shape(void) { needs_rebuild = true; } + + +#ifdef _MSC_VER +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) + +void append_format(char** data, int* size, int* capacity, _Printf_format_string_ const char* format, ...) { + + va_list arg_ptr; + va_start(arg_ptr, format); + int added = vsnprintf(*data + *size, *capacity - *size, format, arg_ptr); + + *size += MIN(added, *capacity - *size); + assert(*size < *capacity); + + va_end(arg_ptr); +} +#else #define MIN(x,y) ({ \ __typeof(x) xv = (x);\ __typeof(y) yv = (y); \ xv < yv ? xv : yv;\ }) - __attribute__((format(printf, 4, 5))) void append_format(char **data, int *size, int *capacity, const char *format, ...) { @@ -604,7 +622,7 @@ void append_format(char **data, int *size, int *capacity, const char *format, .. va_end(arg_ptr); } - +#endif Vector3 VertexInterp(Vector4 p1,Vector4 p2, float threshold) { if (fabsf(threshold-p1.w) < 0.00001) @@ -1245,10 +1263,12 @@ int main(void){ SetTargetFPS(60); # ifndef PLATFORM_WEB +# ifndef _MSC_VER void swizzleWindow(void); swizzleWindow(); void makeWindowKey(void); makeWindowKey(); +# endif # endif const int gamepad = 0; @@ -1494,7 +1514,7 @@ int main(void){ #endif UpdateCameraPro(&camera, (Vector3){0, -delta.x/10, 0}, Vector3Zero(), 0); } - } else if (IsMouseButtonDown(MOUSE_LEFT_BUTTON) && !guiSliderDragging && mouseAction == CONTROL_NONE && Vector2Distance(mouseDownPosition, GetMousePosition()) > 1) { + } else if (IsMouseButtonDown(MOUSE_LEFT_BUTTON) && mouseAction == CONTROL_NONE && Vector2Distance(mouseDownPosition, GetMousePosition()) > 1) { mouseAction = CONTROL_ROTATE_CAMERA; } @@ -1512,12 +1532,15 @@ int main(void){ } } - #ifndef PLATFORM_WEB + + #ifndef PLATFORM_WEB +#ifndef _MSC_VER extern float magnification; if (mouseAction == CONTROL_NONE ) { CameraMoveForward(&camera, 8*magnification, false); } magnification = 0; +#endif #endif } @@ -1892,7 +1915,7 @@ int main(void){ BeginScissorMode((int)view_area.x, (int)view_area.y, (int)view_area.width, (int)view_area.height); { const int first_visible = (int)floorf(-scroll_offset.y / row_height); const int last_visible = first_visible + (int)ceilf(view_area.height / row_height); - for (int i=first_visible; i < MIN(last_visible+1,num_spheres); i++) { + for (int i=first_visible; i < __min(last_visible+1,num_spheres); i++) { Sphere *s = &spheres[i]; const char *text = TextFormat("%c Shape %i", s->subtract ? '-' : '+', i+1); diff --git a/src/shaders.h b/src/shaders.h new file mode 100644 index 0000000..686ce50 --- /dev/null +++ b/src/shaders.h @@ -0,0 +1,768 @@ +unsigned char shader_base_fs[] = { + 0x76, 0x65, 0x63, 0x34, 0x20, 0x63, 0x61, 0x73, 0x74, 0x52, 0x61, 0x79, + 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x72, 0x6f, + 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x72, 0x64, + 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, + 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x74, 0x6d, 0x69, 0x6e, 0x20, 0x3d, 0x20, + 0x30, 0x2e, 0x31, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, + 0x6f, 0x61, 0x74, 0x20, 0x74, 0x6d, 0x61, 0x78, 0x20, 0x3d, 0x20, 0x33, + 0x30, 0x30, 0x2e, 0x30, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x74, 0x20, 0x3d, 0x20, 0x74, + 0x6d, 0x69, 0x6e, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, + 0x63, 0x33, 0x20, 0x6d, 0x20, 0x3d, 0x20, 0x76, 0x65, 0x63, 0x33, 0x28, + 0x2d, 0x31, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, + 0x72, 0x28, 0x20, 0x69, 0x6e, 0x74, 0x20, 0x69, 0x3d, 0x30, 0x3b, 0x20, + 0x69, 0x3c, 0x36, 0x34, 0x3b, 0x20, 0x69, 0x2b, 0x2b, 0x20, 0x29, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x70, 0x72, + 0x65, 0x63, 0x69, 0x73, 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x30, 0x30, 0x30, + 0x31, 0x2a, 0x74, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, + 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x20, + 0x72, 0x6f, 0x2b, 0x72, 0x64, 0x2a, 0x74, 0x20, 0x29, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x28, 0x20, + 0x72, 0x65, 0x73, 0x2e, 0x78, 0x3c, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, + 0x20, 0x7c, 0x7c, 0x20, 0x74, 0x3e, 0x74, 0x6d, 0x61, 0x78, 0x20, 0x29, + 0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x74, 0x20, 0x2b, 0x3d, 0x20, 0x72, 0x65, + 0x73, 0x2e, 0x78, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x6d, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x2e, 0x67, 0x62, + 0x61, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0d, 0x0a, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x28, 0x20, 0x74, 0x3e, 0x74, + 0x6d, 0x61, 0x78, 0x20, 0x29, 0x20, 0x6d, 0x3d, 0x76, 0x65, 0x63, 0x33, + 0x28, 0x2d, 0x31, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x20, + 0x74, 0x2c, 0x20, 0x6d, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, + 0x0d, 0x0a, 0x0d, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x63, 0x61, + 0x6c, 0x63, 0x53, 0x6f, 0x66, 0x74, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, + 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x72, 0x6f, + 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x72, 0x64, + 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x6d, + 0x69, 0x6e, 0x74, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x66, 0x6c, 0x6f, 0x61, + 0x74, 0x20, 0x74, 0x6d, 0x61, 0x78, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x72, + 0x65, 0x73, 0x20, 0x3d, 0x20, 0x31, 0x2e, 0x30, 0x3b, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x74, 0x20, 0x3d, + 0x20, 0x6d, 0x69, 0x6e, 0x74, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x66, 0x6f, 0x72, 0x28, 0x20, 0x69, 0x6e, 0x74, 0x20, 0x69, 0x3d, 0x30, + 0x3b, 0x20, 0x69, 0x3c, 0x31, 0x36, 0x3b, 0x20, 0x69, 0x2b, 0x2b, 0x20, + 0x29, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, + 0x68, 0x20, 0x3d, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, + 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x28, 0x20, 0x72, 0x6f, 0x20, 0x2b, 0x20, 0x72, 0x64, 0x2a, 0x74, + 0x20, 0x29, 0x2e, 0x78, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x6d, 0x69, 0x6e, + 0x28, 0x20, 0x72, 0x65, 0x73, 0x2c, 0x20, 0x38, 0x2e, 0x30, 0x2a, 0x68, + 0x2f, 0x74, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x74, 0x20, 0x2b, 0x3d, 0x20, 0x63, 0x6c, 0x61, 0x6d, + 0x70, 0x28, 0x20, 0x68, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x32, 0x2c, 0x20, + 0x30, 0x2e, 0x31, 0x30, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x28, 0x20, 0x68, 0x3c, 0x30, + 0x2e, 0x30, 0x30, 0x31, 0x20, 0x7c, 0x7c, 0x20, 0x74, 0x3e, 0x74, 0x6d, + 0x61, 0x78, 0x20, 0x29, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6c, 0x61, 0x6d, 0x70, + 0x28, 0x20, 0x72, 0x65, 0x73, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20, + 0x31, 0x2e, 0x30, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, + 0x0a, 0x76, 0x65, 0x63, 0x33, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x4e, 0x6f, + 0x72, 0x6d, 0x61, 0x6c, 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x70, 0x6f, 0x73, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x65, 0x20, 0x3d, + 0x20, 0x76, 0x65, 0x63, 0x32, 0x28, 0x31, 0x2e, 0x30, 0x2c, 0x2d, 0x31, + 0x2e, 0x30, 0x29, 0x2a, 0x30, 0x2e, 0x35, 0x37, 0x37, 0x33, 0x2a, 0x30, + 0x2e, 0x30, 0x30, 0x30, 0x35, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, + 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x20, 0x65, 0x2e, 0x78, 0x79, 0x79, 0x2a, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, + 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x20, 0x70, + 0x6f, 0x73, 0x20, 0x2b, 0x20, 0x65, 0x2e, 0x78, 0x79, 0x79, 0x20, 0x29, + 0x2e, 0x78, 0x20, 0x2b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x65, 0x2e, 0x79, 0x79, 0x78, 0x2a, 0x73, 0x69, + 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, + 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x20, 0x70, 0x6f, 0x73, + 0x20, 0x2b, 0x20, 0x65, 0x2e, 0x79, 0x79, 0x78, 0x20, 0x29, 0x2e, 0x78, + 0x20, 0x2b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x65, 0x2e, 0x79, 0x78, 0x79, 0x2a, 0x73, 0x69, 0x67, 0x6e, + 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x20, 0x70, 0x6f, 0x73, 0x20, 0x2b, + 0x20, 0x65, 0x2e, 0x79, 0x78, 0x79, 0x20, 0x29, 0x2e, 0x78, 0x20, 0x2b, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x65, 0x2e, 0x78, 0x78, 0x78, 0x2a, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, + 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x28, 0x20, 0x70, 0x6f, 0x73, 0x20, 0x2b, 0x20, 0x65, + 0x2e, 0x78, 0x78, 0x78, 0x20, 0x29, 0x2e, 0x78, 0x20, 0x29, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2a, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x65, 0x70, 0x73, 0x20, 0x3d, 0x20, + 0x76, 0x65, 0x63, 0x33, 0x28, 0x20, 0x30, 0x2e, 0x30, 0x30, 0x30, 0x35, + 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x20, 0x29, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, + 0x6e, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x76, 0x65, 0x63, 0x33, 0x28, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, + 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x70, 0x6f, 0x73, 0x2b, 0x65, + 0x70, 0x73, 0x2e, 0x78, 0x79, 0x79, 0x29, 0x2e, 0x78, 0x20, 0x2d, 0x20, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, + 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x70, 0x6f, + 0x73, 0x2d, 0x65, 0x70, 0x73, 0x2e, 0x78, 0x79, 0x79, 0x29, 0x2e, 0x78, + 0x2c, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, + 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x70, 0x6f, 0x73, + 0x2b, 0x65, 0x70, 0x73, 0x2e, 0x79, 0x78, 0x79, 0x29, 0x2e, 0x78, 0x20, + 0x2d, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, + 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, + 0x70, 0x6f, 0x73, 0x2d, 0x65, 0x70, 0x73, 0x2e, 0x79, 0x78, 0x79, 0x29, + 0x2e, 0x78, 0x2c, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, + 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x70, + 0x6f, 0x73, 0x2b, 0x65, 0x70, 0x73, 0x2e, 0x79, 0x79, 0x78, 0x29, 0x2e, + 0x78, 0x20, 0x2d, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, + 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x28, 0x70, 0x6f, 0x73, 0x2d, 0x65, 0x70, 0x73, 0x2e, 0x79, 0x79, + 0x78, 0x29, 0x2e, 0x78, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x6f, 0x72, 0x6d, + 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x6e, 0x6f, 0x72, 0x29, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2a, 0x2f, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, + 0x0d, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6c, 0x63, + 0x41, 0x4f, 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, + 0x70, 0x6f, 0x73, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, + 0x20, 0x6e, 0x6f, 0x72, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x6f, 0x63, 0x63, + 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x30, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x63, 0x61, 0x20, 0x3d, + 0x20, 0x31, 0x2e, 0x30, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, + 0x6f, 0x72, 0x28, 0x20, 0x69, 0x6e, 0x74, 0x20, 0x69, 0x3d, 0x30, 0x3b, + 0x20, 0x69, 0x3c, 0x35, 0x3b, 0x20, 0x69, 0x2b, 0x2b, 0x20, 0x29, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x68, 0x72, + 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x30, 0x31, 0x20, 0x2b, 0x20, 0x30, 0x2e, + 0x31, 0x32, 0x2a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x28, 0x69, 0x29, 0x2f, + 0x34, 0x2e, 0x30, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x61, 0x6f, 0x70, 0x6f, 0x73, + 0x20, 0x3d, 0x20, 0x20, 0x6e, 0x6f, 0x72, 0x20, 0x2a, 0x20, 0x68, 0x72, + 0x20, 0x2b, 0x20, 0x70, 0x6f, 0x73, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x64, + 0x64, 0x20, 0x3d, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, + 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x28, 0x20, 0x61, 0x6f, 0x70, 0x6f, 0x73, 0x20, 0x29, 0x2e, 0x78, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6f, + 0x63, 0x63, 0x20, 0x2b, 0x3d, 0x20, 0x2d, 0x28, 0x64, 0x64, 0x2d, 0x68, + 0x72, 0x29, 0x2a, 0x73, 0x63, 0x61, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x63, 0x61, 0x20, 0x2a, 0x3d, 0x20, + 0x30, 0x2e, 0x39, 0x35, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, + 0x20, 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x28, 0x20, 0x31, 0x2e, 0x30, 0x20, + 0x2d, 0x20, 0x33, 0x2e, 0x30, 0x2a, 0x6f, 0x63, 0x63, 0x2c, 0x20, 0x30, + 0x2e, 0x30, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x20, 0x29, 0x3b, 0x0d, 0x0a, + 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x33, 0x20, 0x72, 0x65, + 0x6e, 0x64, 0x65, 0x72, 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x72, 0x6f, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x72, 0x64, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x63, 0x6f, 0x6c, 0x6f, + 0x72, 0x20, 0x3d, 0x0d, 0x0a, 0x23, 0x69, 0x66, 0x64, 0x65, 0x66, 0x20, + 0x46, 0x41, 0x4c, 0x53, 0x45, 0x5f, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x5f, + 0x4d, 0x4f, 0x44, 0x45, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, + 0x63, 0x33, 0x28, 0x30, 0x2e, 0x29, 0x3b, 0x0d, 0x0a, 0x23, 0x65, 0x6c, + 0x73, 0x65, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, + 0x28, 0x30, 0x2e, 0x34, 0x2c, 0x20, 0x30, 0x2e, 0x35, 0x2c, 0x20, 0x30, + 0x2e, 0x36, 0x29, 0x20, 0x2b, 0x72, 0x64, 0x2e, 0x79, 0x2a, 0x30, 0x2e, + 0x34, 0x3b, 0x0d, 0x0a, 0x23, 0x65, 0x6e, 0x64, 0x69, 0x66, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x72, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x63, 0x61, 0x73, 0x74, 0x52, 0x61, + 0x79, 0x28, 0x72, 0x6f, 0x2c, 0x72, 0x64, 0x29, 0x3b, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x74, 0x20, 0x3d, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x78, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x6d, 0x20, 0x3d, + 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x79, 0x7a, 0x77, 0x3b, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x28, 0x20, 0x6d, 0x2e, + 0x72, 0x3e, 0x2d, 0x30, 0x2e, 0x35, 0x20, 0x29, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x70, 0x6f, 0x73, 0x20, 0x3d, 0x20, + 0x72, 0x6f, 0x20, 0x2b, 0x20, 0x74, 0x2a, 0x72, 0x64, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, + 0x20, 0x6e, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x4e, + 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x28, 0x20, 0x70, 0x6f, 0x73, 0x20, 0x29, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, + 0x2f, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x72, 0x65, 0x66, 0x20, 0x3d, + 0x20, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x20, 0x72, 0x64, + 0x2c, 0x20, 0x6e, 0x6f, 0x72, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x6d, + 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, + 0x20, 0x6d, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x23, 0x69, 0x66, 0x6e, 0x64, 0x65, 0x66, 0x20, 0x46, + 0x41, 0x4c, 0x53, 0x45, 0x5f, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x5f, 0x4d, + 0x4f, 0x44, 0x45, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x69, + 0x6e, 0x67, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x2f, 0x2f, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x6f, 0x63, 0x63, + 0x20, 0x3d, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x41, 0x4f, 0x28, 0x20, 0x70, + 0x6f, 0x73, 0x2c, 0x20, 0x6e, 0x6f, 0x72, 0x20, 0x29, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, + 0x20, 0x20, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x69, 0x72, 0x20, + 0x3d, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x28, + 0x20, 0x76, 0x65, 0x63, 0x33, 0x28, 0x63, 0x6f, 0x73, 0x28, 0x2d, 0x30, + 0x2e, 0x34, 0x29, 0x2c, 0x20, 0x73, 0x69, 0x6e, 0x28, 0x30, 0x2e, 0x37, + 0x29, 0x2c, 0x20, 0x2d, 0x30, 0x2e, 0x36, 0x29, 0x20, 0x29, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x20, 0x68, 0x61, 0x6c, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x72, + 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x20, 0x6c, 0x69, 0x67, 0x68, + 0x74, 0x5f, 0x64, 0x69, 0x72, 0x2d, 0x72, 0x64, 0x20, 0x29, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, + 0x61, 0x74, 0x20, 0x61, 0x6d, 0x62, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x3d, + 0x20, 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x28, 0x20, 0x30, 0x2e, 0x35, 0x2b, + 0x30, 0x2e, 0x35, 0x2a, 0x6e, 0x6f, 0x72, 0x2e, 0x79, 0x2c, 0x20, 0x30, + 0x2e, 0x30, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x20, 0x29, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, + 0x74, 0x20, 0x64, 0x69, 0x66, 0x66, 0x75, 0x73, 0x65, 0x20, 0x3d, 0x20, + 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x28, 0x20, 0x64, 0x6f, 0x74, 0x28, 0x20, + 0x6e, 0x6f, 0x72, 0x2c, 0x20, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, + 0x69, 0x72, 0x20, 0x29, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20, 0x31, + 0x2e, 0x30, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x62, 0x61, 0x63, + 0x6b, 0x5f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x20, 0x3d, 0x20, 0x63, 0x6c, + 0x61, 0x6d, 0x70, 0x28, 0x20, 0x64, 0x6f, 0x74, 0x28, 0x20, 0x6e, 0x6f, + 0x72, 0x2c, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x28, 0x76, 0x65, 0x63, 0x33, 0x28, 0x2d, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x5f, 0x64, 0x69, 0x72, 0x2e, 0x78, 0x2c, 0x30, 0x2e, 0x30, 0x2c, 0x2d, + 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x69, 0x72, 0x2e, 0x7a, 0x29, + 0x29, 0x29, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20, 0x31, 0x2e, 0x30, + 0x20, 0x29, 0x2a, 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x28, 0x20, 0x31, 0x2e, + 0x30, 0x2d, 0x70, 0x6f, 0x73, 0x2e, 0x79, 0x2c, 0x30, 0x2e, 0x30, 0x2c, + 0x31, 0x2e, 0x30, 0x29, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x54, 0x4f, 0x44, 0x4f, + 0x3a, 0x20, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x20, + 0x6f, 0x6e, 0x20, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x73, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x64, 0x69, 0x66, 0x66, + 0x75, 0x73, 0x65, 0x20, 0x2a, 0x3d, 0x20, 0x63, 0x61, 0x6c, 0x63, 0x53, + 0x6f, 0x66, 0x74, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x28, 0x20, 0x70, + 0x6f, 0x73, 0x2c, 0x20, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x69, + 0x72, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x32, 0x2c, 0x20, 0x32, 0x2e, 0x35, + 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x70, 0x65, + 0x20, 0x3d, 0x20, 0x70, 0x6f, 0x77, 0x28, 0x20, 0x63, 0x6c, 0x61, 0x6d, + 0x70, 0x28, 0x20, 0x64, 0x6f, 0x74, 0x28, 0x20, 0x6e, 0x6f, 0x72, 0x2c, + 0x20, 0x68, 0x61, 0x6c, 0x20, 0x29, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, + 0x20, 0x31, 0x2e, 0x30, 0x20, 0x29, 0x2c, 0x31, 0x36, 0x2e, 0x30, 0x29, + 0x2a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x64, + 0x69, 0x66, 0x66, 0x75, 0x73, 0x65, 0x20, 0x2a, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x28, 0x30, 0x2e, 0x30, 0x34, 0x20, + 0x2b, 0x20, 0x30, 0x2e, 0x39, 0x36, 0x2a, 0x70, 0x6f, 0x77, 0x28, 0x20, + 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x28, 0x31, 0x2e, 0x30, 0x2b, 0x64, 0x6f, + 0x74, 0x28, 0x68, 0x61, 0x6c, 0x2c, 0x72, 0x64, 0x29, 0x2c, 0x30, 0x2e, + 0x30, 0x2c, 0x31, 0x2e, 0x30, 0x29, 0x2c, 0x20, 0x35, 0x2e, 0x30, 0x20, + 0x29, 0x29, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x6c, 0x69, 0x6e, 0x20, + 0x3d, 0x20, 0x76, 0x65, 0x63, 0x33, 0x28, 0x30, 0x2e, 0x30, 0x29, 0x3b, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x69, + 0x6e, 0x20, 0x2b, 0x3d, 0x20, 0x31, 0x2e, 0x33, 0x30, 0x2a, 0x64, 0x69, + 0x66, 0x66, 0x75, 0x73, 0x65, 0x2a, 0x76, 0x65, 0x63, 0x33, 0x28, 0x31, + 0x2e, 0x30, 0x30, 0x2c, 0x30, 0x2e, 0x38, 0x30, 0x2c, 0x30, 0x2e, 0x35, + 0x35, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x6c, 0x69, 0x6e, 0x20, 0x2b, 0x3d, 0x20, 0x30, 0x2e, 0x34, 0x30, + 0x2a, 0x61, 0x6d, 0x62, 0x69, 0x65, 0x6e, 0x74, 0x2a, 0x76, 0x65, 0x63, + 0x33, 0x28, 0x30, 0x2e, 0x34, 0x30, 0x2c, 0x30, 0x2e, 0x36, 0x30, 0x2c, + 0x31, 0x2e, 0x30, 0x30, 0x29, 0x3b, 0x2f, 0x2f, 0x2a, 0x6f, 0x63, 0x63, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, + 0x69, 0x6e, 0x20, 0x2b, 0x3d, 0x20, 0x30, 0x2e, 0x35, 0x30, 0x2a, 0x62, + 0x61, 0x63, 0x6b, 0x5f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2a, 0x76, 0x65, + 0x63, 0x33, 0x28, 0x30, 0x2e, 0x32, 0x35, 0x2c, 0x30, 0x2e, 0x32, 0x35, + 0x2c, 0x30, 0x2e, 0x32, 0x35, 0x29, 0x3b, 0x2f, 0x2f, 0x2a, 0x6f, 0x63, + 0x63, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x6c, 0x6f, + 0x72, 0x2a, 0x6c, 0x69, 0x6e, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x2b, 0x3d, + 0x20, 0x31, 0x30, 0x2e, 0x30, 0x30, 0x2a, 0x73, 0x70, 0x65, 0x2a, 0x76, + 0x65, 0x63, 0x33, 0x28, 0x31, 0x2e, 0x30, 0x30, 0x2c, 0x30, 0x2e, 0x39, + 0x30, 0x2c, 0x30, 0x2e, 0x37, 0x30, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x23, 0x65, 0x6e, 0x64, 0x69, 0x66, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x65, + 0x63, 0x33, 0x28, 0x20, 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x28, 0x63, 0x6f, + 0x6c, 0x6f, 0x72, 0x2c, 0x30, 0x2e, 0x30, 0x2c, 0x31, 0x2e, 0x30, 0x29, + 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x6d, 0x61, + 0x74, 0x33, 0x20, 0x73, 0x65, 0x74, 0x43, 0x61, 0x6d, 0x65, 0x72, 0x61, + 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x72, 0x6f, + 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x74, 0x61, + 0x2c, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x63, 0x72, 0x20, 0x29, + 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x63, 0x77, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, + 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x74, 0x61, 0x2d, 0x72, 0x6f, 0x29, 0x3b, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x63, + 0x70, 0x20, 0x3d, 0x20, 0x76, 0x65, 0x63, 0x33, 0x28, 0x73, 0x69, 0x6e, + 0x28, 0x63, 0x72, 0x29, 0x2c, 0x20, 0x63, 0x6f, 0x73, 0x28, 0x63, 0x72, + 0x29, 0x2c, 0x30, 0x2e, 0x30, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x63, 0x75, 0x20, 0x3d, 0x20, 0x6e, + 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x20, 0x63, 0x72, + 0x6f, 0x73, 0x73, 0x28, 0x63, 0x77, 0x2c, 0x63, 0x70, 0x29, 0x20, 0x29, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, + 0x63, 0x76, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x28, 0x20, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x28, 0x63, 0x75, + 0x2c, 0x63, 0x77, 0x29, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6d, 0x61, 0x74, 0x33, + 0x28, 0x20, 0x63, 0x75, 0x2c, 0x20, 0x63, 0x76, 0x2c, 0x20, 0x63, 0x77, + 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x2f, 0x2f, + 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x78, 0x79, 0x7a, 0x20, 0x6d, + 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, + 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x0d, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, + 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x73, + 0x65, 0x63, 0x74, 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, + 0x20, 0x72, 0x6f, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x33, + 0x20, 0x72, 0x64, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x34, + 0x20, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x20, 0x29, 0x20, 0x20, 0x7b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, + 0x2d, 0x28, 0x64, 0x6f, 0x74, 0x28, 0x72, 0x6f, 0x2c, 0x70, 0x6c, 0x61, + 0x6e, 0x65, 0x2e, 0x78, 0x79, 0x7a, 0x29, 0x2b, 0x70, 0x6c, 0x61, 0x6e, + 0x65, 0x2e, 0x77, 0x29, 0x2f, 0x64, 0x6f, 0x74, 0x28, 0x72, 0x64, 0x2c, + 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x2e, 0x78, 0x79, 0x7a, 0x29, 0x3b, 0x0d, + 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x6f, 0x69, 0x64, 0x20, 0x6d, + 0x61, 0x69, 0x6e, 0x28, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x74, 0x6f, 0x74, 0x20, 0x3d, + 0x20, 0x76, 0x65, 0x63, 0x33, 0x28, 0x30, 0x2e, 0x30, 0x29, 0x3b, 0x0d, + 0x0a, 0x2f, 0x2f, 0x20, 0x54, 0x4f, 0x44, 0x4f, 0x3a, 0x20, 0x20, 0x74, + 0x75, 0x72, 0x6e, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x20, 0x6f, 0x6e, 0x20, + 0x41, 0x41, 0x0d, 0x0a, 0x23, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, + 0x41, 0x41, 0x20, 0x31, 0x0d, 0x0a, 0x23, 0x69, 0x66, 0x20, 0x41, 0x41, + 0x3e, 0x31, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x28, + 0x20, 0x69, 0x6e, 0x74, 0x20, 0x6d, 0x3d, 0x30, 0x3b, 0x20, 0x6d, 0x3c, + 0x41, 0x41, 0x3b, 0x20, 0x6d, 0x2b, 0x2b, 0x20, 0x29, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x28, 0x20, 0x69, 0x6e, 0x74, 0x20, + 0x6e, 0x3d, 0x30, 0x3b, 0x20, 0x6e, 0x3c, 0x41, 0x41, 0x3b, 0x20, 0x6e, + 0x2b, 0x2b, 0x20, 0x29, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, + 0x70, 0x69, 0x78, 0x65, 0x6c, 0x20, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x69, + 0x6e, 0x61, 0x74, 0x65, 0x73, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x6f, 0x20, 0x3d, 0x20, + 0x76, 0x65, 0x63, 0x32, 0x28, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x28, 0x6d, + 0x29, 0x2c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x28, 0x6e, 0x29, 0x29, 0x20, + 0x2f, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x28, 0x41, 0x41, 0x29, 0x20, + 0x2d, 0x20, 0x30, 0x2e, 0x35, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x70, 0x20, 0x3d, + 0x20, 0x28, 0x2d, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x78, 0x79, 0x20, 0x2b, 0x20, 0x32, 0x2e, 0x30, 0x2a, 0x28, + 0x67, 0x6c, 0x5f, 0x46, 0x72, 0x61, 0x67, 0x43, 0x6f, 0x6f, 0x72, 0x64, + 0x2e, 0x78, 0x79, 0x2b, 0x6f, 0x29, 0x29, 0x2f, 0x72, 0x65, 0x73, 0x6f, + 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x79, 0x3b, 0x0d, 0x0a, 0x23, + 0x65, 0x6c, 0x73, 0x65, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x70, 0x20, 0x3d, 0x20, 0x28, + 0x2d, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x78, 0x79, 0x20, 0x2b, 0x20, 0x32, 0x2e, 0x30, 0x2a, 0x67, 0x6c, 0x5f, + 0x46, 0x72, 0x61, 0x67, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x78, 0x79, + 0x29, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x79, 0x3b, 0x0d, 0x0a, 0x23, 0x65, 0x6e, 0x64, 0x69, 0x66, 0x0d, + 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, + 0x65, 0x63, 0x33, 0x20, 0x72, 0x6f, 0x20, 0x3d, 0x20, 0x76, 0x69, 0x65, + 0x77, 0x45, 0x79, 0x65, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x74, 0x61, 0x20, 0x3d, + 0x20, 0x76, 0x69, 0x65, 0x77, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3b, + 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x6d, 0x61, 0x74, 0x33, 0x20, 0x63, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x5f, + 0x74, 0x6f, 0x5f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x3d, 0x20, 0x73, + 0x65, 0x74, 0x43, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x28, 0x20, 0x72, 0x6f, + 0x2c, 0x20, 0x74, 0x61, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x20, 0x29, 0x3b, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, + 0x63, 0x33, 0x20, 0x72, 0x61, 0x79, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x63, 0x61, 0x6d, 0x65, 0x72, + 0x61, 0x5f, 0x74, 0x6f, 0x5f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x2a, + 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x20, + 0x76, 0x65, 0x63, 0x33, 0x28, 0x70, 0x2e, 0x78, 0x79, 0x2c, 0x32, 0x2e, + 0x30, 0x29, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x63, 0x6f, + 0x6c, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x28, 0x20, + 0x72, 0x6f, 0x2c, 0x20, 0x72, 0x61, 0x79, 0x5f, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6c, 0x20, + 0x3d, 0x20, 0x70, 0x6f, 0x77, 0x28, 0x20, 0x63, 0x6f, 0x6c, 0x2c, 0x20, + 0x76, 0x65, 0x63, 0x33, 0x28, 0x30, 0x2e, 0x34, 0x35, 0x34, 0x35, 0x29, + 0x20, 0x29, 0x3b, 0x20, 0x2f, 0x2f, 0x20, 0x67, 0x61, 0x6d, 0x6d, 0x61, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, + 0x76, 0x69, 0x73, 0x75, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x20, 0x3e, + 0x20, 0x30, 0x2e, 0x29, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, + 0x74, 0x20, 0x64, 0x69, 0x73, 0x74, 0x20, 0x3d, 0x20, 0x70, 0x6c, 0x61, + 0x6e, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x65, 0x63, 0x74, 0x28, + 0x72, 0x6f, 0x2c, 0x20, 0x72, 0x61, 0x79, 0x5f, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, + 0x30, 0x2c, 0x30, 0x2c, 0x31, 0x2e, 0x2c, 0x30, 0x29, 0x29, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x69, 0x66, 0x20, 0x28, 0x64, 0x69, 0x73, 0x74, 0x20, 0x3e, 0x20, + 0x30, 0x2e, 0x29, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, + 0x65, 0x63, 0x33, 0x20, 0x74, 0x20, 0x3d, 0x20, 0x72, 0x6f, 0x20, 0x2b, + 0x20, 0x64, 0x69, 0x73, 0x74, 0x2a, 0x72, 0x61, 0x79, 0x5f, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x64, 0x66, 0x5f, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3d, 0x20, 0x73, 0x69, 0x67, 0x6e, + 0x65, 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x74, 0x29, 0x2e, 0x78, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, + 0x28, 0x73, 0x64, 0x66, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3c, + 0x20, 0x30, 0x2e, 0x20, 0x3f, 0x20, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x34, + 0x28, 0x31, 0x2e, 0x2c, 0x30, 0x2e, 0x2c, 0x30, 0x2e, 0x2c, 0x20, 0x73, + 0x69, 0x6e, 0x28, 0x73, 0x64, 0x66, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x2a, 0x38, 0x2e, 0x2b, 0x72, 0x75, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x2a, + 0x32, 0x2e, 0x29, 0x2f, 0x34, 0x2e, 0x20, 0x2b, 0x20, 0x30, 0x2e, 0x32, + 0x35, 0x29, 0x3a, 0x20, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x30, + 0x2e, 0x31, 0x35, 0x2c, 0x20, 0x30, 0x2e, 0x31, 0x35, 0x2c, 0x30, 0x2e, + 0x38, 0x2c, 0x73, 0x69, 0x6e, 0x28, 0x73, 0x64, 0x66, 0x5f, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x2a, 0x38, 0x2e, 0x2d, 0x72, 0x75, 0x6e, 0x54, 0x69, + 0x6d, 0x65, 0x2a, 0x32, 0x2e, 0x29, 0x2f, 0x34, 0x2e, 0x20, 0x2b, 0x20, + 0x30, 0x2e, 0x32, 0x35, 0x20, 0x29, 0x29, 0x20, 0x3b, 0x0d, 0x0a, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6c, 0x20, 0x3d, 0x20, 0x6d, + 0x69, 0x78, 0x28, 0x63, 0x6f, 0x6c, 0x2c, 0x20, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x2e, 0x72, 0x67, 0x62, 0x2c, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, + 0x2e, 0x61, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x74, 0x6f, 0x74, 0x20, 0x2b, 0x3d, + 0x20, 0x63, 0x6f, 0x6c, 0x3b, 0x0d, 0x0a, 0x23, 0x69, 0x66, 0x20, 0x41, + 0x41, 0x3e, 0x31, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x74, 0x6f, 0x74, 0x20, 0x2f, 0x3d, 0x20, 0x66, + 0x6c, 0x6f, 0x61, 0x74, 0x28, 0x41, 0x41, 0x2a, 0x41, 0x41, 0x29, 0x3b, + 0x0d, 0x0a, 0x23, 0x65, 0x6e, 0x64, 0x69, 0x66, 0x0d, 0x0a, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6c, + 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x20, 0x74, + 0x6f, 0x74, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x20, 0x29, 0x3b, 0x0d, 0x0a, + 0x7d, 0x0d, 0x0a, 0x00 +}; +unsigned int shader_base_fs_len = 5308; +unsigned char shader_prefix_fs[] = { + 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x64, 0x52, 0x6f, 0x75, 0x6e, + 0x64, 0x42, 0x6f, 0x78, 0x28, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x70, + 0x2c, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x62, 0x2c, 0x20, 0x66, 0x6c, + 0x6f, 0x61, 0x74, 0x20, 0x72, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, + 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x71, 0x20, 0x3d, 0x20, 0x61, + 0x62, 0x73, 0x28, 0x70, 0x29, 0x20, 0x2d, 0x20, 0x62, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6c, 0x65, 0x6e, + 0x67, 0x74, 0x68, 0x28, 0x6d, 0x61, 0x78, 0x28, 0x71, 0x2c, 0x30, 0x2e, + 0x30, 0x29, 0x29, 0x20, 0x2b, 0x20, 0x6d, 0x69, 0x6e, 0x28, 0x6d, 0x61, + 0x78, 0x28, 0x71, 0x2e, 0x78, 0x2c, 0x6d, 0x61, 0x78, 0x28, 0x71, 0x2e, + 0x79, 0x2c, 0x71, 0x2e, 0x7a, 0x29, 0x29, 0x2c, 0x30, 0x2e, 0x30, 0x29, + 0x20, 0x2d, 0x20, 0x72, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, + 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x52, 0x6f, 0x75, 0x6e, 0x64, 0x42, + 0x6f, 0x78, 0x28, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x70, 0x2c, 0x20, + 0x76, 0x65, 0x63, 0x33, 0x20, 0x62, 0x2c, 0x20, 0x66, 0x6c, 0x6f, 0x61, + 0x74, 0x20, 0x72, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, + 0x76, 0x65, 0x63, 0x33, 0x20, 0x71, 0x20, 0x3d, 0x20, 0x61, 0x62, 0x73, + 0x28, 0x70, 0x29, 0x20, 0x2d, 0x20, 0x62, 0x3b, 0x0d, 0x0a, 0x20, 0x20, + 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, + 0x68, 0x28, 0x6d, 0x61, 0x78, 0x28, 0x71, 0x2c, 0x30, 0x2e, 0x30, 0x29, + 0x29, 0x20, 0x2b, 0x20, 0x6d, 0x69, 0x6e, 0x28, 0x6d, 0x61, 0x78, 0x28, + 0x71, 0x2e, 0x78, 0x2c, 0x6d, 0x61, 0x78, 0x28, 0x71, 0x2e, 0x79, 0x2c, + 0x71, 0x2e, 0x7a, 0x29, 0x29, 0x2c, 0x30, 0x2e, 0x30, 0x29, 0x20, 0x2d, + 0x20, 0x72, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x0d, 0x0a, + 0x76, 0x65, 0x63, 0x34, 0x20, 0x6f, 0x70, 0x53, 0x6d, 0x6f, 0x6f, 0x74, + 0x68, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x28, 0x20, 0x76, 0x65, 0x63, 0x34, + 0x20, 0x61, 0x2c, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x62, 0x2c, 0x20, + 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x62, 0x6c, 0x65, 0x6e, 0x64, 0x20, + 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, + 0x6f, 0x61, 0x74, 0x20, 0x68, 0x20, 0x3d, 0x20, 0x20, 0x6d, 0x61, 0x78, + 0x28, 0x20, 0x62, 0x6c, 0x65, 0x6e, 0x64, 0x2d, 0x61, 0x62, 0x73, 0x28, + 0x61, 0x2e, 0x78, 0x2d, 0x62, 0x2e, 0x78, 0x29, 0x2c, 0x20, 0x30, 0x2e, + 0x30, 0x20, 0x29, 0x2f, 0x62, 0x6c, 0x65, 0x6e, 0x64, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x6d, 0x20, + 0x3d, 0x20, 0x68, 0x2a, 0x68, 0x2a, 0x30, 0x2e, 0x35, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x20, + 0x3d, 0x20, 0x6d, 0x2a, 0x62, 0x6c, 0x65, 0x6e, 0x64, 0x2a, 0x28, 0x31, + 0x2e, 0x30, 0x2f, 0x32, 0x2e, 0x30, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x61, 0x2e, + 0x78, 0x3c, 0x62, 0x2e, 0x78, 0x29, 0x20, 0x3f, 0x20, 0x76, 0x65, 0x63, + 0x34, 0x28, 0x61, 0x2e, 0x78, 0x2d, 0x73, 0x2c, 0x6d, 0x69, 0x78, 0x28, + 0x61, 0x2e, 0x67, 0x62, 0x61, 0x2c, 0x62, 0x2e, 0x67, 0x62, 0x61, 0x2c, + 0x6d, 0x29, 0x29, 0x20, 0x3a, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x62, + 0x2e, 0x78, 0x2d, 0x73, 0x2c, 0x6d, 0x69, 0x78, 0x28, 0x61, 0x2e, 0x67, + 0x62, 0x61, 0x2c, 0x62, 0x2e, 0x67, 0x62, 0x61, 0x2c, 0x31, 0x2e, 0x30, + 0x2d, 0x6d, 0x29, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, + 0x76, 0x65, 0x63, 0x34, 0x20, 0x42, 0x6c, 0x6f, 0x62, 0x62, 0x79, 0x4d, + 0x69, 0x6e, 0x28, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x61, 0x2c, 0x20, + 0x76, 0x65, 0x63, 0x34, 0x20, 0x62, 0x2c, 0x20, 0x66, 0x6c, 0x6f, 0x61, + 0x74, 0x20, 0x62, 0x6c, 0x65, 0x6e, 0x64, 0x20, 0x29, 0x0d, 0x0a, 0x7b, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, + 0x68, 0x20, 0x3d, 0x20, 0x20, 0x6d, 0x61, 0x78, 0x28, 0x20, 0x62, 0x6c, + 0x65, 0x6e, 0x64, 0x2d, 0x61, 0x62, 0x73, 0x28, 0x61, 0x2e, 0x78, 0x2d, + 0x62, 0x2e, 0x78, 0x29, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x20, 0x29, 0x2f, + 0x62, 0x6c, 0x65, 0x6e, 0x64, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x6d, 0x20, 0x3d, 0x20, 0x68, 0x2a, + 0x68, 0x2a, 0x30, 0x2e, 0x35, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x20, 0x3d, 0x20, 0x6d, 0x2a, + 0x62, 0x6c, 0x65, 0x6e, 0x64, 0x2a, 0x28, 0x31, 0x2e, 0x30, 0x2f, 0x32, + 0x2e, 0x30, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, + 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x61, 0x2e, 0x78, 0x3c, 0x62, 0x2e, + 0x78, 0x29, 0x20, 0x3f, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x61, 0x2e, + 0x78, 0x2d, 0x73, 0x2c, 0x6d, 0x69, 0x78, 0x28, 0x61, 0x2e, 0x67, 0x62, + 0x61, 0x2c, 0x62, 0x2e, 0x67, 0x62, 0x61, 0x2c, 0x6d, 0x29, 0x29, 0x20, + 0x3a, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x62, 0x2e, 0x78, 0x2d, 0x73, + 0x2c, 0x6d, 0x69, 0x78, 0x28, 0x61, 0x2e, 0x67, 0x62, 0x61, 0x2c, 0x62, + 0x2e, 0x67, 0x62, 0x61, 0x2c, 0x31, 0x2e, 0x30, 0x2d, 0x6d, 0x29, 0x29, + 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x34, + 0x20, 0x4d, 0x69, 0x6e, 0x28, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x61, + 0x2c, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x62, 0x20, 0x29, 0x0d, 0x0a, + 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6e, 0x20, 0x28, 0x61, 0x2e, 0x78, 0x3c, 0x62, 0x2e, 0x78, 0x29, 0x20, + 0x3f, 0x20, 0x61, 0x20, 0x3a, 0x20, 0x62, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, + 0x0a, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x34, 0x20, 0x6f, 0x70, 0x53, 0x6d, + 0x6f, 0x6f, 0x74, 0x68, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x65, + 0x70, 0x70, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x28, 0x20, 0x76, + 0x65, 0x63, 0x34, 0x20, 0x61, 0x2c, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, + 0x62, 0x2c, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x62, 0x6c, 0x65, + 0x6e, 0x64, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x68, 0x20, 0x3d, 0x20, 0x20, + 0x6d, 0x61, 0x78, 0x28, 0x20, 0x62, 0x6c, 0x65, 0x6e, 0x64, 0x2d, 0x61, + 0x62, 0x73, 0x28, 0x61, 0x2e, 0x78, 0x2d, 0x62, 0x2e, 0x78, 0x29, 0x2c, + 0x20, 0x30, 0x2e, 0x30, 0x20, 0x29, 0x2f, 0x62, 0x6c, 0x65, 0x6e, 0x64, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, + 0x20, 0x6d, 0x20, 0x3d, 0x20, 0x68, 0x2a, 0x68, 0x2a, 0x30, 0x2e, 0x35, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, + 0x20, 0x73, 0x20, 0x3d, 0x20, 0x6d, 0x2a, 0x62, 0x6c, 0x65, 0x6e, 0x64, + 0x2a, 0x28, 0x31, 0x2e, 0x30, 0x2f, 0x32, 0x2e, 0x30, 0x29, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, + 0x28, 0x61, 0x2e, 0x78, 0x3c, 0x62, 0x2e, 0x78, 0x29, 0x20, 0x3f, 0x20, + 0x76, 0x65, 0x63, 0x34, 0x28, 0x61, 0x2e, 0x78, 0x2d, 0x73, 0x2c, 0x61, + 0x2e, 0x67, 0x62, 0x61, 0x29, 0x20, 0x3a, 0x20, 0x76, 0x65, 0x63, 0x34, + 0x28, 0x62, 0x2e, 0x78, 0x2d, 0x73, 0x2c, 0x62, 0x2e, 0x67, 0x62, 0x61, + 0x29, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x65, 0x63, + 0x34, 0x20, 0x6f, 0x70, 0x53, 0x6d, 0x6f, 0x6f, 0x74, 0x68, 0x53, 0x75, + 0x62, 0x74, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x20, 0x76, + 0x65, 0x63, 0x34, 0x20, 0x64, 0x31, 0x2c, 0x20, 0x76, 0x65, 0x63, 0x34, + 0x20, 0x64, 0x32, 0x2c, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x6b, + 0x20, 0x29, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, + 0x6f, 0x61, 0x74, 0x20, 0x64, 0x69, 0x73, 0x74, 0x20, 0x3d, 0x20, 0x6f, + 0x70, 0x53, 0x6d, 0x6f, 0x6f, 0x74, 0x68, 0x55, 0x6e, 0x69, 0x6f, 0x6e, + 0x28, 0x64, 0x31, 0x2c, 0x76, 0x65, 0x63, 0x34, 0x28, 0x2d, 0x64, 0x32, + 0x2e, 0x78, 0x2c, 0x20, 0x64, 0x32, 0x2e, 0x67, 0x62, 0x61, 0x29, 0x2c, + 0x6b, 0x29, 0x2e, 0x78, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x2d, + 0x64, 0x69, 0x73, 0x74, 0x2c, 0x20, 0x64, 0x32, 0x2e, 0x67, 0x62, 0x61, + 0x29, 0x3b, 0x20, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x65, + 0x63, 0x34, 0x20, 0x6f, 0x70, 0x53, 0x28, 0x20, 0x76, 0x65, 0x63, 0x34, + 0x20, 0x64, 0x31, 0x2c, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x64, 0x32, + 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x6d, + 0x61, 0x78, 0x28, 0x2d, 0x64, 0x32, 0x2e, 0x78, 0x2c, 0x64, 0x31, 0x2e, + 0x78, 0x29, 0x2c, 0x20, 0x64, 0x31, 0x2e, 0x67, 0x62, 0x61, 0x29, 0x3b, + 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x34, 0x20, + 0x6f, 0x70, 0x55, 0x28, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x64, 0x31, + 0x2c, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x64, 0x32, 0x20, 0x29, 0x0d, + 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6e, 0x20, 0x28, 0x64, 0x31, 0x2e, 0x78, 0x3c, 0x64, 0x32, 0x2e, + 0x78, 0x29, 0x20, 0x3f, 0x20, 0x64, 0x31, 0x20, 0x3a, 0x20, 0x64, 0x32, + 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x33, + 0x20, 0x6f, 0x70, 0x53, 0x79, 0x6d, 0x58, 0x28, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x70, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x70, 0x2e, 0x78, 0x20, 0x3d, 0x20, 0x61, 0x62, 0x73, 0x28, + 0x70, 0x2e, 0x78, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, + 0x0a, 0x76, 0x65, 0x63, 0x33, 0x20, 0x6f, 0x70, 0x53, 0x79, 0x6d, 0x59, + 0x28, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x70, 0x20, 0x29, 0x0d, 0x0a, + 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x2e, 0x79, 0x20, 0x3d, + 0x20, 0x61, 0x62, 0x73, 0x28, 0x70, 0x2e, 0x79, 0x29, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, + 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x33, 0x20, 0x6f, + 0x70, 0x53, 0x79, 0x6d, 0x5a, 0x28, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, + 0x70, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x70, 0x2e, 0x7a, 0x20, 0x3d, 0x20, 0x61, 0x62, 0x73, 0x28, 0x70, 0x2e, + 0x7a, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6e, 0x20, 0x70, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x76, + 0x65, 0x63, 0x33, 0x20, 0x6f, 0x70, 0x53, 0x79, 0x6d, 0x58, 0x59, 0x28, + 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x70, 0x20, 0x29, 0x0d, 0x0a, 0x7b, + 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x2e, 0x78, 0x79, 0x20, 0x3d, + 0x20, 0x61, 0x62, 0x73, 0x28, 0x70, 0x2e, 0x78, 0x79, 0x29, 0x3b, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, + 0x70, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x33, 0x20, + 0x6f, 0x70, 0x53, 0x79, 0x6d, 0x58, 0x5a, 0x28, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x70, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x70, 0x2e, 0x78, 0x7a, 0x20, 0x3d, 0x20, 0x61, 0x62, 0x73, + 0x28, 0x70, 0x2e, 0x78, 0x7a, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x3b, 0x0d, 0x0a, + 0x7d, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x33, 0x20, 0x6f, 0x70, 0x53, 0x79, + 0x6d, 0x59, 0x5a, 0x28, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x70, 0x20, + 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x2e, + 0x79, 0x7a, 0x20, 0x3d, 0x20, 0x61, 0x62, 0x73, 0x28, 0x70, 0x2e, 0x79, + 0x7a, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6e, 0x20, 0x70, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x76, + 0x65, 0x63, 0x33, 0x20, 0x6f, 0x70, 0x53, 0x79, 0x6d, 0x58, 0x59, 0x5a, + 0x28, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x70, 0x20, 0x29, 0x0d, 0x0a, + 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x2e, 0x78, 0x79, 0x7a, + 0x20, 0x3d, 0x20, 0x61, 0x62, 0x73, 0x28, 0x70, 0x2e, 0x78, 0x79, 0x7a, + 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6e, 0x20, 0x70, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, + 0x76, 0x65, 0x63, 0x33, 0x20, 0x6f, 0x70, 0x52, 0x6f, 0x74, 0x61, 0x74, + 0x65, 0x58, 0x59, 0x5a, 0x28, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x70, + 0x2c, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x74, 0x68, 0x65, 0x74, 0x61, + 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, + 0x6f, 0x61, 0x74, 0x20, 0x63, 0x7a, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x73, + 0x28, 0x74, 0x68, 0x65, 0x74, 0x61, 0x2e, 0x7a, 0x29, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x7a, + 0x20, 0x3d, 0x20, 0x73, 0x69, 0x6e, 0x28, 0x74, 0x68, 0x65, 0x74, 0x61, + 0x2e, 0x7a, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, + 0x6f, 0x61, 0x74, 0x20, 0x63, 0x79, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x73, + 0x28, 0x74, 0x68, 0x65, 0x74, 0x61, 0x2e, 0x79, 0x29, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x79, + 0x20, 0x3d, 0x20, 0x73, 0x69, 0x6e, 0x28, 0x74, 0x68, 0x65, 0x74, 0x61, + 0x2e, 0x79, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, + 0x6f, 0x61, 0x74, 0x20, 0x63, 0x78, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x73, + 0x28, 0x74, 0x68, 0x65, 0x74, 0x61, 0x2e, 0x78, 0x29, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x78, + 0x20, 0x3d, 0x20, 0x73, 0x69, 0x6e, 0x28, 0x74, 0x68, 0x65, 0x74, 0x61, + 0x2e, 0x78, 0x29, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x6d, 0x61, 0x74, 0x33, 0x20, 0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x6d, + 0x61, 0x74, 0x33, 0x28, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x7a, + 0x2a, 0x63, 0x79, 0x2c, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x7a, + 0x2a, 0x73, 0x79, 0x2a, 0x73, 0x78, 0x20, 0x2d, 0x20, 0x63, 0x78, 0x2a, + 0x73, 0x7a, 0x2c, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x7a, 0x2a, + 0x73, 0x78, 0x20, 0x2b, 0x20, 0x63, 0x7a, 0x2a, 0x63, 0x78, 0x2a, 0x73, + 0x79, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x79, + 0x2a, 0x73, 0x7a, 0x2c, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x7a, + 0x2a, 0x63, 0x78, 0x20, 0x2b, 0x20, 0x73, 0x7a, 0x2a, 0x73, 0x79, 0x2a, + 0x73, 0x78, 0x2c, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x78, 0x2a, + 0x73, 0x7a, 0x2a, 0x73, 0x79, 0x20, 0x2d, 0x20, 0x63, 0x7a, 0x2a, 0x73, + 0x78, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2d, 0x73, + 0x79, 0x2c, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x79, 0x2a, 0x73, + 0x78, 0x2c, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x79, 0x2a, 0x63, + 0x78, 0x29, 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6d, 0x61, 0x74, 0x2a, 0x70, 0x3b, + 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x0d, 0x0a, 0x00 +}; +unsigned int shader_prefix_fs_len = 2446; +unsigned char slicer_body_fs[] = { + 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x66, 0x72, 0x61, 0x67, + 0x54, 0x65, 0x78, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x3b, 0x0d, 0x0a, 0x6f, + 0x75, 0x74, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x66, 0x69, 0x6e, 0x61, + 0x6c, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x3b, 0x0d, 0x0a, 0x75, 0x6e, 0x69, + 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x7a, + 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x6f, 0x69, 0x64, 0x20, 0x6d, 0x61, + 0x69, 0x6e, 0x28, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x73, 0x64, 0x66, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3d, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x28, 0x76, 0x65, 0x63, 0x33, 0x28, 0x66, 0x72, + 0x61, 0x67, 0x54, 0x65, 0x78, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x2c, 0x20, + 0x7a, 0x29, 0x29, 0x2e, 0x78, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, + 0x20, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x76, 0x65, 0x63, 0x33, 0x28, + 0x73, 0x64, 0x66, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x2c, 0x20, + 0x31, 0x2e, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x00 +}; +unsigned int slicer_body_fs_len = 202; +unsigned char selection_fs[] = { + 0x6f, 0x75, 0x74, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x66, 0x69, 0x6e, + 0x61, 0x6c, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x3b, 0x0d, 0x0a, 0x2f, 0x2f, + 0x20, 0x69, 0x6e, 0x74, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x74, 0x65, + 0x78, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x3b, 0x0d, 0x0a, 0x75, 0x6e, 0x69, + 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x76, 0x69, + 0x65, 0x77, 0x45, 0x79, 0x65, 0x3b, 0x20, 0x0d, 0x0a, 0x75, 0x6e, 0x69, + 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x76, 0x69, + 0x65, 0x77, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3b, 0x20, 0x0d, 0x0a, + 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x76, 0x65, 0x63, 0x32, + 0x20, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x3b, + 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x65, 0x63, 0x34, 0x20, 0x63, 0x61, 0x73, + 0x74, 0x52, 0x61, 0x79, 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x72, 0x6f, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x63, + 0x33, 0x20, 0x72, 0x64, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x74, 0x6d, 0x69, + 0x6e, 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x31, 0x3b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x74, 0x6d, 0x61, 0x78, + 0x20, 0x3d, 0x20, 0x33, 0x30, 0x30, 0x2e, 0x30, 0x3b, 0x0d, 0x0a, 0x0d, + 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x74, + 0x20, 0x3d, 0x20, 0x74, 0x6d, 0x69, 0x6e, 0x3b, 0x0d, 0x0a, 0x20, 0x20, + 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x6d, 0x20, 0x3d, 0x20, 0x76, + 0x65, 0x63, 0x33, 0x28, 0x30, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x66, 0x6f, 0x72, 0x28, 0x20, 0x69, 0x6e, 0x74, 0x20, 0x69, 0x3d, + 0x30, 0x3b, 0x20, 0x69, 0x3c, 0x36, 0x34, 0x3b, 0x20, 0x69, 0x2b, 0x2b, + 0x20, 0x29, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7b, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, + 0x20, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x20, 0x3d, 0x20, 0x30, 0x2e, + 0x30, 0x30, 0x30, 0x31, 0x2a, 0x74, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20, 0x72, 0x65, + 0x73, 0x20, 0x3d, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x64, + 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x28, 0x20, 0x72, 0x6f, 0x2b, 0x72, 0x64, 0x2a, 0x74, 0x20, 0x29, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, + 0x66, 0x28, 0x20, 0x72, 0x65, 0x73, 0x2e, 0x78, 0x3c, 0x70, 0x72, 0x65, + 0x63, 0x69, 0x73, 0x20, 0x7c, 0x7c, 0x20, 0x74, 0x3e, 0x74, 0x6d, 0x61, + 0x78, 0x20, 0x29, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x74, 0x20, 0x2b, 0x3d, + 0x20, 0x72, 0x65, 0x73, 0x2e, 0x78, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x6d, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, + 0x2e, 0x67, 0x62, 0x61, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, + 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x28, 0x20, + 0x74, 0x3e, 0x74, 0x6d, 0x61, 0x78, 0x20, 0x29, 0x20, 0x6d, 0x3d, 0x76, + 0x65, 0x63, 0x33, 0x28, 0x30, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x65, 0x63, 0x34, + 0x28, 0x20, 0x74, 0x2c, 0x20, 0x6d, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, + 0x0d, 0x0a, 0x0d, 0x0a, 0x6d, 0x61, 0x74, 0x33, 0x20, 0x73, 0x65, 0x74, + 0x43, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x28, 0x20, 0x69, 0x6e, 0x20, 0x76, + 0x65, 0x63, 0x33, 0x20, 0x72, 0x6f, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x76, + 0x65, 0x63, 0x33, 0x20, 0x74, 0x61, 0x2c, 0x20, 0x66, 0x6c, 0x6f, 0x61, + 0x74, 0x20, 0x63, 0x72, 0x20, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, + 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x63, 0x77, 0x20, 0x3d, + 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x74, + 0x61, 0x2d, 0x72, 0x6f, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x76, 0x65, 0x63, 0x33, 0x20, 0x63, 0x70, 0x20, 0x3d, 0x20, 0x76, 0x65, + 0x63, 0x33, 0x28, 0x73, 0x69, 0x6e, 0x28, 0x63, 0x72, 0x29, 0x2c, 0x20, + 0x63, 0x6f, 0x73, 0x28, 0x63, 0x72, 0x29, 0x2c, 0x30, 0x2e, 0x30, 0x29, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, + 0x63, 0x75, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x28, 0x20, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x28, 0x63, 0x77, + 0x2c, 0x63, 0x70, 0x29, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, + 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x63, 0x76, 0x20, 0x3d, 0x20, 0x6e, + 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x20, 0x63, 0x72, + 0x6f, 0x73, 0x73, 0x28, 0x63, 0x75, 0x2c, 0x63, 0x77, 0x29, 0x20, 0x29, + 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, + 0x6e, 0x20, 0x6d, 0x61, 0x74, 0x33, 0x28, 0x20, 0x63, 0x75, 0x2c, 0x20, + 0x63, 0x76, 0x2c, 0x20, 0x63, 0x77, 0x20, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, + 0x0d, 0x0a, 0x0d, 0x0a, 0x76, 0x6f, 0x69, 0x64, 0x20, 0x6d, 0x61, 0x69, + 0x6e, 0x28, 0x29, 0x0d, 0x0a, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, + 0x76, 0x65, 0x63, 0x32, 0x20, 0x70, 0x20, 0x3d, 0x20, 0x28, 0x2d, 0x72, + 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x78, 0x79, + 0x20, 0x2b, 0x20, 0x32, 0x2e, 0x30, 0x2a, 0x67, 0x6c, 0x5f, 0x46, 0x72, + 0x61, 0x67, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x78, 0x79, 0x29, 0x2f, + 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x79, + 0x3b, 0x0d, 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6d, 0x61, 0x74, + 0x33, 0x20, 0x63, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x5f, 0x74, 0x6f, 0x5f, + 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x3d, 0x20, 0x73, 0x65, 0x74, 0x43, + 0x61, 0x6d, 0x65, 0x72, 0x61, 0x28, 0x20, 0x76, 0x69, 0x65, 0x77, 0x45, + 0x79, 0x65, 0x2c, 0x20, 0x76, 0x69, 0x65, 0x77, 0x43, 0x65, 0x6e, 0x74, + 0x65, 0x72, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x20, 0x29, 0x3b, 0x0d, 0x0a, + 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x72, 0x61, 0x79, + 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, + 0x20, 0x63, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x5f, 0x74, 0x6f, 0x5f, 0x77, + 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x2a, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, + 0x6c, 0x69, 0x7a, 0x65, 0x28, 0x20, 0x76, 0x65, 0x63, 0x33, 0x28, 0x70, + 0x2e, 0x78, 0x79, 0x2c, 0x32, 0x2e, 0x30, 0x29, 0x20, 0x29, 0x3b, 0x0d, + 0x0a, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x69, 0x6e, 0x61, 0x6c, + 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x76, 0x65, 0x63, 0x34, + 0x28, 0x63, 0x61, 0x73, 0x74, 0x52, 0x61, 0x79, 0x28, 0x20, 0x76, 0x69, + 0x65, 0x77, 0x45, 0x79, 0x65, 0x2c, 0x20, 0x72, 0x61, 0x79, 0x5f, 0x64, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x29, 0x2e, 0x67, + 0x62, 0x61, 0x2c, 0x20, 0x31, 0x29, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, + 0x20, 0x0d, 0x0a, 0x00 +}; +unsigned int selection_fs_len = 1096; diff --git a/x64/Debug/ShapeUpWin.exe.recipe b/x64/Debug/ShapeUpWin.exe.recipe new file mode 100644 index 0000000..d75375d --- /dev/null +++ b/x64/Debug/ShapeUpWin.exe.recipe @@ -0,0 +1,11 @@ + + + + + C:\Users\rosie\source\repos\ShapeUpWin\x64\Debug\ShapeUpWin.exe + + + + + + \ No newline at end of file diff --git a/x64/Debug/ShapeUpWin.ilk b/x64/Debug/ShapeUpWin.ilk new file mode 100644 index 0000000000000000000000000000000000000000..fe144a53f511f73505f5de68817ce43fef171baa GIT binary patch literal 3969088 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ø>wZA*W!sPM__$8+G*`OO)8$?XR` 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 z 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π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

Fn_ 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�SeCpJDi*n%S9H4ELhGF^!o77v$!4yea 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%0AxcM8$-;V|os=PwNbtes`$Zp=IO@fdXwT8) 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

0lS@GHXZf`VB|N47!>FG4}+Bw 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࿧ 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