From 47736862a71d107d582e24ce2c3d90b8779c8745 Mon Sep 17 00:00:00 2001 From: olebeck <31539311+olebeck@users.noreply.github.com> Date: Sat, 1 Nov 2025 00:23:12 +0100 Subject: [PATCH] Add PSVita port (#541) * add psvita to cmake * no PIE for vita * add modules to vpk * use custom pvr apphint * select correct renderer for sdl renderer * patch sdl3 shaders, got something on screen! * use proper cmake patch for sdl * add missing module * remove test window which causes a bug in the vita sdl port to show up * add gxm renderer (not working with display yet) * avoid sdl renderer for vita, seems broken * make gxm renderer work with new d3drm * fix rendering somewhat, some geometry shows up * support paletted textures directly to avoid copying the texture twice * fix Draw2DImage * make 3d work, broken lights * clean up a bit * fix normals matrix * remove some unneeded changes * forgot env var * wrong env dest * run clang format * correct texture address mode, use tlsf instead of sceClibMspace * double buffered uniforms seem to work now * missed a line * update GXMRenderer_EnumDevice * hopefully actually fix uniform buffers * run clang-format * remove a change thats not needed * improve fragment shader performance * add vita to dist folder * add base for vita config app * add config self to vpk * transform touch events to virtual size * add livearea graphics * Update cmake file to include livearea assets * put manual in the right place * add sample rco * add messagebox on vita * triple buffer textures because fences arent a thing on vita and making draw&cpu sync would be too slow * make config app not crash on launch * change defaults * update gxm renderer with interface changes * split 2d and 3d shaders completely * update gxm renderer * fix transition on gxm * clang format * move config cmake * move CONFIG_vita * always clear before drawing 2d image * hopefully fix windows build * clang-format fix broken includes * order again * undo moving qt cmake to its own list * move uic search path * use ifdefs for all d3drm backends, cpack to generate vpk * cmake wrong escape * small cleanups in gxm renderer * defer texture delete to avoid overwriting the texture during a frame * clang-format * more of the layout for config * remove top buttons * use SceAppSettings instead of custom ui * use select for back to info center on vita, to make screenshots possible again * remove accidentally left in add_subdirectory * adjust diskpath to be like other ports * use vita_create_vpk and not cpack * gxm: msaa support, fix wrong file path * gxm: add mipmaps (disabled) * clang-format * fix open isle.ini with fopen * add missing strings * use iniparser_set not dictionary_set * add default save path to config * load config app after initializing ini on vita * fix config build * change the default disk & cd path, update the paf library * update paf library headers * include orders for clang-format * clean up * make shader compiler not required * move asm language * warn instead of error when shader source is changed when no compiler is found --------- Co-authored-by: Li Co-authored-by: Christian Semmler --- .github/workflows/ci.yml | 23 +- CMakeLists.txt | 61 +- CONFIG/{ => qt}/AboutDlg.cpp | 0 CONFIG/{ => qt}/AboutDlg.h | 0 CONFIG/{ => qt}/MainDlg.cpp | 0 CONFIG/{ => qt}/MainDlg.h | 0 CONFIG/{ => qt}/config.cpp | 0 CONFIG/{ => qt}/config.h | 0 CONFIG/{ => qt}/detectdx5.cpp | 0 CONFIG/{ => qt}/detectdx5.h | 0 CONFIG/{ => qt}/res/about.ui | 0 CONFIG/{ => qt}/res/add.svg | 0 CONFIG/{ => qt}/res/config.qrc | 0 CONFIG/{ => qt}/res/config.rc | 0 CONFIG/{ => qt}/res/lego.ico | Bin CONFIG/{ => qt}/res/lego1.png | Bin CONFIG/{ => qt}/res/lego2.png | Bin CONFIG/{ => qt}/res/maindialog.ui | 0 CONFIG/{ => qt}/res/remove.svg | 0 CONFIG/{ => qt}/res/shark.png | Bin CONFIG/vita/CMakeLists.txt | 73 + CONFIG/vita/cxml/config_plugin.xml | 34 + CONFIG/vita/cxml/locale/en.xml | 57 + CONFIG/vita/cxml/settings.xml | 51 + CONFIG/vita/exports.yml | 8 + CONFIG/vita/iniparser_paf.patch | 53 + CONFIG/vita/src/app.cpp | 430 ++++++ CONFIG/vita/src/paf_runtime.cpp | 169 +++ ISLE/isleapp.cpp | 47 +- ISLE/vita/config.cpp | 13 + ISLE/vita/config.h | 8 + ISLE/vita/messagebox.cpp | 52 + ISLE/vita/messagebox.h | 8 + README.md | 1 + miniwin/CMakeLists.txt | 21 +- .../src/d3drm/backends/gxm/gxm_context.cpp | 680 +++++++++ miniwin/src/d3drm/backends/gxm/gxm_context.h | 105 ++ miniwin/src/d3drm/backends/gxm/gxm_memory.cpp | 119 ++ miniwin/src/d3drm/backends/gxm/gxm_memory.h | 15 + .../src/d3drm/backends/gxm/gxm_renderer.cpp | 1101 ++++++++++++++ miniwin/src/d3drm/backends/gxm/razor.h | 13 + .../src/d3drm/backends/gxm/shaders/.gitignore | 2 + .../d3drm/backends/gxm/shaders/CMakeLists.txt | 106 ++ .../d3drm/backends/gxm/shaders/color.frag.cg | 6 + .../d3drm/backends/gxm/shaders/color.frag.gxp | Bin 0 -> 228 bytes .../backends/gxm/shaders/color.frag.perf.txt | 26 + .../d3drm/backends/gxm/shaders/gxm_shaders.h | 32 + .../d3drm/backends/gxm/shaders/gxm_shaders.s | 15 + .../d3drm/backends/gxm/shaders/image.frag.cg | 10 + .../d3drm/backends/gxm/shaders/image.frag.gxp | Bin 0 -> 264 bytes .../backends/gxm/shaders/image.frag.perf.txt | 29 + .../backends/gxm/shaders/main.color.frag.gxp | Bin 0 -> 1248 bytes .../gxm/shaders/main.color.frag.perf.txt | 134 ++ .../d3drm/backends/gxm/shaders/main.frag.cg | 54 + .../gxm/shaders/main.texture.frag.gxp | Bin 0 -> 1312 bytes .../gxm/shaders/main.texture.frag.perf.txt | 139 ++ .../d3drm/backends/gxm/shaders/main.vert.cg | 20 + .../d3drm/backends/gxm/shaders/main.vert.gxp | Bin 0 -> 784 bytes .../backends/gxm/shaders/main.vert.perf.txt | 87 ++ .../d3drm/backends/gxm/shaders/plane.vert.cg | 11 + .../d3drm/backends/gxm/shaders/plane.vert.gxp | Bin 0 -> 284 bytes .../backends/gxm/shaders/plane.vert.perf.txt | 30 + miniwin/src/d3drm/backends/gxm/tlsf.c | 1264 +++++++++++++++++ miniwin/src/d3drm/backends/gxm/tlsf.h | 91 ++ miniwin/src/d3drm/backends/gxm/utils.h | 48 + miniwin/src/d3drm/d3drmrenderer.cpp | 11 + miniwin/src/internal/d3drmrenderer_gxm.h | 181 +++ packaging/vita/sce_sys/icon0.png | Bin 0 -> 1671 bytes .../vita/sce_sys/livearea/contents/bg.png | Bin 0 -> 47338 bytes .../sce_sys/livearea/contents/configure.png | Bin 0 -> 2715 bytes .../vita/sce_sys/livearea/contents/gate.png | Bin 0 -> 8468 bytes .../vita/sce_sys/livearea/contents/logo.png | Bin 0 -> 33724 bytes .../sce_sys/livearea/contents/template.xml | 23 + packaging/vita/sce_sys/manual/001.png | Bin 0 -> 242162 bytes packaging/vita/sce_sys/manual/002.png | Bin 0 -> 98897 bytes packaging/vita/sce_sys/manual/003.png | Bin 0 -> 196455 bytes packaging/vita/sce_sys/manual/004.png | Bin 0 -> 170140 bytes packaging/vita/sce_sys/manual/005.png | Bin 0 -> 149940 bytes packaging/vita/sce_sys/manual/006.png | Bin 0 -> 151558 bytes packaging/vita/sce_sys/manual/007.png | Bin 0 -> 160086 bytes packaging/vita/sce_sys/manual/008.png | Bin 0 -> 157081 bytes packaging/vita/sce_sys/manual/009.png | Bin 0 -> 163583 bytes packaging/vita/sce_sys/manual/010.png | Bin 0 -> 155524 bytes packaging/vita/sce_sys/manual/011.png | Bin 0 -> 175534 bytes packaging/vita/sce_sys/manual/012.png | Bin 0 -> 128494 bytes packaging/vita/sce_sys/manual/013.png | Bin 0 -> 150027 bytes packaging/vita/sce_sys/manual/014.png | Bin 0 -> 147269 bytes packaging/vita/sce_sys/manual/015.png | Bin 0 -> 135605 bytes packaging/vita/sce_sys/manual/016.png | Bin 0 -> 144464 bytes packaging/vita/sce_sys/manual/017.png | Bin 0 -> 141728 bytes packaging/vita/sce_sys/manual/018.png | Bin 0 -> 144819 bytes packaging/vita/sce_sys/manual/019.png | Bin 0 -> 190266 bytes packaging/vita/sce_sys/manual/020.png | Bin 0 -> 155975 bytes packaging/vita/sce_sys/manual/021.png | Bin 0 -> 125672 bytes packaging/vita/sce_sys/manual/022.png | Bin 0 -> 143847 bytes packaging/vita/sce_sys/manual/023.png | Bin 0 -> 157272 bytes packaging/vita/sce_sys/manual/024.png | Bin 0 -> 148858 bytes packaging/vita/sce_sys/manual/025.png | Bin 0 -> 82507 bytes packaging/vita/sce_sys/manual/026.png | Bin 0 -> 206515 bytes packaging/vita/sce_sys/manual/027.png | Bin 0 -> 141617 bytes packaging/vita/sce_sys/manual/028.png | Bin 0 -> 227167 bytes packaging/vita/sce_sys/pic0.png | Bin 0 -> 251847 bytes util/compat.h | 2 + 103 files changed, 5448 insertions(+), 15 deletions(-) rename CONFIG/{ => qt}/AboutDlg.cpp (100%) rename CONFIG/{ => qt}/AboutDlg.h (100%) rename CONFIG/{ => qt}/MainDlg.cpp (100%) rename CONFIG/{ => qt}/MainDlg.h (100%) rename CONFIG/{ => qt}/config.cpp (100%) rename CONFIG/{ => qt}/config.h (100%) rename CONFIG/{ => qt}/detectdx5.cpp (100%) rename CONFIG/{ => qt}/detectdx5.h (100%) rename CONFIG/{ => qt}/res/about.ui (100%) rename CONFIG/{ => qt}/res/add.svg (100%) rename CONFIG/{ => qt}/res/config.qrc (100%) rename CONFIG/{ => qt}/res/config.rc (100%) rename CONFIG/{ => qt}/res/lego.ico (100%) rename CONFIG/{ => qt}/res/lego1.png (100%) rename CONFIG/{ => qt}/res/lego2.png (100%) rename CONFIG/{ => qt}/res/maindialog.ui (100%) rename CONFIG/{ => qt}/res/remove.svg (100%) rename CONFIG/{ => qt}/res/shark.png (100%) create mode 100644 CONFIG/vita/CMakeLists.txt create mode 100644 CONFIG/vita/cxml/config_plugin.xml create mode 100644 CONFIG/vita/cxml/locale/en.xml create mode 100644 CONFIG/vita/cxml/settings.xml create mode 100644 CONFIG/vita/exports.yml create mode 100644 CONFIG/vita/iniparser_paf.patch create mode 100644 CONFIG/vita/src/app.cpp create mode 100644 CONFIG/vita/src/paf_runtime.cpp create mode 100644 ISLE/vita/config.cpp create mode 100644 ISLE/vita/config.h create mode 100644 ISLE/vita/messagebox.cpp create mode 100644 ISLE/vita/messagebox.h create mode 100644 miniwin/src/d3drm/backends/gxm/gxm_context.cpp create mode 100644 miniwin/src/d3drm/backends/gxm/gxm_context.h create mode 100644 miniwin/src/d3drm/backends/gxm/gxm_memory.cpp create mode 100644 miniwin/src/d3drm/backends/gxm/gxm_memory.h create mode 100644 miniwin/src/d3drm/backends/gxm/gxm_renderer.cpp create mode 100644 miniwin/src/d3drm/backends/gxm/razor.h create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/.gitignore create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/CMakeLists.txt create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/color.frag.cg create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/color.frag.gxp create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/color.frag.perf.txt create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/gxm_shaders.h create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/gxm_shaders.s create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/image.frag.cg create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/image.frag.gxp create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/image.frag.perf.txt create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.gxp create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.perf.txt create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.frag.cg create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.gxp create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.perf.txt create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.vert.cg create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.vert.gxp create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/main.vert.perf.txt create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/plane.vert.cg create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/plane.vert.gxp create mode 100644 miniwin/src/d3drm/backends/gxm/shaders/plane.vert.perf.txt create mode 100644 miniwin/src/d3drm/backends/gxm/tlsf.c create mode 100644 miniwin/src/d3drm/backends/gxm/tlsf.h create mode 100644 miniwin/src/d3drm/backends/gxm/utils.h create mode 100644 miniwin/src/internal/d3drmrenderer_gxm.h create mode 100644 packaging/vita/sce_sys/icon0.png create mode 100644 packaging/vita/sce_sys/livearea/contents/bg.png create mode 100644 packaging/vita/sce_sys/livearea/contents/configure.png create mode 100644 packaging/vita/sce_sys/livearea/contents/gate.png create mode 100644 packaging/vita/sce_sys/livearea/contents/logo.png create mode 100644 packaging/vita/sce_sys/livearea/contents/template.xml create mode 100644 packaging/vita/sce_sys/manual/001.png create mode 100644 packaging/vita/sce_sys/manual/002.png create mode 100644 packaging/vita/sce_sys/manual/003.png create mode 100644 packaging/vita/sce_sys/manual/004.png create mode 100644 packaging/vita/sce_sys/manual/005.png create mode 100644 packaging/vita/sce_sys/manual/006.png create mode 100644 packaging/vita/sce_sys/manual/007.png create mode 100644 packaging/vita/sce_sys/manual/008.png create mode 100644 packaging/vita/sce_sys/manual/009.png create mode 100644 packaging/vita/sce_sys/manual/010.png create mode 100644 packaging/vita/sce_sys/manual/011.png create mode 100644 packaging/vita/sce_sys/manual/012.png create mode 100644 packaging/vita/sce_sys/manual/013.png create mode 100644 packaging/vita/sce_sys/manual/014.png create mode 100644 packaging/vita/sce_sys/manual/015.png create mode 100644 packaging/vita/sce_sys/manual/016.png create mode 100644 packaging/vita/sce_sys/manual/017.png create mode 100644 packaging/vita/sce_sys/manual/018.png create mode 100644 packaging/vita/sce_sys/manual/019.png create mode 100644 packaging/vita/sce_sys/manual/020.png create mode 100644 packaging/vita/sce_sys/manual/021.png create mode 100644 packaging/vita/sce_sys/manual/022.png create mode 100644 packaging/vita/sce_sys/manual/023.png create mode 100644 packaging/vita/sce_sys/manual/024.png create mode 100644 packaging/vita/sce_sys/manual/025.png create mode 100644 packaging/vita/sce_sys/manual/026.png create mode 100644 packaging/vita/sce_sys/manual/027.png create mode 100644 packaging/vita/sce_sys/manual/028.png create mode 100644 packaging/vita/sce_sys/pic0.png diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e4306017..8fd81c57 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -48,6 +48,7 @@ jobs: - { name: 'Nintendo 3DS', os: 'ubuntu-latest', generator: 'Ninja', dx5: false, config: false, n3ds: true, werror: true, clang-tidy: false, container: 'devkitpro/devkitarm:latest', cmake-args: '-DCMAKE_TOOLCHAIN_FILE=/opt/devkitpro/cmake/3DS.cmake' } - { name: 'Xbox One', os: 'windows-latest', generator: 'Visual Studio 17 2022', dx5: false, config: false, msvc: true, werror: false, clang-tidy: false, vc-arch: 'amd64', cmake-args: '-DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0.26100.0', xbox-one: true} - { name: 'Android', os: 'ubuntu-latest', generator: 'Ninja', dx5: false, config: false, android: true, werror: true, clang-tidy: false,} + - { name: 'Vita', os: 'ubuntu-latest', generator: 'Ninja', dx5: false, config: false, vita: true, werror: true, clang-tidy: false, cmake-args: '--toolchain /usr/local/vitasdk/share/vita.toolchain.cmake'} steps: - name: Setup vcvars if: ${{ !!matrix.msvc }} @@ -117,6 +118,18 @@ jobs: - name: Setup ninja if: ${{ matrix.msvc }} uses: ashutoshvarma/setup-ninja@master + + - name: Setup vitasdk + if: ${{ matrix.vita }} + run: | + git clone https://github.com/vitasdk/vdpm + cd vdpm + ./bootstrap-vitasdk.sh + export VITASDK=/usr/local/vitasdk + export PATH=$VITASDK/bin:$PATH + echo "VITASDK=/usr/local/vitasdk" >> $GITHUB_ENV + echo "$VITASDK/bin" >> $GITHUB_PATH + ./install-all.sh - uses: actions/checkout@v4 @@ -177,7 +190,7 @@ jobs: run: cmake --build build --verbose --config Release - name: Package (CPack) - if: ${{ !matrix.n3ds && !matrix.android }} + if: ${{ !matrix.n3ds && !matrix.android && !matrix.vita }} run: | cd build success=0 @@ -225,6 +238,13 @@ jobs: mkdir dist mv *.3dsx dist/ mv *.cia dist/ + + - name: Package (Vita) + if: ${{ matrix.vita }} + run: | + cd build + mkdir dist + mv *.vpk dist/ - name: Package (Android) if: ${{ matrix.android }} @@ -246,6 +266,7 @@ jobs: build/dist/*.3dsx build/dist/*.cia build/dist/*.apk + build/dist/*.vpk flatpak: name: "Flatpak (${{ matrix.arch }})" diff --git a/CMakeLists.txt b/CMakeLists.txt index 8a4ec707..60e742d0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -46,18 +46,18 @@ option(ISLE_BUILD_ASSETS "Build assets from the /assets directory" OFF) option(ISLE_ASAN "Enable Address Sanitizer" OFF) option(ISLE_UBSAN "Enable Undefined Behavior Sanitizer" OFF) option(ISLE_WERROR "Treat warnings as errors" OFF) -option(ISLE_DEBUG "Enable imgui debug" ON) +cmake_dependent_option(ISLE_DEBUG "Enable imgui debug" ON "NOT VITA" OFF) cmake_dependent_option(ISLE_USE_DX5 "Build with internal DirectX 5 SDK" "${NOT_MINGW}" "WIN32;CMAKE_SIZEOF_VOID_P EQUAL 4" OFF) cmake_dependent_option(ISLE_MINIWIN "Use miniwin" ON "NOT ISLE_USE_DX5" OFF) cmake_dependent_option(ISLE_EXTENSIONS "Use extensions" ON "NOT ISLE_USE_DX5;NOT WINDOWS_STORE" OFF) -cmake_dependent_option(ISLE_BUILD_CONFIG "Build CONFIG.EXE application" ON "MSVC OR ISLE_MINIWIN;NOT NINTENDO_3DS;NOT WINDOWS_STORE" OFF) +cmake_dependent_option(ISLE_BUILD_CONFIG "Build CONFIG.EXE application" ON "MSVC OR ISLE_MINIWIN;NOT NINTENDO_3DS;NOT WINDOWS_STORE;NOT VITA" OFF) cmake_dependent_option(ISLE_COMPILE_SHADERS "Compile shaders" ON "SDL_SHADERCROSS_BIN;TARGET Python3::Interpreter" OFF) -option(CMAKE_POSITION_INDEPENDENT_CODE "Build with -fPIC" ON) +cmake_dependent_option(CMAKE_POSITION_INDEPENDENT_CODE "Build with -fPIC" ON "NOT VITA" OFF) option(ENABLE_CLANG_TIDY "Enable clang-tidy") option(DOWNLOAD_DEPENDENCIES "Download dependencies" ON) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" CACHE PATH "Directory where to put executables and dll") set(ISLE_EMSCRIPTEN_HOST "" CACHE STRING "Host URL for Emscripten streaming (e.g., https://test.com)") -cmake_dependent_option(BUILD_SHARED_LIBS "Build lego1 as a shared library" ON "NOT EMSCRIPTEN" OFF) +cmake_dependent_option(BUILD_SHARED_LIBS "Build lego1 as a shared library" ON "NOT EMSCRIPTEN;NOT VITA" OFF) message(STATUS "Isle app: ${ISLE_BUILD_APP}") message(STATUS "Config app: ${ISLE_BUILD_CONFIG}") @@ -90,6 +90,7 @@ if (DOWNLOAD_DEPENDENCIES) SDL3 GIT_REPOSITORY "https://github.com/libsdl-org/SDL.git" GIT_TAG "main" + UPDATE_DISCONNECTED TRUE EXCLUDE_FROM_ALL ) endif() @@ -100,6 +101,7 @@ if (DOWNLOAD_DEPENDENCIES) iniparser GIT_REPOSITORY "https://gitlab.com/iniparser/iniparser.git" GIT_TAG "main" + UPDATE_DISCONNECTED TRUE EXCLUDE_FROM_ALL ) block() @@ -598,6 +600,12 @@ if (ISLE_BUILD_APP) ISLE/android/config.cpp ) endif() + if(VITA) + target_sources(isle PRIVATE + ISLE/vita/config.cpp + ISLE/vita/messagebox.cpp + ) + endif() if(Python3_FOUND) if(NOT DEFINED PYTHON_PIL_AVAILABLE) execute_process( @@ -639,18 +647,18 @@ if (ISLE_BUILD_CONFIG) qt_add_executable(isle-config WIN32 LEGO1/mxdirectx/mxdirectxinfo.cpp LEGO1/mxdirectx/legodxinfo.cpp - CONFIG/config.cpp - CONFIG/AboutDlg.cpp - CONFIG/MainDlg.cpp - CONFIG/detectdx5.cpp - CONFIG/res/config.rc - CONFIG/res/config.qrc + CONFIG/qt/config.cpp + CONFIG/qt/AboutDlg.cpp + CONFIG/qt/MainDlg.cpp + CONFIG/qt/detectdx5.cpp + CONFIG/qt/res/config.rc + CONFIG/qt/res/config.qrc ) target_link_libraries(isle-config PRIVATE Qt6::Core Qt6::Widgets) set_property(TARGET isle-config PROPERTY AUTOMOC ON) set_property(TARGET isle-config PROPERTY AUTORCC ON) set_property(TARGET isle-config PROPERTY AUTOUIC ON) - set_property(TARGET isle-config PROPERTY AUTOUIC_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/CONFIG/res") + set_property(TARGET isle-config PROPERTY AUTOUIC_SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/CONFIG/qt/res") list(APPEND isle_targets isle-config) target_compile_definitions(isle-config PRIVATE _AFXDLL MXDIRECTX_FOR_CONFIG) target_include_directories(isle-config PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/LEGO1") @@ -782,7 +790,7 @@ endif() if(BUILD_SHARED_LIBS) list(APPEND install_extra_targets lego1) endif() -if (NOT (NINTENDO_3DS OR WINDOWS_STORE)) +if (NOT (NINTENDO_3DS OR WINDOWS_STORE OR VITA)) install(TARGETS isle ${install_extra_targets} RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" @@ -881,6 +889,35 @@ if(WINDOWS_STORE) PATTERN "*/*.msix" PATTERN "*/*.msixbundle") endif() +if(VITA) + include("${VITASDK}/share/vita.cmake" REQUIRED) + + add_subdirectory(CONFIG/vita) + + set(ISLE_PACKAGE_NAME "vita-isle") + set(VITA_APP_NAME "Lego Island") + set(VITA_TITLEID "LEGO00001") + set(VITA_VERSION "01.00") + + vita_create_self(isle.self isle UNSAFE) + + set(VPK_FILE_ARGS "") + file(GLOB_RECURSE SCE_SYS_FILES packaging/vita/sce_sys/*) + foreach(FILE ${SCE_SYS_FILES}) + file(RELATIVE_PATH REL_FILE ${CMAKE_CURRENT_SOURCE_DIR}/packaging/vita/ ${FILE}) + list(APPEND VPK_FILE_ARGS FILE ${FILE} ${REL_FILE}) + endforeach() + + vita_create_vpk(isle.vpk ${VITA_TITLEID} isle.self + FILE "${CMAKE_CURRENT_BINARY_DIR}/CONFIG/vita/isle-config.self" isle-config.self + FILE "${CMAKE_CURRENT_BINARY_DIR}/CONFIG/vita/config_plugin.rco" config_plugin.rco + VERSION ${VITA_VERSION} + NAME ${VITA_APP_NAME} + ${VPK_FILE_ARGS} + ) + add_dependencies(isle.vpk-vpk config_plugin.rco_target) +endif() + if(MSVC OR IOS) set(CPACK_GENERATOR ZIP) if(IOS) diff --git a/CONFIG/AboutDlg.cpp b/CONFIG/qt/AboutDlg.cpp similarity index 100% rename from CONFIG/AboutDlg.cpp rename to CONFIG/qt/AboutDlg.cpp diff --git a/CONFIG/AboutDlg.h b/CONFIG/qt/AboutDlg.h similarity index 100% rename from CONFIG/AboutDlg.h rename to CONFIG/qt/AboutDlg.h diff --git a/CONFIG/MainDlg.cpp b/CONFIG/qt/MainDlg.cpp similarity index 100% rename from CONFIG/MainDlg.cpp rename to CONFIG/qt/MainDlg.cpp diff --git a/CONFIG/MainDlg.h b/CONFIG/qt/MainDlg.h similarity index 100% rename from CONFIG/MainDlg.h rename to CONFIG/qt/MainDlg.h diff --git a/CONFIG/config.cpp b/CONFIG/qt/config.cpp similarity index 100% rename from CONFIG/config.cpp rename to CONFIG/qt/config.cpp diff --git a/CONFIG/config.h b/CONFIG/qt/config.h similarity index 100% rename from CONFIG/config.h rename to CONFIG/qt/config.h diff --git a/CONFIG/detectdx5.cpp b/CONFIG/qt/detectdx5.cpp similarity index 100% rename from CONFIG/detectdx5.cpp rename to CONFIG/qt/detectdx5.cpp diff --git a/CONFIG/detectdx5.h b/CONFIG/qt/detectdx5.h similarity index 100% rename from CONFIG/detectdx5.h rename to CONFIG/qt/detectdx5.h diff --git a/CONFIG/res/about.ui b/CONFIG/qt/res/about.ui similarity index 100% rename from CONFIG/res/about.ui rename to CONFIG/qt/res/about.ui diff --git a/CONFIG/res/add.svg b/CONFIG/qt/res/add.svg similarity index 100% rename from CONFIG/res/add.svg rename to CONFIG/qt/res/add.svg diff --git a/CONFIG/res/config.qrc b/CONFIG/qt/res/config.qrc similarity index 100% rename from CONFIG/res/config.qrc rename to CONFIG/qt/res/config.qrc diff --git a/CONFIG/res/config.rc b/CONFIG/qt/res/config.rc similarity index 100% rename from CONFIG/res/config.rc rename to CONFIG/qt/res/config.rc diff --git a/CONFIG/res/lego.ico b/CONFIG/qt/res/lego.ico similarity index 100% rename from CONFIG/res/lego.ico rename to CONFIG/qt/res/lego.ico diff --git a/CONFIG/res/lego1.png b/CONFIG/qt/res/lego1.png similarity index 100% rename from CONFIG/res/lego1.png rename to CONFIG/qt/res/lego1.png diff --git a/CONFIG/res/lego2.png b/CONFIG/qt/res/lego2.png similarity index 100% rename from CONFIG/res/lego2.png rename to CONFIG/qt/res/lego2.png diff --git a/CONFIG/res/maindialog.ui b/CONFIG/qt/res/maindialog.ui similarity index 100% rename from CONFIG/res/maindialog.ui rename to CONFIG/qt/res/maindialog.ui diff --git a/CONFIG/res/remove.svg b/CONFIG/qt/res/remove.svg similarity index 100% rename from CONFIG/res/remove.svg rename to CONFIG/qt/res/remove.svg diff --git a/CONFIG/res/shark.png b/CONFIG/qt/res/shark.png similarity index 100% rename from CONFIG/res/shark.png rename to CONFIG/qt/res/shark.png diff --git a/CONFIG/vita/CMakeLists.txt b/CONFIG/vita/CMakeLists.txt new file mode 100644 index 00000000..6d44f518 --- /dev/null +++ b/CONFIG/vita/CMakeLists.txt @@ -0,0 +1,73 @@ +cmake_minimum_required(VERSION 3.25...4.0 FATAL_ERROR) + +project(isle-config LANGUAGES CXX C VERSION 0.1) + +include("${VITASDK}/share/vita.cmake" REQUIRED) + +include(FetchContent) +FetchContent_Declare( + ScePaf_External + URL https://github.com/olebeck/ScePaf/releases/download/v21/ScePaf-1.0.0.zip + URL_HASH SHA256=357b914a5c99ea17afe0edc8787a05cbf2ecce2f1d73bb9be69f371a294b8943 + UPDATE_DISCONNECTED TRUE +) +FetchContent_MakeAvailable(ScePaf_External) + + +FetchContent_Declare( + iniparser_paf + GIT_REPOSITORY "https://gitlab.com/iniparser/iniparser.git" + GIT_TAG "v4.2.6" + UPDATE_DISCONNECTED TRUE + EXCLUDE_FROM_ALL + PATCH_COMMAND patch -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/iniparser_paf.patch +) +block() + set(BUILD_DOCS off) + set(BUILD_SHARED_LIBS off) + FetchContent_MakeAvailable(iniparser_paf) +endblock() + +add_executable(isle-config + src/paf_runtime.cpp + src/app.cpp +) + +set_target_properties(isle-config PROPERTIES + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} +) + +target_compile_options(isle-config PRIVATE + -fno-rtti -fno-exceptions -Wl,-q -Wall -fno-builtin -fshort-wchar -Wno-unused-function -Wno-sign-compare -fno-use-cxa-atexit +) + +target_link_options(isle-config PRIVATE + -nostartfiles -nostdlib +) + +target_link_libraries(isle-config PRIVATE + SceAppMgr_stub + SceLibKernel_stub + SceSysmodule_stub + + ScePafToplevel_stub + ScePafResource_stub + ScePafWidget_stub + ScePafCommon_stub + ScePafStdc_stub + SceAppSettings_stub + SceFios2_stub + SceLibc_stub + + iniparser_paf-static +) + +vita_create_self(isle-config.self isle-config + CONFIG exports.yml + UNSAFE + STRIPPED + REL_OPTIMIZE +) + +include(${scepaf_external_SOURCE_DIR}/rco.cmake) +make_rco(cxml/config_plugin.xml config_plugin.rco) diff --git a/CONFIG/vita/cxml/config_plugin.xml b/CONFIG/vita/cxml/config_plugin.xml new file mode 100644 index 00000000..2f1df305 --- /dev/null +++ b/CONFIG/vita/cxml/config_plugin.xml @@ -0,0 +1,34 @@ + + + + + + + + + + + + + diff --git a/CONFIG/vita/cxml/locale/en.xml b/CONFIG/vita/cxml/locale/en.xml new file mode 100644 index 00000000..22435a39 --- /dev/null +++ b/CONFIG/vita/cxml/locale/en.xml @@ -0,0 +1,57 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CONFIG/vita/cxml/settings.xml b/CONFIG/vita/cxml/settings.xml new file mode 100644 index 00000000..e9dad3fb --- /dev/null +++ b/CONFIG/vita/cxml/settings.xml @@ -0,0 +1,51 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/CONFIG/vita/exports.yml b/CONFIG/vita/exports.yml new file mode 100644 index 00000000..d20ef9e2 --- /dev/null +++ b/CONFIG/vita/exports.yml @@ -0,0 +1,8 @@ +isle-config: + attributes: 0 + process_image: true + version: + major: 1 + minor: 1 + main: + start: module_start \ No newline at end of file diff --git a/CONFIG/vita/iniparser_paf.patch b/CONFIG/vita/iniparser_paf.patch new file mode 100644 index 00000000..e2cdacc8 --- /dev/null +++ b/CONFIG/vita/iniparser_paf.patch @@ -0,0 +1,53 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 4f7fdba..d388fc8 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -1,7 +1,7 @@ + cmake_minimum_required(VERSION 3.18) + + project( +- iniparser ++ iniparser_paf + DESCRIPTION "C library for parsing INI-style files" + HOMEPAGE_URL https://gitlab.com/iniparser/iniparser/ + LANGUAGES C +@@ -108,6 +108,19 @@ foreach(TARGET_TYPE ${TARGET_TYPES}) + -pedantic) + endif(UNIX) + ++ if(VITA) ++ target_compile_options( ++ ${TARGET_NAME} ++ PRIVATE -Wl,-q -Wall -fshort-wchar) ++ target_link_libraries( ++ ${TARGET_NAME} ++ PRIVATE SceLibc_stub ++ ) ++ target_link_options( ++ ${TARGET_NAME} ++ PUBLIC -nostartfiles -nostdlib) ++ endif() ++ + # install targets + install( + TARGETS ${TARGET_NAME} +diff --git a/src/iniparser.c b/src/iniparser.c +index 1086b46..8e0e9c2 100644 +--- a/src/iniparser.c ++++ b/src/iniparser.c +@@ -14,6 +14,15 @@ + #include + #include "iniparser.h" + ++#ifdef __vita__ ++extern FILE* _Stderr; ++#undef stderr ++#define stderr _Stderr ++extern const char _Ctype[]; ++#undef __locale_ctype_ptr ++#define __locale_ctype_ptr() _Ctype ++#endif ++ + /*---------------------------- Defines -------------------------------------*/ + #define ASCIILINESZ (1024) + #define INI_INVALID_KEY ((char*)-1) diff --git a/CONFIG/vita/src/app.cpp b/CONFIG/vita/src/app.cpp new file mode 100644 index 00000000..a97841db --- /dev/null +++ b/CONFIG/vita/src/app.cpp @@ -0,0 +1,430 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +int sceLibcHeapSize = 10 * 1024 * 1024; + +const char* g_iniPath = "ux0:data/isledecomp/isle/isle.ini"; + +paf::Framework* g_fw; +paf::Plugin* g_configPlugin; +sce::AppSettings* g_appSettings; +sce::AppSettings::Interface* g_appSetIf; + +void merge_dicts(dictionary* dst, dictionary* src) +{ + for (int i = 0; i < src->n; i++) { + dictionary_set(dst, src->key[i], src->val[i]); + } +} + +struct setting_map { + const char* key_ini; + const char* key_app; + const char type; +}; + +// mapping from ini key to settings.xml key +const setting_map key_map[] = { + // Game + {"isle:diskpath", "disk_path", 's'}, + {"isle:cdpath", "cd_path", 's'}, + {"isle:savepath", "save_path", 's'}, + {"isle:Transition Type", "transition_type", 'i'}, + {"isle:Music", "music", 'b'}, + {"isle:3DSound", "3d_sound", 'b'}, + + // Graphics + {"isle:Island Texture", "island_texture_quality", 'i'}, + {"isle:Island Quality", "island_model_quality", 'i'}, + //{"isle:Max LOD", "max_lod", 'f'}, + //{"isle:Max Allowed Extras", "max_extras", 'i' }, + {"isle:MSAA", "msaa", 'i'}, + + // Controls + {"isle:Touch Scheme", "touch_control_scheme", 'i'}, + {"isle:Haptic", "rumble", 'b'}, + + // Extensions + {"extensions:texture loader", "texture_loader_extension", 'b'}, + {"texture loader:texture path", "texture_loader_path", 's'} +}; + +struct Config { + sce::AppSettings* settings; + dictionary* dict; + char buffer[128]; + +#define GetDictInt(x, name) x = iniparser_getint(this->dict, name, x) +#define GetDictFloat(x, name) x = iniparser_getdouble(this->dict, name, x) +#define GetDictString(x, name) \ + { \ + const char* val = iniparser_getstring(this->dict, name, nullptr); \ + if (val != nullptr) { \ + x = val; \ + } \ + } +#define GetDictBool(x, name) x = iniparser_getboolean(this->dict, name, x) + +#define SetDictBool(NAME, VALUE) \ + { \ + const char* v = VALUE ? "true" : "false"; \ + sceClibPrintf("SetIniBool(%s, %s)\n", NAME, v); \ + iniparser_set(this->dict, NAME, v); \ + } +#define SetDictInt(NAME, VALUE) \ + { \ + sceClibSnprintf(buffer, sizeof(buffer), "%d", VALUE); \ + sceClibPrintf("SetIniInt(%s, %d)\n", NAME, VALUE); \ + iniparser_set(this->dict, NAME, buffer); \ + } +#define SetDictFloat(NAME, VALUE) \ + { \ + sceClibSnprintf(buffer, sizeof(buffer), "%f", VALUE); \ + sceClibPrintf("SetIniFloat(%s, %f)\n", NAME, VALUE); \ + iniparser_set(this->dict, NAME, buffer); \ + } +#define SetDictString(NAME, VALUE) \ + { \ + sceClibPrintf("SetString(%s, %s)\n", NAME, VALUE); \ + iniparser_set(this->dict, NAME, VALUE); \ + } + + void Init(sce::AppSettings* settings) + { + this->settings = settings; + dict = dictionary_new(0); + + // set defaults + iniparser_set(this->dict, "isle", nullptr); + iniparser_set(dict, "extensions", NULL); + iniparser_set(this->dict, "texture loader", nullptr); + + SetDictString("isle:diskpath", "ux0:data/isledecomp/isle/disk"); + SetDictString("isle:cdpath", "ux0:data/isledecomp/isle/cd"); + SetDictString("isle:savepath", "ux0:data/isledecomp/isle"); + SetDictInt("isle:MSAA", 4); + + SetDictInt("isle:Display Bit Depth", 32); + SetDictBool("isle:Flip Surfaces", false); + SetDictBool("isle:Full Screen", true); + SetDictBool("isle:Exclusive Full Screen", true); + SetDictBool("isle:Wide View Angle", true); + + SetDictInt("isle:Transition Type", 3); // 3: Mosaic + SetDictInt("isle:Touch Scheme", 2); + + SetDictBool("isle:3DSound", true); + SetDictBool("isle:Music", true); + SetDictBool("isle:Haptic", true); + + SetDictBool("isle:UseJoystick", true); + SetDictInt("isle:JoystickIndex", 0); + SetDictBool("isle:Draw Cursor", true); + + SetDictBool("extensions:texture loader", false); + SetDictString("texture loader:texture path", "textures/"); + + SetDictBool("isle:Back Buffers in Video RAM", true); + + SetDictInt("isle:Island Quality", 2); + SetDictInt("isle:Island Texture", 1); + SetDictInt("isle:MSAA", 4); + + SetDictFloat("isle:Max LOD", 3.5); + SetDictInt("isle:Max Allowed Extras", 20); + + SetDictInt("isle:Aspect Ratio", 0); + SetDictInt("isle:Horizontal Resolution", 640); + SetDictInt("isle:Vertical Resolution", 480); + SetDictFloat("isle:Frame Delta", 10.0f); + } + + void LoadIni() + { + dictionary* ini = iniparser_load(g_iniPath); + if (ini) { + merge_dicts(this->dict, ini); + iniparser_freedict(ini); + } + } + + bool SaveIni() + { + FILE* fd = fopen(g_iniPath, "w"); + if (fd) { + iniparser_dump_ini(this->dict, fd); + } + else { + sceClibPrintf("failed to write isle.ini\n"); + } + return true; + } + + void ToSettings() + { + const int len = sizeof(key_map) / sizeof(key_map[0]); + for (int i = 0; i < len; i++) { + const setting_map m = key_map[i]; + switch (m.type) { + case 'f': // float, AppSettings doesnt have float so just use string + case 's': { + const char* value = iniparser_getstring(this->dict, m.key_ini, ""); + this->settings->SetString(m.key_app, value); + sceClibPrintf("ini->settings %s = %s\n", m.key_app, value); + break; + } + case 'i': { + int32_t value = iniparser_getint(this->dict, m.key_ini, 0); + this->settings->SetInt(m.key_app, value); + sceClibPrintf("ini->settings %s = %d\n", m.key_app, value); + break; + } + case 'b': { + bool value = iniparser_getboolean(this->dict, m.key_ini, 0) == 1; + this->settings->SetBool(m.key_app, value); + sceClibPrintf("ini->settings %s = %s\n", m.key_app, value ? "true" : "false"); + break; + } + default: { + sceClibPrintf("invalid setting map entry %s %s %c\n", m.key_app, m.key_ini, m.type); + } + } + } + } + + void FromSettings() + { + const int len = sizeof(key_map) / sizeof(key_map[0]); + for (int i = 0; i < len; i++) { + const setting_map m = key_map[i]; + switch (m.type) { + case 'f': // float, AppSettings doesnt have float so just use string + case 's': { + const char* def = iniparser_getstring(this->dict, m.key_ini, ""); + this->settings->GetString(m.key_app, this->buffer, sizeof(this->buffer), def); + iniparser_set(this->dict, m.key_ini, buffer); + sceClibPrintf("settings->ini %s = %s\n", m.key_ini, buffer); + break; + } + case 'i': { + int32_t value = iniparser_getint(this->dict, m.key_ini, 0); + this->settings->GetInt(m.key_app, &value, value); + SetDictInt(m.key_ini, value); + sceClibPrintf("settings->ini %s = %d\n", m.key_ini, value); + break; + } + case 'b': { + bool value = iniparser_getboolean(this->dict, m.key_ini, 0) == 1; + this->settings->GetBool(m.key_app, &value, value); + SetDictBool(m.key_ini, value); + sceClibPrintf("settings->ini %s = %s\n", m.key_ini, value ? "true" : "false"); + break; + } + default: { + sceClibPrintf("invalid setting map entry %s %s %c\n", m.key_app, m.key_ini, m.type); + } + } + } + } +}; + +Config g_config; + +paf::Plugin* load_config_plugin(paf::Framework* paf_fw) +{ + paf::Plugin::InitParam pluginParam; + pluginParam.name = "config_plugin"; + pluginParam.caller_name = "__main__"; + pluginParam.resource_file = "app0:/config_plugin.rco"; + pluginParam.init_func = NULL; + pluginParam.start_func = NULL; + pluginParam.stop_func = NULL; + pluginParam.exit_func = NULL; + paf::Plugin::LoadSync(pluginParam); + return paf_fw->FindPlugin("config_plugin"); +} + +int load_app_settings_plugin() +{ + paf::Plugin::InitParam pluginParam; + sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_BXCE); + sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_INI_FILE_PROCESSOR); + sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_COMMON_GUI_DIALOG); + + pluginParam.name = "app_settings_plugin"; + pluginParam.resource_file = "vs0:vsh/common/app_settings_plugin.rco"; + pluginParam.caller_name = "__main__"; + pluginParam.set_param_func = sce::AppSettings::PluginSetParamCB; + pluginParam.init_func = sce::AppSettings::PluginInitCB; + pluginParam.start_func = sce::AppSettings::PluginStartCB; + pluginParam.stop_func = sce::AppSettings::PluginStopCB; + pluginParam.exit_func = sce::AppSettings::PluginExitCB; + pluginParam.module_file = "vs0:vsh/common/app_settings.suprx"; + pluginParam.draw_priority = 0x96; + paf::Plugin::LoadSync(pluginParam); + return 0; +} + +int exit_type = 0; + +void save_and_exit() +{ + g_config.FromSettings(); + g_config.SaveIni(); + g_fw->RequestShutdown(); + exit_type = 1; +} + +void save_and_launch() +{ + g_config.FromSettings(); + g_config.SaveIni(); + g_fw->RequestShutdown(); + exit_type = 2; +} + +void CBOnStartPageTransition(const char* elementId, int32_t type) +{ +} + +void CBOnPageActivate(const char* elementId, int32_t type) +{ +} + +void CBOnPageDeactivate(const char* elementId, int32_t type) +{ +} + +int32_t CBOnCheckVisible(const char* elementId, bool* pIsVisible) +{ + *pIsVisible = true; + return SCE_OK; +} + +int32_t CBOnPreCreate(const char* elementId, sce::AppSettings::Element* element) +{ + return SCE_OK; +} + +int32_t CBOnPostCreate(const char* elementId, paf::ui::Widget* widget) +{ + return SCE_OK; +} + +int32_t CBOnPress(const char* elementId, const char* newValue) +{ + if (sce_paf_strcmp(elementId, "save_exit_button") == 0) { + save_and_exit(); + return SCE_OK; + } + + if (sce_paf_strcmp(elementId, "save_launch_button") == 0) { + save_and_launch(); + return SCE_OK; + } + + sceClibPrintf("OnPress %s %s\n", elementId, newValue); + return SCE_OK; +} + +int32_t CBOnPress2(const char* elementId, const char* newValue) +{ + return SCE_OK; +} + +void CBOnTerm(int32_t result) +{ + if (exit_type == 0) { + sceKernelExitProcess(0); + } +} + +const wchar_t* CBOnGetString(const char* elementId) +{ + wchar_t* res = g_configPlugin->GetString(elementId); + if (res[0] != 0) { + return res; + } + return L"unknown string"; +} + +int32_t CBOnGetSurface(paf::graph::Surface** surf, const char* elementId) +{ + return SCE_OK; +} + +void open_settings() +{ + g_config.Init(g_appSettings); + g_config.LoadIni(); + g_config.ToSettings(); + + sce::AppSettings::InterfaceCallbacks ifCb; + ifCb.onStartPageTransitionCb = CBOnStartPageTransition; + ifCb.onPageActivateCb = CBOnPageActivate; + ifCb.onPageDeactivateCb = CBOnPageDeactivate; + ifCb.onCheckVisible = CBOnCheckVisible; + ifCb.onPreCreateCb = CBOnPreCreate; + ifCb.onPostCreateCb = CBOnPostCreate; + ifCb.onPressCb = CBOnPress; + ifCb.onPressCb2 = CBOnPress2; + ifCb.onTermCb = CBOnTerm; + ifCb.onGetStringCb = (sce::AppSettings::InterfaceCallbacks::GetStringCallback) CBOnGetString; + ifCb.onGetSurfaceCb = CBOnGetSurface; + + paf::wstring msg_save_exit(g_configPlugin->GetString("msg_save_exit")); + paf::wstring msg_save_launch(g_configPlugin->GetString("msg_save_launch")); + paf::wstring msg_exit(g_configPlugin->GetString("msg_exit")); + + paf::Plugin* appSetPlug = paf::Plugin::Find("app_settings_plugin"); + g_appSetIf = (sce::AppSettings::Interface*) appSetPlug->GetInterface(1); + g_appSetIf->Show(&ifCb); + g_appSetIf->AddFooterButton("save_exit_button", &msg_save_exit, 1); + g_appSetIf->AddFooterButton("save_launch_button", &msg_save_launch, 2); + g_appSetIf->ShowFooter(); +} + +int main() +{ + paf::Framework::InitParam fwParam; + fwParam.mode = paf::Framework::Mode_Normal; + + paf::Framework* paf_fw = new paf::Framework(fwParam); + g_fw = paf_fw; + + paf_fw->LoadCommonResourceSync(); + load_app_settings_plugin(); + paf::Plugin* configPlugin = load_config_plugin(paf_fw); + g_configPlugin = configPlugin; + configPlugin->SetLocale(Locale_EN); + + size_t fileSize = 0; + const char* mimeType = nullptr; + auto settingsXmlFile = configPlugin->GetResource()->GetFile("settings.xml", &fileSize, &mimeType); + + sce::AppSettings::InitParam settingsParam; + settingsParam.xml_file = settingsXmlFile; + settingsParam.alloc_cb = sce_paf_malloc; + settingsParam.free_cb = sce_paf_free; + settingsParam.realloc_cb = sce_paf_realloc; + settingsParam.safemem_offset = 0; + settingsParam.safemem_size = 0x400; + + sce::AppSettings::GetInstance(settingsParam, &g_appSettings); + g_appSettings->Initialize(); + + open_settings(); + paf_fw->Run(); + + if (exit_type == 2) { + int ret = sceAppMgrLoadExec("app0:/eboot.bin", NULL, NULL); + printf("sceAppMgrLoadExec: %08x\n", ret); + } + return 0; +} diff --git a/CONFIG/vita/src/paf_runtime.cpp b/CONFIG/vita/src/paf_runtime.cpp new file mode 100644 index 00000000..31266a1d --- /dev/null +++ b/CONFIG/vita/src/paf_runtime.cpp @@ -0,0 +1,169 @@ +#include +#include +#include +#include +#include + +char sceUserMainThreadName[] = "isle_config"; +int sceUserMainThreadPriority = 0x10000100; +int sceUserMainThreadCpuAffinityMask = 0x70000; +SceSize sceUserMainThreadStackSize = 0x4000; + +void operator delete(void* ptr, unsigned int n) +{ + return sce_paf_free(ptr); +} + +extern "C" +{ + void user_malloc_init() + { + } + + void user_malloc_finalize(void) + { + } + + void* user_malloc(size_t size) + { + return sce_paf_malloc(size); + } + + void user_free(void* ptr) + { + sce_paf_free(ptr); + } + + void* user_calloc(size_t nelem, size_t size) + { + return sce_paf_calloc(nelem, size); + } + + void* user_realloc(void* ptr, size_t new_size) + { + return sce_paf_realloc(ptr, new_size); + } + + void* user_memalign(size_t boundary, size_t size) + { + return sce_paf_memalign(boundary, size); + } + + void* user_reallocalign(void* ptr, size_t size, size_t boundary) + { + sceClibPrintf("[PAF2LIBC] reallocalign is not supported\n"); + abort(); + return NULL; + } + + int user_malloc_stats(struct malloc_managed_size* mmsize) + { + sceClibPrintf("malloc_stats\n"); + abort(); + return 0; + } + + int user_malloc_stats_fast(struct malloc_managed_size* mmsize) + { + sceClibPrintf("user_malloc_stats_fast\n"); + abort(); + return 0; + } + + size_t user_malloc_usable_size(void* ptr) + { + return sce_paf_musable_size(ptr); + } +} + +void* user_new(std::size_t size) +{ + return sce_paf_malloc(size); +} + +void* user_new(std::size_t size, const std::nothrow_t& x) +{ + return sce_paf_malloc(size); +} + +void* user_new_array(std::size_t size) +{ + return sce_paf_malloc(size); +} + +void* user_new_array(std::size_t size, const std::nothrow_t& x) +{ + return sce_paf_malloc(size); +} + +void user_delete(void* ptr) +{ + sce_paf_free(ptr); +} + +void user_delete(void* ptr, const std::nothrow_t& x) +{ + sce_paf_free(ptr); +} + +void user_delete_array(void* ptr) +{ + sce_paf_free(ptr); +} + +void user_delete_array(void* ptr, const std::nothrow_t& x) +{ + sce_paf_free(ptr); +} + +int paf_init() +{ + int load_res; + ScePafInit init_param; + SceSysmoduleOpt sysmodule_opt; + + init_param.global_heap_size = 0x1000000; + init_param.cdlg_mode = 0; + init_param.global_heap_alignment = 0; + init_param.global_heap_disable_assert_on_alloc_failure = 0; + + load_res = 0xDEADBEEF; + sysmodule_opt.flags = 0; + sysmodule_opt.result = &load_res; + + int res = sceSysmoduleLoadModuleInternalWithArg( + SCE_SYSMODULE_INTERNAL_PAF, + sizeof(init_param), + &init_param, + &sysmodule_opt + ); + if ((res | load_res) != 0) { + sceClibPrintf( + "[PAF PRX Loader] Failed to load the PAF prx. (return value 0x%x, result code 0x%x )\n", + res, + load_res + ); + return -1; + } + return 0; +} + +int main(); + +extern "C" int module_start(SceSize args, void* argp) +{ + int res = paf_init(); + if (res < 0) { + sceKernelExitProcess(res); + return SCE_KERNEL_START_FAILED; + } + + res = main(); + sceKernelExitProcess(res); + return SCE_KERNEL_START_SUCCESS; +} + +extern "C" void _start() +{ + module_start(0, nullptr); +} diff --git a/ISLE/isleapp.cpp b/ISLE/isleapp.cpp index c7444362..7b0fa23d 100644 --- a/ISLE/isleapp.cpp +++ b/ISLE/isleapp.cpp @@ -77,6 +77,14 @@ #include "android/config.h" #endif +#ifdef __vita__ +#include "vita/config.h" +#include "vita/messagebox.h" + +#include +#include +#endif + DECOMP_SIZE_ASSERT(IsleApp, 0x8c) // GLOBAL: ISLE 0x410030 @@ -316,6 +324,23 @@ SDL_AppResult SDL_AppInit(void** appstate, int argc, char** argv) // Create global app instance g_isle = new IsleApp(); +#ifdef __vita__ + SceAppUtilInitParam appUtilInitParam = {0}; + SceAppUtilBootParam appUtilBootParam = {0}; + sceAppUtilInit(&appUtilInitParam, &appUtilBootParam); + SceAppUtilAppEventParam eventParam = {0}; + sceAppUtilReceiveAppEvent(&eventParam); + if (eventParam.type == 0x05) { + g_isle->LoadConfig(); + char buffer[2048]; + sceAppUtilAppEventParseLiveArea(&eventParam, buffer); + if (strstr(buffer, "-config")) { + sceClibPrintf("Loading Config App.\n"); + sceAppMgrLoadExec("app0:/isle-config.self", NULL, NULL); + } + } +#endif + switch (g_isle->ParseArguments(argc, argv)) { case SDL_APP_FAILURE: Any_ShowSimpleMessageBox( @@ -452,6 +477,19 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) break; } +#ifdef __vita__ + // reject back touch panel + switch (event->type) { + case SDL_EVENT_FINGER_MOTION: + case SDL_EVENT_FINGER_DOWN: + case SDL_EVENT_FINGER_UP: + case SDL_EVENT_FINGER_CANCELED: + if (event->tfinger.touchID == 2) { + return SDL_APP_CONTINUE; + } + } +#endif + switch (event->type) { case SDL_EVENT_WINDOW_FOCUS_GAINED: if (!IsleDebug_Enabled()) { @@ -556,7 +594,11 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) } break; +#ifdef __vita__ // conflicts with screenshot button combination + case SDL_GAMEPAD_BUTTON_BACK: +#else case SDL_GAMEPAD_BUTTON_START: +#endif if (InputManager()) { InputManager()->QueueEvent(c_notificationKeyPress, SDLK_ESCAPE, 0, 0, SDLK_ESCAPE); } @@ -884,7 +926,7 @@ MxResult IsleApp::SetupWindow() SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, g_targetHeight); SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN, m_fullScreen); SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING, WINDOW_TITLE); -#if defined(MINIWIN) && !defined(__3DS__) && !defined(WINDOWS_STORE) +#if defined(MINIWIN) && !defined(__3DS__) && !defined(WINDOWS_STORE) && !defined(__vita__) SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN, true); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); @@ -1110,6 +1152,9 @@ bool IsleApp::LoadConfig() Android_SetupDefaultConfigOverrides(dict); #endif +#ifdef __vita__ + VITA_SetupDefaultConfigOverrides(dict); +#endif iniparser_dump_ini(dict, iniFP); SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "New config written at '%s'", iniConfig.GetData()); fclose(iniFP); diff --git a/ISLE/vita/config.cpp b/ISLE/vita/config.cpp new file mode 100644 index 00000000..40979ba2 --- /dev/null +++ b/ISLE/vita/config.cpp @@ -0,0 +1,13 @@ +#include "config.h" + +#include +#include + +void VITA_SetupDefaultConfigOverrides(dictionary* p_dictionary) +{ + SDL_Log("Overriding default config for VITA"); + + iniparser_set(p_dictionary, "isle:diskpath", "ux0:data/isledecomp/isle/disk"); + iniparser_set(p_dictionary, "isle:cdpath", "ux0:data/isledecomp/isle/cd"); + iniparser_set(p_dictionary, "isle:MSAA", "4"); +} diff --git a/ISLE/vita/config.h b/ISLE/vita/config.h new file mode 100644 index 00000000..9c725c6f --- /dev/null +++ b/ISLE/vita/config.h @@ -0,0 +1,8 @@ +#ifndef VITA_CONFIG_H +#define VITA_CONFIG_H + +#include "dictionary.h" + +void VITA_SetupDefaultConfigOverrides(dictionary* p_dictionary); + +#endif // VITA_CONFIG_H diff --git a/ISLE/vita/messagebox.cpp b/ISLE/vita/messagebox.cpp new file mode 100644 index 00000000..6b3a485e --- /dev/null +++ b/ISLE/vita/messagebox.cpp @@ -0,0 +1,52 @@ +#include "messagebox.h" + +#include "../../miniwin/src/d3drm/backends/gxm/gxm_context.h" + +#include +#include + +bool Vita_ShowSimpleMessageBox(SDL_MessageBoxFlags flags, const char* title, const char* message, SDL_Window* window) +{ + int ret; + SceMsgDialogParam param; + SceMsgDialogUserMessageParam msgParam; + SceMsgDialogButtonsParam buttonParam; + SceMsgDialogResult dialog_result; + SceCommonDialogErrorCode init_result; + bool setup_minimal_gxm = false; + + SDL_zero(param); + sceMsgDialogParamInit(¶m); + param.mode = SCE_MSG_DIALOG_MODE_USER_MSG; + + SDL_zero(msgParam); + char message_data[0x1000]; + SDL_snprintf(message_data, sizeof(message_data), "%s\r\n\r\n%s", title, message); + + msgParam.msg = (const SceChar8*) message_data; + msgParam.buttonType = SCE_MSG_DIALOG_BUTTON_TYPE_OK; + param.userMsgParam = &msgParam; + + if (!gxm) { + gxm = (GXMContext*) SDL_malloc(sizeof(GXMContext)); + } + if (ret = gxm->init(SCE_GXM_MULTISAMPLE_NONE); ret < 0) { + return false; + } + + init_result = (SceCommonDialogErrorCode) sceMsgDialogInit(¶m); + if (init_result >= 0) { + while (sceMsgDialogGetStatus() == SCE_COMMON_DIALOG_STATUS_RUNNING) { + gxm->clear(0, 0, 0, true); + gxm->swap_display(); + } + SDL_zero(dialog_result); + sceMsgDialogGetResult(&dialog_result); + sceMsgDialogTerm(); + return dialog_result.buttonId == SCE_MSG_DIALOG_BUTTON_ID_OK; + } + else { + return false; + } + return true; +} diff --git a/ISLE/vita/messagebox.h b/ISLE/vita/messagebox.h new file mode 100644 index 00000000..7ad877ee --- /dev/null +++ b/ISLE/vita/messagebox.h @@ -0,0 +1,8 @@ +#ifndef VITA_MESSAGE_BOX_H +#define VITA_MESSAGE_BOX_H + +#include + +bool Vita_ShowSimpleMessageBox(SDL_MessageBoxFlags flags, const char* title, const char* message, SDL_Window* window); + +#endif // VITA_MESSAGE_BOX_H diff --git a/README.md b/README.md index a6bd8eff..435e7628 100644 --- a/README.md +++ b/README.md @@ -18,6 +18,7 @@ Please note: this project is primarily dedicated to achieving platform independe | Xbox One | [![CI](https://github.com/isledecomp/isle-portable/actions/workflows/ci.yml/badge.svg)](https://github.com/isledecomp/isle-portable/actions/workflows/ci.yml) | | iOS | [![CI](https://github.com/isledecomp/isle-portable/actions/workflows/ci.yml/badge.svg)](https://github.com/isledecomp/isle-portable/actions/workflows/ci.yml) | | Android | [![CI](https://github.com/isledecomp/isle-portable/actions/workflows/ci.yml/badge.svg)](https://github.com/isledecomp/isle-portable/actions/workflows/ci.yml) | +| Playstation Vita | [![CI](https://github.com/isledecomp/isle-portable/actions/workflows/ci.yml/badge.svg)](https://github.com/isledecomp/isle-portable/actions/workflows/ci.yml) | We are actively working to support more platforms. If you have experience with a particular platform, we encourage you to contribute to `isle-portable`. You can find a [list of ongoing efforts](https://github.com/isledecomp/isle-portable/wiki/Work%E2%80%90in%E2%80%90progress-ports) in our Wiki. diff --git a/miniwin/CMakeLists.txt b/miniwin/CMakeLists.txt index 07f40b04..4293780e 100644 --- a/miniwin/CMakeLists.txt +++ b/miniwin/CMakeLists.txt @@ -30,7 +30,7 @@ target_compile_definitions(miniwin PRIVATE list(APPEND GRAPHICS_BACKENDS USE_SOFTWARE_RENDER) list(APPEND GRAPHICS_BACKENDS USE_SDL_GPU) -if(NOT WINDOWS_STORE) +if(NOT (VITA OR WINDOWS_STORE)) find_package(OpenGL) if(OpenGL_FOUND) message(STATUS "Found OpenGL: enabling OpenGL 1.x renderer") @@ -69,6 +69,25 @@ if(NOT WINDOWS_STORE) endif() endif() +if(VITA) + add_subdirectory(src/d3drm/backends/gxm/shaders) + + target_sources(miniwin PRIVATE + src/d3drm/backends/gxm/gxm_context.cpp + src/d3drm/backends/gxm/gxm_renderer.cpp + src/d3drm/backends/gxm/gxm_memory.cpp + src/d3drm/backends/gxm/tlsf.c + ) + target_link_libraries(miniwin PRIVATE + SceGxm_stub + SceRazorCapture_stub + SceRazorHud_stub + taihen_stub + gxm_shaders + ) + list(APPEND GRAPHICS_BACKENDS USE_GXM) + list(REMOVE_ITEM GRAPHICS_BACKENDS USE_SOFTWARE_RENDER USE_SDL_GPU) +endif() if(NINTENDO_3DS) if(ISLE_DEBUG) diff --git a/miniwin/src/d3drm/backends/gxm/gxm_context.cpp b/miniwin/src/d3drm/backends/gxm/gxm_context.cpp new file mode 100644 index 00000000..1e13d1d0 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/gxm_context.cpp @@ -0,0 +1,680 @@ +#include "gxm_context.h" + +#include "gxm_memory.h" +#include "shaders/gxm_shaders.h" +#include "tlsf.h" +#include "utils.h" + +#include +#include +#include +#include +#include + +static bool gxm_initialized = false; + +bool with_razor_capture; +bool with_razor_hud; + +#define CDRAM_POOL_SIZE 64 * 1024 * 1024 +#define VITA_GXM_COLOR_FORMAT SCE_GXM_COLOR_FORMAT_A8B8G8R8 + +typedef struct GXMDisplayData { + void* address; + int index; +} GXMDisplayData; + +static void display_callback(const void* callback_data) +{ + const GXMDisplayData* display_data = (const GXMDisplayData*) callback_data; + + SceDisplayFrameBuf framebuf; + SDL_memset(&framebuf, 0x00, sizeof(SceDisplayFrameBuf)); + framebuf.size = sizeof(SceDisplayFrameBuf); + framebuf.base = display_data->address; + framebuf.pitch = VITA_GXM_SCREEN_STRIDE; + framebuf.pixelformat = VITA_GXM_PIXEL_FORMAT; + framebuf.width = VITA_GXM_SCREEN_WIDTH; + framebuf.height = VITA_GXM_SCREEN_HEIGHT; + sceDisplaySetFrameBuf(&framebuf, SCE_DISPLAY_SETBUF_NEXTFRAME); + sceDisplayWaitSetFrameBuf(); +} + +#ifdef GXM_WITH_RAZOR +static int load_suprx(const char* name) +{ + sceClibPrintf("loading %s\n", name); + int modid = _sceKernelLoadModule(name, 0, nullptr); + if (modid < 0) { + sceClibPrintf("%s load: 0x%08x\n", name, modid); + return modid; + } + int status; + int ret = sceKernelStartModule(modid, 0, nullptr, 0, nullptr, &status); + if (ret < 0) { + sceClibPrintf("%s start: 0x%08x\n", name, ret); + } + return ret; +} + +static void load_razor() +{ + with_razor_capture = false; + with_razor_hud = false; + if (load_suprx("app0:librazorcapture_es4.suprx") >= 0) { + with_razor_capture = true; + } + + if (with_razor_capture) { + // sceRazorGpuCaptureEnableSalvage("ux0:data/gpu_crash.sgx"); + } + + if (with_razor_hud) { + sceRazorGpuTraceSetFilename("ux0:data/gpu_trace", 3); + } +} +#endif + +int gxm_library_init() +{ + if (gxm_initialized) { + return 0; + } + +#ifdef GXM_WITH_RAZOR + load_razor(); +#endif + + SceGxmInitializeParams initializeParams; + SDL_memset(&initializeParams, 0, sizeof(SceGxmInitializeParams)); + initializeParams.flags = 0; + initializeParams.displayQueueMaxPendingCount = VITA_GXM_PENDING_SWAPS; + initializeParams.displayQueueCallback = display_callback; + initializeParams.displayQueueCallbackDataSize = sizeof(GXMDisplayData); + initializeParams.parameterBufferSize = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE; + + int err = sceGxmInitialize(&initializeParams); + if (err != 0) { + SDL_LogError(SDL_LOG_CATEGORY_RENDER, "gxm init failed: %d", err); + return err; + } + gxm_initialized = true; + return 0; +} + +GXMContext* gxm; + +void GXMContext::init_cdram_allocator() +{ + // allocator + this->cdramMem = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, + CDRAM_POOL_SIZE, + 16, + SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, + &this->cdramUID, + "cdram_pool" + ); + this->cdramPool = SDL_malloc(tlsf_size()); + tlsf_create(this->cdramPool); + tlsf_add_pool(this->cdramPool, this->cdramMem, CDRAM_POOL_SIZE); +} + +int GXMContext::init_context() +{ + int ret; + + const unsigned int patcherBufferSize = 64 * 1024; + const unsigned int patcherVertexUsseSize = 64 * 1024; + const unsigned int patcherFragmentUsseSize = 64 * 1024; + + // allocate buffers + this->vdmRingBuffer = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE, + 4, + SCE_GXM_MEMORY_ATTRIB_READ, + &this->vdmRingBufferUid, + "vdmRingBuffer" + ); + + this->vertexRingBuffer = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE, + 4, + SCE_GXM_MEMORY_ATTRIB_READ, + &this->vertexRingBufferUid, + "vertexRingBuffer" + ); + + this->fragmentRingBuffer = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE, + 4, + SCE_GXM_MEMORY_ATTRIB_READ, + &this->fragmentRingBufferUid, + "fragmentRingBuffer" + ); + + this->fragmentUsseRingBuffer = vita_mem_fragment_usse_alloc( + SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE, + &this->fragmentUsseRingBufferUid, + &this->fragmentUsseRingBufferOffset + ); + + // create context + SceGxmContextParams contextParams; + memset(&contextParams, 0, sizeof(SceGxmContextParams)); + contextParams.hostMem = SDL_malloc(SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE); + contextParams.hostMemSize = SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE; + contextParams.vdmRingBufferMem = this->vdmRingBuffer; + contextParams.vdmRingBufferMemSize = SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE; + contextParams.vertexRingBufferMem = this->vertexRingBuffer; + contextParams.vertexRingBufferMemSize = SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE; + contextParams.fragmentRingBufferMem = this->fragmentRingBuffer; + contextParams.fragmentRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE; + contextParams.fragmentUsseRingBufferMem = this->fragmentUsseRingBuffer; + contextParams.fragmentUsseRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE; + contextParams.fragmentUsseRingBufferOffset = this->fragmentUsseRingBufferOffset; + + ret = SCE_ERR(sceGxmCreateContext, &contextParams, &this->context); + if (ret < 0) { + return ret; + } + this->contextHostMem = contextParams.hostMem; + + // shader patcher + this->patcherBuffer = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + patcherBufferSize, + 4, + SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, + &this->patcherBufferUid, + "patcherBuffer" + ); + + this->patcherVertexUsse = + vita_mem_vertex_usse_alloc(patcherVertexUsseSize, &this->patcherVertexUsseUid, &this->patcherVertexUsseOffset); + + this->patcherFragmentUsse = vita_mem_fragment_usse_alloc( + patcherFragmentUsseSize, + &this->patcherFragmentUsseUid, + &this->patcherFragmentUsseOffset + ); + + SceGxmShaderPatcherParams patcherParams; + memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams)); + patcherParams.userData = NULL; + patcherParams.hostAllocCallback = &patcher_host_alloc; + patcherParams.hostFreeCallback = &patcher_host_free; + patcherParams.bufferAllocCallback = NULL; + patcherParams.bufferFreeCallback = NULL; + patcherParams.bufferMem = this->patcherBuffer; + patcherParams.bufferMemSize = patcherBufferSize; + patcherParams.vertexUsseAllocCallback = NULL; + patcherParams.vertexUsseFreeCallback = NULL; + patcherParams.vertexUsseMem = this->patcherVertexUsse; + patcherParams.vertexUsseMemSize = patcherVertexUsseSize; + patcherParams.vertexUsseOffset = this->patcherVertexUsseOffset; + patcherParams.fragmentUsseAllocCallback = NULL; + patcherParams.fragmentUsseFreeCallback = NULL; + patcherParams.fragmentUsseMem = this->patcherFragmentUsse; + patcherParams.fragmentUsseMemSize = patcherFragmentUsseSize; + patcherParams.fragmentUsseOffset = this->patcherFragmentUsseOffset; + + ret = SCE_ERR(sceGxmShaderPatcherCreate, &patcherParams, &this->shaderPatcher); + if (ret < 0) { + return ret; + } + return 0; +} + +int GXMContext::create_display_buffers(SceGxmMultisampleMode msaaMode) +{ + int ret; + + const uint32_t alignedWidth = ALIGN(VITA_GXM_SCREEN_WIDTH, SCE_GXM_TILE_SIZEX); + const uint32_t alignedHeight = ALIGN(VITA_GXM_SCREEN_HEIGHT, SCE_GXM_TILE_SIZEY); + uint32_t sampleCount = alignedWidth * alignedHeight; + uint32_t depthStrideInSamples = alignedWidth; + + if (msaaMode == SCE_GXM_MULTISAMPLE_4X) { + sampleCount *= 4; + depthStrideInSamples *= 2; + } + else if (msaaMode == SCE_GXM_MULTISAMPLE_2X) { + sampleCount *= 2; + } + + // render target + SceGxmRenderTargetParams renderTargetParams; + memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams)); + renderTargetParams.flags = 0; + renderTargetParams.width = VITA_GXM_SCREEN_WIDTH; + renderTargetParams.height = VITA_GXM_SCREEN_HEIGHT; + renderTargetParams.scenesPerFrame = 1; + renderTargetParams.multisampleMode = msaaMode; + renderTargetParams.multisampleLocations = 0; + renderTargetParams.driverMemBlock = -1; // Invalid UID + ret = SCE_ERR(sceGxmCreateRenderTarget, &renderTargetParams, &this->renderTarget); + if (ret < 0) { + return ret; + } + this->renderTargetInit = true; + + for (int i = 0; i < GXM_DISPLAY_BUFFER_COUNT; i++) { + this->displayBuffers[i] = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, + 4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT, + SCE_GXM_COLOR_SURFACE_ALIGNMENT, + SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, + &this->displayBuffersUid[i], + "displayBuffers" + ); + + ret = SCE_ERR( + sceGxmColorSurfaceInit, + &this->displayBuffersSurface[i], + SCE_GXM_COLOR_FORMAT_A8B8G8R8, + SCE_GXM_COLOR_SURFACE_LINEAR, + (msaaMode == SCE_GXM_MULTISAMPLE_NONE) ? SCE_GXM_COLOR_SURFACE_SCALE_NONE + : SCE_GXM_COLOR_SURFACE_SCALE_MSAA_DOWNSCALE, + SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT, + VITA_GXM_SCREEN_WIDTH, + VITA_GXM_SCREEN_HEIGHT, + VITA_GXM_SCREEN_STRIDE, + this->displayBuffers[i] + ); + if (ret < 0) { + return ret; + } + + ret = SCE_ERR(sceGxmSyncObjectCreate, &this->displayBuffersSync[i]); + if (ret < 0) { + return ret; + } + } + + // depth & stencil + this->depthBufferData = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + 4 * sampleCount, + SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, + SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, + &this->depthBufferUid, + "depthBufferData" + ); + + this->stencilBufferData = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + 1 * sampleCount, + SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, + SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, + &this->stencilBufferUid, + "stencilBufferData" + ); + + ret = SCE_ERR( + sceGxmDepthStencilSurfaceInit, + &this->depthSurface, + SCE_GXM_DEPTH_STENCIL_FORMAT_DF32_S8, + SCE_GXM_DEPTH_STENCIL_SURFACE_TILED, + depthStrideInSamples, + this->depthBufferData, + this->stencilBufferData + ); + if (ret < 0) { + return ret; + } + + return 0; +} + +void GXMContext::destroy_display_buffers() +{ + if (this->renderTargetInit) { + sceGxmFinish(this->context); + sceGxmDestroyRenderTarget(this->renderTarget); + this->renderTargetInit = false; + } + for (int i = 0; i < GXM_DISPLAY_BUFFER_COUNT; i++) { + if (this->displayBuffers[i]) { + vita_mem_free(this->displayBuffersUid[i]); + this->displayBuffers[i] = nullptr; + this->displayBuffersUid[i] = -1; + sceGxmSyncObjectDestroy(this->displayBuffersSync[i]); + } + } + + if (this->depthBufferData) { + vita_mem_free(this->depthBufferUid); + this->depthBufferData = nullptr; + this->depthBufferUid = -1; + } + + if (this->stencilBufferData) { + vita_mem_free(this->stencilBufferUid); + this->stencilBufferData = nullptr; + this->stencilBufferUid = -1; + } +} + +void GXMContext::init_clear_mesh() +{ + this->clearVertices = static_cast(this->alloc(sizeof(GXMVertex2D) * 4, 4)); + this->clearVertices[0] = {.position = {-1.0, 1.0}, .texCoord = {0, 0}}; + this->clearVertices[1] = {.position = {1.0, 1.0}, .texCoord = {0, 0}}; + this->clearVertices[2] = {.position = {-1.0, -1.0}, .texCoord = {0, 0}}; + this->clearVertices[3] = {.position = {1.0, -1.0}, .texCoord = {0, 0}}; + + this->clearIndices = static_cast(this->alloc(sizeof(uint16_t) * 4, 4)); + this->clearIndices[0] = 0; + this->clearIndices[1] = 1; + this->clearIndices[2] = 2; + this->clearIndices[3] = 3; +} + +int GXMContext::register_base_shaders() +{ + int ret; + // register plane, color, image shaders + ret = SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + this->shaderPatcher, + planeVertexProgramGxp, + &this->planeVertexProgramId + ); + if (ret < 0) { + return ret; + } + + ret = SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + this->shaderPatcher, + colorFragmentProgramGxp, + &this->colorFragmentProgramId + ); + if (ret < 0) { + return ret; + } + + ret = SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + this->shaderPatcher, + imageFragmentProgramGxp, + &this->imageFragmentProgramId + ); + if (ret < 0) { + return ret; + } + this->color_uColor = sceGxmProgramFindParameterByName(colorFragmentProgramGxp, "uColor"); // vec4 + return 0; +} + +int GXMContext::patch_base_shaders(SceGxmMultisampleMode msaaMode) +{ + int ret; + { + GET_SHADER_PARAM(positionAttribute, planeVertexProgramGxp, "aPosition", -1); + GET_SHADER_PARAM(texCoordAttribute, planeVertexProgramGxp, "aTexCoord", -1); + + SceGxmVertexAttribute vertexAttributes[2]; + SceGxmVertexStream vertexStreams[1]; + + // position + vertexAttributes[0].streamIndex = 0; + vertexAttributes[0].offset = 0; + vertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + vertexAttributes[0].componentCount = 2; + vertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(positionAttribute); + + // uv + vertexAttributes[1].streamIndex = 0; + vertexAttributes[1].offset = 8; + vertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + vertexAttributes[1].componentCount = 2; + vertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(texCoordAttribute); + + vertexStreams[0].stride = sizeof(GXMVertex2D); + vertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT; + + ret = SCE_ERR( + sceGxmShaderPatcherCreateVertexProgram, + this->shaderPatcher, + this->planeVertexProgramId, + vertexAttributes, + 2, + vertexStreams, + 1, + &this->planeVertexProgram + ); + if (ret < 0) { + return ret; + } + + ret = SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + this->shaderPatcher, + this->colorFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + msaaMode, + NULL, + planeVertexProgramGxp, + &this->colorFragmentProgram + ); + if (ret < 0) { + return ret; + } + + ret = SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + this->shaderPatcher, + this->imageFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + msaaMode, + &blendInfoTransparent, + planeVertexProgramGxp, + &this->imageFragmentProgram + ); + if (ret < 0) { + return ret; + } + } + + return 0; +} + +void GXMContext::destroy_base_shaders() +{ + sceGxmShaderPatcherReleaseVertexProgram(this->shaderPatcher, this->planeVertexProgram); + sceGxmShaderPatcherReleaseFragmentProgram(this->shaderPatcher, this->colorFragmentProgram); + sceGxmShaderPatcherReleaseFragmentProgram(this->shaderPatcher, this->imageFragmentProgram); +} + +int GXMContext::init(SceGxmMultisampleMode msaaMode) +{ + int ret = 0; + ret = gxm_library_init(); + if (ret < 0) { + return ret; + } + if (this->cdramPool == nullptr) { + this->init_cdram_allocator(); + } + + if (this->context == nullptr) { + ret = this->init_context(); + if (ret < 0) { + return ret; + } + } + + if (this->planeVertexProgramId == 0) { + ret = this->register_base_shaders(); + if (ret < 0) { + return ret; + } + } + + if (this->clearVertices == nullptr) { + this->init_clear_mesh(); + } + + // recreate when msaa is different + if (msaaMode != this->displayMsaa && this->renderTargetInit) { + this->destroy_display_buffers(); + this->destroy_base_shaders(); + } + + if (!this->renderTargetInit) { + ret = this->create_display_buffers(msaaMode); + if (ret < 0) { + return ret; + } + ret = this->patch_base_shaders(msaaMode); + if (ret < 0) { + return ret; + } + } + return 0; +} + +static int inuse_mem = 0; +void* GXMContext::alloc(size_t size, size_t align) +{ + if (this->cdramPool == nullptr) { + this->init_cdram_allocator(); + } + DEBUG_ONLY_PRINTF("cdram_alloc(%d, %d) inuse=%d ", size, align, inuse_mem); + void* ptr = tlsf_memalign(this->cdramPool, align, size); + DEBUG_ONLY_PRINTF("ptr=%p\n", ptr); + inuse_mem += tlsf_block_size(ptr); + return ptr; +} + +void GXMContext::free(void* ptr) +{ + inuse_mem -= tlsf_block_size(ptr); + DEBUG_ONLY_PRINTF("cdram_free(%p)\n", ptr); + tlsf_free(this->cdramPool, ptr); +} + +void GXMContext::clear(float r, float g, float b, bool new_scene) +{ + new_scene = new_scene && !this->sceneStarted; + if (new_scene) { + sceGxmBeginScene( + this->context, + 0, + this->renderTarget, + nullptr, + nullptr, + this->displayBuffersSync[this->backBufferIndex], + &this->displayBuffersSurface[this->backBufferIndex], + &this->depthSurface + ); + this->sceneStarted = true; + } + + float color[] = {r, g, b, 1}; + + sceGxmSetVertexProgram(this->context, this->planeVertexProgram); + sceGxmSetFragmentProgram(this->context, this->colorFragmentProgram); + + void* vertUniforms; + void* fragUniforms; + sceGxmReserveVertexDefaultUniformBuffer(gxm->context, &vertUniforms); + sceGxmReserveFragmentDefaultUniformBuffer(gxm->context, &fragUniforms); + + sceGxmSetVertexStream(gxm->context, 0, this->clearVertices); + sceGxmSetUniformDataF(fragUniforms, this->color_uColor, 0, 4, color); + + sceGxmSetFrontDepthFunc(gxm->context, SCE_GXM_DEPTH_FUNC_ALWAYS); + sceGxmDraw(gxm->context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, this->clearIndices, 4); + if (new_scene) { + sceGxmEndScene(this->context, nullptr, nullptr); + this->sceneStarted = false; + } +} + +void GXMContext::copy_frontbuffer() +{ + SceGxmTexture texture; + sceGxmTextureInitLinearStrided( + &texture, + this->displayBuffers[this->frontBufferIndex], + SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR, + VITA_GXM_SCREEN_WIDTH, + VITA_GXM_SCREEN_HEIGHT, + VITA_GXM_SCREEN_STRIDE * 4 + ); + sceGxmSetVertexProgram(this->context, this->planeVertexProgram); + sceGxmSetFragmentProgram(this->context, this->imageFragmentProgram); + + void* vertUniforms; + void* fragUniforms; + sceGxmReserveVertexDefaultUniformBuffer(this->context, &vertUniforms); + sceGxmReserveFragmentDefaultUniformBuffer(this->context, &fragUniforms); + + sceGxmSetVertexStream(this->context, 0, this->clearVertices); + sceGxmSetFragmentTexture(this->context, 0, &texture); + + sceGxmSetFrontDepthFunc(this->context, SCE_GXM_DEPTH_FUNC_ALWAYS); + sceGxmDraw(this->context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, this->clearIndices, 4); +} + +void GXMContext::destroy() +{ + sceGxmDisplayQueueFinish(); + if (gxm->context) { + sceGxmFinish(gxm->context); + } + + this->destroy_display_buffers(); + this->destroy_base_shaders(); + + sceGxmShaderPatcherDestroy(this->shaderPatcher); + sceGxmDestroyContext(this->context); + vita_mem_fragment_usse_free(this->fragmentUsseRingBufferUid); + vita_mem_free(this->fragmentRingBufferUid); + vita_mem_free(this->vertexRingBufferUid); + vita_mem_free(this->vdmRingBufferUid); + SDL_free(this->contextHostMem); +} + +void GXMContext::swap_display() +{ + if (this->sceneStarted) { + sceGxmEndScene(gxm->context, nullptr, nullptr); + this->sceneStarted = false; + } + + SceCommonDialogUpdateParam updateParam; + SDL_zero(updateParam); + updateParam.renderTarget.colorFormat = VITA_GXM_COLOR_FORMAT; + updateParam.renderTarget.surfaceType = SCE_GXM_COLOR_SURFACE_LINEAR; + updateParam.renderTarget.width = VITA_GXM_SCREEN_WIDTH; + updateParam.renderTarget.height = VITA_GXM_SCREEN_HEIGHT; + updateParam.renderTarget.strideInPixels = VITA_GXM_SCREEN_STRIDE; + updateParam.renderTarget.colorSurfaceData = this->displayBuffers[this->backBufferIndex]; + updateParam.displaySyncObject = this->displayBuffersSync[this->backBufferIndex]; + sceCommonDialogUpdate(&updateParam); + + sceGxmPadHeartbeat( + &this->displayBuffersSurface[this->backBufferIndex], + this->displayBuffersSync[this->backBufferIndex] + ); + + // display + GXMDisplayData displayData; + displayData.address = this->displayBuffers[this->backBufferIndex]; + displayData.index = this->backBufferIndex; + sceGxmDisplayQueueAddEntry( + this->displayBuffersSync[this->frontBufferIndex], + this->displayBuffersSync[this->backBufferIndex], + &displayData + ); + + this->frontBufferIndex = this->backBufferIndex; + this->backBufferIndex = (this->backBufferIndex + 1) % GXM_DISPLAY_BUFFER_COUNT; +} diff --git a/miniwin/src/d3drm/backends/gxm/gxm_context.h b/miniwin/src/d3drm/backends/gxm/gxm_context.h new file mode 100644 index 00000000..3b867f8d --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/gxm_context.h @@ -0,0 +1,105 @@ +#pragma once + +#include + +#define VITA_GXM_SCREEN_WIDTH 960 +#define VITA_GXM_SCREEN_HEIGHT 544 +#define VITA_GXM_SCREEN_STRIDE 1024 +#define VITA_GXM_PENDING_SWAPS 2 +#define VITA_GXM_PIXEL_FORMAT SCE_DISPLAY_PIXELFORMAT_A8B8G8R8 + +#define GXM_DISPLAY_BUFFER_COUNT 3 + +typedef struct GXMVertex2D { + float position[2]; + float texCoord[2]; +} GXMVertex2D; + +typedef struct GXMContext { + // context + SceUID vdmRingBufferUid; + SceUID vertexRingBufferUid; + SceUID fragmentRingBufferUid; + SceUID fragmentUsseRingBufferUid; + size_t fragmentUsseRingBufferOffset; + + void* vdmRingBuffer; + void* vertexRingBuffer; + void* fragmentRingBuffer; + void* fragmentUsseRingBuffer; + + void* contextHostMem; + SceGxmContext* context; + + // shader patcher + SceUID patcherBufferUid; + void* patcherBuffer; + + SceUID patcherVertexUsseUid; + size_t patcherVertexUsseOffset; + void* patcherVertexUsse; + SceUID patcherFragmentUsseUid; + size_t patcherFragmentUsseOffset; + void* patcherFragmentUsse; + + SceGxmShaderPatcher* shaderPatcher; + + // clear + SceGxmShaderPatcherId planeVertexProgramId; + SceGxmShaderPatcherId colorFragmentProgramId; + SceGxmShaderPatcherId imageFragmentProgramId; + SceGxmVertexProgram* planeVertexProgram; + SceGxmFragmentProgram* colorFragmentProgram; + SceGxmFragmentProgram* imageFragmentProgram; + const SceGxmProgramParameter* color_uColor; + GXMVertex2D* clearVertices; + uint16_t* clearIndices; + + // display + SceGxmRenderTarget* renderTarget; + bool renderTargetInit = false; + void* displayBuffers[GXM_DISPLAY_BUFFER_COUNT]; + SceUID displayBuffersUid[GXM_DISPLAY_BUFFER_COUNT]; + SceGxmColorSurface displayBuffersSurface[GXM_DISPLAY_BUFFER_COUNT]; + SceGxmSyncObject* displayBuffersSync[GXM_DISPLAY_BUFFER_COUNT]; + int backBufferIndex = 0; + int frontBufferIndex = 1; + SceGxmMultisampleMode displayMsaa; + + // depth buffer + SceUID depthBufferUid; + void* depthBufferData; + SceUID stencilBufferUid; + void* stencilBufferData; + SceGxmDepthStencilSurface depthSurface; + + // allocator + SceUID cdramUID; + void* cdramMem; + void* cdramPool; + + bool sceneStarted; + + void swap_display(); + void copy_frontbuffer(); + int init(SceGxmMultisampleMode msaaMode); + void init_cdram_allocator(); + int init_context(); + int create_display_buffers(SceGxmMultisampleMode msaaMode); + void init_clear_mesh(); + void destroy_display_buffers(); + int register_base_shaders(); + int patch_base_shaders(SceGxmMultisampleMode msaaMode); + void destroy_base_shaders(); + + void destroy(); + void clear(float r, float g, float b, bool new_scene); + void* alloc(size_t size, size_t align); + void free(void* ptr); +} GXMContext; + +// global so that common dialog can be rendererd without GXMRenderer +extern GXMContext* gxm; + +extern bool with_razor_capture; +extern bool with_razor_hud; diff --git a/miniwin/src/d3drm/backends/gxm/gxm_memory.cpp b/miniwin/src/d3drm/backends/gxm/gxm_memory.cpp new file mode 100644 index 00000000..01313d0a --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/gxm_memory.cpp @@ -0,0 +1,119 @@ +#include "gxm_memory.h" + +#include "tlsf.h" +#include "utils.h" + +#include +#include +#include +#include + +void* patcher_host_alloc(void* user_data, unsigned int size) +{ + void* mem = SDL_malloc(size); + (void) user_data; + return mem; +} + +void patcher_host_free(void* user_data, void* mem) +{ + (void) user_data; + SDL_free(mem); +} + +void* vita_mem_alloc(unsigned int type, size_t size, size_t alignment, int attribs, SceUID* uid, const char* name) +{ + void* mem; + + if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW) { + size = ALIGN(size, 256 * 1024); + } + else if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_NC_RW) { + size = ALIGN(size, 1024 * 1024); + } + else { + size = ALIGN(size, 4 * 1024); + } + + *uid = sceKernelAllocMemBlock(name, type, size, NULL); + + if (*uid < 0) { + SDL_Log("sceKernelAllocMemBlock: 0x%x", *uid); + return NULL; + } + + if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { + return NULL; + } + + if (sceGxmMapMemory(mem, size, (SceGxmMemoryAttribFlags) attribs) < 0) { + SDL_Log("sceGxmMapMemory 0x%x 0x%x %d failed", mem, size, attribs); + return NULL; + } + + return mem; +} + +void vita_mem_free(SceUID uid) +{ + void* mem = NULL; + if (sceKernelGetMemBlockBase(uid, &mem) < 0) { + return; + } + sceGxmUnmapMemory(mem); + sceKernelFreeMemBlock(uid); +} + +void* vita_mem_vertex_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset) +{ + void* mem = NULL; + + size = ALIGN(size, 4096); + *uid = sceKernelAllocMemBlock("vertex_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL); + + if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { + return NULL; + } + if (sceGxmMapVertexUsseMemory(mem, size, usse_offset) < 0) { + return NULL; + } + + return mem; +} + +void vita_mem_vertex_usse_free(SceUID uid) +{ + void* mem = NULL; + if (sceKernelGetMemBlockBase(uid, &mem) < 0) { + return; + } + sceGxmUnmapVertexUsseMemory(mem); + sceKernelFreeMemBlock(uid); +} + +void* vita_mem_fragment_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset) +{ + void* mem = NULL; + + size = ALIGN(size, 4096); + *uid = sceKernelAllocMemBlock("fragment_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL); + + if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { + return NULL; + } + if (sceGxmMapFragmentUsseMemory(mem, size, usse_offset) < 0) { + return NULL; + } + + return mem; +} + +void vita_mem_fragment_usse_free(SceUID uid) +{ + void* mem = NULL; + if (sceKernelGetMemBlockBase(uid, &mem) < 0) { + return; + } + sceGxmUnmapFragmentUsseMemory(mem); + sceKernelFreeMemBlock(uid); +} diff --git a/miniwin/src/d3drm/backends/gxm/gxm_memory.h b/miniwin/src/d3drm/backends/gxm/gxm_memory.h new file mode 100644 index 00000000..f169603d --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/gxm_memory.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +void* patcher_host_alloc(void* user_data, unsigned int size); +void patcher_host_free(void* user_data, void* mem); + +void* vita_mem_alloc(unsigned int type, size_t size, size_t alignment, int attribs, SceUID* uid, const char* name); +void vita_mem_free(SceUID uid); + +void* vita_mem_vertex_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset); +void vita_mem_vertex_usse_free(SceUID uid); +void* vita_mem_fragment_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset); +void vita_mem_fragment_usse_free(SceUID uid); diff --git a/miniwin/src/d3drm/backends/gxm/gxm_renderer.cpp b/miniwin/src/d3drm/backends/gxm/gxm_renderer.cpp new file mode 100644 index 00000000..efb25bdd --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/gxm_renderer.cpp @@ -0,0 +1,1101 @@ +#include "d3drmrenderer_gxm.h" +#include "gxm_context.h" +#include "gxm_memory.h" +#include "meshutils.h" +#include "razor.h" +#include "shaders/gxm_shaders.h" +#include "tlsf.h" +#include "utils.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// from isleapp +extern bool g_dpadUp; +extern bool g_dpadDown; +extern bool g_dpadLeft; +extern bool g_dpadRight; + +typedef struct GXMVertex { + float position[3]; + float normal[3]; + float texCoord[2]; +} GXMVertex; + +Direct3DRMRenderer* GXMRenderer::Create(DWORD width, DWORD height, DWORD msaaSamples) +{ + int ret = gxm_library_init(); + if (ret < 0) { + return nullptr; + } + + SceGxmMultisampleMode msaaMode = SCE_GXM_MULTISAMPLE_NONE; + if (msaaSamples == 2) { + msaaMode = SCE_GXM_MULTISAMPLE_2X; + } + if (msaaSamples == 4) { + msaaMode = SCE_GXM_MULTISAMPLE_4X; + } + + if (!gxm) { + gxm = (GXMContext*) SDL_malloc(sizeof(GXMContext)); + memset(gxm, 0, sizeof(GXMContext)); + } + ret = SCE_ERR(gxm->init, msaaMode); + if (ret < 0) { + return nullptr; + } + + return new GXMRenderer(width, height, msaaMode); +} + +GXMRenderer::GXMRenderer(DWORD width, DWORD height, SceGxmMultisampleMode msaaMode) +{ + m_width = VITA_GXM_SCREEN_WIDTH; + m_height = VITA_GXM_SCREEN_HEIGHT; + m_virtualWidth = width; + m_virtualHeight = height; + + // register shader programs + int ret = SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + gxm->shaderPatcher, + mainVertexProgramGxp, + &this->mainVertexProgramId + ); + if (ret < 0) { + return; + } + + ret = SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + gxm->shaderPatcher, + mainColorFragmentProgramGxp, + &this->mainColorFragmentProgramId + ); + if (ret < 0) { + return; + } + + ret = SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + gxm->shaderPatcher, + mainTextureFragmentProgramGxp, + &this->mainTextureFragmentProgramId + ); + if (ret < 0) { + return; + } + + // main shader + { + GET_SHADER_PARAM(positionAttribute, mainVertexProgramGxp, "aPosition", ); + GET_SHADER_PARAM(normalAttribute, mainVertexProgramGxp, "aNormal", ); + GET_SHADER_PARAM(texCoordAttribute, mainVertexProgramGxp, "aTexCoord", ); + + SceGxmVertexAttribute vertexAttributes[3]; + SceGxmVertexStream vertexStreams[1]; + + // position + vertexAttributes[0].streamIndex = 0; + vertexAttributes[0].offset = 0; + vertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + vertexAttributes[0].componentCount = 3; + vertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(positionAttribute); + + // normal + vertexAttributes[1].streamIndex = 0; + vertexAttributes[1].offset = 12; + vertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + vertexAttributes[1].componentCount = 3; + vertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(normalAttribute); + + vertexAttributes[2].streamIndex = 0; + vertexAttributes[2].offset = 24; + vertexAttributes[2].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + vertexAttributes[2].componentCount = 2; + vertexAttributes[2].regIndex = sceGxmProgramParameterGetResourceIndex(texCoordAttribute); + + vertexStreams[0].stride = sizeof(GXMVertex); + vertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT; + + ret = SCE_ERR( + sceGxmShaderPatcherCreateVertexProgram, + gxm->shaderPatcher, + this->mainVertexProgramId, + vertexAttributes, + 3, + vertexStreams, + 1, + &this->mainVertexProgram + ); + if (ret < 0) { + return; + } + } + + // main color opaque + ret = SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + gxm->shaderPatcher, + this->mainColorFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + msaaMode, + &blendInfoOpaque, + mainVertexProgramGxp, + &this->opaqueColorFragmentProgram + ); + if (ret < 0) { + return; + } + + // main color blended + ret = SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + gxm->shaderPatcher, + this->mainColorFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + msaaMode, + &blendInfoTransparent, + mainVertexProgramGxp, + &this->blendedColorFragmentProgram + ); + if (ret < 0) { + return; + } + + // main texture opaque + ret = SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + gxm->shaderPatcher, + this->mainTextureFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + msaaMode, + &blendInfoOpaque, + mainVertexProgramGxp, + &this->opaqueTextureFragmentProgram + ); + if (ret < 0) { + return; + } + + // main texture transparent + ret = SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + gxm->shaderPatcher, + this->mainTextureFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + msaaMode, + &blendInfoTransparent, + mainVertexProgramGxp, + &this->blendedTextureFragmentProgram + ); + if (ret < 0) { + return; + } + + // vertex uniforms + this->uModelViewMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uModelViewMatrix"); + this->uNormalMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uNormalMatrix"); + this->uProjectionMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uProjectionMatrix"); + + // fragment uniforms + this->uLights = sceGxmProgramFindParameterByName(mainColorFragmentProgramGxp, "uLights"); // SceneLight[2] + this->uAmbientLight = sceGxmProgramFindParameterByName(mainColorFragmentProgramGxp, "uAmbientLight"); // vec3 + this->uShininess = sceGxmProgramFindParameterByName(mainColorFragmentProgramGxp, "uShininess"); // float + this->uColor = sceGxmProgramFindParameterByName(mainColorFragmentProgramGxp, "uColor"); // vec4 + + for (int i = 0; i < GXM_FRAGMENT_BUFFER_COUNT; i++) { + this->lights[i] = static_cast(gxm->alloc(sizeof(GXMSceneLightUniform), 4)); + } + for (int i = 0; i < GXM_VERTEX_BUFFER_COUNT; i++) { + this->quadVertices[i] = static_cast(gxm->alloc(sizeof(GXMVertex2D) * 4 * 50, 4)); + } + this->quadIndices = static_cast(gxm->alloc(sizeof(uint16_t) * 4, 4)); + this->quadIndices[0] = 0; + this->quadIndices[1] = 1; + this->quadIndices[2] = 2; + this->quadIndices[3] = 3; + + volatile uint32_t* notificationMem = sceGxmGetNotificationRegion(); + for (uint32_t i = 0; i < GXM_FRAGMENT_BUFFER_COUNT; i++) { + this->fragmentNotifications[i].address = notificationMem++; + this->fragmentNotifications[i].value = 0; + } + this->currentFragmentBufferIndex = 0; + + for (uint32_t i = 0; i < GXM_VERTEX_BUFFER_COUNT; i++) { + this->vertexNotifications[i].address = notificationMem++; + this->vertexNotifications[i].value = 0; + } + this->currentVertexBufferIndex = 0; + m_initialized = true; +} + +GXMRenderer::~GXMRenderer() +{ + for (int i = 0; i < GXM_FRAGMENT_BUFFER_COUNT; i++) { + if (this->lights[i]) { + gxm->free(this->lights[i]); + } + } + for (int i = 0; i < GXM_VERTEX_BUFFER_COUNT; i++) { + if (this->quadVertices[i]) { + gxm->free(this->quadVertices[i]); + } + } + if (this->quadIndices) { + gxm->free(this->quadIndices); + } +} + +void GXMRenderer::PushLights(const SceneLight* lightsArray, size_t count) +{ + if (count > 3) { + SDL_Log("Unsupported number of lights (%d)", static_cast(count)); + count = 3; + } + + m_lights.assign(lightsArray, lightsArray + count); +} + +void GXMRenderer::SetFrustumPlanes(const Plane* frustumPlanes) +{ +} + +void GXMRenderer::SetProjection(const D3DRMMATRIX4D& projection, D3DVALUE front, D3DVALUE back) +{ + memcpy(&m_projection, projection, sizeof(D3DRMMATRIX4D)); +} + +struct TextureDestroyContextGXM { + GXMRenderer* renderer; + Uint32 textureId; +}; + +void GXMRenderer::AddTextureDestroyCallback(Uint32 id, IDirect3DRMTexture* texture) +{ + auto* ctx = new TextureDestroyContextGXM{this, id}; + texture->AddDestroyCallback( + [](IDirect3DRMObject* obj, void* arg) { + auto* ctx = static_cast(arg); + auto& cache = ctx->renderer->m_textures[ctx->textureId]; + ctx->renderer->m_textures_delete[gxm->backBufferIndex].push_back(cache.gxmTexture); + cache.texture = nullptr; + memset(&cache.gxmTexture, 0, sizeof(SceGxmTexture)); + delete ctx; + }, + ctx + ); +} + +void GXMRenderer::DeferredDelete(int index) +{ + for (auto& del : this->m_textures_delete[index]) { + void* textureData = sceGxmTextureGetData(&del); + gxm->free(textureData); + } + this->m_textures_delete[index].clear(); + + for (auto& del : this->m_buffers_delete[index]) { + gxm->free(del); + } + this->m_buffers_delete[index].clear(); +} + +static int calculateMipLevels(int width, int height) +{ + if (width <= 0 || height <= 0) { + return 1; + } + int maxDim = (width > height) ? width : height; + return floor(log2(maxDim)) + 1; +} + +static int nextPowerOf2(int n) +{ + if (n <= 0) { + return 1; + } + n--; + n |= n >> 1; + n |= n >> 2; + n |= n >> 4; + n |= n >> 8; + n |= n >> 16; + n++; + return n; +} + +static void convertTextureMetadata( + SDL_Surface* surface, + bool isUi, + bool* supportedFormat, + SceGxmTextureFormat* gxmTextureFormat, + size_t* textureSize, // size in bytes + size_t* textureAlignment, // alignment in bytes + size_t* textureStride, // stride in bytes + size_t* paletteOffset, // offset from textureData in bytes + size_t* mipLevels +) +{ + int bytesPerPixel; + size_t paletteSize = 0; + *mipLevels = 1; + + switch (surface->format) { + case SDL_PIXELFORMAT_INDEX8: { + *supportedFormat = true; + *gxmTextureFormat = SCE_GXM_TEXTURE_FORMAT_P8_ABGR; + *textureAlignment = SCE_GXM_PALETTE_ALIGNMENT; + bytesPerPixel = 1; + if (!isUi) { + *mipLevels = calculateMipLevels(surface->w, surface->h); + } + paletteSize = 256 * 4; // palette + break; + } + case SDL_PIXELFORMAT_ABGR8888: { + *supportedFormat = true; + *gxmTextureFormat = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR; + *textureAlignment = SCE_GXM_TEXTURE_ALIGNMENT; + bytesPerPixel = 4; + if (!isUi) { + *mipLevels = calculateMipLevels(surface->w, surface->h); + } + break; + } + default: { + *supportedFormat = false; + *gxmTextureFormat = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR; + *textureAlignment = SCE_GXM_TEXTURE_ALIGNMENT; + bytesPerPixel = 4; + break; + } + } + *textureStride = ALIGN(surface->w, 8) * bytesPerPixel; + + *mipLevels = 1; // look weird + + size_t totalSize = 0; + int currentW = surface->w; + int currentH = surface->h; + + // top mip + totalSize += (ALIGN(currentW, 8) * currentH) * bytesPerPixel; + + for (size_t i = 1; i < *mipLevels; ++i) { + currentW = currentW > 1 ? currentW / 2 : 1; + currentH = currentH > 1 ? currentH / 2 : 1; + int po2W = nextPowerOf2(currentW * 2); + int po2H = nextPowerOf2(currentH * 2); + if (po2W < 8) { + po2W = 8; + } + totalSize += po2W * po2H * bytesPerPixel; + } + + if (paletteSize != 0) { + int alignBytes = ALIGNMENT(totalSize, SCE_GXM_PALETTE_ALIGNMENT); + totalSize += alignBytes; + *paletteOffset = totalSize; + totalSize += paletteSize; + } + + *textureSize = totalSize; +} + +void copySurfaceToGxmARGB888(SDL_Surface* src, uint8_t* textureData, size_t dstStride, size_t mipLevels) +{ + uint8_t* currentLevelData = textureData; + uint32_t currentLevelWidth = src->w; + uint32_t currentLevelHeight = src->h; + size_t bytesPerPixel = 4; + + // copy top level mip (cant use transfer because this isnt gpu mapped) + size_t topLevelStride = ALIGN(currentLevelWidth, 8) * bytesPerPixel; + for (int y = 0; y < currentLevelHeight; y++) { + uint8_t* srcRow = (uint8_t*) src->pixels + (y * src->pitch); + uint8_t* dstRow = textureData + (y * topLevelStride); + memcpy(dstRow, srcRow, currentLevelWidth * bytesPerPixel); + } + + for (size_t i = 1; i < mipLevels; ++i) { + uint32_t currentLevelSrcStride = SDL_max(currentLevelWidth, 8) * bytesPerPixel; + uint32_t currentLevelDestStride = SDL_max((currentLevelWidth / 2), 8) * bytesPerPixel; + uint8_t* nextLevelData = currentLevelData + (currentLevelSrcStride * currentLevelHeight); + + sceGxmTransferDownscale( + SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // src format + currentLevelData, // src address + 0, + 0, + currentLevelWidth, + currentLevelHeight, // x,y,w,h + currentLevelSrcStride, // stride + SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // dst format + nextLevelData, // dst address + 0, + 0, // x,y + currentLevelDestStride, // stride + NULL, // sync + SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag + NULL // notification + ); + + currentLevelData = nextLevelData; + currentLevelWidth = currentLevelWidth / 2; + currentLevelHeight = currentLevelHeight / 2; + } +} + +void copySurfaceToGxmIndexed8( + DirectDrawSurfaceImpl* surface, + SDL_Surface* src, + uint8_t* textureData, + size_t dstStride, + uint8_t* paletteData, + size_t mipLevels +) +{ + LPDIRECTDRAWPALETTE _palette; + surface->GetPalette(&_palette); + auto palette = static_cast(_palette); + + // copy palette + memcpy(paletteData, palette->m_palette->colors, 256 * 4); + + uint8_t* currentLevelData = textureData; + uint32_t currentLevelWidth = src->w; + uint32_t currentLevelHeight = src->h; + size_t bytesPerPixel = 1; + + // copy top level mip (cant use transfer because this isnt gpu mapped) + size_t topLevelStride = ALIGN(currentLevelWidth, 8) * bytesPerPixel; + for (int y = 0; y < currentLevelHeight; y++) { + uint8_t* srcRow = (uint8_t*) src->pixels + (y * src->pitch); + uint8_t* dstRow = textureData + (y * topLevelStride); + memcpy(dstRow, srcRow, currentLevelWidth * bytesPerPixel); + } + + for (size_t i = 1; i < mipLevels; ++i) { + uint32_t currentLevelSrcStride = SDL_max(currentLevelWidth, 8) * bytesPerPixel; + uint32_t currentLevelDestStride = SDL_max((currentLevelWidth / 2), 8) * bytesPerPixel; + uint8_t* nextLevelData = currentLevelData + (currentLevelSrcStride * currentLevelHeight); + + sceGxmTransferDownscale( + SCE_GXM_TRANSFER_FORMAT_U8_R, // src format + currentLevelData, // src address + 0, + 0, + currentLevelWidth, + currentLevelHeight, // x,y,w,h + currentLevelSrcStride, // stride + SCE_GXM_TRANSFER_FORMAT_U8_R, // dst format + nextLevelData, // dst address + 0, + 0, // x,y + currentLevelDestStride, // stride + NULL, // sync + SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag + NULL // notification + ); + + currentLevelData = nextLevelData; + currentLevelWidth = currentLevelWidth / 2; + currentLevelHeight = currentLevelHeight / 2; + } + + palette->Release(); +} + +void copySurfaceToGxm( + DirectDrawSurfaceImpl* surface, + uint8_t* textureData, + size_t dstStride, + size_t paletteOffset, + size_t mipLevels +) +{ + SDL_Surface* src = surface->m_surface; + + switch (src->format) { + case SDL_PIXELFORMAT_ABGR8888: { + copySurfaceToGxmARGB888(src, textureData, dstStride, mipLevels); + break; + } + case SDL_PIXELFORMAT_INDEX8: { + copySurfaceToGxmIndexed8(surface, src, textureData, dstStride, textureData + paletteOffset, mipLevels); + break; + } + default: { + DEBUG_ONLY_PRINTF("unsupported format %d\n", SDL_GetPixelFormatName(src->format)); + SDL_Surface* dst = SDL_CreateSurfaceFrom(src->w, src->h, SDL_PIXELFORMAT_ABGR8888, textureData, src->w * 4); + SDL_BlitSurface(src, nullptr, dst, nullptr); + SDL_DestroySurface(dst); + break; + } + } +} + +Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture, bool isUi, float scaleX, float scaleY) +{ + auto texture = static_cast(iTexture); + auto surface = static_cast(texture->m_surface); + + bool supportedFormat; + SceGxmTextureFormat gxmTextureFormat; + size_t textureSize; + size_t textureAlignment; + size_t textureStride; + size_t paletteOffset; + size_t mipLevels; + + int textureWidth = surface->m_surface->w; + int textureHeight = surface->m_surface->h; + + convertTextureMetadata( + surface->m_surface, + isUi, + &supportedFormat, + &gxmTextureFormat, + &textureSize, + &textureAlignment, + &textureStride, + &paletteOffset, + &mipLevels + ); + + if (!supportedFormat) { + return NO_TEXTURE_ID; + } + + for (Uint32 i = 0; i < m_textures.size(); ++i) { + auto& tex = m_textures[i]; + if (tex.texture == texture) { + if (tex.version != texture->m_version) { + sceGxmNotificationWait(tex.notification); + tex.notification = &this->fragmentNotifications[this->currentFragmentBufferIndex]; + uint8_t* textureData = (uint8_t*) sceGxmTextureGetData(&tex.gxmTexture); + copySurfaceToGxm(surface, textureData, textureStride, paletteOffset, mipLevels); + tex.version = texture->m_version; + } + return i; + } + } + + DEBUG_ONLY_PRINTF( + "Create Texture %s w=%d h=%d s=%d size=%d align=%d mips=%d\n", + SDL_GetPixelFormatName(surface->m_surface->format), + textureWidth, + textureHeight, + textureStride, + textureSize, + textureAlignment, + mipLevels + ); + + // allocate gpu memory + uint8_t* textureData = (uint8_t*) gxm->alloc(textureSize, textureAlignment); + copySurfaceToGxm(surface, textureData, textureStride, paletteOffset, mipLevels); + + SceGxmTexture gxmTexture; + SCE_ERR( + sceGxmTextureInitLinear, + &gxmTexture, + textureData, + gxmTextureFormat, + textureWidth, + textureHeight, + mipLevels + ); + if (isUi) { + sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT); + sceGxmTextureSetMagFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT); + sceGxmTextureSetUAddrMode(&gxmTexture, SCE_GXM_TEXTURE_ADDR_CLAMP); + sceGxmTextureSetVAddrMode(&gxmTexture, SCE_GXM_TEXTURE_ADDR_CLAMP); + } + else { + sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_LINEAR); + sceGxmTextureSetMagFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_LINEAR); + sceGxmTextureSetUAddrMode(&gxmTexture, SCE_GXM_TEXTURE_ADDR_REPEAT); + sceGxmTextureSetVAddrMode(&gxmTexture, SCE_GXM_TEXTURE_ADDR_REPEAT); + } + if (gxmTextureFormat == SCE_GXM_TEXTURE_FORMAT_P8_ABGR) { + sceGxmTextureSetPalette(&gxmTexture, textureData + paletteOffset); + } + + for (Uint32 i = 0; i < m_textures.size(); ++i) { + auto& tex = m_textures[i]; + if (!tex.texture) { + memset(&tex, 0, sizeof(tex)); + tex.texture = texture; + tex.version = texture->m_version; + tex.gxmTexture = gxmTexture; + tex.notification = &this->fragmentNotifications[this->currentFragmentBufferIndex]; + AddTextureDestroyCallback(i, texture); + return i; + } + } + + GXMTextureCacheEntry tex; + memset(&tex, 0, sizeof(tex)); + tex.texture = texture; + tex.version = texture->m_version; + tex.gxmTexture = gxmTexture; + tex.notification = &this->fragmentNotifications[this->currentFragmentBufferIndex]; + m_textures.push_back(tex); + Uint32 textureId = (Uint32) (m_textures.size() - 1); + AddTextureDestroyCallback(textureId, texture); + return textureId; +} + +const SceGxmTexture* GXMRenderer::UseTexture(GXMTextureCacheEntry& texture) +{ + texture.notification = &this->fragmentNotifications[this->currentFragmentBufferIndex]; + sceGxmSetFragmentTexture(gxm->context, 0, &texture.gxmTexture); + return &texture.gxmTexture; +} + +GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup) +{ + GXMMeshCacheEntry cache{&meshGroup, meshGroup.version}; + + cache.flat = meshGroup.quality == D3DRMRENDER_FLAT || meshGroup.quality == D3DRMRENDER_UNLITFLAT; + + std::vector vertices; + std::vector indices; + if (cache.flat) { + FlattenSurfaces( + meshGroup.vertices.data(), + meshGroup.vertices.size(), + meshGroup.indices.data(), + meshGroup.indices.size(), + meshGroup.texture != nullptr, + vertices, + indices + ); + } + else { + vertices = meshGroup.vertices; + indices.resize(meshGroup.indices.size()); + std::transform(meshGroup.indices.begin(), meshGroup.indices.end(), indices.begin(), [](DWORD index) { + return static_cast(index); + }); + } + + size_t vertexBufferSize = sizeof(GXMVertex) * vertices.size(); + size_t indexBufferSize = sizeof(uint16_t) * indices.size(); + void* meshData = gxm->alloc(vertexBufferSize + indexBufferSize, 4); + + GXMVertex* vertexBuffer = (GXMVertex*) meshData; + uint16_t* indexBuffer = (uint16_t*) ((uint8_t*) meshData + vertexBufferSize); + + for (int i = 0; i < vertices.size(); i++) { + D3DRMVERTEX vertex = vertices.data()[i]; + vertexBuffer[i] = GXMVertex{ + .position = + { + vertex.position.x, + vertex.position.y, + vertex.position.z, + }, + .normal = + { + vertex.normal.x, + vertex.normal.y, + vertex.normal.z, + }, + .texCoord = + { + vertex.tu, + vertex.tv, + } + }; + } + memcpy(indexBuffer, indices.data(), indices.size() * sizeof(uint16_t)); + + cache.meshData = meshData; + cache.vertexBuffer = vertexBuffer; + cache.indexBuffer = indexBuffer; + cache.indexCount = indices.size(); + return cache; +} + +struct GXMMeshDestroyContext { + GXMRenderer* renderer; + Uint32 id; +}; + +void GXMRenderer::AddMeshDestroyCallback(Uint32 id, IDirect3DRMMesh* mesh) +{ + auto* ctx = new GXMMeshDestroyContext{this, id}; + mesh->AddDestroyCallback( + [](IDirect3DRMObject*, void* arg) { + auto* ctx = static_cast(arg); + auto& cache = ctx->renderer->m_meshes[ctx->id]; + cache.meshGroup = nullptr; + ctx->renderer->m_buffers_delete[gxm->backBufferIndex].push_back(cache.meshData); + cache.meshData = nullptr; + cache.indexBuffer = nullptr; + cache.vertexBuffer = nullptr; + cache.indexCount = 0; + delete ctx; + }, + ctx + ); +} + +Uint32 GXMRenderer::GetMeshId(IDirect3DRMMesh* mesh, const MeshGroup* meshGroup) +{ + for (Uint32 i = 0; i < m_meshes.size(); ++i) { + auto& cache = m_meshes[i]; + if (cache.meshGroup == meshGroup) { + if (cache.version != meshGroup->version) { + cache = std::move(this->GXMUploadMesh(*meshGroup)); + } + return i; + } + } + + auto newCache = this->GXMUploadMesh(*meshGroup); + + for (Uint32 i = 0; i < m_meshes.size(); ++i) { + auto& cache = m_meshes[i]; + if (!cache.meshGroup) { + cache = std::move(newCache); + AddMeshDestroyCallback(i, mesh); + return i; + } + } + + m_meshes.push_back(std::move(newCache)); + AddMeshDestroyCallback((Uint32) (m_meshes.size() - 1), mesh); + return (Uint32) (m_meshes.size() - 1); +} + +bool razor_live_started = false; +bool razor_display_enabled = false; + +void GXMRenderer::StartScene() +{ + if (gxm->sceneStarted) { + return; + } + + this->DeferredDelete(gxm->frontBufferIndex); + +#ifdef GXM_WITH_RAZOR + bool dpad_up_clicked = !this->last_dpad_up && g_dpadUp; + bool dpad_down_clicked = !this->last_dpad_down && g_dpadDown; + bool dpad_left_clicked = !this->last_dpad_left && g_dpadLeft; + bool dpad_right_clicked = !this->last_dpad_right && g_dpadRight; + this->last_dpad_up = g_dpadUp; + this->last_dpad_down = g_dpadDown; + this->last_dpad_left = g_dpadLeft; + this->last_dpad_right = g_dpadRight; + + if (with_razor_hud) { + if (dpad_up_clicked) { + razor_display_enabled = !razor_display_enabled; + sceRazorHudSetDisplayEnabled(razor_display_enabled); + } + if (dpad_left_clicked) { + if (razor_live_started) { + sceRazorGpuLiveStop(); + } + else { + sceRazorGpuLiveStart(); + } + razor_live_started = !razor_live_started; + } + if (dpad_right_clicked) { + sceRazorGpuTraceTrigger(); + } + } + if (with_razor_capture) { + if (dpad_down_clicked) { + sceRazorGpuCaptureSetTriggerNextFrame("ux0:/data/capture.sgx"); + } + } +#endif + + sceGxmBeginScene( + gxm->context, + SCE_GXM_SCENE_FRAGMENT_TRANSFER_SYNC, + gxm->renderTarget, + nullptr, + nullptr, + gxm->displayBuffersSync[gxm->backBufferIndex], + &gxm->displayBuffersSurface[gxm->backBufferIndex], + &gxm->depthSurface + ); + sceGxmSetCullMode(gxm->context, SCE_GXM_CULL_CCW); + gxm->sceneStarted = true; + this->quadsUsed = 0; + this->cleared = false; + + sceGxmNotificationWait(&this->vertexNotifications[this->currentVertexBufferIndex]); + sceGxmNotificationWait(&this->fragmentNotifications[this->currentFragmentBufferIndex]); +} + +HRESULT GXMRenderer::BeginFrame() +{ + this->transparencyEnabled = false; + this->StartScene(); + + auto lightData = this->LightsBuffer(); + int i = 0; + for (const auto& light : m_lights) { + if (!light.directional && !light.positional) { + lightData->ambientLight[0] = light.color.r; + lightData->ambientLight[1] = light.color.g; + lightData->ambientLight[2] = light.color.b; + continue; + } + if (i == 2) { + sceClibPrintf("light overflow\n"); + continue; + } + + lightData->lights[i].color[0] = light.color.r; + lightData->lights[i].color[1] = light.color.g; + lightData->lights[i].color[2] = light.color.b; + lightData->lights[i].color[3] = light.color.a; + + bool isDirectional = light.directional == 1.0; + if (isDirectional) { + lightData->lights[i].vec[0] = light.direction.x; + lightData->lights[i].vec[1] = light.direction.y; + lightData->lights[i].vec[2] = light.direction.z; + } + else { + lightData->lights[i].vec[0] = light.position.x; + lightData->lights[i].vec[1] = light.position.y; + lightData->lights[i].vec[2] = light.position.z; + } + lightData->lights[i].isDirectional = isDirectional; + i++; + } + sceGxmSetFragmentUniformBuffer(gxm->context, 0, lightData); + + return DD_OK; +} + +void GXMRenderer::EnableTransparency() +{ + this->transparencyEnabled = true; +} + +void GXMRenderer::SubmitDraw( + DWORD meshId, + const D3DRMMATRIX4D& modelViewMatrix, + const D3DRMMATRIX4D& worldMatrix, + const D3DRMMATRIX4D& viewMatrix, + const Matrix3x3& normalMatrix, + const Appearance& appearance +) +{ + auto& mesh = m_meshes[meshId]; + +#ifdef DEBUG + char marker[256]; + snprintf(marker, sizeof(marker), "SubmitDraw: %d", meshId); + sceGxmPushUserMarker(gxm->context, marker); +#endif + + bool textured = appearance.textureId != NO_TEXTURE_ID; + const SceGxmFragmentProgram* fragmentProgram; + if (this->transparencyEnabled) { + fragmentProgram = textured ? this->blendedTextureFragmentProgram : this->blendedColorFragmentProgram; + } + else { + fragmentProgram = textured ? this->opaqueTextureFragmentProgram : this->opaqueColorFragmentProgram; + } + sceGxmSetVertexProgram(gxm->context, this->mainVertexProgram); + sceGxmSetFragmentProgram(gxm->context, fragmentProgram); + + void* vertUniforms; + void* fragUniforms; + sceGxmReserveVertexDefaultUniformBuffer(gxm->context, &vertUniforms); + sceGxmReserveFragmentDefaultUniformBuffer(gxm->context, &fragUniforms); + + // vertex uniforms + sceGxmSetUniformDataF(vertUniforms, this->uModelViewMatrix, 0, 4 * 4, &modelViewMatrix[0][0]); + sceGxmSetUniformDataF(vertUniforms, this->uNormalMatrix, 0, 3 * 3, &normalMatrix[0][0]); + sceGxmSetUniformDataF(vertUniforms, this->uProjectionMatrix, 0, 4 * 4, &this->m_projection[0][0]); + + // fragment uniforms + float color[4] = { + appearance.color.r / 255.0f, + appearance.color.g / 255.0f, + appearance.color.b / 255.0f, + appearance.color.a / 255.0f + }; + sceGxmSetUniformDataF(fragUniforms, this->uColor, 0, 4, color); + sceGxmSetUniformDataF(fragUniforms, this->uShininess, 0, 1, &appearance.shininess); + + if (textured) { + auto& texture = m_textures[appearance.textureId]; + this->UseTexture(texture); + } + sceGxmSetVertexStream(gxm->context, 0, mesh.vertexBuffer); + sceGxmSetFrontDepthFunc(gxm->context, SCE_GXM_DEPTH_FUNC_LESS_EQUAL); + sceGxmDraw(gxm->context, SCE_GXM_PRIMITIVE_TRIANGLES, SCE_GXM_INDEX_FORMAT_U16, mesh.indexBuffer, mesh.indexCount); + +#ifdef DEBUG + sceGxmPopUserMarker(gxm->context); +#endif +} + +HRESULT GXMRenderer::FinalizeFrame() +{ + return DD_OK; +} + +void GXMRenderer::Resize(int width, int height, const ViewportTransform& viewportTransform) +{ + m_width = width; + m_height = height; + m_viewportTransform = viewportTransform; +} + +void GXMRenderer::Clear(float r, float g, float b) +{ + this->StartScene(); + gxm->clear(r, g, b, false); + this->cleared = true; +} + +void GXMRenderer::Flip() +{ + if (!gxm->sceneStarted) { + return; + } + + ++this->vertexNotifications[this->currentVertexBufferIndex].value; + ++this->fragmentNotifications[this->currentFragmentBufferIndex].value; + sceGxmEndScene( + gxm->context, + &this->vertexNotifications[this->currentVertexBufferIndex], + &this->fragmentNotifications[this->currentFragmentBufferIndex] + ); + gxm->sceneStarted = false; + + this->currentVertexBufferIndex = (this->currentVertexBufferIndex + 1) % GXM_VERTEX_BUFFER_COUNT; + this->currentFragmentBufferIndex = (this->currentFragmentBufferIndex + 1) % GXM_FRAGMENT_BUFFER_COUNT; + gxm->swap_display(); +} + +void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const SDL_Rect& dstRect, FColor color) +{ + this->StartScene(); + if (!this->cleared) { + gxm->clear(0, 0, 0, false); + this->cleared = true; + } + +#ifdef DEBUG + char marker[256]; + snprintf(marker, sizeof(marker), "Draw2DImage: %d", textureId); + sceGxmPushUserMarker(gxm->context, marker); +#endif + + sceGxmSetVertexProgram(gxm->context, gxm->planeVertexProgram); + if (textureId != NO_TEXTURE_ID) { + sceGxmSetFragmentProgram(gxm->context, gxm->imageFragmentProgram); + } + else { + sceGxmSetFragmentProgram(gxm->context, gxm->colorFragmentProgram); + } + + void* vertUniforms; + void* fragUniforms; + sceGxmReserveVertexDefaultUniformBuffer(gxm->context, &vertUniforms); + sceGxmReserveFragmentDefaultUniformBuffer(gxm->context, &fragUniforms); + + float left = -this->m_viewportTransform.offsetX / this->m_viewportTransform.scale; + float right = (this->m_width - this->m_viewportTransform.offsetX) / this->m_viewportTransform.scale; + float top = -this->m_viewportTransform.offsetY / this->m_viewportTransform.scale; + float bottom = (this->m_height - this->m_viewportTransform.offsetY) / this->m_viewportTransform.scale; + +#define virtualToNDCX(x) (((x - left) / (right - left)) * 2 - 1); +#define virtualToNDCY(y) -(((y - top) / (bottom - top)) * 2 - 1); + + float x1_virtual = static_cast(dstRect.x); + float y1_virtual = static_cast(dstRect.y); + float x2_virtual = x1_virtual + dstRect.w; + float y2_virtual = y1_virtual + dstRect.h; + + float x1 = virtualToNDCX(x1_virtual); + float y1 = virtualToNDCY(y1_virtual); + float x2 = virtualToNDCX(x2_virtual); + float y2 = virtualToNDCY(y2_virtual); + + float u1 = 0.0; + float v1 = 0.0; + float u2 = 0.0; + float v2 = 0.0; + + if (textureId != NO_TEXTURE_ID) { + GXMTextureCacheEntry& texture = m_textures[textureId]; + const SceGxmTexture* gxmTexture = this->UseTexture(texture); + float texW = sceGxmTextureGetWidth(gxmTexture); + float texH = sceGxmTextureGetHeight(gxmTexture); + + u1 = static_cast(srcRect.x) / texW; + v1 = static_cast(srcRect.y) / texH; + u2 = static_cast(srcRect.x + srcRect.w) / texW; + v2 = static_cast(srcRect.y + srcRect.h) / texH; + } + else { + SET_UNIFORM(fragUniforms, gxm->color_uColor, color); + } + + GXMVertex2D* quadVertices = this->QuadVerticesBuffer(); + quadVertices[0] = GXMVertex2D{.position = {x1, y1}, .texCoord = {u1, v1}}; + quadVertices[1] = GXMVertex2D{.position = {x2, y1}, .texCoord = {u2, v1}}; + quadVertices[2] = GXMVertex2D{.position = {x1, y2}, .texCoord = {u1, v2}}; + quadVertices[3] = GXMVertex2D{.position = {x2, y2}, .texCoord = {u2, v2}}; + + sceGxmSetVertexStream(gxm->context, 0, quadVertices); + + sceGxmSetFrontDepthWriteEnable(gxm->context, SCE_GXM_DEPTH_WRITE_DISABLED); + sceGxmSetFrontDepthFunc(gxm->context, SCE_GXM_DEPTH_FUNC_ALWAYS); + sceGxmDraw(gxm->context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, this->quadIndices, 4); + sceGxmSetFrontDepthWriteEnable(gxm->context, SCE_GXM_DEPTH_WRITE_ENABLED); + +#ifdef DEBUG + sceGxmPopUserMarker(gxm->context); +#endif +} + +void GXMRenderer::SetDither(bool dither) +{ +} + +void GXMRenderer::Download(SDL_Surface* target) +{ + SDL_Rect srcRect = { + static_cast(m_viewportTransform.offsetX), + static_cast(m_viewportTransform.offsetY), + static_cast(target->w * m_viewportTransform.scale), + static_cast(target->h * m_viewportTransform.scale), + }; + SDL_Surface* src = SDL_CreateSurfaceFrom( + VITA_GXM_SCREEN_WIDTH, + VITA_GXM_SCREEN_HEIGHT, + SDL_PIXELFORMAT_ABGR8888, + gxm->displayBuffers[gxm->frontBufferIndex], + VITA_GXM_SCREEN_STRIDE * 4 + ); + SDL_BlitSurfaceScaled(src, &srcRect, target, nullptr, SDL_SCALEMODE_NEAREST); + SDL_DestroySurface(src); +} diff --git a/miniwin/src/d3drm/backends/gxm/razor.h b/miniwin/src/d3drm/backends/gxm/razor.h new file mode 100644 index 00000000..d09260e7 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/razor.h @@ -0,0 +1,13 @@ +#pragma once + +#include +#include + +extern "C" +{ + extern int sceRazorGpuCaptureSetTrigger(int frames, const char* path); + + extern int sceRazorGpuTraceTrigger(); + extern int sceRazorGpuTraceSetFilename(const char* filename, int counter); + extern int sceRazorHudSetDisplayEnabled(bool enable); +} diff --git a/miniwin/src/d3drm/backends/gxm/shaders/.gitignore b/miniwin/src/d3drm/backends/gxm/shaders/.gitignore new file mode 100644 index 00000000..21ce5a1f --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/.gitignore @@ -0,0 +1,2 @@ +*.exe +cache/ \ No newline at end of file diff --git a/miniwin/src/d3drm/backends/gxm/shaders/CMakeLists.txt b/miniwin/src/d3drm/backends/gxm/shaders/CMakeLists.txt new file mode 100644 index 00000000..8d6da2ee --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/CMakeLists.txt @@ -0,0 +1,106 @@ +cmake_minimum_required(VERSION 3.25...4.0 FATAL_ERROR) + +enable_language(ASM) + +find_program(PSP2CGC NAMES ${CMAKE_CURRENT_SOURCE_DIR}/psp2cgc.exe psp2cgc.exe psp2cgc) +find_program(PSP2SHADERPERF NAMES ${CMAKE_CURRENT_SOURCE_DIR}/psp2shaderperf.exe psp2shaderperf.exe psp2shaderperf) + +list(APPEND CGC_COMMON_FLAGS "-Wperf" "-cache" "-cachedir" "${CMAKE_CURRENT_BINARY_DIR}/cache" "-W4" "-Wsuppress=5206,5203") + +make_directory("${CMAKE_CURRENT_BINARY_DIR}/cache") + +# compile .cg to .gxp if psp2cgc is found +macro(COMPILE_SHADER INPUT_CG OUTPUT_GXP PROFILE) + set(EXTRA_FLAGS "${ARGN}") + + set(INPUT_CG_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${INPUT_CG}") + set(OUTPUT_GXP_PATH "${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_GXP}") + set(TRACKED_GXP_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${OUTPUT_GXP}") + + if(PSP2CGC) + if(EXISTS ${TRACKED_GXP_PATH}) + file(COPY ${TRACKED_GXP_PATH} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) + endif() + add_custom_command( + OUTPUT "${OUTPUT_GXP_PATH}" + COMMAND "${PSP2CGC}" ${CGC_COMMON_FLAGS} -profile "${PROFILE}" ${EXTRA_FLAGS} "${INPUT_CG_PATH}" -o "${OUTPUT_GXP_PATH}" + COMMAND ${CMAKE_COMMAND} -E copy "${OUTPUT_GXP_PATH}" "${TRACKED_GXP_PATH}" + DEPENDS "${INPUT_CG_PATH}" + COMMENT "Compiling ${INPUT_CG} -> ${OUTPUT_GXP} ${PROFILE}" + ) + else() + if(NOT EXISTS "${TRACKED_GXP_PATH}") + message(FATAL_ERROR "missing shader ${TRACKED_GXP_PATH} ${INPUT_CG}, but psp2cgc.exe not found") + endif() + add_custom_command( + OUTPUT "${OUTPUT_GXP_PATH}" + COMMAND /usr/bin/env bash + ARGS "-c" + "if [ \"${INPUT_CG_PATH}\" -nt \"${TRACKED_GXP_PATH}\" ]; then + echo 'warning: ${INPUT_CG} changed but dont have psp2cgc, cant recompile' >&2; + fi" + COMMAND ${CMAKE_COMMAND} -E copy "${TRACKED_GXP_PATH}" "${OUTPUT_GXP_PATH}" + DEPENDS "${INPUT_CG_PATH}" "${TRACKED_GXP_PATH}" + VERBATIM + COMMENT "Copy ${TRACKED_GXP_PATH} -> ${OUTPUT_GXP} ${PROFILE}" + ) + endif() + set(TARGET_NAME "compile_${OUTPUT_GXP}") + string(REPLACE "." "_" TARGET_NAME "${TARGET_NAME}") + add_custom_target("${TARGET_NAME}" DEPENDS "${OUTPUT_GXP_PATH}") + add_dependencies(gxm_shaders_compile "${TARGET_NAME}") +endmacro() + + +# analyze gxp to create a .perf.txt +macro(GENERATE_PERF GXP_FILE) + set(GXP_PATH "${CMAKE_CURRENT_BINARY_DIR}/${GXP_FILE}") + string(REPLACE ".gxp" ".perf.txt" PERF_FILE_NAME "${GXP_FILE}") + set(PERF_FILE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${PERF_FILE_NAME}") + + add_custom_command( + OUTPUT "${PERF_FILE_PATH}" + COMMAND "${PSP2SHADERPERF}" -stats -symbols -disasm "${GXP_PATH}" > "${PERF_FILE_PATH}" + DEPENDS "${GXP_PATH}" + COMMENT "Generating performance analysis for ${GXP_FILE}" + ) + set(TARGET_NAME "perf_${PERF_FILE_NAME}") + string(REPLACE "." "_" TARGET_NAME "${TARGET_NAME}") + add_custom_target("${TARGET_NAME}" DEPENDS "${PERF_FILE_PATH}") + add_dependencies(gxm_perfs "${TARGET_NAME}" ) +endmacro() + + + +add_library(gxm_shaders STATIC gxm_shaders.s) + +target_include_directories(gxm_shaders PRIVATE + ${CMAKE_CURRENT_BINARY_DIR} +) + +add_custom_target(gxm_shaders_compile) +add_dependencies(gxm_shaders gxm_shaders_compile) + +COMPILE_SHADER(plane.vert.cg plane.vert.gxp sce_vp_psp2) +COMPILE_SHADER(color.frag.cg color.frag.gxp sce_fp_psp2) +COMPILE_SHADER(image.frag.cg image.frag.gxp sce_fp_psp2) +COMPILE_SHADER(main.vert.cg main.vert.gxp sce_vp_psp2) +COMPILE_SHADER(main.frag.cg main.color.frag.gxp sce_fp_psp2) +COMPILE_SHADER(main.frag.cg main.texture.frag.gxp sce_fp_psp2 -DTEXTURED=1) + + +# .perf.txt +if(PSP2SHADERPERF) + add_custom_target(gxm_perfs) + add_dependencies(gxm_shaders gxm_perfs) + GENERATE_PERF(plane.vert.gxp) + GENERATE_PERF(color.frag.gxp) + GENERATE_PERF(image.frag.gxp) + GENERATE_PERF(main.vert.gxp) + GENERATE_PERF(main.color.frag.gxp) + GENERATE_PERF(main.texture.frag.gxp) +else() + message(STATUS "psp2shaderperf not found") +endif() + + diff --git a/miniwin/src/d3drm/backends/gxm/shaders/color.frag.cg b/miniwin/src/d3drm/backends/gxm/shaders/color.frag.cg new file mode 100644 index 00000000..67533b51 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/color.frag.cg @@ -0,0 +1,6 @@ +void main( + uniform float4 uColor : COLOR, + out float4 outColor : COLOR +) { + outColor = uColor; +} diff --git a/miniwin/src/d3drm/backends/gxm/shaders/color.frag.gxp b/miniwin/src/d3drm/backends/gxm/shaders/color.frag.gxp new file mode 100644 index 0000000000000000000000000000000000000000..dea3d7eb0cb0c10951912f13220266c553f79b77 GIT binary patch literal 228 zcmZ>d2w-4j4PbuEz`(#$#~u1@JJUW!1_>aKK>$R603#4D0pbE6W@2Cgk|4kcWHT_7 zfY}TT89+J(%0{O^I%0s>!HyX$6#!KLqaC1p3m^@$%K*wpP>f(pVK#%s* + +#define GXP(sym) \ + extern uint8_t _inc_##sym[]; \ + static const SceGxmProgram* sym = (const SceGxmProgram*) _inc_##sym; + +GXP(mainVertexProgramGxp); +GXP(mainColorFragmentProgramGxp); +GXP(mainTextureFragmentProgramGxp); +GXP(planeVertexProgramGxp); +GXP(imageFragmentProgramGxp); +GXP(colorFragmentProgramGxp); + +static const SceGxmBlendInfo blendInfoOpaque = { + .colorMask = SCE_GXM_COLOR_MASK_ALL, + .colorFunc = SCE_GXM_BLEND_FUNC_NONE, + .alphaFunc = SCE_GXM_BLEND_FUNC_NONE, + .colorSrc = SCE_GXM_BLEND_FACTOR_ZERO, + .colorDst = SCE_GXM_BLEND_FACTOR_ZERO, + .alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO, + .alphaDst = SCE_GXM_BLEND_FACTOR_ZERO, +}; + +static const SceGxmBlendInfo blendInfoTransparent = { + .colorMask = SCE_GXM_COLOR_MASK_ALL, + .colorFunc = SCE_GXM_BLEND_FUNC_ADD, + .alphaFunc = SCE_GXM_BLEND_FUNC_ADD, + .colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA, + .colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + .alphaSrc = SCE_GXM_BLEND_FACTOR_ONE, + .alphaDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, +}; diff --git a/miniwin/src/d3drm/backends/gxm/shaders/gxm_shaders.s b/miniwin/src/d3drm/backends/gxm/shaders/gxm_shaders.s new file mode 100644 index 00000000..2421947d --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/gxm_shaders.s @@ -0,0 +1,15 @@ +.section .rodata, "a", %progbits + +.macro embed file, symbol +.global _inc_\symbol +.align 16 +_inc_\symbol: + .incbin "\file" +.endm + +embed "main.vert.gxp", mainVertexProgramGxp +embed "main.color.frag.gxp", mainColorFragmentProgramGxp +embed "main.texture.frag.gxp", mainTextureFragmentProgramGxp +embed "plane.vert.gxp", planeVertexProgramGxp +embed "image.frag.gxp", imageFragmentProgramGxp +embed "color.frag.gxp", colorFragmentProgramGxp diff --git a/miniwin/src/d3drm/backends/gxm/shaders/image.frag.cg b/miniwin/src/d3drm/backends/gxm/shaders/image.frag.cg new file mode 100644 index 00000000..b3bc6b02 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/image.frag.cg @@ -0,0 +1,10 @@ +void main( + float4 vPosition : POSITION, + float2 vTexCoord : TEXCOORD0, + + uniform sampler2D uTexture, + + out float4 outColor : COLOR +) { + outColor = tex2D(uTexture, vTexCoord); +} diff --git a/miniwin/src/d3drm/backends/gxm/shaders/image.frag.gxp b/miniwin/src/d3drm/backends/gxm/shaders/image.frag.gxp new file mode 100644 index 0000000000000000000000000000000000000000..fefde5f0ee5d234b85ac9b626ce2afa4af56d59f GIT binary patch literal 264 zcmZ>d2w-4j4Pa(vWMJrwdbjp}nejG84haSj01ANth+YE31whOM76B2AVEGm(zXC{? zK-t)+6riAk9Wz)e0;(VYN_#+Q2Pka;q+OtF2*t<(vW*4A`3Vtm08$DNCWK^n`DFlP cF|ja#-31b4f>;NU$3m8dq*j!a7Nvru0FHwZv;Y7A literal 0 HcmV?d00001 diff --git a/miniwin/src/d3drm/backends/gxm/shaders/image.frag.perf.txt b/miniwin/src/d3drm/backends/gxm/shaders/image.frag.perf.txt new file mode 100644 index 00000000..4b69dc4b --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/image.frag.perf.txt @@ -0,0 +1,29 @@ +Total estimated cost: 0 cycles, parallel mode +Register count: 2 PAs, 0 temps, 0 SAs * +Texture reads: 1 non-dependent, dependent: 0 unconditional, 0 conditional + +High level analysis: +No warnings. + +* Please refer to the Razor documentation for details regarding the meaning of these numbers. Decreasing the number of registers used will not necessarily increase performance + +Instruction statistics: +Number of alu ops: 0 +Number of mem ops: 0 +Number of tex ops: 0 +Number of floating point ops: 0 +Number of integer ops: 0 +Number of pack ops: 0 +Number of mov ops: 0 +Number of nop ops: 0 + + +Samplers: +TEXUNIT0 = uTexture + +Iterators: + + +Primary program: +pa0 = tex2D(uTexture, TEXCOORD0.xy) + diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.gxp b/miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.gxp new file mode 100644 index 0000000000000000000000000000000000000000..713e10c9ed88b5b800a9f484fd88afc7747a6ecc GIT binary patch literal 1248 zcmZ`&O-NKx6h8OO(|L*Z-Wv-hG<=4Hi>L`&%tEI(IHrpNrA<%~WkU|wjON&)Mck`* z%ra4{O%ycq93$F9>mtTz69noeXj2TduvN9wuWuQZ_p@1FaebH8`acYnH0^#H5t z34GK6R%H3fi@>Sp%nE}BV1aKn=w$$45WNBW!BlYuo#-1GfQ^0vzgnDcHKZu3#_<3G zHx{7(f`xNh+UhSLOlF{`JouQV6=OQZu|+VgQZ2 zY=v?F&Kii;;$ypHxT3rG)G8UkMIjfVe0PUdH5vtIi<9R!%Y_{AZ!j2RLoo3JcwkA~`qHg&@$6w;$(4crrBFQAvTtT# zgRtw&ekx5q505omn+e6a)9%eS@d*(Yfea5_6fL4Yo41&7P&~8hc=VTX1fW?u+%yyx z!8F&B!qGf?nsX6`%o|(6yg~cr0<5)!I=Cc(1cL>fbE@rGg$~XP8AgHvU(Sl-r#%Fic6=>>ot{L`dkV#nM*hkE>57ByV>ddO*Q7wk|M&l7**H7Jop>fh>e_Pfox~54N z{72W#;4ajabFk~L+}PCBx!A$D$iuP4Nzz5Kl&;Ak*x>g$yhD%u!tS@8(#61jM19xh z3MQSaELJ&lODEJB0Pk{M{`W!<9T1qk42mitn$dH~tX6KYZ#z<^A;`#6`;E z+ax}ojIw(;p7G}+C;Lo>XwEf4?z literal 0 HcmV?d00001 diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.perf.txt b/miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.perf.txt new file mode 100644 index 00000000..5292cb7a --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/main.color.frag.perf.txt @@ -0,0 +1,134 @@ +Total estimated cost: 63.5 cycles, parallel mode +Register count: 8 PAs, 16 temps, 38 SAs * +Texture reads: 0 non-dependent, dependent: 0 unconditional, 0 conditional + +High level analysis: +No warnings. + +* Please refer to the Razor documentation for details regarding the meaning of these numbers. Decreasing the number of registers used will not necessarily increase performance + +Instruction statistics: +Number of alu ops: 63 +Number of mem ops: 0 +Number of tex ops: 0 +Number of floating point ops: 43 +Number of integer ops: 1 +Number of pack ops: 1 +Number of mov ops: 15 +Number of nop ops: 2 + +Constants: +[DEFAULT + 0 ] sa0 = (float1) uShininess +[DEFAULT + 2 ] sa2 = (float4) uColor +[BUFFER0 + 0 ] = (float4) uLights[0].color +[BUFFER0 + 4 ] = (float4) uLights[0].vec +[BUFFER0 + 8 ] = (float1) uLights[0].isDirectional +[BUFFER0 + 10 ] = (float4) uLights[1].color +[BUFFER0 + 14 ] = (float4) uLights[1].vec +[BUFFER0 + 18 ] = (float1) uLights[1].isDirectional +[BUFFER0 + 20 ] = (float3) uAmbientLight +[LITERAL + 1 ] sa7 = 0xffffffff (-1.#QNAN0f) (-1.#QNANh, -1.#QNANh) +[LITERAL + 2 ] sa8 = 0x3f800000 (1.000000f) (0.00000h, 1.87500h) +[BUFFER0 ] sa6 = buffer base address + +Iterators: +pa0 = (float4) TEXCOORD1 +pa4 = (float4) TEXCOORD2 + + +Secondary program: + 0 : lda32 sa1, [sa6, 0x9] + 1 : lda32.fetch3 sa9, [sa6, 0x4] + 2 : mul.f32 sa32.xy, -sa8.yz, sa0.yy + 3 : mul.f32 sa34.x, -sa10.y, sa0.y + 4 : lda32.fetch4 sa12, [sa6, 0x0] + 5 : mov.f32 sa36.xy, {0, 0} + 6 : mov.f32 sa30.x, {0} + 7 : lda32 sa15, [sa6, 0x13] + 8 : lda32.fetch3 sa16, [sa6, 0xe] + 9 : mul.f32 sa26.xy, -sa16.xy, sa14.yy + 10: mul.f32 sa28.x, -sa18.x, sa14.y + 11: lda32.fetch4 sa19, [sa6, 0xa] + 12: lda32.fetch3 sa22, [sa6, 0x14] + 13: nop + +Primary program: + 0 : cmp.gt.f32 p0, sa0.x, {0} + 1 : mov.f32 i0.xyz, pa0.xyz + 2 : add.f32 i1.xyz, sa8.yzw, -i0.xyz + 2 : +dot.f32 pa3.x, i0.xyz, i0.xyz + 3 : mov.f32 i2.xyz, sa32.xyz + 4 : mad.f32 i2.xyz, -sa0.yyy, i1.xyz, i2.xyz + 5 : add.f32 i1.xyz, i2.xyz, i1.xyz + 5 : +rsq.f32 pa3.x, pa3.x + 6 : dot.f32 i2.x, i1.xyz, i1.xyz + 7 : rsq.f32 pa3.x, i2.x + 7 : +mul.f32 i0.xyz, -i0.xyz, pa2.yyy + 8 : mad.f32 i2.xyz, pa2.yyy, i1.xyz, i0.xyz + 8 : +mov.f32 r6.xy, i0.xy + 9 : mov.f32 r8.x, i0.z + 10: dot.f32 i0.x, i2.xyz, i2.xyz + 10: +mov.f32 r2.xy, i2.xy + 11: mov.f32 r4.x, i2.z + 12: rsq.f32 pa3.x, i0.x + 12: +mul.f32 i0.xyz, i1.xyz, pa2.yyy + 13: dot.f32 i0.x, pa4.xyz, i0.xyz + 14: max.f32 r14.x, i0.x, {0} + 15: p0 br #19 + 16: mov.f32 r10.xy, sa36.xy + 17: or.u32 r12.x, sa30.x, 0x0 + 18: br #30 +#19: cmov.lezero.f32 r0.x, r14.x, {0}, sa8.x + 20: cmov.ltzero.f32 i0.x, r14.x, sa8.x, {0} + 21: mad.f32 i0.x, r0.x, {1}, -i0.x + 22: mul.f32 i1.xyz, r2.xyz, pa2.yyy + 23: dot.f32 i1.x, pa4.xyz, i1.xyz + 24: max.f32 i1.x, i1.x, {0} + 25: mul.f32 i0.xyz, sa12.xyz, i0.xxx + 25: +log.f32 pa3.x, i1.x + 26: mul.f32 i1.x, sa0.x, pa2.y + 27: exp.f32 i1.x, i1.x + 28: mad.f32 r10.xy, i0.xy, i1.xx, {0, 0} + 29: mul.f32 r12.x, i0.z, i1.x +#30: nop + 31: mov.f32 i0.xyz, sa16.xyz + 32: mad.f32 i0.xyz, -pa0.xyz, {1, 1, 1}, i0.xyz + 33: mov.f32 i1.xyz, sa26.xyz + 34: mad.f32 i1.xyz, -sa14.yyy, i0.xyz, i1.xyz + 35: add.f32 i0.xyz, i1.xyz, i0.xyz + 35: +mov.f32 i2.xyz, r6.xyz + 36: dot.f32 i1.x, i0.xyz, i0.xyz + 37: rsq.f32 i1.x, i1.x + 38: mad.f32 i2.xyz, i1.xxx, i0.xyz, i2.xyz + 39: mul.f32 i0.xyz, i0.xyz, i1.xxx + 39: +mov.f32 r0.xy, i2.xy + 40: dot.f32 i0.x, pa4.xyz, i0.xyz + 41: max.f32 pa2.x, i0.x, {0} + 42: dot.f32 i0.x, i2.xyz, i2.xyz + 43: mov.f32 r2.x, i2.z + 44: rsq.f32 pa0.-y, i0.x + 45: !p0 br #57 + 46: cmov.lezero.f32 pa0.x, pa2.x, {0}, sa8.x + 47: cmov.ltzero.f32 i0.x, pa2.x, sa8.x, {0} + 48: mad.f32 i0.x, pa0.x, {1}, -i0.x + 49: mul.f32 i1.xyz, r0.xyz, pa0.yyy + 50: dot.f32 i1.x, pa4.xyz, i1.xyz + 51: max.f32 i1.x, i1.x, {0} + 52: mul.f32 i0.xyz, sa18.yzw, i0.xxx + 52: +log.f32 pa0.x, i1.x + 53: mul.f32 i1.x, sa0.x, pa0.x + 54: exp.f32 i1.x, i1.x + 55: mad.f32 r10.xy, i0.xy, i1.xx, r10.xy + 56: mad.f32 r12.x, i0.z, i1.x, r12.x +#57: nop + 58: mad.f32 i0.xy, r14.xx, sa12.xy, sa22.xy + 59: mad.f32 i0.--z, r14.--x, sa14.--x, sa24.--x + 60: mov.f32 i1.xyz, sa18.yzw + 61: mad.f32 i0.xyz, pa2.xxx, i1.xyz, i0.xyz + 62: mov.f32 i1.xyz, r10.xyz + 63: mov.f32 i2.xyzw, sa2.xyzw + 64: mad.f32 i0.xyz, i2.xyz, i0.xyz, i1.xyz + 65: min.f32 i0.xyz, i0.xyz, {1, 1, 1} + 66: max.f32 i2.xyz, i0.xyz, {0, 0, 0} + 67: pack.f16.f32 pa0.xyzw, i2.xyzw + diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.frag.cg b/miniwin/src/d3drm/backends/gxm/shaders/main.frag.cg new file mode 100644 index 00000000..6960a5f1 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/main.frag.cg @@ -0,0 +1,54 @@ +struct SceneLight { + float4 color; + float4 vec; + float isDirectional; +}; + +void main( + float4 vPosition : POSITION, + float2 vTexCoord : TEXCOORD0, + float3 vViewPos : TEXCOORD1, + float3 vNormal : TEXCOORD2, + + uniform __nostrip SceneLight uLights[2] : BUFFER[0], + uniform __nostrip float3 uAmbientLight : BUFFER[0], + uniform __nostrip float uShininess, + uniform __nostrip float4 uColor, + uniform __nostrip sampler2D uTexture, + + out float4 outColor : COLOR +) { + float3 diffuse = float3(0.0, 0.0, 0.0); + float3 specular = float3(0.0, 0.0, 0.0); + + float3 viewVec = normalize(-vViewPos); // Assuming camera at origin + + diffuse += uAmbientLight; + + for (int i = 0; i < 2; ++i) { + float3 lightColor = uLights[i].color.rgb; + float isDirectional = uLights[i].isDirectional; + + float3 lightVec = normalize(lerp(uLights[i].vec.xyz - vViewPos, -uLights[i].vec.xyz, isDirectional)); + + float3 halfVec = normalize(viewVec + lightVec); + float dotNL = max(dot(vNormal, lightVec), 0.0); + float dotNH = max(dot(vNormal, halfVec), 0.0); + + // Diffuse contribution + diffuse += dotNL * lightColor; + + // Specular + float spec = pow(dotNH, uShininess); + if(uShininess > 0.0) { + specular += spec * lightColor * sign(dotNL); + } + } + + outColor.rgb = clamp(diffuse * uColor.rgb + specular, 0.0, 1.0); + outColor.a = uColor.a; +#if TEXTURED + float4 texel = tex2D(uTexture, vTexCoord); + outColor.rgb *= texel.rgb; +#endif +} diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.gxp b/miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.gxp new file mode 100644 index 0000000000000000000000000000000000000000..501bfea422685f9e7d2e7935e9c4e5d4a7212680 GIT binary patch literal 1312 zcmaJ=O-NKx6h8OO(|MKl-Wv;^X!s0?HsuH|W}(v?oYF;sQj6$^C>wIXX8f6nXc713 z8#8|}p-m9vJbxB#qJ79{ZX!d42wKHJi&|wn4a?5CGo=Z2;JtIdbIy0q`R;qS^?W<9 zl6GHB3BX(U^kiV}!ZBu9pa2*Q3bqg3s1KkAeHk19U4|K)LSKzVCi)@D{U*pf08*rt z;=2)n6ZX-*VBwldgT(^EWCnW5Yv`AXF_{3SD#%a?ROZUat>F{IN4InP3DcU4yS0-p zOnruXwOQ95_*{tE8z7EO&zd>S5pC1YjGP8sWHUj^x3wrG_d)RZy7Mp);dZk(QNxFXC45O9xGw5MMQYMu!Uo-7MmZ1t z)EWV5U7PEg#KNE8N=(?QXO43&EJ!YzF3f0jUJk%UU7+RLXgPO4=Xni8I~^d#*VP{A z4On*0|b?Ht0{~l#pvPaK3VjYa%?U z!+suY5)qS&yw$9aF%DeA?ZMdt>wzI5^#MCHzBrP#s>iYtw;CPGQm_BLZbV$W$?MRi zUfORj4>sEqI>+nbx!ct{E3f1~hVQP&UEfZjpU zWv;EN1zqE$3;v<&f&T#N%GfydSFUaAI=S4!xR``f%Oj+VWJz5ky|Bd}b67%;^TNT` zp47#_d`fedWwJVbS57%t?o8TF%&CHckr zy@;3a`OT*pWWHD*K>UvKct44cUr5>`d|xWAslTE!nWqrd{?F29yW)v>BG%sz>6T=7 zvJcXy<2Sle{TG9mk9Y14+=_MX%*Xqq@xEARDxOSS?f#Q!*iFR1P9nlx#K_HS@mL}y P8$~<>M7X$bOq!Kp2 literal 0 HcmV?d00001 diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.perf.txt b/miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.perf.txt new file mode 100644 index 00000000..ef379b18 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/main.texture.frag.perf.txt @@ -0,0 +1,139 @@ +Total estimated cost: 64.5 cycles, parallel mode +Register count: 12 PAs, 16 temps, 38 SAs * +Texture reads: 1 non-dependent, dependent: 0 unconditional, 0 conditional + +High level analysis: +No warnings. + +* Please refer to the Razor documentation for details regarding the meaning of these numbers. Decreasing the number of registers used will not necessarily increase performance + +Instruction statistics: +Number of alu ops: 64 +Number of mem ops: 0 +Number of tex ops: 0 +Number of floating point ops: 44 +Number of integer ops: 1 +Number of pack ops: 1 +Number of mov ops: 15 +Number of nop ops: 2 + +Constants: +[DEFAULT + 0 ] sa0 = (float1) uShininess +[DEFAULT + 2 ] sa2 = (float4) uColor +[BUFFER0 + 0 ] = (float4) uLights[0].color +[BUFFER0 + 4 ] = (float4) uLights[0].vec +[BUFFER0 + 8 ] = (float1) uLights[0].isDirectional +[BUFFER0 + 10 ] = (float4) uLights[1].color +[BUFFER0 + 14 ] = (float4) uLights[1].vec +[BUFFER0 + 18 ] = (float1) uLights[1].isDirectional +[BUFFER0 + 20 ] = (float3) uAmbientLight +[LITERAL + 1 ] sa7 = 0xffffffff (-1.#QNAN0f) (-1.#QNANh, -1.#QNANh) +[LITERAL + 2 ] sa8 = 0x3f800000 (1.000000f) (0.00000h, 1.87500h) +[BUFFER0 ] sa6 = buffer base address + +Samplers: +TEXUNIT0 = uTexture + +Iterators: +pa0 = (float4) TEXCOORD1 +pa8 = (float4) TEXCOORD2 + + +Secondary program: + 0 : lda32 sa1, [sa6, 0x9] + 1 : lda32.fetch3 sa9, [sa6, 0x4] + 2 : mul.f32 sa32.xy, -sa8.yz, sa0.yy + 3 : mul.f32 sa34.x, -sa10.y, sa0.y + 4 : lda32.fetch4 sa12, [sa6, 0x0] + 5 : mov.f32 sa36.xy, {0, 0} + 6 : mov.f32 sa30.x, {0} + 7 : lda32 sa15, [sa6, 0x13] + 8 : lda32.fetch3 sa16, [sa6, 0xe] + 9 : mul.f32 sa26.xy, -sa16.xy, sa14.yy + 10: mul.f32 sa28.x, -sa18.x, sa14.y + 11: lda32.fetch4 sa19, [sa6, 0xa] + 12: lda32.fetch3 sa22, [sa6, 0x14] + 13: nop + +Primary program: +pa4 = tex2D(uTexture, TEXCOORD0.xy) + 0 : cmp.gt.f32 p0, sa0.x, {0} + 1 : mov.f32 i0.xyz, pa0.xyz + 2 : add.f32 i1.xyz, sa8.yzw, -i0.xyz + 2 : +dot.f32 pa3.x, i0.xyz, i0.xyz + 3 : mov.f32 i2.xyz, sa32.xyz + 4 : mad.f32 i2.xyz, -sa0.yyy, i1.xyz, i2.xyz + 5 : add.f32 i1.xyz, i2.xyz, i1.xyz + 5 : +rsq.f32 pa3.x, pa3.x + 6 : dot.f32 i2.x, i1.xyz, i1.xyz + 7 : rsq.f32 pa3.x, i2.x + 7 : +mul.f32 i0.xyz, -i0.xyz, pa2.yyy + 8 : mad.f32 i2.xyz, pa2.yyy, i1.xyz, i0.xyz + 8 : +mov.f32 r6.xy, i0.xy + 9 : mov.f32 r8.x, i0.z + 10: dot.f32 i0.x, i2.xyz, i2.xyz + 10: +mov.f32 r2.xy, i2.xy + 11: mov.f32 r4.x, i2.z + 12: rsq.f32 pa3.x, i0.x + 12: +mul.f32 i0.xyz, i1.xyz, pa2.yyy + 13: dot.f32 i0.x, pa8.xyz, i0.xyz + 14: max.f32 r14.x, i0.x, {0} + 15: p0 br #19 + 16: mov.f32 r10.xy, sa36.xy + 17: or.u32 r12.x, sa30.x, 0x0 + 18: br #30 +#19: cmov.lezero.f32 r0.x, r14.x, {0}, sa8.x + 20: cmov.ltzero.f32 i0.x, r14.x, sa8.x, {0} + 21: mad.f32 i0.x, r0.x, {1}, -i0.x + 22: mul.f32 i1.xyz, r2.xyz, pa2.yyy + 23: dot.f32 i1.x, pa8.xyz, i1.xyz + 24: max.f32 i1.x, i1.x, {0} + 25: mul.f32 i0.xyz, sa12.xyz, i0.xxx + 25: +log.f32 pa3.x, i1.x + 26: mul.f32 i1.x, sa0.x, pa2.y + 27: exp.f32 i1.x, i1.x + 28: mad.f32 r10.xy, i0.xy, i1.xx, {0, 0} + 29: mul.f32 r12.x, i0.z, i1.x +#30: nop + 31: mov.f32 i0.xyz, sa16.xyz + 32: mad.f32 i0.xyz, -pa0.xyz, {1, 1, 1}, i0.xyz + 33: mov.f32 i1.xyz, sa26.xyz + 34: mad.f32 i1.xyz, -sa14.yyy, i0.xyz, i1.xyz + 35: add.f32 i0.xyz, i1.xyz, i0.xyz + 35: +mov.f32 i2.xyz, r6.xyz + 36: dot.f32 i1.x, i0.xyz, i0.xyz + 37: rsq.f32 i1.x, i1.x + 38: mad.f32 i2.xyz, i1.xxx, i0.xyz, i2.xyz + 39: mul.f32 i0.xyz, i0.xyz, i1.xxx + 39: +mov.f32 r0.xy, i2.xy + 40: dot.f32 i0.x, pa8.xyz, i0.xyz + 41: max.f32 pa2.x, i0.x, {0} + 42: dot.f32 i0.x, i2.xyz, i2.xyz + 43: mov.f32 r2.x, i2.z + 44: rsq.f32 pa0.-y, i0.x + 45: !p0 br #57 + 46: cmov.lezero.f32 pa0.x, pa2.x, {0}, sa8.x + 47: cmov.ltzero.f32 i0.x, pa2.x, sa8.x, {0} + 48: mad.f32 i0.x, pa0.x, {1}, -i0.x + 49: mul.f32 i1.xyz, r0.xyz, pa0.yyy + 50: dot.f32 i1.x, pa8.xyz, i1.xyz + 51: max.f32 i1.x, i1.x, {0} + 52: mul.f32 i0.xyz, sa18.yzw, i0.xxx + 52: +log.f32 pa0.x, i1.x + 53: mul.f32 i1.x, sa0.x, pa0.x + 54: exp.f32 i1.x, i1.x + 55: mad.f32 r10.xy, i0.xy, i1.xx, r10.xy + 56: mad.f32 r12.x, i0.z, i1.x, r12.x +#57: nop + 58: mad.f32 i0.xy, r14.xx, sa12.xy, sa22.xy + 59: mad.f32 i0.--z, r14.--x, sa14.--x, sa24.--x + 60: mov.f32 i1.xyz, sa18.yzw + 61: mad.f32 i0.xyz, pa2.xxx, i1.xyz, i0.xyz + 62: mov.f32 i1.xyz, r10.xyz + 63: mov.f32 i2.xyzw, sa2.xyzw + 64: mad.f32 i0.xyz, i2.xyz, i0.xyz, i1.xyz + 65: min.f32 i0.xyz, i0.xyz, {1, 1, 1} + 66: max.f32 i0.xyz, i0.xyz, {0, 0, 0} + 67: mad.f32 i2.xyz, pa4.xyz, i0.xyz, {0, 0, 0} + 68: pack.f16.f32 pa0.xyzw, i2.xyzw + diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.vert.cg b/miniwin/src/d3drm/backends/gxm/shaders/main.vert.cg new file mode 100644 index 00000000..2f74fee6 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/main.vert.cg @@ -0,0 +1,20 @@ +void main( + float3 aPosition : POSITION, + float3 aNormal : NORMAL, + float2 aTexCoord : TEXCOORD0, + + column_major uniform float4x4 uModelViewMatrix, + column_major uniform float3x3 uNormalMatrix, + column_major uniform float4x4 uProjectionMatrix, + + out float4 vPosition : POSITION, + out float2 vTexCoord : TEXCOORD0, + out float3 vViewPos : TEXCOORD1, + out float3 vNormal : TEXCOORD2 +) { + float4 viewPos = mul(uModelViewMatrix, float4(aPosition, 1.0)); + vPosition = mul(uProjectionMatrix, viewPos); + vViewPos = viewPos.xyz; + vNormal = normalize(mul(uNormalMatrix, aNormal)); + vTexCoord = aTexCoord; +} diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.vert.gxp b/miniwin/src/d3drm/backends/gxm/shaders/main.vert.gxp new file mode 100644 index 0000000000000000000000000000000000000000..b4d3427db1fb1ad7850fa0e5775fd878df32f95f GIT binary patch literal 784 zcmZuv&ubGw6n?Y$;qJQGA3<~#gzm{6dI;hnhY-`WMMNX36cJBGn?t0!5>pz`!|b{Z z2}L6wih^J)^&D~(6cl@uTERN15A^gN%sfZuJ*o$=& z{1)@ih@#w%`RZ6sGqjkXjSd)9B?W$|;fuk$%!g7zn(u|imaJL}J>DDInsuH~w;s0x ze`p(DciKUBXzT5_q<^0Xd*RtFS#!FtgkE*l2xW(D2)z=OH-tVNj7VQR@E^qfgy{c9 z=+K`~;$#2Lu|;0aZBMH#MZOwS2z6F@M*5FBAva`6&G39C`KkW|&rvdfNyxbY5+O4K z=_Jp~$+@_1vTRE9O(~lSCl>;6X#O`a`H_RO>A)YnL@(2y{leEHJ8LZ<4(%hBLMZXq z)Ia@vv@ibM38(vAoav~uMyNP!*T*x-QJD}n|L*$JPwm3yWrKHo+b{MFPLssnr@9Q)#ae65^BPOAQt_5*%UA2Q)k?M5sJCEcESWI3 O;oYv?62tKh`uzhx*TC@r literal 0 HcmV?d00001 diff --git a/miniwin/src/d3drm/backends/gxm/shaders/main.vert.perf.txt b/miniwin/src/d3drm/backends/gxm/shaders/main.vert.perf.txt new file mode 100644 index 00000000..ab3c679e --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/main.vert.perf.txt @@ -0,0 +1,87 @@ +Total estimated cost: 18 cycles, parallel mode +Register count: 12 PAs, 0 temps, 56 SAs * +Texture reads: 0 non-dependent, dependent: 0 unconditional, 0 conditional + +High level analysis: +- One or multiple vertex outputs are misaligned due to a three coefficient TEXCOORD vertex output. This will lead to additional data movement instructions being generated. If only one three coefficient TEXCOORD output is present, assigning it the coordinate with the greatest index will allow the previous coordinates to be aligned. + +* Please refer to the Razor documentation for details regarding the meaning of these numbers. Decreasing the number of registers used will not necessarily increase performance + +Instruction statistics: +Number of alu ops: 19 +Number of mem ops: 0 +Number of tex ops: 0 +Number of floating point ops: 14 +Number of integer ops: 0 +Number of pack ops: 0 +Number of mov ops: 4 +Number of nop ops: 0 + +Constants: +[DEFAULT + 0 ] sa0 = (float4) uModelViewMatrix[4] +[DEFAULT + 32 ] sa32 = (float3) uNormalMatrix[3] +[DEFAULT + 16 ] sa16 = (float4) uProjectionMatrix[4] + +Vertex attributes: +pa0 = (float4) aPosition +pa4 = (float4) aNormal +pa8 = (float4) aTexCoord + + +Secondary program: + 0 : nop + 1 : mov.f32 i0.xyzw, sa8.xyzw + 2 : mul.f32 i1.xyzw, sa16.xyzw, i0.xxxx + 3 : mad.f32 i1.xyzw, sa20.xyzw, i0.yyyy, i1.xyzw + 4 : mad.f32 i1.xyzw, sa24.xyzw, i0.zzzz, i1.xyzw + 5 : mad.f32 sa52.xy, sa28.xy, i0.ww, i1.xy + 6 : mad.f32 sa54.xy, sa30.xy, i0.ww, i1.zw + 7 : mov.f32 i1.xyzw, sa12.xyzw + 8 : mul.f32 i2.xyzw, sa28.xyzw, i1.wwww + 9 : mad.f32 i2.xyzw, sa24.xyzw, i1.zzzz, i2.xyzw + 10: mad.f32 i2.xyzw, sa20.xyzw, i1.yyyy, i2.xyzw + 11: mad.f32 sa48.xy, sa16.xy, i1.xx, i2.xy + 12: mad.f32 sa50.xy, sa18.xy, i1.xx, i2.zw + 13: mov.f32 i2.xyzw, sa4.xyzw + 14: mul.f32 i1.xyzw, sa16.xyzw, i2.xxxx + 15: mad.f32 i1.xyzw, sa20.xyzw, i2.yyyy, i1.xyzw + 16: mad.f32 i1.xyzw, sa24.xyzw, i2.zzzz, i1.xyzw + 17: mad.f32 sa44.xy, sa28.xy, i2.ww, i1.xy + 18: mad.f32 sa46.xy, sa30.xy, i2.ww, i1.zw + 19: mov.f32 i1.xyzw, sa0.xyzw + 20: mul.f32 i0.xyzw, sa16.xyzw, i1.xxxx + 20: +mov.f32 sa4.xy, i1.yy + 21: mad.f32 i0.xyzw, sa20.xyzw, i1.yyyy, i0.xyzw + 22: mad.f32 i0.xyzw, sa24.xyzw, i1.zzzz, i0.xyzw + 23: mad.f32 sa18.xy, sa28.xy, i1.ww, i0.xy + 24: mad.f32 sa16.xy, sa30.xy, i1.ww, i0.zw + 25: mov.f32 sa4.-y, i2.-y + 26: mov.f32 sa6.xy, (sa8.y, sa12.y) + 27: mov.f32 sa0.x, i1.x + 28: mov.f32 sa0.-y, i2.-x + 29: mov.f32 sa8.-y, sa12.-x + 30: mov.f32 sa10.-y, sa14.-x + 31: mov.f32 sa2.xy, sa8.xy + 32: mov.f32 sa8.x, i1.z + 33: mov.f32 sa8.-y, i2.-z + +Primary program: + 0 : mov.f32 o4.xy, pa8.xy + 1 : mov.f32 i0.xyz, pa4.xyz + 2 : mad.f32 i1.xyz, sa32.xyz, i0.xxx, {0, 0, 0} + 3 : mad.f32 i1.xyz, sa36.xyz, i0.yyy, i1.xyz + 4 : mad.f32 i0.xyz, sa40.xyz, i0.zzz, i1.xyz + 5 : mov.f32 i1.xyz, pa0.xyz + 6 : mov.f32 i2.xyzw, sa48.xyzw + 7 : mad.f32 i2.xyzw, sa52.xyzw, i1.zzzz, i2.xyzw + 8 : mad.f32 i2.xyzw, sa44.xyzw, i1.yyyy, i2.xyzw + 9 : mad.f32 o0.xy, sa18.xy, i1.xx, i2.xy + 10: mad.f32 o2.xy, sa16.xy, i1.xx, i2.zw + 11: dot.f32 o6.x, sa0.xyzw, i1.xyz1 + 12: dot.f32 o6.-y, sa4.xyzw, i1.xyz1 + 13: dot.f32 o6.--z, sa8.xyzw, i1.xyz1 + 14: dot.f32 i1.x, i0.xyz, i0.xyz + 15: rsq.f32 i1.x, i1.x + 16: mad.f32 o10.xy, i0.yz, i1.xx, {0, 0} + 17: mad.f32 o8.-y, i0.-x, i1.-x, {0, 0} + diff --git a/miniwin/src/d3drm/backends/gxm/shaders/plane.vert.cg b/miniwin/src/d3drm/backends/gxm/shaders/plane.vert.cg new file mode 100644 index 00000000..532431d6 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/plane.vert.cg @@ -0,0 +1,11 @@ + +void main( + float2 aPosition : POSITION, + float2 aTexCoord : TEXCOORD0, + + out float4 vPosition : POSITION, + out float2 vTexCoord : TEXCOORD0 +) : POSITION { + vPosition = float4(aPosition, 1.f, 1.f); + vTexCoord = aTexCoord; +} diff --git a/miniwin/src/d3drm/backends/gxm/shaders/plane.vert.gxp b/miniwin/src/d3drm/backends/gxm/shaders/plane.vert.gxp new file mode 100644 index 0000000000000000000000000000000000000000..b9a45ae858e364e9a219726f8ad631114492277e GIT binary patch literal 284 zcmZ>d2w-4j4PcgGWMHtFTcWvD(*HgSgCqkoU;=Uu0C52ja{w^}Ffy3r1EoWtv@w*1QvwWZKxbkCc9&lb3>?jhtPK{73@j5` z1($L#HiS)R6l?}MS78A|fckF*kS-Q(2AF;+FrN?1X92Pk1M-VAOEUBG7!pHLE1dK5 Hi&7W>phO%r literal 0 HcmV?d00001 diff --git a/miniwin/src/d3drm/backends/gxm/shaders/plane.vert.perf.txt b/miniwin/src/d3drm/backends/gxm/shaders/plane.vert.perf.txt new file mode 100644 index 00000000..60080fde --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/shaders/plane.vert.perf.txt @@ -0,0 +1,30 @@ +Total estimated cost: 3 cycles, parallel mode +Register count: 8 PAs, 0 temps, 0 SAs * +Texture reads: 0 non-dependent, dependent: 0 unconditional, 0 conditional + +High level analysis: +No warnings. + +* Please refer to the Razor documentation for details regarding the meaning of these numbers. Decreasing the number of registers used will not necessarily increase performance + +Instruction statistics: +Number of alu ops: 4 +Number of mem ops: 0 +Number of tex ops: 0 +Number of floating point ops: 2 +Number of integer ops: 0 +Number of pack ops: 0 +Number of mov ops: 1 +Number of nop ops: 0 + + +Vertex attributes: +pa0 = (float4) aPosition +pa4 = (float4) aTexCoord + + +Primary program: + 0: mov.f32 o4.xy, pa4.xy + 1: mul.f32 o0.xy, pa0.xy, {1, 1} + 2: mul.f32 o2.xy, {1, 1}, {1, 1} + diff --git a/miniwin/src/d3drm/backends/gxm/tlsf.c b/miniwin/src/d3drm/backends/gxm/tlsf.c new file mode 100644 index 00000000..31d25bdc --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/tlsf.c @@ -0,0 +1,1264 @@ +#include +#include +#include +#include +#include +#include + +#include "tlsf.h" + +#if defined(__cplusplus) +#define tlsf_decl inline +#else +#define tlsf_decl static +#endif + +/* +** Architecture-specific bit manipulation routines. +** +** TLSF achieves O(1) cost for malloc and free operations by limiting +** the search for a free block to a free list of guaranteed size +** adequate to fulfill the request, combined with efficient free list +** queries using bitmasks and architecture-specific bit-manipulation +** routines. +** +** Most modern processors provide instructions to count leading zeroes +** in a word, find the lowest and highest set bit, etc. These +** specific implementations will be used when available, falling back +** to a reasonably efficient generic implementation. +** +** NOTE: TLSF spec relies on ffs/fls returning value 0..31. +** ffs/fls return 1-32 by default, returning 0 for error. +*/ + +/* +** Detect whether or not we are building for a 32- or 64-bit (LP/LLP) +** architecture. There is no reliable portable method at compile-time. +*/ +#if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) \ + || defined (_WIN64) || defined (__LP64__) || defined (__LLP64__) +#define TLSF_64BIT +#endif + +/* +** gcc 3.4 and above have builtin support, specialized for architecture. +** Some compilers masquerade as gcc; patchlevel test filters them out. +*/ +#if defined (__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \ + && defined (__GNUC_PATCHLEVEL__) + +#if defined (__SNC__) +/* SNC for Playstation 3. */ + +tlsf_decl int tlsf_ffs(unsigned int word) +{ + const unsigned int reverse = word & (~word + 1); + const int bit = 32 - __builtin_clz(reverse); + return bit - 1; +} + +#else + +tlsf_decl int tlsf_ffs(unsigned int word) +{ + return __builtin_ffs(word) - 1; +} + +#endif + +tlsf_decl int tlsf_fls(unsigned int word) +{ + const int bit = word ? 32 - __builtin_clz(word) : 0; + return bit - 1; +} + +#elif defined (_MSC_VER) && (_MSC_VER >= 1400) && (defined (_M_IX86) || defined (_M_X64)) +/* Microsoft Visual C++ support on x86/X64 architectures. */ + +#include + +#pragma intrinsic(_BitScanReverse) +#pragma intrinsic(_BitScanForward) + +tlsf_decl int tlsf_fls(unsigned int word) +{ + unsigned long index; + return _BitScanReverse(&index, word) ? index : -1; +} + +tlsf_decl int tlsf_ffs(unsigned int word) +{ + unsigned long index; + return _BitScanForward(&index, word) ? index : -1; +} + +#elif defined (_MSC_VER) && defined (_M_PPC) +/* Microsoft Visual C++ support on PowerPC architectures. */ + +#include + +tlsf_decl int tlsf_fls(unsigned int word) +{ + const int bit = 32 - _CountLeadingZeros(word); + return bit - 1; +} + +tlsf_decl int tlsf_ffs(unsigned int word) +{ + const unsigned int reverse = word & (~word + 1); + const int bit = 32 - _CountLeadingZeros(reverse); + return bit - 1; +} + +#elif defined (__ARMCC_VERSION) +/* RealView Compilation Tools for ARM */ + +tlsf_decl int tlsf_ffs(unsigned int word) +{ + const unsigned int reverse = word & (~word + 1); + const int bit = 32 - __clz(reverse); + return bit - 1; +} + +tlsf_decl int tlsf_fls(unsigned int word) +{ + const int bit = word ? 32 - __clz(word) : 0; + return bit - 1; +} + +#elif defined (__ghs__) +/* Green Hills support for PowerPC */ + +#include + +tlsf_decl int tlsf_ffs(unsigned int word) +{ + const unsigned int reverse = word & (~word + 1); + const int bit = 32 - __CLZ32(reverse); + return bit - 1; +} + +tlsf_decl int tlsf_fls(unsigned int word) +{ + const int bit = word ? 32 - __CLZ32(word) : 0; + return bit - 1; +} + +#else +/* Fall back to generic implementation. */ + +tlsf_decl int tlsf_fls_generic(unsigned int word) +{ + int bit = 32; + + if (!word) bit -= 1; + if (!(word & 0xffff0000)) { word <<= 16; bit -= 16; } + if (!(word & 0xff000000)) { word <<= 8; bit -= 8; } + if (!(word & 0xf0000000)) { word <<= 4; bit -= 4; } + if (!(word & 0xc0000000)) { word <<= 2; bit -= 2; } + if (!(word & 0x80000000)) { word <<= 1; bit -= 1; } + + return bit; +} + +/* Implement ffs in terms of fls. */ +tlsf_decl int tlsf_ffs(unsigned int word) +{ + return tlsf_fls_generic(word & (~word + 1)) - 1; +} + +tlsf_decl int tlsf_fls(unsigned int word) +{ + return tlsf_fls_generic(word) - 1; +} + +#endif + +/* Possibly 64-bit version of tlsf_fls. */ +#if defined (TLSF_64BIT) +tlsf_decl int tlsf_fls_sizet(size_t size) +{ + int high = (int)(size >> 32); + int bits = 0; + if (high) + { + bits = 32 + tlsf_fls(high); + } + else + { + bits = tlsf_fls((int)size & 0xffffffff); + + } + return bits; +} +#else +#define tlsf_fls_sizet tlsf_fls +#endif + +#undef tlsf_decl + +/* +** Constants. +*/ + +/* Public constants: may be modified. */ +enum tlsf_public +{ + /* log2 of number of linear subdivisions of block sizes. Larger + ** values require more memory in the control structure. Values of + ** 4 or 5 are typical. + */ + SL_INDEX_COUNT_LOG2 = 5, +}; + +/* Private constants: do not modify. */ +enum tlsf_private +{ +#if defined (TLSF_64BIT) + /* All allocation sizes and addresses are aligned to 8 bytes. */ + ALIGN_SIZE_LOG2 = 3, +#else + /* All allocation sizes and addresses are aligned to 4 bytes. */ + ALIGN_SIZE_LOG2 = 2, +#endif + ALIGN_SIZE = (1 << ALIGN_SIZE_LOG2), + + /* + ** We support allocations of sizes up to (1 << FL_INDEX_MAX) bits. + ** However, because we linearly subdivide the second-level lists, and + ** our minimum size granularity is 4 bytes, it doesn't make sense to + ** create first-level lists for sizes smaller than SL_INDEX_COUNT * 4, + ** or (1 << (SL_INDEX_COUNT_LOG2 + 2)) bytes, as there we will be + ** trying to split size ranges into more slots than we have available. + ** Instead, we calculate the minimum threshold size, and place all + ** blocks below that size into the 0th first-level list. + */ + +#if defined (TLSF_64BIT) + /* + ** TODO: We can increase this to support larger sizes, at the expense + ** of more overhead in the TLSF structure. + */ + FL_INDEX_MAX = 32, +#else + FL_INDEX_MAX = 30, +#endif + SL_INDEX_COUNT = (1 << SL_INDEX_COUNT_LOG2), + FL_INDEX_SHIFT = (SL_INDEX_COUNT_LOG2 + ALIGN_SIZE_LOG2), + FL_INDEX_COUNT = (FL_INDEX_MAX - FL_INDEX_SHIFT + 1), + + SMALL_BLOCK_SIZE = (1 << FL_INDEX_SHIFT), +}; + +/* +** Cast and min/max macros. +*/ + +#define tlsf_cast(t, exp) ((t) (exp)) +#define tlsf_min(a, b) ((a) < (b) ? (a) : (b)) +#define tlsf_max(a, b) ((a) > (b) ? (a) : (b)) + +/* +** Set assert macro, if it has not been provided by the user. +*/ +#if !defined (tlsf_assert) +#define tlsf_assert assert +#endif + +/* +** Static assertion mechanism. +*/ + +#define _tlsf_glue2(x, y) x ## y +#define _tlsf_glue(x, y) _tlsf_glue2(x, y) +#define tlsf_static_assert(exp) \ + typedef char _tlsf_glue(static_assert, __LINE__) [(exp) ? 1 : -1] + +/* This code has been tested on 32- and 64-bit (LP/LLP) architectures. */ +tlsf_static_assert(sizeof(int) * CHAR_BIT == 32); +tlsf_static_assert(sizeof(size_t) * CHAR_BIT >= 32); +tlsf_static_assert(sizeof(size_t) * CHAR_BIT <= 64); + +/* SL_INDEX_COUNT must be <= number of bits in sl_bitmap's storage type. */ +tlsf_static_assert(sizeof(unsigned int) * CHAR_BIT >= SL_INDEX_COUNT); + +/* Ensure we've properly tuned our sizes. */ +tlsf_static_assert(ALIGN_SIZE == SMALL_BLOCK_SIZE / SL_INDEX_COUNT); + +/* +** Data structures and associated constants. +*/ + +/* +** Block header structure. +** +** There are several implementation subtleties involved: +** - The prev_phys_block field is only valid if the previous block is free. +** - The prev_phys_block field is actually stored at the end of the +** previous block. It appears at the beginning of this structure only to +** simplify the implementation. +** - The next_free / prev_free fields are only valid if the block is free. +*/ +typedef struct block_header_t +{ + /* Points to the previous physical block. */ + struct block_header_t* prev_phys_block; + + /* The size of this block, excluding the block header. */ + size_t size; + + /* Next and previous free blocks. */ + struct block_header_t* next_free; + struct block_header_t* prev_free; +} block_header_t; + +/* +** Since block sizes are always at least a multiple of 4, the two least +** significant bits of the size field are used to store the block status: +** - bit 0: whether block is busy or free +** - bit 1: whether previous block is busy or free +*/ +static const size_t block_header_free_bit = 1 << 0; +static const size_t block_header_prev_free_bit = 1 << 1; + +/* +** The size of the block header exposed to used blocks is the size field. +** The prev_phys_block field is stored *inside* the previous free block. +*/ +static const size_t block_header_overhead = sizeof(size_t); + +/* User data starts directly after the size field in a used block. */ +static const size_t block_start_offset = + offsetof(block_header_t, size) + sizeof(size_t); + +/* +** A free block must be large enough to store its header minus the size of +** the prev_phys_block field, and no larger than the number of addressable +** bits for FL_INDEX. +*/ +static const size_t block_size_min = + sizeof(block_header_t) - sizeof(block_header_t*); +static const size_t block_size_max = tlsf_cast(size_t, 1) << FL_INDEX_MAX; + + +/* The TLSF control structure. */ +typedef struct control_t +{ + /* Empty lists point at this block to indicate they are free. */ + block_header_t block_null; + + /* Bitmaps for free lists. */ + unsigned int fl_bitmap; + unsigned int sl_bitmap[FL_INDEX_COUNT]; + + /* Head of free lists. */ + block_header_t* blocks[FL_INDEX_COUNT][SL_INDEX_COUNT]; +} control_t; + +/* A type used for casting when doing pointer arithmetic. */ +typedef ptrdiff_t tlsfptr_t; + +/* +** block_header_t member functions. +*/ + +static size_t block_size(const block_header_t* block) +{ + return block->size & ~(block_header_free_bit | block_header_prev_free_bit); +} + +static void block_set_size(block_header_t* block, size_t size) +{ + const size_t oldsize = block->size; + block->size = size | (oldsize & (block_header_free_bit | block_header_prev_free_bit)); +} + +static int block_is_last(const block_header_t* block) +{ + return block_size(block) == 0; +} + +static int block_is_free(const block_header_t* block) +{ + return tlsf_cast(int, block->size & block_header_free_bit); +} + +static void block_set_free(block_header_t* block) +{ + block->size |= block_header_free_bit; +} + +static void block_set_used(block_header_t* block) +{ + block->size &= ~block_header_free_bit; +} + +static int block_is_prev_free(const block_header_t* block) +{ + return tlsf_cast(int, block->size & block_header_prev_free_bit); +} + +static void block_set_prev_free(block_header_t* block) +{ + block->size |= block_header_prev_free_bit; +} + +static void block_set_prev_used(block_header_t* block) +{ + block->size &= ~block_header_prev_free_bit; +} + +static block_header_t* block_from_ptr(const void* ptr) +{ + return tlsf_cast(block_header_t*, + tlsf_cast(unsigned char*, ptr) - block_start_offset); +} + +static void* block_to_ptr(const block_header_t* block) +{ + return tlsf_cast(void*, + tlsf_cast(unsigned char*, block) + block_start_offset); +} + +/* Return location of next block after block of given size. */ +static block_header_t* offset_to_block(const void* ptr, size_t size) +{ + return tlsf_cast(block_header_t*, tlsf_cast(tlsfptr_t, ptr) + size); +} + +/* Return location of previous block. */ +static block_header_t* block_prev(const block_header_t* block) +{ + tlsf_assert(block_is_prev_free(block) && "previous block must be free"); + return block->prev_phys_block; +} + +/* Return location of next existing block. */ +static block_header_t* block_next(const block_header_t* block) +{ + block_header_t* next = offset_to_block(block_to_ptr(block), + block_size(block) - block_header_overhead); + tlsf_assert(!block_is_last(block)); + return next; +} + +/* Link a new block with its physical neighbor, return the neighbor. */ +static block_header_t* block_link_next(block_header_t* block) +{ + block_header_t* next = block_next(block); + next->prev_phys_block = block; + return next; +} + +static void block_mark_as_free(block_header_t* block) +{ + /* Link the block to the next block, first. */ + block_header_t* next = block_link_next(block); + block_set_prev_free(next); + block_set_free(block); +} + +static void block_mark_as_used(block_header_t* block) +{ + block_header_t* next = block_next(block); + block_set_prev_used(next); + block_set_used(block); +} + +static size_t align_up(size_t x, size_t align) +{ + tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two"); + return (x + (align - 1)) & ~(align - 1); +} + +static size_t align_down(size_t x, size_t align) +{ + tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two"); + return x - (x & (align - 1)); +} + +static void* align_ptr(const void* ptr, size_t align) +{ + const tlsfptr_t aligned = + (tlsf_cast(tlsfptr_t, ptr) + (align - 1)) & ~(align - 1); + tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two"); + return tlsf_cast(void*, aligned); +} + +/* +** Adjust an allocation size to be aligned to word size, and no smaller +** than internal minimum. +*/ +static size_t adjust_request_size(size_t size, size_t align) +{ + size_t adjust = 0; + if (size) + { + const size_t aligned = align_up(size, align); + + /* aligned sized must not exceed block_size_max or we'll go out of bounds on sl_bitmap */ + if (aligned < block_size_max) + { + adjust = tlsf_max(aligned, block_size_min); + } + } + return adjust; +} + +/* +** TLSF utility functions. In most cases, these are direct translations of +** the documentation found in the white paper. +*/ + +static void mapping_insert(size_t size, int* fli, int* sli) +{ + int fl, sl; + if (size < SMALL_BLOCK_SIZE) + { + /* Store small blocks in first list. */ + fl = 0; + sl = tlsf_cast(int, size) / (SMALL_BLOCK_SIZE / SL_INDEX_COUNT); + } + else + { + fl = tlsf_fls_sizet(size); + sl = tlsf_cast(int, size >> (fl - SL_INDEX_COUNT_LOG2)) ^ (1 << SL_INDEX_COUNT_LOG2); + fl -= (FL_INDEX_SHIFT - 1); + } + *fli = fl; + *sli = sl; +} + +/* This version rounds up to the next block size (for allocations) */ +static void mapping_search(size_t size, int* fli, int* sli) +{ + if (size >= SMALL_BLOCK_SIZE) + { + const size_t round = (1 << (tlsf_fls_sizet(size) - SL_INDEX_COUNT_LOG2)) - 1; + size += round; + } + mapping_insert(size, fli, sli); +} + +static block_header_t* search_suitable_block(control_t* control, int* fli, int* sli) +{ + int fl = *fli; + int sl = *sli; + + /* + ** First, search for a block in the list associated with the given + ** fl/sl index. + */ + unsigned int sl_map = control->sl_bitmap[fl] & (~0U << sl); + if (!sl_map) + { + /* No block exists. Search in the next largest first-level list. */ + const unsigned int fl_map = control->fl_bitmap & (~0U << (fl + 1)); + if (!fl_map) + { + /* No free blocks available, memory has been exhausted. */ + return 0; + } + + fl = tlsf_ffs(fl_map); + *fli = fl; + sl_map = control->sl_bitmap[fl]; + } + tlsf_assert(sl_map && "internal error - second level bitmap is null"); + sl = tlsf_ffs(sl_map); + *sli = sl; + + /* Return the first block in the free list. */ + return control->blocks[fl][sl]; +} + +/* Remove a free block from the free list.*/ +static void remove_free_block(control_t* control, block_header_t* block, int fl, int sl) +{ + block_header_t* prev = block->prev_free; + block_header_t* next = block->next_free; + tlsf_assert(prev && "prev_free field can not be null"); + tlsf_assert(next && "next_free field can not be null"); + next->prev_free = prev; + prev->next_free = next; + + /* If this block is the head of the free list, set new head. */ + if (control->blocks[fl][sl] == block) + { + control->blocks[fl][sl] = next; + + /* If the new head is null, clear the bitmap. */ + if (next == &control->block_null) + { + control->sl_bitmap[fl] &= ~(1U << sl); + + /* If the second bitmap is now empty, clear the fl bitmap. */ + if (!control->sl_bitmap[fl]) + { + control->fl_bitmap &= ~(1U << fl); + } + } + } +} + +/* Insert a free block into the free block list. */ +static void insert_free_block(control_t* control, block_header_t* block, int fl, int sl) +{ + block_header_t* current = control->blocks[fl][sl]; + tlsf_assert(current && "free list cannot have a null entry"); + tlsf_assert(block && "cannot insert a null entry into the free list"); + block->next_free = current; + block->prev_free = &control->block_null; + current->prev_free = block; + + tlsf_assert(block_to_ptr(block) == align_ptr(block_to_ptr(block), ALIGN_SIZE) + && "block not aligned properly"); + /* + ** Insert the new block at the head of the list, and mark the first- + ** and second-level bitmaps appropriately. + */ + control->blocks[fl][sl] = block; + control->fl_bitmap |= (1U << fl); + control->sl_bitmap[fl] |= (1U << sl); +} + +/* Remove a given block from the free list. */ +static void block_remove(control_t* control, block_header_t* block) +{ + int fl, sl; + mapping_insert(block_size(block), &fl, &sl); + remove_free_block(control, block, fl, sl); +} + +/* Insert a given block into the free list. */ +static void block_insert(control_t* control, block_header_t* block) +{ + int fl, sl; + mapping_insert(block_size(block), &fl, &sl); + insert_free_block(control, block, fl, sl); +} + +static int block_can_split(block_header_t* block, size_t size) +{ + return block_size(block) >= sizeof(block_header_t) + size; +} + +/* Split a block into two, the second of which is free. */ +static block_header_t* block_split(block_header_t* block, size_t size) +{ + /* Calculate the amount of space left in the remaining block. */ + block_header_t* remaining = + offset_to_block(block_to_ptr(block), size - block_header_overhead); + + const size_t remain_size = block_size(block) - (size + block_header_overhead); + + tlsf_assert(block_to_ptr(remaining) == align_ptr(block_to_ptr(remaining), ALIGN_SIZE) + && "remaining block not aligned properly"); + + tlsf_assert(block_size(block) == remain_size + size + block_header_overhead); + block_set_size(remaining, remain_size); + tlsf_assert(block_size(remaining) >= block_size_min && "block split with invalid size"); + + block_set_size(block, size); + block_mark_as_free(remaining); + + return remaining; +} + +/* Absorb a free block's storage into an adjacent previous free block. */ +static block_header_t* block_absorb(block_header_t* prev, block_header_t* block) +{ + tlsf_assert(!block_is_last(prev) && "previous block can't be last"); + /* Note: Leaves flags untouched. */ + prev->size += block_size(block) + block_header_overhead; + block_link_next(prev); + return prev; +} + +/* Merge a just-freed block with an adjacent previous free block. */ +static block_header_t* block_merge_prev(control_t* control, block_header_t* block) +{ + if (block_is_prev_free(block)) + { + block_header_t* prev = block_prev(block); + tlsf_assert(prev && "prev physical block can't be null"); + tlsf_assert(block_is_free(prev) && "prev block is not free though marked as such"); + block_remove(control, prev); + block = block_absorb(prev, block); + } + + return block; +} + +/* Merge a just-freed block with an adjacent free block. */ +static block_header_t* block_merge_next(control_t* control, block_header_t* block) +{ + block_header_t* next = block_next(block); + tlsf_assert(next && "next physical block can't be null"); + + if (block_is_free(next)) + { + tlsf_assert(!block_is_last(block) && "previous block can't be last"); + block_remove(control, next); + block = block_absorb(block, next); + } + + return block; +} + +/* Trim any trailing block space off the end of a block, return to pool. */ +static void block_trim_free(control_t* control, block_header_t* block, size_t size) +{ + tlsf_assert(block_is_free(block) && "block must be free"); + if (block_can_split(block, size)) + { + block_header_t* remaining_block = block_split(block, size); + block_link_next(block); + block_set_prev_free(remaining_block); + block_insert(control, remaining_block); + } +} + +/* Trim any trailing block space off the end of a used block, return to pool. */ +static void block_trim_used(control_t* control, block_header_t* block, size_t size) +{ + tlsf_assert(!block_is_free(block) && "block must be used"); + if (block_can_split(block, size)) + { + /* If the next block is free, we must coalesce. */ + block_header_t* remaining_block = block_split(block, size); + block_set_prev_used(remaining_block); + + remaining_block = block_merge_next(control, remaining_block); + block_insert(control, remaining_block); + } +} + +static block_header_t* block_trim_free_leading(control_t* control, block_header_t* block, size_t size) +{ + block_header_t* remaining_block = block; + if (block_can_split(block, size)) + { + /* We want the 2nd block. */ + remaining_block = block_split(block, size - block_header_overhead); + block_set_prev_free(remaining_block); + + block_link_next(block); + block_insert(control, block); + } + + return remaining_block; +} + +static block_header_t* block_locate_free(control_t* control, size_t size) +{ + int fl = 0, sl = 0; + block_header_t* block = 0; + + if (size) + { + mapping_search(size, &fl, &sl); + + /* + ** mapping_search can futz with the size, so for excessively large sizes it can sometimes wind up + ** with indices that are off the end of the block array. + ** So, we protect against that here, since this is the only callsite of mapping_search. + ** Note that we don't need to check sl, since it comes from a modulo operation that guarantees it's always in range. + */ + if (fl < FL_INDEX_COUNT) + { + block = search_suitable_block(control, &fl, &sl); + } + } + + if (block) + { + tlsf_assert(block_size(block) >= size); + remove_free_block(control, block, fl, sl); + } + + return block; +} + +static void* block_prepare_used(control_t* control, block_header_t* block, size_t size) +{ + void* p = 0; + if (block) + { + tlsf_assert(size && "size must be non-zero"); + block_trim_free(control, block, size); + block_mark_as_used(block); + p = block_to_ptr(block); + } + return p; +} + +/* Clear structure and point all empty lists at the null block. */ +static void control_construct(control_t* control) +{ + int i, j; + + control->block_null.next_free = &control->block_null; + control->block_null.prev_free = &control->block_null; + + control->fl_bitmap = 0; + for (i = 0; i < FL_INDEX_COUNT; ++i) + { + control->sl_bitmap[i] = 0; + for (j = 0; j < SL_INDEX_COUNT; ++j) + { + control->blocks[i][j] = &control->block_null; + } + } +} + +/* +** Debugging utilities. +*/ + +typedef struct integrity_t +{ + int prev_status; + int status; +} integrity_t; + +#define tlsf_insist(x) { tlsf_assert(x); if (!(x)) { status--; } } + +static void integrity_walker(void* ptr, size_t size, int used, void* user) +{ + block_header_t* block = block_from_ptr(ptr); + integrity_t* integ = tlsf_cast(integrity_t*, user); + const int this_prev_status = block_is_prev_free(block) ? 1 : 0; + const int this_status = block_is_free(block) ? 1 : 0; + const size_t this_block_size = block_size(block); + + int status = 0; + (void)used; + tlsf_insist(integ->prev_status == this_prev_status && "prev status incorrect"); + tlsf_insist(size == this_block_size && "block size incorrect"); + + integ->prev_status = this_status; + integ->status += status; +} + +int tlsf_check(tlsf_t tlsf) +{ + int i, j; + + control_t* control = tlsf_cast(control_t*, tlsf); + int status = 0; + + /* Check that the free lists and bitmaps are accurate. */ + for (i = 0; i < FL_INDEX_COUNT; ++i) + { + for (j = 0; j < SL_INDEX_COUNT; ++j) + { + const int fl_map = control->fl_bitmap & (1U << i); + const int sl_list = control->sl_bitmap[i]; + const int sl_map = sl_list & (1U << j); + const block_header_t* block = control->blocks[i][j]; + + /* Check that first- and second-level lists agree. */ + if (!fl_map) + { + tlsf_insist(!sl_map && "second-level map must be null"); + } + + if (!sl_map) + { + tlsf_insist(block == &control->block_null && "block list must be null"); + continue; + } + + /* Check that there is at least one free block. */ + tlsf_insist(sl_list && "no free blocks in second-level map"); + tlsf_insist(block != &control->block_null && "block should not be null"); + + while (block != &control->block_null) + { + int fli, sli; + tlsf_insist(block_is_free(block) && "block should be free"); + tlsf_insist(!block_is_prev_free(block) && "blocks should have coalesced"); + tlsf_insist(!block_is_free(block_next(block)) && "blocks should have coalesced"); + tlsf_insist(block_is_prev_free(block_next(block)) && "block should be free"); + tlsf_insist(block_size(block) >= block_size_min && "block not minimum size"); + + mapping_insert(block_size(block), &fli, &sli); + tlsf_insist(fli == i && sli == j && "block size indexed in wrong list"); + block = block->next_free; + } + } + } + + return status; +} + +#undef tlsf_insist + +static void default_walker(void* ptr, size_t size, int used, void* user) +{ + (void)user; + printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, block_from_ptr(ptr)); +} + +void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user) +{ + tlsf_walker pool_walker = walker ? walker : default_walker; + block_header_t* block = + offset_to_block(pool, -(int)block_header_overhead); + + while (block && !block_is_last(block)) + { + pool_walker( + block_to_ptr(block), + block_size(block), + !block_is_free(block), + user); + block = block_next(block); + } +} + +size_t tlsf_block_size(void* ptr) +{ + size_t size = 0; + if (ptr) + { + const block_header_t* block = block_from_ptr(ptr); + size = block_size(block); + } + return size; +} + +int tlsf_check_pool(pool_t pool) +{ + /* Check that the blocks are physically correct. */ + integrity_t integ = { 0, 0 }; + tlsf_walk_pool(pool, integrity_walker, &integ); + + return integ.status; +} + +/* +** Size of the TLSF structures in a given memory block passed to +** tlsf_create, equal to the size of a control_t +*/ +size_t tlsf_size(void) +{ + return sizeof(control_t); +} + +size_t tlsf_align_size(void) +{ + return ALIGN_SIZE; +} + +size_t tlsf_block_size_min(void) +{ + return block_size_min; +} + +size_t tlsf_block_size_max(void) +{ + return block_size_max; +} + +/* +** Overhead of the TLSF structures in a given memory block passed to +** tlsf_add_pool, equal to the overhead of a free block and the +** sentinel block. +*/ +size_t tlsf_pool_overhead(void) +{ + return 2 * block_header_overhead; +} + +size_t tlsf_alloc_overhead(void) +{ + return block_header_overhead; +} + +pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes) +{ + block_header_t* block; + block_header_t* next; + + const size_t pool_overhead = tlsf_pool_overhead(); + const size_t pool_bytes = align_down(bytes - pool_overhead, ALIGN_SIZE); + + if (((ptrdiff_t)mem % ALIGN_SIZE) != 0) + { + printf("tlsf_add_pool: Memory must be aligned by %u bytes.\n", + (unsigned int)ALIGN_SIZE); + return 0; + } + + if (pool_bytes < block_size_min || pool_bytes > block_size_max) + { +#if defined (TLSF_64BIT) + printf("tlsf_add_pool: Memory size must be between 0x%x and 0x%x00 bytes.\n", + (unsigned int)(pool_overhead + block_size_min), + (unsigned int)((pool_overhead + block_size_max) / 256)); +#else + printf("tlsf_add_pool: Memory size must be between %u and %u bytes.\n", + (unsigned int)(pool_overhead + block_size_min), + (unsigned int)(pool_overhead + block_size_max)); +#endif + return 0; + } + + /* + ** Create the main free block. Offset the start of the block slightly + ** so that the prev_phys_block field falls outside of the pool - + ** it will never be used. + */ + block = offset_to_block(mem, -(tlsfptr_t)block_header_overhead); + block_set_size(block, pool_bytes); + block_set_free(block); + block_set_prev_used(block); + block_insert(tlsf_cast(control_t*, tlsf), block); + + /* Split the block to create a zero-size sentinel block. */ + next = block_link_next(block); + block_set_size(next, 0); + block_set_used(next); + block_set_prev_free(next); + + return mem; +} + +void tlsf_remove_pool(tlsf_t tlsf, pool_t pool) +{ + control_t* control = tlsf_cast(control_t*, tlsf); + block_header_t* block = offset_to_block(pool, -(int)block_header_overhead); + + int fl = 0, sl = 0; + + tlsf_assert(block_is_free(block) && "block should be free"); + tlsf_assert(!block_is_free(block_next(block)) && "next block should not be free"); + tlsf_assert(block_size(block_next(block)) == 0 && "next block size should be zero"); + + mapping_insert(block_size(block), &fl, &sl); + remove_free_block(control, block, fl, sl); +} + +/* +** TLSF main interface. +*/ + +#if _DEBUG +int test_ffs_fls() +{ + /* Verify ffs/fls work properly. */ + int rv = 0; + rv += (tlsf_ffs(0) == -1) ? 0 : 0x1; + rv += (tlsf_fls(0) == -1) ? 0 : 0x2; + rv += (tlsf_ffs(1) == 0) ? 0 : 0x4; + rv += (tlsf_fls(1) == 0) ? 0 : 0x8; + rv += (tlsf_ffs(0x80000000) == 31) ? 0 : 0x10; + rv += (tlsf_ffs(0x80008000) == 15) ? 0 : 0x20; + rv += (tlsf_fls(0x80000008) == 31) ? 0 : 0x40; + rv += (tlsf_fls(0x7FFFFFFF) == 30) ? 0 : 0x80; + +#if defined (TLSF_64BIT) + rv += (tlsf_fls_sizet(0x80000000) == 31) ? 0 : 0x100; + rv += (tlsf_fls_sizet(0x100000000) == 32) ? 0 : 0x200; + rv += (tlsf_fls_sizet(0xffffffffffffffff) == 63) ? 0 : 0x400; +#endif + + if (rv) + { + printf("test_ffs_fls: %x ffs/fls tests failed.\n", rv); + } + return rv; +} +#endif + +tlsf_t tlsf_create(void* mem) +{ +#if _DEBUG + if (test_ffs_fls()) + { + return 0; + } +#endif + + if (((tlsfptr_t)mem % ALIGN_SIZE) != 0) + { + printf("tlsf_create: Memory must be aligned to %u bytes.\n", + (unsigned int)ALIGN_SIZE); + return 0; + } + + control_construct(tlsf_cast(control_t*, mem)); + + return tlsf_cast(tlsf_t, mem); +} + +tlsf_t tlsf_create_with_pool(void* mem, size_t bytes) +{ + tlsf_t tlsf = tlsf_create(mem); + tlsf_add_pool(tlsf, (char*)mem + tlsf_size(), bytes - tlsf_size()); + return tlsf; +} + +void tlsf_destroy(tlsf_t tlsf) +{ + /* Nothing to do. */ + (void)tlsf; +} + +pool_t tlsf_get_pool(tlsf_t tlsf) +{ + return tlsf_cast(pool_t, (char*)tlsf + tlsf_size()); +} + +void* tlsf_malloc(tlsf_t tlsf, size_t size) +{ + control_t* control = tlsf_cast(control_t*, tlsf); + const size_t adjust = adjust_request_size(size, ALIGN_SIZE); + block_header_t* block = block_locate_free(control, adjust); + return block_prepare_used(control, block, adjust); +} + +void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size) +{ + control_t* control = tlsf_cast(control_t*, tlsf); + const size_t adjust = adjust_request_size(size, ALIGN_SIZE); + + /* + ** We must allocate an additional minimum block size bytes so that if + ** our free block will leave an alignment gap which is smaller, we can + ** trim a leading free block and release it back to the pool. We must + ** do this because the previous physical block is in use, therefore + ** the prev_phys_block field is not valid, and we can't simply adjust + ** the size of that block. + */ + const size_t gap_minimum = sizeof(block_header_t); + const size_t size_with_gap = adjust_request_size(adjust + align + gap_minimum, align); + + /* + ** If alignment is less than or equals base alignment, we're done. + ** If we requested 0 bytes, return null, as tlsf_malloc(0) does. + */ + const size_t aligned_size = (adjust && align > ALIGN_SIZE) ? size_with_gap : adjust; + + block_header_t* block = block_locate_free(control, aligned_size); + + /* This can't be a static assert. */ + tlsf_assert(sizeof(block_header_t) == block_size_min + block_header_overhead); + + if (block) + { + void* ptr = block_to_ptr(block); + void* aligned = align_ptr(ptr, align); + size_t gap = tlsf_cast(size_t, + tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr)); + + /* If gap size is too small, offset to next aligned boundary. */ + if (gap && gap < gap_minimum) + { + const size_t gap_remain = gap_minimum - gap; + const size_t offset = tlsf_max(gap_remain, align); + const void* next_aligned = tlsf_cast(void*, + tlsf_cast(tlsfptr_t, aligned) + offset); + + aligned = align_ptr(next_aligned, align); + gap = tlsf_cast(size_t, + tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr)); + } + + if (gap) + { + tlsf_assert(gap >= gap_minimum && "gap size too small"); + block = block_trim_free_leading(control, block, gap); + } + } + + return block_prepare_used(control, block, adjust); +} + +void tlsf_free(tlsf_t tlsf, void* ptr) +{ + /* Don't attempt to free a NULL pointer. */ + if (ptr) + { + control_t* control = tlsf_cast(control_t*, tlsf); + block_header_t* block = block_from_ptr(ptr); + tlsf_assert(!block_is_free(block) && "block already marked as free"); + block_mark_as_free(block); + block = block_merge_prev(control, block); + block = block_merge_next(control, block); + block_insert(control, block); + } +} + +/* +** The TLSF block information provides us with enough information to +** provide a reasonably intelligent implementation of realloc, growing or +** shrinking the currently allocated block as required. +** +** This routine handles the somewhat esoteric edge cases of realloc: +** - a non-zero size with a null pointer will behave like malloc +** - a zero size with a non-null pointer will behave like free +** - a request that cannot be satisfied will leave the original buffer +** untouched +** - an extended buffer size will leave the newly-allocated area with +** contents undefined +*/ +void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) +{ + control_t* control = tlsf_cast(control_t*, tlsf); + void* p = 0; + + /* Zero-size requests are treated as free. */ + if (ptr && size == 0) + { + tlsf_free(tlsf, ptr); + } + /* Requests with NULL pointers are treated as malloc. */ + else if (!ptr) + { + p = tlsf_malloc(tlsf, size); + } + else + { + block_header_t* block = block_from_ptr(ptr); + block_header_t* next = block_next(block); + + const size_t cursize = block_size(block); + const size_t combined = cursize + block_size(next) + block_header_overhead; + const size_t adjust = adjust_request_size(size, ALIGN_SIZE); + + tlsf_assert(!block_is_free(block) && "block already marked as free"); + + /* + ** If the next block is used, or when combined with the current + ** block, does not offer enough space, we must reallocate and copy. + */ + if (adjust > cursize && (!block_is_free(next) || adjust > combined)) + { + p = tlsf_malloc(tlsf, size); + if (p) + { + const size_t minsize = tlsf_min(cursize, size); + memcpy(p, ptr, minsize); + tlsf_free(tlsf, ptr); + } + } + else + { + /* Do we need to expand to the next block? */ + if (adjust > cursize) + { + block_merge_next(control, block); + block_mark_as_used(block); + } + + /* Trim the resulting block and return the original pointer. */ + block_trim_used(control, block, adjust); + p = ptr; + } + } + + return p; +} \ No newline at end of file diff --git a/miniwin/src/d3drm/backends/gxm/tlsf.h b/miniwin/src/d3drm/backends/gxm/tlsf.h new file mode 100644 index 00000000..9f890175 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/tlsf.h @@ -0,0 +1,91 @@ +#ifndef INCLUDED_tlsf +#define INCLUDED_tlsf + +/* +** Two Level Segregated Fit memory allocator, version 3.1. +** Written by Matthew Conte +** http://tlsf.baisoku.org +** +** Based on the original documentation by Miguel Masmano: +** http://www.gii.upv.es/tlsf/main/docs +** +** This implementation was written to the specification +** of the document, therefore no GPL restrictions apply. +** +** Copyright (c) 2006-2016, Matthew Conte +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the copyright holder nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL MATTHEW CONTE BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include + +#if defined(__cplusplus) +extern "C" +{ +#endif + + /* tlsf_t: a TLSF structure. Can contain 1 to N pools. */ + /* pool_t: a block of memory that TLSF can manage. */ + typedef void* tlsf_t; + typedef void* pool_t; + + /* Create/destroy a memory pool. */ + tlsf_t tlsf_create(void* mem); + tlsf_t tlsf_create_with_pool(void* mem, size_t bytes); + void tlsf_destroy(tlsf_t tlsf); + pool_t tlsf_get_pool(tlsf_t tlsf); + + /* Add/remove memory pools. */ + pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes); + void tlsf_remove_pool(tlsf_t tlsf, pool_t pool); + + /* malloc/memalign/realloc/free replacements. */ + void* tlsf_malloc(tlsf_t tlsf, size_t bytes); + void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t bytes); + void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size); + void tlsf_free(tlsf_t tlsf, void* ptr); + + /* Returns internal block size, not original request size */ + size_t tlsf_block_size(void* ptr); + + /* Overheads/limits of internal structures. */ + size_t tlsf_size(void); + size_t tlsf_align_size(void); + size_t tlsf_block_size_min(void); + size_t tlsf_block_size_max(void); + size_t tlsf_pool_overhead(void); + size_t tlsf_alloc_overhead(void); + + /* Debugging. */ + typedef void (*tlsf_walker)(void* ptr, size_t size, int used, void* user); + void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user); + /* Returns nonzero if any internal consistency check fails. */ + int tlsf_check(tlsf_t tlsf); + int tlsf_check_pool(pool_t pool); + +#if defined(__cplusplus) +}; +#endif + +#endif diff --git a/miniwin/src/d3drm/backends/gxm/utils.h b/miniwin/src/d3drm/backends/gxm/utils.h new file mode 100644 index 00000000..18fe5dc1 --- /dev/null +++ b/miniwin/src/d3drm/backends/gxm/utils.h @@ -0,0 +1,48 @@ +#pragma once + +#include +#include +#include + +#ifdef DEBUG +#define DEBUG_ONLY_PRINTF(...) sceClibPrintf(__VA_ARGS__) +#else +#define DEBUG_ONLY_PRINTF(...) +#endif + +#define SCE_ERR(func, ...) \ + ({ \ + DEBUG_ONLY_PRINTF("%s\n", #func); \ + int __sce_err_ret_val = func(__VA_ARGS__); \ + if (__sce_err_ret_val < 0) { \ + sceClibPrintf(#func " error: 0x%x\n", __sce_err_ret_val); \ + } \ + __sce_err_ret_val; \ + }) + +#define ALIGN(x, a) (((x) + ((a) -1)) & ~((a) -1)) + +#define ALIGNMENT(n, a) (((a) - ((n) % (a))) % (a)) + +#define SET_UNIFORM(buffer, param, value) \ + do { \ + size_t __offset = sceGxmProgramParameterGetResourceIndex(param); \ + void* __dst = (uint8_t*) (buffer) + (__offset * sizeof(uint32_t)); \ + memcpy(__dst, reinterpret_cast(&(value)), sizeof(value)); \ + } while (0) + +#define GET_SHADER_PARAM(var, gxp, name, ret) \ + const SceGxmProgramParameter* var = sceGxmProgramFindParameterByName(gxp, name); \ + if (!var) { \ + SDL_Log("Failed to find param %s", name); \ + return ret; \ + } + +static void printMatrix4x4(const float mat[4][4]) +{ + sceClibPrintf("mat4{\n"); + for (int i = 0; i < 4; i++) { + sceClibPrintf("%f %f %f %f\n", mat[i][0], mat[i][1], mat[i][2], mat[i][3]); + } + sceClibPrintf("}\n"); +} diff --git a/miniwin/src/d3drm/d3drmrenderer.cpp b/miniwin/src/d3drm/d3drmrenderer.cpp index f1e1fb8b..b30c5b23 100644 --- a/miniwin/src/d3drm/d3drmrenderer.cpp +++ b/miniwin/src/d3drm/d3drmrenderer.cpp @@ -20,6 +20,9 @@ #ifdef USE_SOFTWARE_RENDER #include "d3drmrenderer_software.h" #endif +#ifdef USE_GXM +#include "d3drmrenderer_gxm.h" +#endif Direct3DRMRenderer* CreateDirect3DRMRenderer( const IDirect3DMiniwin* d3d, @@ -66,6 +69,11 @@ Direct3DRMRenderer* CreateDirect3DRMRenderer( if (SDL_memcmp(guid, &DirectX9_GUID, sizeof(GUID)) == 0) { return DirectX9Renderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight); } +#endif +#ifdef USE_GXM + if (SDL_memcmp(guid, &GXM_GUID, sizeof(GUID)) == 0) { + return GXMRenderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight, d3d->GetMSAASamples()); + } #endif return nullptr; } @@ -93,4 +101,7 @@ void Direct3DRMRenderer_EnumDevices(const IDirect3DMiniwin* d3d, LPD3DENUMDEVICE #ifdef USE_SOFTWARE_RENDER Direct3DRMSoftware_EnumDevice(cb, ctx); #endif +#ifdef USE_GXM + GXMRenderer_EnumDevice(cb, ctx); +#endif } diff --git a/miniwin/src/internal/d3drmrenderer_gxm.h b/miniwin/src/internal/d3drmrenderer_gxm.h new file mode 100644 index 00000000..1a8fe16c --- /dev/null +++ b/miniwin/src/internal/d3drmrenderer_gxm.h @@ -0,0 +1,181 @@ +#pragma once + +#include "../d3drm/backends/gxm/gxm_context.h" +#include "d3drmrenderer.h" +#include "d3drmtexture_impl.h" +#include "ddpalette_impl.h" +#include "ddraw_impl.h" + +#include +#include +#include +#include +#include + +DEFINE_GUID(GXM_GUID, 0x682656F3, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x58, 0x4D); + +#define GXM_VERTEX_BUFFER_COUNT 2 +#define GXM_FRAGMENT_BUFFER_COUNT 3 + +#define GXM_WITH_RAZOR DEBUG + +struct GXMTextureCacheEntry { + IDirect3DRMTexture* texture; + Uint32 version; + SceGxmTexture gxmTexture; + SceGxmNotification* notification; // latest frame it was used in +}; + +struct GXMMeshCacheEntry { + const MeshGroup* meshGroup; + int version; + bool flat; + + void* meshData; + void* vertexBuffer; + void* indexBuffer; + uint16_t indexCount; +}; + +struct SceneLightGXM { + float color[4]; + float vec[4]; + float isDirectional; + float _align; +}; + +struct GXMSceneLightUniform { + SceneLightGXM lights[2]; + float ambientLight[3]; +}; + +class GXMRenderer : public Direct3DRMRenderer { +public: + static Direct3DRMRenderer* Create(DWORD width, DWORD height, DWORD msaaSamples); + GXMRenderer(DWORD width, DWORD height, SceGxmMultisampleMode msaaMode); + ~GXMRenderer() override; + + void PushLights(const SceneLight* lightsArray, size_t count) override; + void SetProjection(const D3DRMMATRIX4D& projection, D3DVALUE front, D3DVALUE back) override; + void SetFrustumPlanes(const Plane* frustumPlanes) override; + Uint32 GetTextureId(IDirect3DRMTexture* texture, bool isUi, float scaleX, float scaleY) override; + Uint32 GetMeshId(IDirect3DRMMesh* mesh, const MeshGroup* meshGroup) override; + HRESULT BeginFrame() override; + void EnableTransparency() override; + void SubmitDraw( + DWORD meshId, + const D3DRMMATRIX4D& modelViewMatrix, + const D3DRMMATRIX4D& worldMatrix, + const D3DRMMATRIX4D& viewMatrix, + const Matrix3x3& normalMatrix, + const Appearance& appearance + ) override; + HRESULT FinalizeFrame() override; + void Resize(int width, int height, const ViewportTransform& viewportTransform) override; + void Clear(float r, float g, float b) override; + void Flip() override; + void Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const SDL_Rect& dstRect, FColor color) override; + void Download(SDL_Surface* target) override; + void SetDither(bool dither) override; + + void DeferredDelete(int index); + +private: + void AddTextureDestroyCallback(Uint32 id, IDirect3DRMTexture* texture); + void AddMeshDestroyCallback(Uint32 id, IDirect3DRMMesh* mesh); + + GXMMeshCacheEntry GXMUploadMesh(const MeshGroup& meshGroup); + + void StartScene(); + const SceGxmTexture* UseTexture(GXMTextureCacheEntry& texture); + + inline GXMVertex2D* QuadVerticesBuffer() + { + GXMVertex2D* verts = &this->quadVertices[this->currentVertexBufferIndex][this->quadsUsed * 4]; + this->quadsUsed += 1; + if (this->quadsUsed >= 50) { + SDL_Log("QuadVerticesBuffer overflow"); + this->quadsUsed = 0; // declare bankruptcy + } + return verts; + } + + inline GXMSceneLightUniform* LightsBuffer() { return this->lights[this->currentFragmentBufferIndex]; } + + std::vector m_textures; + std::vector m_meshes; + D3DRMMATRIX4D m_projection; + std::vector m_lights; + std::vector m_textures_delete[GXM_FRAGMENT_BUFFER_COUNT]; + std::vector m_buffers_delete[GXM_FRAGMENT_BUFFER_COUNT]; + + bool transparencyEnabled = false; + + // shader + SceGxmShaderPatcherId mainVertexProgramId; + SceGxmShaderPatcherId mainColorFragmentProgramId; + SceGxmShaderPatcherId mainTextureFragmentProgramId; + + SceGxmVertexProgram* mainVertexProgram; + SceGxmFragmentProgram* opaqueColorFragmentProgram; + SceGxmFragmentProgram* blendedColorFragmentProgram; + SceGxmFragmentProgram* opaqueTextureFragmentProgram; + SceGxmFragmentProgram* blendedTextureFragmentProgram; + + // main shader vertex uniforms + const SceGxmProgramParameter* uModelViewMatrix; + const SceGxmProgramParameter* uNormalMatrix; + const SceGxmProgramParameter* uProjectionMatrix; + + // main shader fragment uniforms + const SceGxmProgramParameter* uShininess; + const SceGxmProgramParameter* uColor; + const SceGxmProgramParameter* uLights; + const SceGxmProgramParameter* uAmbientLight; + + // uniforms / quad meshes + GXMSceneLightUniform* lights[GXM_FRAGMENT_BUFFER_COUNT]; + GXMVertex2D* quadVertices[GXM_VERTEX_BUFFER_COUNT]; + uint16_t* quadIndices; + int quadsUsed = 0; + bool cleared = false; + + SceGxmNotification vertexNotifications[GXM_VERTEX_BUFFER_COUNT]; + SceGxmNotification fragmentNotifications[GXM_FRAGMENT_BUFFER_COUNT]; + int currentFragmentBufferIndex = 0; + int currentVertexBufferIndex = 0; + +#ifdef GXM_WITH_RAZOR + bool last_dpad_up; + bool last_dpad_down; + bool last_dpad_left; + bool last_dpad_right; +#endif + + bool m_initialized = false; +}; + +int gxm_library_init(); + +inline static void GXMRenderer_EnumDevice(LPD3DENUMDEVICESCALLBACK cb, void* ctx) +{ + D3DDEVICEDESC halDesc = {}; + halDesc.dcmColorModel = D3DCOLORMODEL::RGB; + halDesc.dwFlags = D3DDD_DEVICEZBUFFERBITDEPTH; + halDesc.dwDeviceZBufferBitDepth = DDBD_16; + halDesc.dwDeviceZBufferBitDepth |= DDBD_32; + halDesc.dpcTriCaps.dwTextureCaps = D3DPTEXTURECAPS_PERSPECTIVE; + halDesc.dpcTriCaps.dwShadeCaps = D3DPSHADECAPS_ALPHAFLATBLEND; + halDesc.dpcTriCaps.dwTextureFilterCaps = D3DPTFILTERCAPS_LINEAR; + + D3DDEVICEDESC helDesc = {}; + helDesc.dwDeviceRenderBitDepth = DDBD_32; + + int ret = gxm_library_init(); + if (ret < 0) { + SDL_Log("gxm_library_init failed: %08x", ret); + return; + } + + EnumDevice(cb, ctx, "GXM HAL", &halDesc, &helDesc, GXM_GUID); +} diff --git a/packaging/vita/sce_sys/icon0.png b/packaging/vita/sce_sys/icon0.png new file mode 100644 index 0000000000000000000000000000000000000000..fe68bd7c0d44174f18546d91d0355ba2da83765c GIT binary patch literal 1671 zcmV;226*|2P)C00001b5ch_0Itp) z=>Px#1ZP1_K>z@;j|==^1poj5Gf+%aMgO?~%Mu{+jtHbHB>MXL|L2_PnxL?rGC)8; z0C+8NLll$7rh<{E z-AP12RCr$Pn(2D-It&I|vOrnV-v8Bp8NU*;odBf^=A5VVqaIyC}%%p-0mZ}B#E*5cx2M7?xBCg;9T{n)YU=Pzg0mLMbo|hr`=jH)91xL`?~9(Oe+)nF)nqI36W% zI%)9%%QFO+rqhXb`#qDUQXr=PDzv|enl=;grr-(;DVO1XKaS;X*9BOX{Nz&Q#uN&Q z$+RePN^*_n0;$&-S8!rzCE@~?AR_&DyS_gjDWS(zQol0~7l>qjDdh?*J3e>2Y3h59 zCD3*IeSYa}x6<>7Y-6X>G^NVxlh9Zo(zEgSttVF?&2Gm9c|5v+wrOvz)YN&zt{aAF zIvztYC0nDhK%{?tB_x}w&T<6_9A`MD=KWo*IoIU~5fPaZdadwO0vcupPv^OUmXyL$ zt|^!%HXmQ6b-bFCu%@v<*_@4+^bDxB)m%X^L6rJ&u#8tjzl!DpR#PyJ+pQhWlnPyk zoC|=rC7Rm#gshR0=2&^b0|l-Rn1?A9n3@pq8+9H{l3beQ6hTTGJh=diQQ>n19y~bb zQ`G7CnLnK5q_jbEf#o9PA{>Sox_TOvkTV_C>DkJb1MkqU!fMVm7f=eq@-WIU`=CmJ za~<;uM2X>NdtScG1}SNdm1jIuz&n<(wdl6Q?T2#~BM;c#BLvDQo6X@cP5A_JL6)S% zPICbj(JUV-Ubd8;7cNRPDN0N_7a#`HqFNGj9P!o!=zB&*%>}e&!x6PCJ=XxSkS==pXeCUv$}Fg>{DJ0))69 z>pEivcVeA|mEDDPow0&DvCe;ht%~_#d4JC@nB~P2%Pk*5FS)eb)+naH%32HPCK{WL z9>W42QX++QO}LhCQ=h@Q3KcaJPypX{x$&@}DB0;G5x=#lRJ|BR4W=tdfXyqN&V(}h zJgP^8GfyI*TaUVO`{ev|;-4K@5EQY>#siJj&GO9dWC^DpayytNB(%XI}20$RM!FW^I2qA%le zXvvn#!W;${(2(Z}DEU{o)cPWHXj@@51x*F?B~?CXG5l;POp*i$uli76;Q14lKhW2t zlqFVkrn!KIm9O4O1+?038CKs;T_9dNLgDpwnh;nnV@N4WtmaH}fg0Luw`E8Pe0&@Z zWtkKtkpHRAq0IuTy9jL>3eaM+@f)^>lt8{^gDWtJ$7A376b30_jn!R%77YccCnPWI z(-ea$0UqTJhkT%2K^sykDo6=ytZo(Re_cQwa(siyYy1A=Lq{M1sMCbP66#iHE|5 z=|dpu_0Jy5+jCAzwT`uDCr~!dOBiG&(el(3Ng$Ww9~C5^(xn0=7ilgKlTfAypO*X; z-36j#9R1eJYZ{-WLP~NCYd6DL0|9TEA3OXr&YA$peA}XxJ}K3wEAV-f<^nYJPjz>e ze}>5g`hNN7MX5F@DJbqunhQ9!fIp7eX~G3mxAqE>Ps5!w7eFDG&=(f5#Mp{Tfv8*Z z-xL7rzXF5n0_gop`X>-rE=Hln6#|#}R&r=AP%lQIe`&ZaU?ILoa{*xy4Lzn`6ZnCl zFR{2r1A(=PSQoGkKTUH1;Trz47WnajuW2q2pg=mQaQwjJ&|Kh;{{=5E{{X7fTy@X) RAIbm#002ovPDHLkV1m$Y>OlYi literal 0 HcmV?d00001 diff --git a/packaging/vita/sce_sys/livearea/contents/bg.png b/packaging/vita/sce_sys/livearea/contents/bg.png new file mode 100644 index 0000000000000000000000000000000000000000..5e742ac37ae645df3ce2865b2df8f8460002b4f7 GIT binary patch literal 47338 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 literal 0 HcmV?d00001 diff --git a/packaging/vita/sce_sys/livearea/contents/configure.png b/packaging/vita/sce_sys/livearea/contents/configure.png new file mode 100644 index 0000000000000000000000000000000000000000..df07b590fb3e02fdcd6ab37eaf23107628febef6 GIT binary patch literal 2715 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 + + + bg.png + + + gate.png + + + + logo.png + + + + + psla:-config + configure.png + + Configure + + + + \ No newline at end of file diff --git a/packaging/vita/sce_sys/manual/001.png b/packaging/vita/sce_sys/manual/001.png new file mode 100644 index 0000000000000000000000000000000000000000..5bfb092355a4d6c22eea2d8e36475da5534523c8 GIT binary patch literal 242162 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� zaL`>_4-pb}N3K3ypMYfk=0YMbACG<)7B&XoATd-Kg46e6^X+SE;A&!RbHe@`tZzKM zfP;3hK_@{nJ4ZWoXo3EiOP;9c(~$_ z;4&VdXqQX_%ij|n#LP+bIt&ubs7w(eAqtw(NJiHSZZg8Ug9B-79ZbaR!<9ko z8hta`K6vu^=ceCy-`dF0A(fBO&|kAL%<|Ni((FMX3)lA9+^oEr{>DnL(w9Jq+* zr*GWCNwcIu8L~i%q-RkHQrZkUA!bfk8!SMhrHo7o93W15dWL(3gAnfw zl06~Ea}g~ESPar8EZ_l;a&nM)mhsRas+6PfTM#7>J+pKihCPSI9|kdV;K0!{1RZ74-T7TKdsjK}4+9+4U@C78knA z;}9;B?3`i<)rB8|y%IFfW+`-x{^126&@2R1^mDocrIphdJ0245I%SL?QCX#h;V;pw*s1RHx&E!reh|cBF2xme$1Br{) zrEf6Q*@@|VTpkyuqN2tU=lP5w}n>C6vrv= z81rnC&0y*3R=N3^neYw7G^_ECer{PS}(9CH9`cO}?|_ zWY{9#EI=|}f4a7IQ@9*oN{(;eqV0YV1J7d*ljr~K`CtF;cb~lU(jPu~_uZEsdgzPa z{ys4B&_jR-nUcq!J%cH(>57VIC=~7vKX;Oaqxk-I8w@I`G%YtbhJ@s%qdlQuIFr?% zU^7maM1uW$LB$#n7$C*$Y6+V03eCzeD3lP1SHzEb8w!69je{o{KXj1=$^ga#C)uJh zM8%kA0l5l>BNXcE4|T%ta`ep6hdVnDAFUZ1tJ%N5=IGJ>qoMwzUJJ(X5xZ8W)!K1G zpc3mgaEFV~k|c2mZ+*e>kiXcZOyf#}ToMUUV1=!>z$x$Q64vD~ht6&yG@DfnVL@7h z1_^K0Hq8m!f}iXO>x-n0t@9%z^WpII8<N=q*$qfywF}iviQF<5-C%^u~AKv}ll`HRl@r&R4_7}g1?&hJF1WMj`wqlBw zS32QcTImao0wHWB+JTy<%5G(eq`0n!)oIj=6We0BSVdzRS`KnJa&`@2jvO@!`W`c; z*vxLY-4h%h4qBoiv`|pR#uQ-fJ?u$6ja9qF7q$& z=<2c6JhoIrk|G|QFg03GSC>#H8)YC}2`7|rER1B=V^7QxBep zN*)&|S;87<30^DVzJ%aEO z5fbt=E^{zw?tx1bvvjls!SP@aCD;>$fd#~af_o#M1Tjy=)M4;7`)M!wSPxb&)ldz! z#e2TL-|Ia;JdAt4YW4#nj-Izz=5H6@3 z%PZPsWdv;414X28k74-CJQSVn+aTFMW)gQ&lNxD`$67mgHbVqNf{2w&q1(ek8D>R} zA78`?Th388cX60jr{&p!M5vnQVY2~YyEM6G%jqWC5+I}n zoK8!yhg=U{#34xtShN@yS%8B@foMm-d>z8xtE8=hjRx8RhLE^y*miu2Fn=JvX|DiFL-O*hm}T1(7GqvD56KZS zZ>w>Ec`WXs?t~=nQWoP6bzuT(755M1Y?tOrv2CRg_ z;Q(`lyEe?Y;|ph>xEmWCipuwE-pA}r8GN;@>=sOMzZ7plbxxi+73e6a6sfFjl zrAuf^aAkKNvm>){NT`gyo{e|hoVpcOlqsfOSU&gEQ?Ebu)W9bY-n{$nH@}HVlE)wV zHkcB$BtQN!(LWK#d6Um8sUA7FSOTp6FSqg-CrSSBwkQ@}5R6Xz8=_}TJC1NNmZW8JA; zz>LEUzchm7x9N0tXI-6=PQQ>N#pS_7=g+zgZ*#|y*wvm_7hgDxr|Srros)|KBf?b| z>63(Poe-{YseKb&6RWEzh8HJCt-Of0Ti3ACDm)5u7T0nn7yTXcXh{YJz?Rg<`?{q^@C1SU&DkT6P~x*yJ)g*HSuoRu{ePo+X<#9??oTV-XXPGNS3!!0gDzRF+# zVPH0wm6_vG6-Yp2;H;Dx3}wKL89Yl1$r1#_EF3Ln3U)9Oq7PROX7F3U{X{7(f9TNE z^KgKcJ$(4gnTOAu0cSE+Q}aHWjIo}^F$az>fd8PZ?0)2+yj)(cVh6{mu>MJ6xCNNp zx^+t>$N4(tB_%^=hrsTDwXwL}4ou}c?R8j*l*h6oo4N}KsS^GF36;$;QoQV5h?iKR zePXlsp|t9To{e)cxhX(yURztUc1=*BE2inXtTXfT_4Bby6O@0&IA^4G03dl{;9xz` zz@pvF%A}U&HR9*OTstwcg4;Y3kYHgE*b^)?z=J^&Hzo^-)C=4hK}ZgcjJ$j0cURv1 z1cI5z-=I9n_cufG`WsI@1@CQYB!Z9x2@wm|0wmxDIU^?}NF;Iz7`l#Iit;RpyhL77K6JK>K>}{cV|7~V z01~^^E{v{Vkm%XotyI1K4j@>ZEZ7lYZCB{orQZxm^Mnu|Z-`lfgzgI2+Bh0ucy5EF znSvwhYF8v;bu~5BkHjHaUk`T;96U(whUV~54YUx^#HTi5mZX+hnFUOUVf*7b0g}t` zaaph=7~Ra%#$jrJwNL0fAe74zF7@>z2Wx9f9{Tl_-~H})zy1Vb-*12ad*A-{zkKnF z4}ImKA5#c?^Yz!yjo}W68hFb#0w;&Z-D3t5j+@5OpWuA_euu}S(CKu}zCJjiH8n^8 zB~}H$Lu0Uz6UvbEz#AS1R>)m~fWdeet%roI3ua>JqeRX!wE#MN zv;*ECLuJ>ly?^aR_|t-&mPo`CaXZ|0>QG;&-@*uB8Z)&(m`lLA$5Jv47k2Ylxg_4y z7ZltEQXWMw@zuOd;qXMWX;ZEQBi=4Tq^O7>S;P-3#OkJ^t_c<}lbhW>@*W3wE`NU$Xf z30VuEeDlhc-~Hq#|MD+XhyCsEf8{Ge#uX5`c@ykNqkF6q#NoNJ9?Q|AJzk&B;q}`< z@foe%c$C^iQWd9Cn1_2#oH#KIMyD^-*i)8{tHbew(kF5xKq41m846aPqX7<;N`mgD99&V!t=guJriOt5u%bQZUhH|lrUpy$D>}#f zPWAO6E9iPq)Y4953Xz32NLw~Ki*JlhVy$4e2=+(M%8Rz>x8!Y!%N1JjIhN2NtSit2 z8j(q1fe+B=DvE2}#YwOCIPO(Qn4d*L=lJCD#dwj)|N7}qlTeb3j5LjGG)bc&d~FBo z56&NCgVy3pI2%pXFts{2JG%)I8qapHetu;c7{MjL`L_Da@)ZT~0E6UvKl#(Y{QB45 z``(o+zotwYg9JAXLRj;@I|y$#Hv~DsqemP26OhONl5k&Nw=*j%OQBL2hR;1aePZ|= zK+@?B3VAiUK%0T~!9_C|fe}3a>9qcb`4g(P7v)RyvCURmyl@sF$Eb`SeN$?6s5`Z6YFJRVo@4?xM!fB!QyBp*FWQt~HH?p|29 zaPHEj4yjHvqPD5kZlxJ?g5RebZ)$4Ht3ZE~n#Ev%M8(+w*oLNYSglZ4`|A%rlAM~LZN`n&w;PNnOpEh3;}#0pD$p_ zM)xKmn5%&y&T(c}$F$WU*KrliaFJO=Urh zz9{9mz$xXEaeoq^!vNA1LLjNv8`f7AJKPGj&jI%V{Q6d<(o7bp+0A%n@P5+sf;Ja) z`#t(!Wa=knlF`1mlcn9}< zK#zC~b#*SFWI!OWCnm02mzru=QY}s1m2G+Xjbq!KhqtuB{IEKcT$ZEl#tI`eknz^}I-Cxnj%_%S6%wln~Q)LOMvh?Y(F}2&R#uL6an}nT` z!q=*_{8X8!6)tycYn2=)ISPfM)vJ@voUz+QqJs77*Cb|U3V|FuHA_dOip^Y|nVFfG zn7JCrN=Zq9PpnBvN?E_&UQm#-di83;TP8dqLL6WP%z!r+g#`%Vco zTrO0{b45j5sZ{56hiy1}TCZ0a$ruE6*os@mg?b{%!IcF74tztc4k{c9MTgs1hydXy zH6!`y_4OGKQQhXTTL5WQK^+skkBn%0g0>}8XCs8-LGsn4G?o{eWfp zm;dV-YNwFYsA1jniGx4LIrtoT?+c*g75GO*((rts{3V)_FQNwa?jKlWFgE-M`~!(k zRv@{jvFqIxjR;B=$<~uS8}SmOJ~bmDyW$ddtY~dbKs%DKP6d=CB_yZ}6eMK}mwI}_ zbDA(fq7MftNKm&vOEPKa01}%E=YaquR<+R`&Tnp3^lOT^V-zH^jMRkGdXsOk4%w@R>i1y=oQF@L*Y^saoBj23ZU7Q+mA&JHG$< z&wmC)J|m4H$jk|xgw{tQ

YrsR?S`N4HYCpPH_NHs-NACprKUJj92E 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

Ld@D_F)1AmKJeS|hG4DtgDi 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Ð>Y!euK(Q&1`T3jv)ut6cZeQB-_iaH^^1WqA>v4%>DvorV_whhb7 zuKTDAkNd$-a8D7(UWC)JGm`0sLaTs^B3O!pO&gVX1+NhsL;-B`YYM7}f8|#{)S$6clTK6y&IOv6NS`O^M?l5y1)?e}=l$qv zHVJmAouK3^z$Bb*a3N_&had0-cZ@J)+qm<1_!b{T!5`_oFnHS*p;vOP;`!R8H6LKK zI(qFUg`)W|Nxd6YW^@Gu=}Pv)Zi=j|crz_{iVs4gj-oj17!)$2Bs*3A>!b|UYfJ$) z-Q?r-mJl*Jk7ni#gr6(}z%UJ@6Bc4BYI=F@6tfE(tWp~6@HBBc#6 zt{40pr~(Z-Jyc@6h@%GoG5I05C*bh==w> zC`*Aq=SRo=b3IMB^V!bc*eTEbV>4~;d%NfBjqm%*W||iJo9~wZF3bJ-_LBI#SiUq; z=kRzhL{PQI_$?GG-ZxRXJ!{ILsz8j6^KT znikf2%3jOi{4%zn>T|Ep|837|Pxs85@Kfs3>VIUXzQ=WMY@X%z=0fW)sUq7d)m<

!9H9)~`m5RD_i2_jG2#uVO?G0z+ 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 literal 0 HcmV?d00001 diff --git a/packaging/vita/sce_sys/manual/003.png b/packaging/vita/sce_sys/manual/003.png new file mode 100644 index 0000000000000000000000000000000000000000..6948e4cb694006298ba81a270528ff4a47b838fd GIT binary patch literal 196455 zcmV)ZK&!urP)?SNC9v}b!0sXfkB4n@s|Ns2BCS72v?j9@eBPu64mMKY|K54TsWU&0V z896aq<|-^FT&pEMnJYAt5DXr8mCg9JC@Vmj{kaxBI9W?UOMra2OhjBVOraAJD_d7# z>mn;fOPnBHtXWy2K|X6RE?f~?s)K^N4@#glFfT4Sl^#HvFEWNJAS>TAE`)r0CnH)@ zNm%MAEKEabGZ+;pI&?ZTLHxESNMER7T4VUQHDqS32~?(FVsSDrJ}fM5g^IzEh`B95 zhxYgRQ%Pe;JX>;lc<0~9CN5lVipCEzANaW%VuQk4Sz}&TY(rR<92-aJF)LFT5K|#4 z#l5a7V?1tmxDRMHRZK@NE_deKyem?qO;e+yovr%!<(-v=Q$HVo9~=q+0@6G*3`ZvT zvNu>mQydBrUtfuOP)NzgvNvh4@uzA7q&YInc1t3*bBs5~}ZDM$G5%#@0Nn3>6XUv+kDuY!D{2oDEv zH$$a~x0Q{MuC1~&MLS4Veq2L&HbIu7gM!j5FWuU~=e1HlQloK{$b*x9eK#n9I7Fx? zD4fRBoS}!pzTH=eT;sW=lsr7#-Qt69P6t{rd|^|%RzSTyHe6SKlqDzf>Er=YrQGZ6 zU`$>3>8r@f%SkOm;=XXxgx$Z7yq*Zo!3t&8^IckeHx{ zV8f+kW|N&}dz`V`>U2$ZtDR=TrK0G$E;krM9~l(4h*7}F=K9r5*KUZ4Ac36gAckHQhpBmW!3?VzL;RMt>-R7A4M< z;xHf!IP$kw{tfP+J1*#js4cGAm$S>@Nbtf>>cVKf)Bsh=w(4A&{hf2Z&-3I7I(P5A zJM){}`SK@!NCM<}Kj(bT`JV6j&il{uKgb9UHk;v7<*!nyjK;#kA!T4-pi-$*>h*ew zL=vc02L?*uu0XXyBGIz}_e=0@7!JK2uEA9`{LrG8=oOMb?E(L%(qf^vM!~-ydW%J= zSK@to_@Pdzq&H6?vB290*VJlylN7qFEVIX)^@ll*H0J%yAMUmN<%ozX4j{=IvcNId z>va~!0^$)UQNU2E86^C>ML!8t^EcrqN__Y9bKliJtpWcro}w3{`(frn(B}f9iAmR z9uhtGwh54+&9(eVLjwOZm=F4A(UM3QB=qkS3xP;TpdyeTg3qQOa+c%|3duY?@qd3` z{y5Onz$efF_kqhnNR;sZSO60E$CR8gRRSXp_#i%*bpczW*D0BI=1I}R8KhVIDf=6} zp7*fa(Wil4hv~OK?i21J7fotSg6>E!GK`4|oocq0H4QYU(1gn@!M=>

y23)$9~u%SG{wU#_j2>U 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 M07*qoM6N<$g5Z;(wg3PC literal 0 HcmV?d00001 diff --git a/packaging/vita/sce_sys/manual/004.png b/packaging/vita/sce_sys/manual/004.png new file mode 100644 index 0000000000000000000000000000000000000000..05ba6671a1132abeb663016d64022d4bc91e5ea3 GIT binary patch literal 170140 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

KS151{ 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 z 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 P>~T2nY+HHG_uhX1e_G#8 literal 0 HcmV?d00001 diff --git a/packaging/vita/sce_sys/manual/005.png b/packaging/vita/sce_sys/manual/005.png new file mode 100644 index 0000000000000000000000000000000000000000..e93792d2791e1b874555784ce64b847cb80717b4 GIT binary patch literal 149940 zcmYJ4Rajg-w1#n~z)&bw7+`RBcbmbT7I$|qQrvAAT#7rixD?k?+}+)a6sN%9KNsg* z?3?T-$&+ubth`xCqEwaTurWw5;Nak}Az*2BI5-5*+xG_z@vWrX@EHmRhX|*ts44R> z1fu##A?wh1|L+A34*vD!`C)_#PP6p&^_9xJ`sMZI<>fJxj_Tj@3$AXZgmsPf2ds;S zX9l&Rd|GNmB_xCqcG?XmtT%?fPs01jzSjO$2bIT9dYrDH(aYj};ipLSc z$>~`GIRROS0tJV;_(#I~VNUOlA24tTj!#cb?VVa0e!M(9vYOYdp52JBQdHK~)-uu^ z3Ul~}g=v5J8BasuS<+{i(17J4baZ|rE-vnsJMEg)HF|I+$i>sSeWuC=EQ0A>+}vO) z6>y33zdYSe@pF8QNpg`R2Ya;qZ0q`@`Pn+7>+)!${nrA$SZql}r5Y!PgcXcQBR-v# z#)pYKEi+fbpsaw4(bt56_#MVfDZ6D@mqGmCd`2ubt(sH(@48Ti7=Oc_9M3$AtpRScp z%P*Z;*l}}nZ->Q5sK-|>pXiCxtfskFwk@-oC050A$p>^f$_ey|2#_)g$!W+~nj1!^ z=BHJBpHJqA4-EIT*G=`2uuE(rAtoybq&MeeGuDz}melS@#?`b?|b+JK&@!Exaf^lNJ(5poV0W;X$Zl_Hezz-^@5zm z`GqnrnMa*$-dyZ9QQ7`d{IIIgCJTK48L#=52Cr|Khpok#0j5k+E_eoPuGtOFBWKqG zocj93le!W=b3YSEx#g(v#;WsXCHlBqd_IP75d=y5d=kxQUH9|SkIVT@&8E_o>_aHc zknC(M|Fz<3byix-k=4AI!tdv-H(!0Ai-mW{)q;C^Q@@)*N!73QCKX<$PsZk6*-bXw zFbkQq$)y<|1DLVF;$ZJYi;bU+n0J7enWqalu6Mqc^U#Y^)?V+>koBn5zA;et&q#k~ zagL?Aq_l}Nb=Fj(QQqZhE-NW1u2P&_u)zoOTBA6}+g~7X)#7!!Y`Fg{EgU=?97I|| z(>we08BMf@7(bsXWD|vq1EyixJwr;6fS40VCnMfHlN87vMQRc-ino1E zm@F(w<*ItDwdIoJIvv~8AOV~|j!q-N|AMvD0V<&uu&k>4O_dHzBZ6CR!eoS|1 zW1p`TZ+PEKn_&!DUozHKzZI1W)cAgQCao4tg-K(dJ7vGDz1V4mngiOrRQ~;{G)$ld zX%`NRaKGz>yfrN7Gfh;@(RzNDS7~S#?sB23O(6#!T_kmPHg>u-s+=@tv2N&mZmLY6 z1BE+jw8*1W_ANi1d=#$I!2Y*PnalY5ezLQ&qY2CJLRE)?2e)L|c;VvpXijc2m|O*7 zI{VVd*km#k9JErSd{Y+0J~tY>VV^q(?86TEuL)#g!@>xk3X^Y3{pI0q8X>U@AxJ#$ z&964|^KKUvV0jUD-~YY7{hA7=(M7RMAVJem8e3n+SE)G&xSGq0aIK(YjpMa1(GEdb z6)Knm>SOybQ|62JxL!=Mm3z2^>}j_M`b1V5(rQQeFjn{6#cyg#JZFEgF7+{eNarx@ zd?Xb(JSLj)4Uu(b{Nz6?o^I>ykXmm{VVEEAIG2YiN^sInOt;<&uOo-kB6wk^R4sbz z&sUhC{>v-INLnA8({PSL_~Q5#RheMy&)U_S6yCrdU>MA|H zS*H9~X!32?dd|+fl;m%XGm);jiT zmsm;HTwafnozIO+Sbt5mes!{k!9j=ifP$cP^Al8=r`wKVx?Hj9-Ik`|FOhr0=bLli zIF8felMXMm(qsSqK|+{|nY(|6aR+kTOn`Icl&r{+rPL>XVHJxO!QbVfq%7B)IPH(2 z&V@>MFE}Tf+s8X-km^p?o50GxV^50V^7h9s-S-3v#9pusK zE)&U|6P=L`Nn!>Czp}^;%?mAY4R{gJK`_FJCf(gUB$`3O8;@;bYo%{-@reegLnY^ zX(0IURd!>hWkk>6-{oAZ|1&z_%zw?*Y%xBx%cgxHD#hsSka+$c?P|HHk#YROS4+aZ znJ*D?%2ykG7A1!rTFzV3{xO&XcXnfaE4N}}F2cK_M~6ZjE9=S)-Lmv4vXZ_^`y_MT+QPrd6?nzse8(`!GY~gN8fQB z#eDhb<0-aJjmC}Fevisr+g*Tv?p%H`2G)_LztPiw6Xc?R_&ViIw~=J6l1{`rFeJi* zaR$}*O;+r)(KjLB$`SgOS0;M?({C&JT-#cNZv`+FYjY3S zzlHiN7m{PU8PXB%$+#tpQ-1e~4&Mb~23>^)PC^0bif^5C!uq8tI?{$%pA0Jz@6O*8 z-d@i`6-z1CqP*r9ue`H+64S~h_v>Is<5a^i9(C64Q2c>HO!n_n2}aF$OlRNmlI?ki z1WKhT-)hmzJMs%nTAUXiWeZo2O%3ew_u_A+lWTcQFTubfyCnB^s$Q=(`F1Sva$cj% zbMfZUKJU-e5KStu{We^xCDKx+Dux_eD03=w&c%fIf8TGS3d})uP(|mQW@2B9x5gm! z3_)@kvKlIO6)m!Utoh$b;!r4TGU820%WSr{-A8&Udm#-K{3)qTwgC56<4N9aC-?K! zz%9S$5R`ii)Qm-;w}`5sjpbJ%H-+UCAH8$&%av^P$|ruAIBFMkph)UMF}OFGsJmRQ ziYtwQT)NpJy9MHmul%4wARd9-txo?z?p2)QJ-FZH8ev>kCtX?&+POgL00V}ED3zdK z?`akeR69do8Vi*=Jdxh!L!r^*2QOL`i~EFus$gK>0@96OueT9}+U!KRBDv5qeXg`6 z9QvxQ5cWk-@}_nM!a19;b__H*xhz{i2#QD6{JqsDD;Pg)h?o`KXoh|YK_m_act<&+ zgM|q*OmpY2ltBFBkEIjPQGw90T+@&`)q`^P3m5j?UC4sOdwLstfu7`2t$j#W5OzTs z4}y_3g*6G*Ba#Y)rGA{FAF+Z-bAZ4|HhC1<6z1)Mt+`tG9T(IhDVMg;uRMn)1Q=+K zR%ML9Dw1`wKoBa4cmV-2;^4RBewPOrSy<=_qs>-ys1!k{G@vw?x&eV#*JK02xc9kX^ZtMuCO+6wHuP)9}))e89d7(#$S^iR`J>dTp`vc>Eg#r0$~*0pGgBhQYD;PgCmr8OJB@O%-K}f{MUA$4yT}Q1E5GxI&7? zZ`D}$lSw>Ecp4Z`9HAPFt1?@r3Ytvi*NsCozlyMGIc{qSeR7;ka$IcWST;}duMT>SIsV6&hGBdsIP~ZQCM@>avOf3NY}EM5hxG@VMm_u(2o#j z(4hmsvNAAJZE?y*?JN`n*6&CUEkjjAIc!`$F|LHad*@dXH1Q93{x+>idNQzYsq_OAIs6MHpLpWU!7$@utm#oj zTEuG-cd=jI)h!jg{NAvhz-N=}iiyJ)6SCCaL zngNJl{_#IpGL|$f-N6L|o3ta+rhsgd1g>&wV)YNIV((=i%Nf~a4?mp?9jDXXM%mFrPmVxf7^g5HAHd&Uc%=>fEg}6=8T2lM7c- zA#T5g;R_oJsk47cHvvUGtlvG$4t${%2$qO{KHh7}R!Vf-9dn|#hpWA(i8jH#mQU<|Y^GaH`V90spv)PzZ}7$p4u1}q zE5vp*%0)o#JLdee_H|4cVQV!ZKnvdFF#E+{kGRu6DNVC$rr&G+LK88d5L<@<0pGm6 z;#CC)zUyUUPL&4I)qsUq`1RfYvXkx39n*EyO%m3mUG*d;+YcPSH)+;gE=N&b>8+u! zLb|6m=e~@HLnalmfjv*0-a60O@@Yi*LZj}vFV@c)v9B`c-)L0`%-z#_N}uSUppfq< z*ezapbEptbKh4tP8O6RU)kf%lkv53-w)+q^41)bil^t?g3LW9x%zMiFdRq~3q5EvB z`fA0i#s@6B>ybb)dsX^o3u=7#C@|-wDGRio)C`iH$MgfF-9Rh=VUj@|tz8_T4!NZ} zU5m9p1xlui`4rsZ=K<9k8LKBep|2}mbN1a_Vuuw`f4=HsPk)bZsSw|wLPS&%pZxt` z$IY^6XO^xxUv>x^U~v6v27aWl5WBedzX|kxV@Cu_C>Hx-&$BiP+VS52xpv$4#T0bw zZCh2Mp-1Skv_R`3cE4<@ZuWA;x;QShhF99LywX1BPaO+^)YmT6Jv1NxZBB)+iPPe| zBe6^jGAzA1ZnJ%Cq@5;J?5f-VX?6G88iCnQM%l};5Kl-#MAwbFE?;dEbhz3DumDgJ z*|+h@d%j>3KYRcs=y8Sj=K|HNJs=j$ZW$W?N^-6WJ855SJ2E*y^bqds`co`A+7u56 zJI7|TM-asg&x6j%+@oZ0g=`6K(l9+@k&pEk;46;Q_WsUsbWB^>B@v}Js5@}MNF=6mo zr3!~qVx=$*(QCK(_M3o8bC}#*_207UA$C3Sy=oWjgTY9cTz^mCnVM13R-^lq(LsCm zzXgGFwB`Ts%XfCc{L|R{gN|UWUU#+o_Ez(M>~i~7y(TkerP^a3Zo=qfw9nx`MEb7< z6P|Z3rvxpUg1uZ|0T&zB%&pso#GH%#|EuPlnI$A_ud}%wd0zewCLgwCDI%QEDq;&% zY?Sj?3ZH53+oY5aiV+RU{^<8AFrIT4!J{HKp8HO1n{Yj6K(y$^BwOYEK?qnN{L&F4 zjCx|JPmuc+ZhXT~7|IuTp!Wa$=)RYoIz94CCA>5-QCA*jx_1{?H9^h|H$_P;8gI|S zq=1bVdaDi#(Ack_2+L5Sl1&J3k{8iKRwb8${&fL~YebIiII}Giwy@vm1Q+t}&(Bo02D{`e~*-l>1R#8Yd9#jw*B1$yew}}Ib(wK@*;)z=Kq35qF%kK^C33dc=ew9>Vc>+kT;T_KsrD^vQBc3L88~@* zvwLugHqoUH?pZ!cHdne=eNRD?*3r7-QdVgM(ss=_i%F<^5&@4kXlQ2Vag{tp;5m}UENrh8#IRI2o zqt}?-uZ%+4P$B!dlb1DLt#Wca)rAVA8)nxDGHN2ATv|>Ge65zaVv>gqYOEOxRu(Bp zB7Y{8SfdAANu8kq-u25C_8ZZvfwwo=G)soIDpcefAj?Srtxic-b+D)eqyS35LklJs zharg`$8g5ZV*>c(M2m8%zlheJ(+(Q0g*1f+AJv8;aqS4;BKUxh6~I-ya6*~Kvgm{_ zDIDOYArg211jehZRju_~7pV=I1`=O|8K@q&O8Za>1G(!cJcnsHWx*$hZYkX*6qF7d z2LGOt>tgn2rZjq9agB~h zfBsxuohHd)b`aT9S5aAv9GlU1q)ZzbD<3-e)Em@bY4bDSHCw=q*@1;+3y<^8dKoCHvLw;3)p ze0x*yegqa@EMXh6McCa;pbbSP39)SAI8jVc)9&vFx$UN=I%gaj?jYB0qT`86Il`m% zMkD|G+}C)M+-tX~s-WVT!cycNwMRrAVzvEiHTzIHH4pNobsh`m4y5iLEaiUlrgn#9 zHT9Oe;-)_+&~798kkA9|Bg%43Ds@)j^F*}c@Os?8guW7{J)-Z|{evX~#s4{9OgS9X zSPBi!2O?m4GvHCtJZ=?YR`)G@+FaOwWdPTF4&L0{Qn0ddv~!HPO9E2X23|#c1Rd-V zKH&kn2bNctwL?QAq@v&i+OFN%9kURxqyqc1)u_TWK79gbY(?`z;8rnJ`Eu5-sa{o& zD;4gLz{v=pz=YY4z{KTC^{@_dSdAtU8n6}~(z{a1@E8`F8O8w;9ujW1RM*q%Mar?4 z3HJU+PX$sW${>~O?Q1q)go22wZM8b)6_pE0bAwb0dhzn>kaptw?4@cTnBk4H_<}9Qz5e)icfIuvb@?1tB62lKd0)dQn0XsHpjnmM6ov*f5FA8}$J?kB zC>P%{grQu{b|~lvp+0)6-_Gw|AlD}QnkEhJxvI@>($(Xt^dy>7BdMbx59b*7oCt z4K!q*D(31{tT9I66Oz)<%rQ1N1-<{QpGzIF91eu+Zi_641+OA4QR-vsVa6QHkbOi{ zizxhU5xf9?3f3;rn*E!)-yPZ5n7CP7c{ucgS{y;ebq%{7WC>*~aV&W6Nhv&t9GH1& zzHiCU!my4}BTObB1E!&l_X33SVF8h>X$ zm2l{Vn{k){9+bdZEZ?%BNu0(kh=PosqurHWc9)9k-k*dPME4Ue5L7NxyiGzQusJf% zgwO&*ay2J#Az^(7>~RLiNNZKA+ap>L*Fd=$_4W8KvIMN6dOu4QpoB2NMTyzlCpI{{ zz_D~p!VGz2(*gCYE;6sQ_>m4)md*UdmavZ0}8c`)%+_>{5Zb#uH(i~x~fhFH$n5G%_ z23e%CKoriFFXdTWBry6=S}K_a&P`; zCe^DmWFqq9Z1vWYU!oUMUoygwlc)(tqX~j-{4-Y~iz%xo=r`R3^B2Bzn@cm&^)3|% zEFL$__ol(??B!gE3MMafWm>(A89NQ30W_%tLwMz2IG6$ep{OFgf&z3!nE4AplTWi6 zv_Vi5g8_;{p@E2sPb0VS#KlRf#z6q8oN+KXe!CcElS)Ms#wp`|C_9tXcs<>vL?F_S z7&D8#A7%6wBz^r;XJ6E!h`2S^uGbnG%(oG;HZ3zxX5-&?wd{Jp90yM@1`8|A^1Xrr zQfSZi)-E3J*sS(bzUCSi>wZENJx4ivIAF*zW#uEx^|uJm4&5<6@4wjJW#YzQm+g+) zk~e?xq^9UiWj%^We~JV*BTYt5ZiGzPaS zdK6K&S(Z6b7Gp{Mtn-c8uSA*@B@V=%%m4Jb(Tuv5C2>4BY{k*xTZ zS(CO=MP+A=%w}w*1HdbN794;lYxZ1ZvgXYG$4ybGxWT8{opkZ|@SS!P=Nfi9DFYjy zJ^jcVn-8}8d!t@;iwk5@*w|o70`R5OrP@0>@RH=MdF5#aq7e}BykfDANKatm8-H>+ zx0lbeQtA?@58_w^4G=3GIQ<-pIc=Z9vAc)jk2w6~RcBSq)mxlS9fOKl&p!vl` zkLJ{nA)zm>z`tgjK6TyGnLnEMZPa?&-0 z5x)F;?l}|b+j8~qL=fIh&6k_RT8494n0LL}9U{!}uI-rAdPF{F+ukt|F>Wc>zk=^7UwWrRqWg6ZLT z4jA}w6nFUBR(Ks<34a)WqZRD)pr9}v{J9yZ)E&B$Ugf+${l((_MCr(yev5xGcdLH1 zuLCjY${p)~j&RC~X&V_V`2{&*C&Kp*!B<`eBH2nn+~f5Q*QouT2QD!Z8x$4S92dvO z3k9jErKrjC6(OZ#G&Dlx2S$(=aNC$^6^cVVL$LhXw#_vw>b>G4CA2$2U8EU)V8qc% z^fqcnFm_+6(IC-}kBV}^GOwQ@fJfOp2@|{cZ+EF~hZ3(bj&ToMjzCKXKw&}CN>@T^ zB_|Iv^YE{5dwgr4QqCZKmim{!34E{ro<~01O=N_mk=<~8B38F^v#Tv7;4||g_R~Rh z;IMZR&2ZCL{=iU^tuJof`izpGxySkuM8t68vir;=ayhSIr37SSyHV@S6pO}@qj*nd z5`>Xcdd}+T*5lZ%iGps;SRVYgB(Scd2#K1*7V z61dQ?P&52l!T}NHNYZP@Z`f;$EyKa?B-ZRz+!Zxg(J)tx&8XS0ZU(r6k(iU&91%bt z*#2yEQS1O+3AJ#aUfIjV`O6>3-0Yx&`&Z&_dMfXv49fm^uQW)X)BEPCGcyFQ#|f<( z>Mfp~VO@34B+BZ!IQsb%!|FYDi?Zp?bH~HOofHV(ql@?cTykv(LhKQ}eJM~N6+&12 zlvt-}Ik@k(3aOVbY-$UA#|L7not8K;fkVwkVRilCJS|uUaQLC1n=jl7HDXDk+26k# z*CK#ip`35hl)(0WZv(jV0iX3_wAEpG(@o%0P~ERzuq43Jd=g;DF;u!z3l7j7CB0vT z3^oTr=*0*z zLLC`*I-Ns9n4WnZV*z0D62)U@2SpZDkR$)e`pG;kP+pa9MV!6m!D;8)m!l?7gTDT! z3a|J72*QTH$Wac_^K?h>2G7(Fv!?hw7HzYgI2FaitMkp9*90f*Jow8E9z{o|r)QEJ zIIOfow#21U5V4sTv5h-?y!kVeBF%%RGg&f6Ab+ti0T2bVLi0P~r~tFV668NmyvhX; z(shkt!Pc~i0B`$IIPcJJ5-aK^TmyV*r&ePL=$&2oAY>Z^j{sWsi<6HDm(y>=0!3-#mrjFW=2pg}@&K*w zc|R@juP~5uVv^GbI!x6DP@MO4@K;}OPgwo8Q%f<$g8%l5@;TMZ}M0h|^SB z8Hd;i7JZ)4l?*e6uJ7I7l^r9?@7;C1PFRKA68`%(9ABPsv%4IHPp8;lUoUq_(KCbO zef-C;!JUC`G&&mx4ze*Jkl4ZEG8o!u_d(0tsw<9#)>7?}n6%Ddh_M#$`kjx!=1Ew% z@?hGL=)Ck}ELobRgGkl&z%f6|9%i{_vM*AeW~Dr6IW+VUDN38#PBRe@WycJeEUO7Q zFVdbao1VlMms6TOzq$^?Y$?{`W^uj1u*5AfPHCJ$~0R z+}O+WnOdcN_m~=qlEEkXV!d*qyF+xjnTxMOa!Meutc&P#dsoC-%ge?vz3f?8 zG2Bq&Y4e89$@dHnj{4~l2S5hUB>r7AmJ6~h#wFp+v%L{wHS|0YF|*Gub6Fegj74>oj3pb{n*a^MVp`?4w#4`@Wt9h z4R?eWLv*!)*51SSq^5BShgEvE(eV}Ym-MFKlKmnsiXx~JXS}AvpT;pPZu7h-n4x)V zl5%e#h7JuoSXxz>qGx*br<>XB?AAl+R#$n*fK1Ho>5>MQ=jr`+W@b6-%s+}eW$%C; zS4GVv9rHt7q<`Xea}L&M5skf9@$vD!Tmnm65-?`nuOQvg7`Nd5c8oz0vLmL_!EpEBDtj0!1u?D*? zE-DoLzW!aLO(rxhqzNx7`KTV8TTgBKR3Yzdos3E7?Hj^gi!M=mKRIw7kjt_Rq5{Px zTODXOG$D|GmkVkylr!=@JB|1_nDAlZEs1oxoq2UN->Uuk^5bCh`^v6%IXalXF(orI z;{r*^A3n|2-`}6@{?U+yneF`kv_C4kc_Z^DolS)tRS1$^#U@sSeXt5?liA?U>h_Ke zd+W%iI(0qt?~IR!Wk)k(52)BBBAN3iS5d)8l$S_t(t#kVf>OCqB-|je(4xlMF{RA| z1W*tl;2Px3osI|UyfzDmB0W74mV|&zpzQ`+9u^gonT5&54AOe*1=f4N^71k(N%hMw8dL&* zHd}pjg_;ou(8U39oc$xiSU|PPyI?IdQGGD~g%>_(v;Q|cek};z3iiWE(V5U|-wU$M z&95zq3Xw#REcpH_?vO~!PLBU&q2{IuLa(xv1d7To&x%q4f~kBmGl`f$D%O--?KKzr zwgmv7nxMLVKdrr7I<|$5@xfSd&G4|MoSdqpka`d-tAw8Nr@GqI)apMQYJP{y%aK%; zm7i64o6Fv~G#tjMr$Pv?%po%$#4gabq=fHrot!GXEOW>I9>vG6#UeeaIt{Ap9j8DF z6ZzI!(-;Iuo)n&Wno8^e?fJo=d_ppNLaY<#m=Lx2_v^2x*GC%G4ddBA4-~<_gOS1L z3|X3fFHCCN@ae`-tB5%_@|M>XMaKDj;{0+;B= zA6z%lsi3e}H_<*56q2keH9(qb!4_zo^EDI{CEo{J(k=)d`0e6cogGm_RWE~eXT2mxg+9_51*A-j}%Z#xq@fC&n+)V5{io*S!Gar;}tC2|zB zH5R2|Ef5eFsxjn@VZ&0I;sTgthsZQEcUn|d$^6o)l>g@e1t0Hh!vPd^H3x=34>wk! z_JgRlzqS+NyrH-1d?Jg>%Yi95t_PPpp@ad1)7 zsNX(>_8YaF4Ey`h56XSn@eE_3$Sh$J-)f3GKtuuulAd=$!Be!gR6{+P%gys2iXb%~ za5eOV*q&dW@d=2izxY}zT`nPFzI!Ghf`Gu?mR7&ezwq(q+2R7SzWfFA^6=lKS%N&c zk9>*Ovq3`W$0V#hj+M+q6d@O6#svf=0dtJ}5D$HQ9_tSoXi;v#(t*+?w(uUHB##U* zwKqH18HtIsG79R=d5)r=Rg#la!V3!BnvxnuWgjYgJ_&ejs{^bVVf2*($c8m3KLfQO zqyYRrLXhCsfWIa1B;Y|g#T?_wA|S6JFqHoD?U&K}OAaop_&X-HYN@QBrGs6O9WprZ z00y073fUn`)+b568q%={f}X;TdH@LBY2=|hErmwKEhV2d1q(I}mkWmvrI!{%VnCNQ zlde(fcK!aHg+--nL(Szo)&BKS{8c?_>?#RH`BCemy=P!VGa_)Q^V=-;LKhyD2bWCL z8^XB?(CBy8Bke}@=GwupP5-tz<3}!yq6Q&sZ$f<>#37>cFj?`zlo|JL@L+SaDBcDT zgG8g!_Ny~x4?K=fmb5A#K3-JGXwzs(j$;2VENDEc%;$20_xUOQ4>h%P1|L^w2prrAbaau0V$Gvl}kxaxzs(LjDhP8#z8Abo81@Y<+otKIBuACs&^| z-@ZB@dG8qin!>E2D~;}E1Fe?)7Z+^|1&y_Eb>)ai0!f4}#l1iYb>AD?qvt2J>emAt zF|vz$cy~Q8O%QH4u?m8N~-usu6?xw@o0 z{}_cp7V(Y&xsqU&^dmcFa!M4^P2$mZieL5NRBCJaglai|8mHo7P)xyc?-0YldV*TraFh%Z{N%r2=Scka^t=kK`E)iQT zi@gf$gLVg1`kzGN!3)U}R5X<&z@x8`(0|cm(x1p30PEswxLC$NZ`nPl8^|x=+0kD| zy1I%qzhYY#eRU{u?k5Bw_o5X3Sn8n9U=p2(i?i^tBo48l)8N~A{x^(S$!aCruqF0* z1FYR_2hYJ#9nLf~FLd6gxn+rq`t5xrY-F-cOGucgtRDXh&utjS>$Kpx*-uWi^tLsS z1fZ@j4JEl$w6yROG+O4K{q@^&PtTZ0(bjfto94f;K?Be*1$VcFnGPKXpnzl7ff7`F z?m=p6(hWgsFi2gY5?WFuRMoD-^(|Sz#?Ylr!b1&KXW|1fcD=q>vZ2Zy;09caxtR^M zQGP>=)jT&pMgbn7;k*tWMhXHOv`TwZ;{92Fl!x~*6-i~Ts8zJ=S|B4JaZ9scB;J}i zb)rFmv?)L_TtK%u`ETf#YEIsLwZAU35dcjj&@IVrF` zulhE{zL`@s{tM*GQfPzXY zOl-0)bRI3>^7Bu|Nf}Ej5T!afWzVY=l)ixehnbp9h5AZ&^9kr3>YpSQHaqv!ysnkX zJf(MYM#-us@EJtQxiD%qt-|NJI0SkrSO3Q{Qa5dJi48BV+BjmMNWp2IHAD~pVIVdq zvR5f<8foN)>61P*o$;R6MzO#+ybv%W?-OBg5S{RPBeuDbSNBuuo$}52iE(RuLe%Bo zN_2k*ca;;o``quX$1&^Wj_J>eDW6h)>0}CsY|er|-n<<{7^g@~wp~WY$Nw;RU`+=a ze;xg6f}IPG;j1tEe8os9Sy1>nW$u$I9M~L>Xwp{uLe;z^+7+aQt4*K zucG=90zzN2(IOi-Z)Ef~AZwAXw|KaCOuC1eNEC4C$F*nCTJjZ)OR!1NsRSnT(th&k zo%kjs9hohpv$+1EqyM6N@Cu`^U78%hBHv0?NrmP^LrBhUQ3aV^GW~_|m{&;M_3zci1tTWxIzo6^{ z@;bc;B__f_=FfU1-zy@3K#)9RdsMKfC=y{6t^i&vK5152f4}B+ zFt$53Jk_rmG=OF6A0+Km161&@!BH}yrv1at(Wx*kA_kMa8g|R$zQ0eqqTC^=uz^al zKJ^)RqzkeF$xzWQ?qKPjCzbs*0IKBM21+2b-}33!K=k&unhNxLkV6XGt$!2Mwzleb zGXGsxl^Fq4TYC@HQdM;paeDb@jxt0L+Rx~p7hual1cE%k!$2whVq#rk`@ltc4}0@B zT9VEJfh47bKD(m;;q&u`arOXZ3pz=KW#fsX^ANyp6jM*b5>-@m%_7FJY}j5%1Oues zICFNgjd+d_9#8~1oJBNVX0Mr_eGlK|fESETn#1ALqrm2nnKreYi8u9f+4U-r-)!y&qW^W-H$;r_pbLkTFiU|=y~bmS#lG$@Uh?eiWvHk+2Isf- z;OSn`2ZR;UcNFIr%hSlLt(|`92>^omMdSY7k*DMF58n-Z5L>^V^UPJR5uQZJC~a0c zIHRIOPzqa{r3w7~9Z>hp69I@o^`-U_*$eZ}{+JP`SSke22!x zEnNX*V7&2ldkXA&qDMv2ZCUYsv+z(3Mu-`tLs15*O5h@uh2#xmkPj46gMpid(EyM} z&q@8@uaAzgv)E0%(|k&^OLEqESm>p`5j{!s^YdosoxWA^KG7@7d=7%UWzG6FHWJ$k zYzF`S<{sSg>gJC90E@0Ce)InxE6}46YCJSW3dm-5?F- zS3cGVRW4?yE7U|qXS;Eyu*Yy2_~|tvlfSlQrZSI;0q8{vT9Qd+{6yI-K8^VH_-7TK z0hXep-L&ZBLfi)u<;9sF8Q!1p`okPK5zW+Lin4wU97?0LcMS0@Tx)e8UG<0f2XfI$ zjEq}@=(MQba&H+_3~=zU7EhBN5h$nyy)vq>b;w2l5juH6N((`-v^#!If`JSIe-WQP zz=M_Lvn?=QB?j#>Li=avxv>9XU=;>+_I!fqN#pzU7TLhTu=e*FWX$aY?$&hSLV*wW zJ5rnPlj;PdkN0Wzg1Z>;V20sL;KbAP-QC^OXgdp{q+A5(Y6g{f@KnPk5E9>92X?Cb z5zmwaB4fjzl<58Npg=&`-bG3wKf|#saCM6mg)r#w#S@49GyK{QH=*^lmtzMCQ=}r4 z-}vUCpR3zW6A4ft|2R<~=&EYk+U?$#5kG}6w=n|&q2`b!*u!4|<*7NpJq%Ae9E2g` z^|;Z)rQE%r!-uFd3g#GnAslc{s={PxjWEC(L(Nz3bMDWAQ=1ue{*;NNMQqXK2o6d_ zHpqCrMd(!sm`YVU)jaq*$b$#yt})chD;r8Paz-+`H3?2XYJmbN+5cuk9UZ4~WGG4k zK^dGf3q#FrpLZ398Q>w?@d%aQqa*;mF1&D2@1Oj>Y19I^CkY?-03*u|KQMqsB560<&)=0N?ULFtG*&=?;COtyR#lGb z?9nB?IW#w|K(C6R<{fPvv;S^~tn!JEmM8+5Nn>WZQ_Q6xt*QJ|gY|5v$2o(n(y3z9 z7&Q)&BT|@tnv5ym#r8em zlxys=Z(pj(Ls0B0VD~~K?5S6#8W{5Oe^}uY6NO*p8ZP1cVog=B^cFrTkFF}5Yudo zcyutD5yG>{p*+33Oxr(0wM;KOoyhzAq(xwhBaIS}@5#4wYtACf|hI+}uqpb%|jB zhq{F|5JDWqJR2L22GD;BD0%d9StFmKA;rBXf7xKx-3Hs(vORkpC!i3=x~ZsrxF|1` zMTaV;XJ)186qx+9@q&XHeHDn~Mfc`|gMp<9EeJ{AQOsJ1 z6sNUF;-hUwXMBNY-ty+=i?voA-mZ*7tvVK=`-a%yv?SlLY}s&6dsd-w2rjvZbu#Bb zUn(^;HL@hKRnXb)*d11c%DmDEUZ?`w|w}?MJ6$qC7Ecp&c#;5`D)x4#vG2wZW)3+ z1Bo)(220~k(czawT;gCQPHW0BB&EW2kwoH;>oF0sL-rS5iiCv}EnABC`%U|)nw1&H z&>BVy@2#TwdAOl|L0*0ZZdo{h{vQdO>2Sz(k(;$X0dWmc&RA@jox}4d)S(5Na{0Z4 zfPWn>6c>6F{>fDoM@ONo>?9zftY`y5UlBH1PFMTg8I{+!xY6q@?{Q246L&Ud_ewm_ z>A~(nN0o;BK{z@6x`lE#{nZjKb)`JS-`~!T&G;*vaI;2^xPwE8?%JekOds{K0x4$d zzy=HdN8+FO>(r*x-gl1jpFa~0=%Z)1_eJ1@*zkxkH369z6j7u6!D!7R-^P3$4^ngf z?BkplxuQWE=xdfs!gr2o#yw$3j->W8W&GITix$zg$}~d<$N1diqeF>H3?vpVpY+A^ zCsP9vza^|3&9$J9s384D0Ih%w^b7l0jfrSbiU>c=#LsD@{MFR?hB3R@&XqbJ1UD2) z`)!F)`oN{gAR!1lhBRYCBO>v0^tN0>)5~5pTSt-kPeh{Z*USAV(I^Dp>q7d4qTRg# zQ`AUC*5)eaX{XEW-JQV^q2ZCcximH{t+Nw8tw5lQ33PE~h3-o5e0pH~D}|hv zV=FPJMDAt?kzFLGcu1oT&zJo#PazTl6H|4#dJ2Yp;x~?gfx~mlAh^$5b~{_i??1^Z ztLDKmM`+a5r5Z2INjaJ7HuWBKOJi14{gqve}UUNbBj&?x4 zlkf(+h1U%=(A?I_kesR@S_2+r0S6ho+}%L{X&J&nyk8$cJ`eznzE@(HYBnc&*X(o< zWi2LQggP#*Wo!n@a%hNE`)u(T+z=ZYIv4=A{d>LV9`UIbQ#8c_euk;#fpYyO zS{v?Q?egXm^}yDtUnaFMSv-Ir&!5I5To61UyI-YP3(PH5okN>z@6bkpIXD#dQ^vW3 z1Rf>;H}sYil3cEb=F-NtMnz6$RHMBkr}h?h=-0HAeflXy1d-B`nxj)rtbLrSZ~gtR z{It}4+0xWnS>f%0_%+kn*4Ccy`j^Ke7QJaq%xYFACpLR0BZ~Gf^{o{Z0ew8G@ID(E z65BaBtZ$bM<##x&L;NiQ>dzji{|ER$2fq|nUX&jne3?lS;zWeUj3kLB;hG>xQc?~t zp)O$R;>*g)jRU(iD=Y6VKoSe;CO+1O^AsVGbG!I77SCZl2I3?v14E*apd{hozQ;-G z8=c8M(P$+nU7aO4oFqpQnxN6<>mbR87feZ#l$3zNaVe>mxez3rR*R6Fsg`J+5fWKZ zLZc*Uc#vRy{QY7RtKC}4C}5K)>Jt)5SXxK|SL9#as5k?fB>;HY z)}@JOUs8%dBfH{Mk8G0)o+0u|UJ zN5X_Yn(d@idoP50iz^N9|ts#sv5u>!x2= zUsYB0&2uX@|6#>;FhusGr!N;E*?i%`1+^OQT)(xy86eM@R~GE?KgqWLZ{jZcAreTw_U#hlkC)dGq2_ zDlkyc{KmiLQg!j7<+L4rF9dYB&ojbQ+!86uE15D5l-cPYKfP}^Z3my!H zRO?tBk)|er3)ZGhs}ucXa&M>u2a}UnQqqO?WA}I6PtLB$&dxs3(b188qT)maJeQX* z9W{OWbcAI3^eRB%!gCkauecn%eEatD!gJ@AZ{ECOg<5@KYAMPxOKb)0S z0!H?Z)E^JrR%OK{+O+RI((2yQk`<3m8gtWbH#9sDB#%w=%y57f-LQQ5yB}}*_m`f3 z200OJ6ids>Q4>Zr^=)ZEfxP^_$nPUk-$93eo0`7E%m)Okd>SDD71do`)Q8vR_I=rC)*$|9F9o3X)Ku-(hctfBPP=J;ir zWwEjI3w9QO2h*5);D@ii`s%;K^73*M6I&x*eDO7egd_>6oaXkyB*{NXSYDptFfJn_ zx^^WdcmDfJ*49`=-J@@V=)IQHVABZ(bqr`}79d*+P&TvHCLKcaqCg>mR;fr8d^*t=H5g~zP z5F?j+dPalwd8z6GnHib*aOrYYc&oku-30&Jx0~(fy}A4XsGJqSmp88m_qTTaH{V>o ztiAxufXQ;fS6w*Rlq4f!#4b4aG8TzI`_xPr?dipI4S{17j5P+XTtP^xm+dSoSat`) zBDt$pwMMkM+khl#Zr;~=^r%00!2n4frl|odf+XSi0FHMKaVJ1f5Bhjc<~$}>mMUGk z|4AST3K|_06f|zqq}9O5>I^LP1==Ti<+*d4(q4LL0~idbSXl9iCLuSVr)S|p!7iD` z#77VFc&HbU1VyGb63!VO1W0(! zTftj!A$*9V)NT+L_@rd3#4aaJrfA_LN&b!C*|I9(lDM2C6;%oUZJK8gwn-pPCQTZL z=7|GP65Y^nA0T<=nU~J#AgOEZ5##fjdgEkolK~_w;)+tFt+lPG4xW25+mHvcWveb< zMmf@xc^M%ASEefX!urDZL`X&vB+c93{07Ysf@I~&+N#UJUcsA}FITJA*VbORumUVu zcaAGcFV+3{=$gH*Md@3ZuGx67(!CxwR8mA}_Rh}jLg>sa*b09E5;ZY%*-JE0&38XSKkxWFJu;z|(`sht~_ZmR%DC}b0c zdAJq|%##c77{t3#$o#b$iNCB~;*WW%C()&)D&hW;1e}#|q!pfr+oY4mF-TUAi-sS< z!~s;$B%}pwhfhBFq;4VErghi@3=5x3YZ4U6)ai&i+zYSCyi`>c z9u9&7evVx@R#nvw>zP&U?SNp@C|MC$h}*X9 z=#?w4Z3ESF2aw4^{}&}lJPMN7y!hPqLX;%-VMQU{&QkYovPqoNm0TD~5?<4suKPiK@!muG!7f+n1*qy9ULZM18hLDfRz#r z>IW!7IO-fS#;vYfc(mr|(Y^XuiNMAyuQU-EG@hIW?nXp}13|4=W34K@N)3eIFX$L} z2uC?m72bZ~!m;O$wF)JmXWW6yuW7#hA1hXF-=03zf6>&AjxCF(PA%Vl|J=&|`^|rV zssRCmVrKK^&A}KqQC|{IbxEy8*>ov998TopNmH;&DT_)@^I^!-)4|I&v(h=a!M<4J z3LltO@g=Py7O=ANB4gF8!K{Im$MQvdF8H>y?8Op*1O!Ix-Oe0;f0x;+66zEd$5${( zk_C{cN=q?H;}}rs8DP)U4d@+C!PyZco^FGAH}%dKP_rv30UVNW;9fmd3CC%GTU08I zEJ=IvH-W^H0Ktdo=xB$9*j7(MtpS{XG(l#bK!vn=;X+t(xO%mtBDr+7C&&mu0=Dm^%&KrT23Rg^#;3~{ zE=(|j1ShbUTk0UuH($m{Fjkl_^KCGzWgU4!B|Oo1Z9pFjb&t>~T+2AXkrdSNo0Wxw ze+!skiG^phPN?O9D;(cgTFQp)IZ8Q4-d(}-s}wjgYjU>~AqjDpny5Z%ba%E&WC<-= ziAr^+QA5?kB~&F`Ba5qVlwqat5hRC<2oi@$OvivIAxL^wPwF8^kRB2&JwZJ|up>G{ zfTW{*Px+ps2+CdqNJO!M-cNWqEL=iMR)7Qu5sVRvuAxl1ocSEck>{Q}#voantHE@m zlE&@xI;Q3?T9n`Q!;e4S+%jvHQ&CZAZS8ZY6geqym;jUsWZb0hVjk{~^bQZE3^js#cf1vz?rBH5xYJX3x|` zvlh)-9W9O2r_>z)a8Vx3^?Yw*Yc9ojz zcWTB|lK}meH-D&&2TKGc30NROlN=UK!?qB%Fza;^Gij|ZO5SB6#IJ9zKj!4Ezt&d$Dey!_0(T3=saMBRR&U47}&=F4!4 zF9ct{a0z6|g-h!8_6egV`rw>0%x=ZOdwRpwuy&qcm;fYZI!D*cikYk|#tM$F(B+4P zI;n@zs->|}tdAj#6<@L>_wHTrKvcPhH##k$EVU91juQs|CbzV-y`h2g_g0!{QJm?4 zK#v*-Q;lzkMn!`5=_DN_3(*)EhmfF@aj>!?lh(l@C@5p00Ew8)43MDWIeN5CjMrmw zJxGzJ|AUaAi*t!g%jXahU_+e=K5^y+aD>~Dp`QduC>I@5<#!$jNSwOz*GxS-b?TYQ z9k=d5J1;^~-Y!7WP>Tr!zL!bqTvlH~IRzGq8r02gYnu9s4Of*KdN(Y|%t}-*R1RE# z1hMe4GHhTRU#9#tlqmuvam~%fki@1e$^GJsyNxPU+|WceXXIbF1xwi>Cj4{!IMvzNkkq`NIat%BtXOylTfJuBy}02ZV-~y5e^QZZg9uZ zg#d{IKyu$O1u^^Cx!Exl$u;2c9Nl}A#nq_qhDQC-C>*p?Gs6Ln%*z+PfyWFqL;#su zz@sWW{KEPdU$l>lE4c%0XGz&%Fhpj|$UpO0+|;c}&D-vE!OwZc!GrTZO#X0DKtO1E zEyn8Mj)99~g`Th)%n@*F2$5cr1e>{`Br!9TByj(c5+Of;aUzgHY6$@GVrfY5znB$s zyIEBtmUUyOq%1i+<1n-tPHS>=8=3oCf>lf6<5eexs?b>a#Omm%i4$z4{6FOc1Pqc% zUx}SR@D*Q=v3+oBE|Gz93B(gh5_3;cl1O=D zNbr6!wPFx65k-lW7$_0F9Lzv6W6@YIdh{)AUR6RPK8TP4a(-j8@~GV{C;@i|m#7~& zEAMt;G+8<9VehD=OKs)+KjjSLp5vkkg9sL7WspRpO@ej`Zl(Y%*|T7iIP`@?kSHfA zYLaUfH3=#83=%R|!JQ#U)`v4l+FHZ09swAx07)%sqBoEIZR+7%O-af1jUYz|lCG&| z*BoB6=3ah&*TFyipFaURou4*0=O-mOO${xdw|oUb5{)^H>Z)Mh%}B@vjIFh!cVo_6 zV4B?*ATifLqVKV@vg!+o-nH?vVq3g0P0ftNh!=(^&a)V@PzCt1%`5I0pF8J}>P4)w|4?U3vRX@|S?W@@imn4l0&UHQF~hjbWYa>!ol~H}s;jGO{S@sKQ%x%z z?pj~(>MD^4TTP#JU`W8bK~a){LS$hNap90b-8UdfXpO?I4hwNVhEp;aB)v+q3U=&V zuuv*0%FA2Znntq%T9>GRG@y}jq4fxg4NwVh{>OhDJ9g~3_WyXZ9fN6q+q!i&-207A zvv5{s=UI!k96r3pDL?<-L69X~OV+G8?BsO(cvn|fdg;D>_YTf*nl*KcJBH@LT(|_3 zU?>eU953J^N)kCQBy_W2nyn5JF9UsJrOO;K=0>2T0R@SW98IbQhYD|h^Y(2OI=})W zLj4*P8?gc(DOm(b+^e;qGateb4Z$FVikho5%h96uL z;1Hpa;c;3SK?1LPFi3!sg>`ixDV_*oJ}C3LG3H85BgIR)g0c6ZO%vuESR z{H}bbjcc3^I&IxLb!w+db-1f5u5|mGS3Wp+&}q@4MWN_!Y~GAHuwaq^AM1lJU;q{& zk$UR;ZkSEN8$#lxw_dG`o5&2BvPK3jSj0Z74jlOUoR5!62$RIK(EPGxh(}5a{IUiX zNxVvRyB4^*>~$IbS3?6J*U)|xAu%76k%1tQ$h6gng|?bPX$%OICQPCjHZA-iAaF>v z7UhUUD>TyrYG6p@*l9B^gQ=4zG8rTp7=n$MMAoa&h!WfoEkKfOFnmTgGViTtMM%OC zlD4*Rbyc_sNgF~^bp^#q?Ruc(f&fX9)7HaC$<&RDz^%!5cAl}3AeriP5DZqQsZ-ZX z?fgP@xU+oMuG%-RoCj_e%?M~k`9Y9iM_;hIYJIRTLNaR9#9f}AqPmeIBnFa11jNc% zehB8OmzCZ_R*RMiLSjXb{BYpMb3U&&m#_#t_4dXVEF-G~5h)WHiOm8?Fh|x4EExfk zc6A#`m&ir^cfWl1o$D{uVDZcEfDJ8T0`df<3JDb0HX=zf zE;=KE0we$lStpYOQ6icu85AyYSiNvzLS|p>P9a~ z44aoBD~8gw37C^XN+2{cL5pH>XeL_OQ&A7PhTk2&6m_6m+$r*O1;` z$_H)P6WRA8s8l1>6({=@`|@du$LEe6$;@1_qUr+p#NQk{`dZS|jZR5UPW~=QNdfu! z>FypL%JlSZ=d+!k#>M5YxpCu0e%HN&KmF8oc+K&`jKa*O^Ba4U zB_*1K9qG55aiAXB9eGq1Ygs(z$EScyVGc1?#sWxA?z(^VetLR2YscZwA17**J`f~q z>sX1*RNl{cDfAkh>3}eOvc)6uqF1FU*I?ZO9u%lq2WW~2|}X| zAX&&DK}s+l8L*lrP5x(G$u(%*?2``2aQ46vzMV95#)Y= zM=VJsu1u0tlL_+6&d)!;ehnw#fxk%B{Gcsfy!dH&z~{wFVz2K6X~LWxcreM{5Fim$ z%{1n{2yBeA0#K*}XA(=41}kN?1IAo~G8|6O7%LNv^v*{&k)QHudox)lA652jYs*xx zUyu3BXqQl;+J(#umoLDAi<5s+(!L|%SFT)nZMJ{WYo(>z-P4_&ofah}C)!)6qdhj&2j};-;JlvaGjvnDPB5U^ea}nNGuD#MKFUayFWffGlLEiMK^5E1|b|3pY&0U=rPiz`Cn`T&p+9Se`b)6t_W_&P4y zs=*Aq^e{jIjPx)_&<_S179`32Q;Z2cB@7HhNKVuozY(WWos5f%YsuLbT2z$2Yt^b% z-rfr~z5DK8jvcF_NvOe|eeSsnK+lC*-wU;^tuE*7-msfJ+kN}?sFr(MowjVbu?5=M zvz=Xs4}S0g$ddE$3*HU1dpkB1?%Oxxyq%rhZ2x`jzP=ZLyY1sNBcHlbd5yG6HoLo!&QJ}bVkGd6QY4CXc_&A0Le$E zP8_+h!le!l3(UN$p3cC7gh%|)wW$%%p_(a_AJ%g_U6jO4|~W)UPY z*VsHP0wHf>0d$Zg6P~xQcp!BHf&@&FUp_zW=NI|3A4-lVnaFtO>8Jh33_;C9$_KXL zPR7kU%)|xzb!6U+Ckc{itO<}o_*Kfn6w``etH@>^PRT5fb4uc-l1(z)i|VTQ+I|TAua9MQpafx<+(iH8)Ty#1DJfZ$xr!4CU}Z&c7#o|v{yJ^Jf|t&PhlhW2VMUd?y-JO_ zYE|xgXZt%jJ8!*LTKfJ^Ki}(WZhrsgpMLgq`rCc@;BdX zrg^Oab~YLub&KZKcdRxsRsxL02t{Nh7^qCeFfd}!aEK``CUEwQnmEDQ(xTsF#vwog zc5A)1;GM;2nSxRQK4RD;bR@23>i+Xs))q54^5p#3&s`<(GjhX~cW`J}NErf07fv&P zM6gpL#yL#tK}iz9c8r_!1c;svgGpO^LvoWn0VFq4Qc@Z<8V#G8gvxKmFKhht>#vom z3!VW;+`qZ-jk>B`4Uk-bH8Mz?58g{J-Tu>0KLI50^z+ZR<8I{Ue%85VOY-sKXUg-t zHZn*Kf?M<2y@ThG5)>yuiGNb9ubLn+lq9UoS3i&la9EiMy!eV*X1y?76_SX z0Hz2Dh!Vf2iIFE`!4Sdd{R4FHIS5H4N2eXFbBLbgaA_Q-9*GKQp^z<4eK{yeBG7&< zpDRN0(W#FN)r}A&p{0*iUyIO?{o~#)I-JshA}_`AS573%%u+qNj0dOcMkt< ztd5L|nTE8CXDV(i1=S)KGf3tqxVnPpT>l`wz?2Pu$%zX|-Ap2z#KD2NI|~;IdGqAx zOq#UX0U>cHKXHnY0P^CLh=FKL{eCC16^S}NVpzzaA@87=Nc{lenXf=EG?Ada54Tuqp znxMu3M2M1g&I)G*=iZKSl2N1+|rc z$jWnnX};B{*-7e#4FyMIJU-zLLQ--kHoo9`WU?SaQ0v5qwg{<%6DLlehRu60EbsY1 zhATm$0cS?%TgNa+=vTmn!fVt7NZ$Dc43TPW{ewsn0TNO$4$J2O%CoUjuigjNLBbwSv8B(k2R$CkJTFUtMvRo)`e9WwLGsr_wdxCntpX&i z`}WQNtF>#}XX)wbQKdffjy-qbfBi{>1U1gd+#3dvfE)orJ`hF8I&^Ue66^&Qyc^0o zk{g8O4RVTlIWuIi`UZoR0qH?)xd6#Z#N;m|Nznez60}W0NlD3&eOE z*~BaOMUG*%0!bEtK+`um63rtj2Q-ot5JBwNSvH1 zS+WFdS9EU@sNKRpXf`kXJ54|C>s$NgU;gr(8g$O=*)tTgXCFCoL#=fJQ^D=;(rW0U5G<<#OWU5Ad_{4}XA% z7hYKTZ|~n~WZ^WBBn4FdxnNm5np@zt0XeY+$&pOd$1o=&29(VB;^Q41U;OYxYFI}H z*emahS~`8soc+%~5F~iF>#KJrM;e4+M5SXu4YN!9Fi!vE?@nV<66FX;FjPA-N#dYu zf_LMw+MgnJj#Lq%D{)!y8cqXGm?y9JtuD)b^#!)kp#)_C@x?2<&-G| zi3IZtMg$4VmKWMMuW^D=G7g1{gOJ8Zo1)FYpv5htgB%*NPZ)Ls_m(39F#q#;Rvw6w zSi$`j8c@=xOmkE^I;Oq*?h&dkaG~AB&hETo?`uDO3)18Eu2rwU{`zP6XIt#;-~Z`P zAN;R_2k-sdZ10nv-n^r^xqQ#8S!>o{oc=J=H6%zFByX^BH$LV#JshiTEk#J=JcHx{ zs~0cG4j~SL4V)OXLj(nbSez62c;Or_?r3fl<0P0x!cw4Ff6g)-Yg2IgG}AWYu{-wk zi4(6M`1#&@pO$&sS1TG3mIAgY3kQ>>FD zQ)EorxVlzXk0|0g&JYr@^9DT}riBoa2!h0lL4w%=nCJSD2}o`lnyw&8@(>cbm`0E^ zD=#{JebF)Pg?GWfxl|S2PLQA^(LwUVt}SQd?7_pKAS*!9yz6g&do>Io*|>4mmaeWY zP&tN%E5%Cem?ZI$>mZRzEi4I=DCPMNK2Gb^c4rAPniF;Y? zingmOA)*r=6~e>#7{Swl_kdb_LA@W3!kS>7b z1}Lv2A|fK%O9;b)BpE%afl?SvN)o-c0Z8tmgG2LSEn}G%h)c<>RXBH}qoZ=urdF^b z+FJ|V?Pi~!v3Bu@QVXdkNs@n%<*}Kv9yc=+1nXFA z-V9;{9cm1aCm@`9P3JP#{PcB!mW2GjG3*zcckQ6XFES*WY39&hHl2 z6CM%?rZBqJ%S?)rfg#~p4U$RG(JUhxDS2WX<)b->$d)VPd+*g9J9hk>o_^-+{4KL)Jhf;`XXoMb9}py{bk?q0x^(Gof93*P zqyKARNfV{Z%{>7Y2FYcT8v-W(7alMof~M+na${D$(7U}$j~{>h!nwv(2>LQAtC*L^ z931>a2+p0@yn?d4$l?!ApM3rGkdVa0ci(*%7_s^Dr{Mi2CzprrDLX?=l6GnRjyifGN-63Kj%#Pu2s#=uOcMhA|$V-r+1v)vt`z- zSsTxGcHWzDo=KAP&hWezAel}1B)hDsd(RS6H{=!si6ud@SrjBI5R%K^fRb5Gp|j-_ z4(Y?l|Nggk36uX#kl?VrEG9{q8w`>}LmCtyIb9Z+{Nd>@et6v@Br)VGM8xK+?>;@< zQBjdxvnRCtcnl^TO|;xU=fTts-ema0Pz>3u)C3>LAo?0ZCUoS}jFNg;HKn9Ua74z4 z!tzq8IzeItOX@L3$a+O}Gj0+~6F^AD9c6Wpo_J!?z>tWj+&uO9U4#ULGPpDe3171I zn{QTpvtsj#^>3~enqa6JKtlG&$Ea>@t)lR178^Oy+1Zkl zvu)d%{Hs2^cXASFhght8H$6r29Q}3hB9d;(8fauAsQTG-?1z8cja_|7*`| zZQb`-SC>07U*o`6KskZ`l6+ym{L$|Z4Z6l{T=uDDyB*V>0PEPJP(Q!X2YUN4{s4_)k zAV)qvX8;Qdl5>SrHc>Hq>((N7_jI3K_ED8#A&IFV3j=MHKD!St1H0>s#si5cK)&)m z@caM#NTZJ&8@KX>_T*s%Q|<)=~3K){R{PUp{$TDNp923)%pTq{#I;s`zq-rU^6 zoMw3{MM#d1~D}ARoWWbWI^Q@T}9kl1s@;QK^2w`kx05 zdO;AGN_yB>uk-57?S95(Pn0s#FR7#Dze8a3J4=AXjCwowhkE>gk24=G+Zq&?`62&ym?dX1=blR zH?ND5gv=3mNYLC#_z@tnp*e#AlGj3y6tyr&);JxWad7s%_nSpX4jw-EEka_yD(<$A z&%E2WyX-e?h`NV+J~&8>1UMliqb9E7x;d`9dv|L)Wy?#Y0wX-C8x$lICwZ>}gs&fn z;FyY-7=+~hcBBL#5j`64WCTbkI`Z)g@1C>s8SJj|7PC83;#9X%k&y$hpE!QJy!?1g z&GF)LEXRSuB>Tk84uoX7<%2;&`a*(`kXETc4k}35RLm4exkkuT;C|){7e_8W{mU{} z%CxV?Y=IHQNg70R6+^8Q7r8X)31*2fMreRA=DLE(vXEjY(G9RD1Y1RS_gU6u!vqTh z<=LC3PF*KRK$Hmmd*t0zhJ-NhX2Cx9@@-w6ot-z%p6NQg_2Bt?_rCr4r=P$w!Q^;Q zKR>;{;YRJtvNqG5GP}kJ32aEzh7zW%A8}CDqA}DVt~z{jNoMExw)!a z2R{AuL~=)R`O(m$E=P~nlmi`8lS0eOcm447fdl1d7m;^k`+#A25G232#?Ft4JPoa^ z>~tA?53dUiR$^nXUyr?>cO3`bl$}n-327G>U*EZtM%>ibqbM1PB=MwB$RuGf1zD<3 zU}KIACL67GU|I7*!DtGw!LwnSk--9iBT5q{N#cz|t{P1vc{j?m1!?X%XU?2KNLo7A zI32|9JWM1KlUaZI7A%n+C|7=JY1y9h(?M8&A0-J3$)BG(HED*kGY6oo?e6Zjb8fB5 z%tT4T?wl~h#TI}uw@!BlNwPA%BL=-jRMptV`xT!~Mv1Zk1&2X^hFS zDY+jWuK`O0#K#`M8-+%peNXXY`asnnUT|3#+()>Zf@)CkX5}OI-%O(X;e{bicVLlzBjv`2 zHOE2A03&-y%aoTFUt^G@g1-ZhjM}|>vZwrkY!XSe1S9LQWqEl8nw^x(g}-e4FV?%? zN$qngn34ySEQ$T@m+yqUMap0tajL+iAR!hX!R%G4Hjj{ui*R7YIkE0yP*B7;p;Twk zXjtmk_hsDR-t5z-mn;DnSm@+fM*XOFN-$1>vp1$yRHv9ZMd-lC;C`nis@CWDDIe`|+pW$q`c5OGJ5)g1C z6CnY^6)acG58y2wK{tsKB5+LGt3iogw{_sOgbB(8I!>0(G z#Fvz;N=;QFBrPqSV6)yhd!zF#IJH~DfBM_8_9N#hS>)isKm7@e)*bI}0}JKgy_{81 z;M08j{?D&|ibeFEx-@*o-c)qoYUXna(xy z=Wp4#W$H#?&OTKkrVuj& zCHZ*GA`nY&y!XZ%>$o?lnVM;&pXRLCJ^j7+b}xm;r@B$FVRHsW2u}(HcwXFejFUin zP)Nv6`DIxwtH!lcfaLExk&*(CBFG3>uPFi~)%8>Kkc`v?<|j?+xrB)#87tr2R2yE0 z8peU}7>C9PD+BB>sYjUZgtp*#;G=Wr&c(_`y&G(Py8kFvq4n$I9vCLqGPgBu%H zEuc6FKysEKnJPf?TvbC=MmRHC?}dYBvttKB(zT}SvooFN4}S3T`&B=Gd!Ah24-U2+ z{ONB;(11|@A_24E&wpQdI8_yRMh}UUrYB{PaHm-W0b>i-va>71zI8tVlH-eqDN(}5bQg3Dm!Lo*@tVuBFT%77cCNm<&Fj<$$|xGN{^8A8=z{SZCtY@ zKPl;NuU@%Q2TpdxPv3rf@7}$?fv(xG;r6!($=TC4rcOPGx${52`lo};Ci(Wt&sVqBe`rZAN5Tb3!U~3)W65w&Pr2My-jXwMky8xlnYU2YRAhrmc}hnK#;?&Y zuGzCkKbti+VUovCf8GaYGm_HuXmSo`2QT6{4qYD~j>Ad)Lb=^+J{F_b8@HuP=S&VX zIhW{=Az=~$AX%0r6!wcHQ#JNROI&B?nY*ZO^71-!T3S9kdmJH&Pe>4}ATdQXB1ohT z5r9O)0=%M_&n35Bu%MQ8;$W{ILW0R@1c`%KMXj)-BO4$&@d0S zzr}lI1vn*b_4jviaY+(q0!q4i3?JNXoOb-+H#Adlxg+ zJ;_S+>^+6Hl-vvSFf4fNkd@Nqu@LsqboauM7Q998S4!ETmcmI5&n%noU&v_eV&cpEC!Y8*@xyBuRqvlm6IvbLTIA|NAMlSx=n${qO(t1QR3F5eDi8 z2tjeOxaREH*I%Z|Z>64g>_6HoqzaDrFXegSLJ zlAQYee==aPbg z>+|P#wcN-#``HaJT<6DA&6{dhp+Kjszae}BL*hAkvaRi8dh6J`K4*@tCCx-{y=hbX zLWfB>_YJu<;N@hn>f#w0_d(atReEfijUA5gs++y{HIgKrIJ5B_uvg8&Zk;Umw3WWR z|4XunaL8%i^;4&Ao;V@)hs975v)^LBVjR*0oILG!;`{Gy=XlPs6d+0Ed_p*y<%;P- zPd<=Mc7z5-l%2u*2z7RZe+bRf+RY6o-wu5Kc{g)&l+S@|9^IEMF>`@cDPb3U4x7~- zhb`kk;epi+3wPABJU=E#3SvL|?Br)aNN!91*@C;^d2i|L0!we|d;>_t;+-S&ZsfMM zhJ!&YEU+_MYAH2;{`q$^$YN#F5YX^F45B!cU%j9GY&S6yXq48gv&kl#+zQQY2={x? zK!T-_?Ptrrnqgb9B2GBY=!dBSJWyhZ>ISRWpdS74$6MeLpnHYg(0}~nsq7PCmwII6 zSiuc0ej2sT(@#HLlbrm+WY0PK1xOsb6`ovJC@kSrqTT?AQh}S16oU!NrRiKMI8?v} zLJ}Bg>6VtZASA>iBsJAB@cF<%&^xxaf!Hane~FN;%@i!<5exu{OoT+MhoqpO;O=Li z#eLR=IWGBU@7@L1W=kiy1Ba)sSp$$rsGh5~nD9VLCG30U){f<1I`y1WLa9<;y?+@<%jb$1~R^a(vAAn8+>M@x{PL zF?9egPEI}mXic^gKLaQmmsDIxQaKOXkOzz#>oR;QQ z&CM-mx8&!qSrd;@)_Usxr8MaNhKvsa2>~Ktg89Q1atrt(dOmM$y`W(s8wyO-1RTbp zeX<&B%b%FrO~>2XafT{ZH-Af#!A3p`F0H+Atxev4-Y90(&p`%|aHWR9auE`~8|yqG zBolq$T3g^e>6GH*$%9Gq@~vA!2@DNpJ!wjAet!L$ZUk-27KI`SEm!n!gaTyclVA3< z4G`Z`C{N!9HxA^Sivr(7I!F`z*Ge`eiI0K{*}vbG)W;l9F6I_<_S3XBsQ`(GhxZ}n zGu9w2Y;DbnU9hE%f3fE5;E(_yLEpZ}u*xrn<-sPw3ic%>s^(Rz>>IPX!u~t)tN;FQ z?;p;dy|HT5SAW^CVb#{DMfr!PmSDakKq5h_H6g)uWRSpR#2YR`!kXnAOIxsC?^ABT zYV6u0t2Ky1trgkXC)iz24~YWV;NpXK*`E_8`GEz0vheV7!qxR8MNW4Yp6oHKVDG`D z`*6-Q+x9*w?nXUCegdd|g(8%n%mG-5K8gTGj^+HM=^#;t+QMBb^|k}w0&b1H2#E_Y z(u%1900}sn=H}L5J>rM41+nrYi|F0aXl{M^<#(DAtaMOt{dC#sn3&`w&Q76-^egsT z{4^s3B+25Zx4e8&2MG`FS%Fibg^*nW|K1{iqfZFepp=dXwKfMj_5%c%SOo3j_ung( z3l*Et)7Ar*Q~4(5E}MAadB}65)*gq z+vnqvlhftlQR;7RziKPy`mHIcuLo_Tt*4MYo?=9hfc1~ULym7(Diz)@+OM{#aNfPT zaACxx)l_bN5*u*ycJ|!20+>t6(XUI0G%7VLUCI;%EPya5a^s`CrEEVhRjeWc`EGC@ z@i2Q>2!O++?zVg=FSX<7bk4lLGwernp$ci{dMiw<=0Pqkp>MQ zIiy5NcI-&SS}C@c78bpnV5trgeo&i4=&d72uvlATb91x(yq36=2+0w5ge2d?!!%g1&*< zXOkG}DOeM@pdg*GjqW#YQwTH1bG$MNEf)JyJ`J=`x3t^F!zWc#H}R|fBDldzM$kg)HsQW ziIp3|l)Q9~r)A&jizG{=x;ah;hD7VCl})MER#(TeUSP0Ens0Y?ojhP;a|L`mo18OU zVPSjs-u79QkB}U`Lv_Px!UD{dpE6QOLL+7oa0}@iHpW^?7kK~6=GK$9zxUpIO-&1% za4f|n^nSs!nJYk&o^Efy&j&3Kk3{^U)7+G7L4mly&6aoLRS;|vkR%9+3wC!XE0Gya znU*$Lgv8CeG(E(Tk)?ng(!?S-I4zC7s&a8QG9`#odye;!BP3CVkSM~#g~_AA*|emA z6mtYfZr!P#LjEtfHn+eciO=d%C`wVsN&N#(CnqyYy>HyU-IAZbWX<6biq{+66qEqBvO~uR2TAwI6RdB!hjRkjAcT3`au-S3N?hXG{U1!fU+xshS-;V3bKfC7e z;X4>VgVz99)%6tDACY&%>$MFpR2jpNIVha{`^`N8l2NZrYnle4WHmri-qDerEkN=- zN)E6eP~D_TIe%^&U3XdtlS>hN~MFiuNto1;TFOMN%c_ zvW-s#NWv5WM40H^uoD(l5+r=6vz@&GBvnBk@M+c--qP;LRXD~`Xqc=3yl z;^GBqjxS#nAW0Pnn|tO=&bF48EiCEi4!F!zguc2OdvHb!3C|2B>QwP$l*`RoET_dHn`)LHOi`mr~r0;W{_Hvn$mQXq{>%)Jk-Ce?TM%PalCqGRdFg%=o`DN>8Fv93L zM`~_wI_6NGTdH(s&$rZ`TN;g|uHzrNcbY11><|&N3vA_?6KT`S? zK7e!xkdV%(24@zlav>zF7x?qLWu2WlIcH8HFnL{5&vtbZBlGXD!JVulm=cgi1c_3a z#(wEZe86>3scEItM@{$yD0u}bnfA&jix8A)L)X>)H7Tbw3U@q&#$`r;e=}<0ME5it zA9#^Ik>ka$50rrWo0ZRTx7`e&a#Ofuu{p0W8+1w8;&%uUzo)-Im*nfO@dVHUQit%L z{iBqQIMxg=nert^$BVDOo}B!}7fQGN`(gV_hZZbIw6WO`W@D3So(?_`=bJWmk7PyS(hB-X4LrwsQuDgq5?xWN0=Xd8Z&sQ0H`Q zIlJX^m4^b!!){V893h!t`0nBE zDHH)w=Dk7_QWph%5o5F1)MzOw0LeS^-$6n0PVcOtrQ86*Bv5HDWE<%q@$t6#x})Rx zXCRCmQP+TALP%17*fw!`|JT{ZCeVBckci35cdFxsGSnnW&@?Gn(+sT(XOOymJ3s$= z89`D_p?D0*gHr@-jWEY`06K&VKJAqz6d!#gNofBUZx}7Ah|YzL=gqfqMQDmR`U~G+ z(W{Y$_Hi^qS=Y7rE~H#WL}o^~?rl$;&T-r}Q$sY1I2C;jWApToq?DD-pZ`0Y4Fn{K z5on_(?lww?(&t5CTGVtsQ@cY$SA~Quu(3%z(9!Wlh@)egP=*CsVwgwsy?zOS{}&b( zh`!Nakko_jz-N#ov8+ytFpeVj?%ncv^Zs&d-n@CQ`phfM&%bee(Hu!HZY zVQYn7Xl+MZ+uGpy=uu4K5#e~H$ruvFLxCj8ok!;dE_xBKRB$c|4p-q0kjY}N^J;PJ4t%dXbSO>v^2=X;{r%TpANcxH zl`6L@G!!pwtF9dpo}jfZSRm(z1_@If)rfbNFot61&iK5OC%4VpwH+9lcjd|z_oSqa zOUmXS&dYNZArU5Ytk#aGh>coprluL^)CSYesc90rsw#CWLekWPas-W6@P$#L2yqhI zDDV{m;bux5J)?Lxx~o!0ezF_y$VDAvpm6!K3uS~jgE}OiF zrdP}o1WDfY>t#2NAE&uLp5C)3z4rfJ4)!$@FASTH&q^Jwwu)9)siXA`Hc@L(Uudu0 zq*R7@*dziZiKz>|P7U$+`oMu7f4p@|rMlJFn3a{%Sz7Ar>#M$?zHot6ovvNJ{LSU8 zq``7WM;f&}2qY4k;TLXpJwSpJ{uO{E`JD0>Pky#--qmC6?ej{nlwP?4kbr1B9GmAV zG9pTl5kVqtplQ0*!D=;JmIk$%uUP{vL>oc!iqIG&3U+(;rE6k#h07YmMa;k@CD=^$n7 zc+O72rSkz|ry)ubZ)YwH_zSBH3rXV#oWCrc%cXuB6eICiiv}S9IRY0vCHL&vrwEcQ z013?zinAh#h`?WTv=xF;RYiPM;g?9QZw<9J3sOBiJP?wQkkqe3QWL-a`o|v+03>%C z8^NB;Ybh;l@bzt1i?#izf?MsI(3UR;NaWx^4+@EEbv;7jT3>w!B}oC8t7Nzq%+Jry z*|p0(f5wa%{z+Ryr%qinfBrj5mfdlssC>06>)vxkIW&@9U@vh(AaP1uqe-L+N!@&c zd^8a&(+ngDhS;~kJ+-lgMQ15*kHUj`)%}&;%x00obE%`0v*n{4d0SIa2i65hHytxb zG4U%@p%X6LE?Xd^GS!ij+AHw@E{s>WD>;^BD!hJ(<74)9pN!W{){5oukPx6FrR;i2 zUS~^sdikP7i;$D@b}HT}P8@7zFvYYm#YME0*Cj9f6|Y`H!}4>RHvKg*@vkKyC z$)>Wo`LkS=s_|}CS(&D!05n@?X(5|L$Cng!EU3_J)VtmrNL;Y`P7 zx~kgn`7e8^%|Mb&z$ls^N0@o?i2)?ea98bZ+1({Sz}wNqe{yA%_*Hjw=j^aUhIfYz zMW|l%EsE#GzUPj zl}ni7DjsW}!DUYAq)U4y{p!_*_N#?^_AGjGQF?8ynTUpd>UwczaxZMr2na2)SwW*4 zu98%EbNjiK%RykYs8o1bio*QyRsr6|!a}j4y_s$jjN0d(qdMgP35t@TL88TRGyn}EeDV;%K%X{)ZT!?$9BWG*LVSf;>NOQriVw+(=;uheXwM?7>jb)j~({%A!xp_BI z@Vb_#U#+c0NPf5IcZ&*ZYlFr4)kI2g)&esxHsKb7B$`O^5~Oc*!@M_FVreY~$!B*} zA9fNXv1NbMfWw-Xi;$S9L6D%XS-x4&ILn_~0hpwvSiN-Yr7%-c^ zWC;k5GUo9v!6+;Kttl&r$9yy`C8SjglQfRB*snPj(YCsL`La5gCdu`>WF<(F%U-Z8 zoFoZ`N2ZY!!8tl|yxgA;sT2eSN0P*C8*ks+LqViSFPS`-e5)Z?Oi=lQ?uvj)vI_7n8B)(Byf9$d4w4xY{GJQsEVcoqH$T> z(9mEtW=vHM7{fck%TCFQ2S^Iwe*+}ZW^gQ6dn8H-k@n|mYoB{_`FenaXZ^ziL4xsC zt#*n~UeEPA*Y66@oGQ~J!k(7E|Nibf!Lb3sQ_V*HVZ3%kbzJ4aI9)o^F~OIEnJuE5 zW;+;jMw_PT>{hZ(L`Xm%l;Sr(inoPDPZyzX)IRzR<3a@pT+%oxstzB{RI!g;+qP}< zaomOt^NYE3TX)Pg7CMe?_VJVL6bhwuo08|8-S&lf@8hN0aQsW!K0XYY!!>V~+Ge^* zeH2r7W?_;06!d$M5+o#6P&X;LEnR1}T`8;*KQT#=hAK0|#vmcJjQfFyO9)A{fKN0{ z010$7sMVL?8P==Pb8}BNuZoIOsp1QEF53zJG3B$4LTLZ6vbuWz{{4=Qj=KdV@mVb` z^Ol3w0d)f&*`S8&6sj)ont;aYFF36@_VcmGD~%W@OC0=~nA6u!o%)4l{j3KuqJzXV zA%jbjU_^svYOt~j4i=Rz)4XP8g1XT~T$#%09{8L4kelGI3{aA;f0xG1h1*i>cOA<% zgQuH^PEA%UJg_Jl_@yajojGSp+uPM%Y|?1KU}fJDy&)n@eS#&V^+v2PF{l^LS!hMf zj2ZI}X3AEjtFm&No11ac`go0|1pohu4xC3iy0EbPczI1t@#5om@5aZsv=pL&;s}sP z2Ujr}!VC#)um9Q&d`HkQpVE4y|LAo=o3#6)z1LEVfT5|kj9 zQJ#2R4i>&KUSzq#_o`KdWSR&G((*WlS?DvSP?$BA~Eri%phnIQ+ad9g``0S~JN zP(PQR_{W$rV@8jDVoY?j*O)Pvt~9GsR4Nsywq=;r4vOyjsT0}bV~RUEu&!SW=C3S? zjK8B&mEsf`jzfV&f|-l1-_>6mt1I+-U6>4kM&QJvHJ(C{07G-%&IV8xzq3T+>RK%f z@f_*kEE2Jo87G&SEJY#0zENtOBr$5;j~akMTVOiJ>H1(MuH9Jj3#LEkr7T&3u@S+s zLD`a*my@1e2v)1vCAi&SQhEjJJsRfK7&yYhcgSFOv@kJfG=OmlGqDTd4{#~mbsHxT zX7lyk!9IZNbLV2wg$g!LFpdU`j9j)%m6hJ!PLhNlJf8$5f$Nv`rz068bKkBogd~=U z$Q1aH*REA$&&>vDa{8T(^EF?(qP+_K??@$yImwS;14xABV4PODA4vLDHwMG9^v5_F z#L!%R3r*#g&IK%*wN&hTn~0G7@w<2oKP_Qk;P;InNh!OYlU`cb&|qeDi6jXcW@;pEg z5t6K|ma19?3EvA6mKZP0`mBqtyVh672z7odDzdY)uVv5upZ_`aIko@!{QC85R!Mv& zD-S(BX8h9|HMbJL;H?IABh(Ma^Jy{2hAW~`JCG#NiIL#o%|dLz3Qbm^1Xja)K{CxC z;%cI~=od{w(%<;3huA{=6-lQn_Fy`QzMpmJ#*GCu=?Kaa@Mv<$JV8cMQntCfw=pbM-~?^1_H;9rMZ!c-r8c2OBkC-4b4jV8OeY zWZNK@AXJpU|1-}EuC0%qM~B$DC6vnwQJ{Nb;9`gSd_+{)T;-ml$DjG6jl|Y{o!>9 zYzv+9uQN}*j5$$TiI$3)ep2BvUYEeVu__F2$xA^Lb6d{fyc99l$)5t#wWQ$g-BWYl zMn+Pk=7)O=V_kWlhPvk!yBlq6v{5ASIGty^&$otCa!H)`pOSv3{9>N{B9dVEZz z-~9PCHH#O|U%V09tXYekHg2f_NN~!=;+nNC&~T`f24@K{!I>=g?3p!VhSQ=wH3pC@U2`j;Uhsku5-@IXh=q=g zK_S_^nL%PGQK&N~__7EIW|B-JNQ}br-9lL2u@WDm_PL>sao@)4hWGi<-Y7>O3$Rsu zXqXGfGDAXn-W^Mkg?R8G-u>S8;WaKZq9+p}*#eMEoX`uBiBEl4R)C1)W#ulxNOsxv zl+H`^3ui2gswax1S=e*qofM9>mkXz(NP{#QSmld3Oje+ zEcv4j60{=_62F?7@{W$?RjZm25;Fmk-uWb;5F~8Go-CnphLb^((jFScJRTGZ{s9R! zQ}d?=EM42(os=|V=~CxytD3*qvu8Z*iu5af>Zzr1Una0}YYY;M*J}wv*P&3tvq|WD zjUc&FMd-^ngZd0MCcnDN=Qi&<=oPpD<36AhD(Kc=nDS z4;hlSrXH*aJ?i+}q^;T1@dYE43y_%UYBUWXqh`FI6ELi%K^pWm!XoJGYueYU-Qk&DX)o64{s zl9G@ffMk5+tXUIBIUT$;Wy&2iR#7~mkA$VQnD6T<(e{UjC`p#D@ZG!u8G+wmHp8XP zBlc~bi0Xz#)0$A}U_YOsByqD#<@m_~@E})&?epi|T~hbC>mZ@M0Eu1cc9u{CkSJ_< zd4PSCGw&V3+t>gkIQEx~#eR?`T7bG~}Rc}Zp1bjky*U8D* zI0FTfBml`q0TO?JWb11?5-Tfzm^xK}WNh)1Pfi?l?_L6%)l(vhl4?psA{r(2gF)hp zvyHJ9EY5-|LL%5CO$H%(#Kh2%b&C=oq?PEwD5G?RvZQQ>R4R2(^Dw@piG4DZ2g)cL zQsXki86;r1R={Q1{hqPqx_fQ$;u~iHlFrd-mXKI=@W7VSG$Txe7sk%u@s7XHZG9nL)CCy+DfZX1#ghdt@RGslW_ZCPP@H zqweN|)@fZ+_qeq@UTAlhbnhN>xL{)mKZenwec@ zYJmhj@Qw6wia2DF?;1W*Fo;x=N z{N6t52CnSPn)32?wHn+J-{8vt2;S$*XptIVV#Q1n10mui;?b+A#UMR)42}U~rmE`F zrG|#mR-EppW_%>hv{t_5cuh^s@h!)b{c6UGGl0h=Uj=*Q5~{Z`URBXdlJK6!>IRcj zQQzEJy0jM~6Dt@b%q9VyvS-W2ji5`{u6u9Y?(Xgyn#-pc)eVMH#uq0GBTKsyrm#6H zv|1d5LkfpgKpI4nTp-6+Fichm$cT3Ah46{Gz8e~!#WENlVkrF~HH(1Oh=_=$h$fIE zTe9Dpo4s~zA4b6K89&pnd`mlc`8cXUO}!8o4D#Yd4!o>{kV&*oe&{s}!$Xa^1wwxx zxWJTNfx-v0j+d{M8K$X?2X*ts7bi|v#6(t{IPt{^aCN{esfeLD@;VwC#*7&w+CTt_ zc^^sQO7-v(5>z@ibSkH!f+lpuKQLU!jxS!kcrmcjy>9xt-LqyCW64o0U<_@nA3##P zmRU2-jW}kU<*A`O!M;N+X3Y+kDzKi~asx54-oTCxA0@iLhV7Hzzz`i?^Kn7{w<&^! z<>zKsELzlukqLV$DzZE7->+pe(68T&pL@M83o$nc#;6E{m#BTjB_TUMbv*-r2DX(2S4U}9%VRAaMnBr+P z&(8P`0TM5Q#A-nr&i`PX2+fj&66!kzKJ6&6_)m?s@<{9u> zc;=Dt@T#U(3Z~5kNpk#nA4uTZo;Y#;{yCg6die^PHkt$q4Q^;)K{A%XX(hNmIt9aa zGAew<^c!0C^)*vp00$-5%nM%$lA)nCI{Fg&EO7T?u3ejX{rdIKuL-6IxI7?Muy?t=5Lw5*bg8PXJ}cfQn|WT-?<~CrZ7mfgZABcuI$ByKnh;I70YYMaP6&aumy1b zVGp~)$cUOeBtQ{f*VF`3Btq=F0ZNijo0xefbmdBMn)#J9MrP%5`uNM)oi}5*K3GlT z2dIP3iWwUW5r&g56F}>kveI#bhZy?BR%XS3NaWba&#%K%B=8bLNkB6}{h&N4FOOy& z0BDzt0ZC%sYXl#QVodq&*1A5QW6!k;vRRA$D58e*l2YJxPxtPnPZbxBFP=Je+qQi> z=Iz^;zh^!M+nyRVeYyfK$ocb{FTbp2kWdjMFi9|HZ4gKd3Bm8z=5M}P0n*qPuE2`* z&*8N0CLsaULQw6f#rzIrnb7a9)hHXrU9&YsxKrH_7%Qh*l2?BKakcz#i27Zg7rfybfYXNbR{P{Ls+Xt{i#owW2LsB0-YO(!Y33 zf<_o)fgv?EXZgU0fK7sz=?@GPvO+cskf4pS9)oG4UeVp`I@2OWq~SfIjXI`aZyVMl zz_u61o!0>*pS-tj)C4TPwRGaT+2_Cg_S>KD9lYn{bnyJa9UiHN4!!h@QrU9wpp*ZR zBTajo_SQv2sKdj(hqgG==luVd#0-QOo2~M)`>_!F#5&5n|0m`^J_>IZC;KB{&MgDeaS^aNpgX#S2K|lwa}## zot%6+=6dYs*Oy$o{`b#6kG+2FG=A~P2cC)X8ni}OyuTsZlq8wrs+CNs&du%fDV8RK zx?%1w3KT)6V5Z_z-Q9bVi~SaNmG9fP&;7`eBipuY0d?cIQTN)36SK0uBuT>JX@dtz z2ok1e;5s2C2#G$Vwtju#1btY(ZdyhkI{GZVqNjxwG!YjGrM;NG1h=^^JY(-(#q{aZ zsj}I+b?48YpM9RD(>wU{%P%_~I`oX&jvWW@-Rs(#+1i6t0UPALG-1vNw5lo)Eg)lH zD@qhVhW7XLpfE;6K;z6ZIU%0E|FLr)f6O@fw-;X!EfgkBmJ=(2?cuxGpi3ObS&*RF z%(jb1ET<{~I)^9NASib{8NAc7n6ky-)Np(GCp~`SO*$?AC8q z=%Q=uYq9jidpZ#6j49Bo69C9SA-%^I2$CjRWi>tll21UUyiymDQP}FT_dPu%b~s_U z!kHj(bbRU1f|s7z5q1wDX>CJDrlG0z1u(jm`Rd%U--8dR-z&MBA6-22q;-3g&@&Ko<&N~5J5pgW4#5Ue324e{(za8 zI9Lb!fRby9BgdDOl@-T~eLE)R+W2At5->|<784|1Vm5-AvM(fTM5pHPVZ(PnapKx1 z*VbfLR0woLjujTD8z=dlC&45sUR+atrs(INcf7i9UwO?QKk$9#8=S&Fd^!Fqz?0zH8U*_g{MH87x}q?eP;Rpsj7Kmq1?Bp;g*cC)y-cRT)*N zeL$LIWP9wjU-`l@{ef0rd@`BDaskf|kv(+m=*g>IkZnn+AR#XJGQ$Q;jl#K*vNTGbv z8x^tcUL8sfoo!OL7k2<9d(qBhFVml<4h`NsecEg6_ZenJZFLZElz{E*>*(EEhG$otCsTU;G%QUK7L(I2qp}{s7 zaS^(1A|rJs$=I0UciusHRlH?OxxIbmuJZD!7&QTl*2qJen46GL&&H37qj?5~gxMr3 zP!F%~1Ic>dLS2q4VxVV3ToUtM_ll6PXX4~NK!)~#x~Xf5nD!pL>J$Ar;Mlso(>{6Q zy$MT~D#9K(=jhjMZZ39635Z)T+ejZFAi=@_a%AL^-Ws{Y)J=IggCvIX7TF`^xxSq| zz9z%LfuM@U$eWc}+5!`hXtfAQmi`7$7`3IQ0x6;1z47CFNfHK0u^&RxwQE<{DuAS> z1}W_g$(LWcvdLeE2nqN$Vi1k>+Auv#gDiY6pd>N$WKF0W+^sWPGSIeVYxFp6uc(Iz zpS^oOp&H~(R9p*n5VSXNfX-vz(l}pTrv<1YL_|M6iFFA_Gg2;Hx9#4{l<*neanG(xk(f`ri8SsB`ik_^j!)t|GJaPBLj^qloxMt22A@TFm z2^6wm+3Mn&EnBAU*|KE|<&%sZUo6A}CbCql86_oDMqH~M8YFU~V45$>Ib!YdX0Ce%D_5d=yTD4U3;o~8iz$6SoC=E;Gb zx}LhU&|=-}D@IZb^9-!0pc?&|UA>x7UM`jpsHsV&-x^FDC`Umu2_O->6U`PZkPB1X z8AuY>Wy>h}zO&P5?b4+(p0&TCS#vhF0@NvOUf_Vx|Th|qT<^zD(Y&TRYO%VwK{)$N6XO=7~sHQ9_T7ldXn z1xY|&yaL80vhqr1#55*Kh#>Gx0tUG|k4tm3TVde$22#kTgwBOSBo_kg+f$gIK|~@aR!|0?%e4K@zbV)1AD${$XadV1XxiH%5@i0Fvru zIBXPWamvc->{@boEt#zXBsBQSkIh&ci7Jh$8`ky523xR!pkv3!-01E`L}na5oZHw~ zqKU_R?PYg}6wH(#%)7xn0c^F)*ZbD4r@E1~LJvi)Z!M0y8B~f)VNi3J9sg z!G8z_9)uEQFS5ZD5ip!$UYm zbz6^u600*|vc6|b%O?h02pY#|e^W$Vo3PX*n5*F1U=*zFwZ|+qWq>BO3f z0u1ElFd@Pq0dSZgi7X!L7kT}Uw`MF|swx2}fV(U>)siJkQev|Z!fKkGexN3uFlyoi z!K#_SQd=g7^LPlG4Ri@Te`26b40h;4^d^K2_1)l(CUz*8BNU_GTgL`%IpcJDyrYl7 zl){b*v0R?qoo5rSDTaJE{Rck?n~SHHx9VVHg&h zrWYF1`gG&ychxnC&M#wzO~@rc;sQ5z7ayfG&^>l?UAYql@9B)yK8Kos9W~S;9Np~6 zIo)uACN}9`lxN?(D*M4NmQkBNeOgaX&uSeYWSZbi+~a6%^`wOpgl}h9SYV&@#VIn> zG$cq+lH{&ga(MCSYp8B!>cVFNBqUdKrmP={6|vFswJ*O^&2Y}eGgTuaKnSbn1IR2J zRFd#Rg9QB)gakWaJ`qqsi_`!K(`?|-&^jyu`$;SFl$)?Rf#?^v)d`vRQI66gJ3f?m z3A9Vca%bsSc0ellJ%ERIYAR0h8RG0Mgln*?;kjNLZXQ{sA7DXt82oNC7oD!Y1y*a!-o%JEgvkKjqlEYH_V)0$ zv7ujhu<>TiCL{#bz0)V?!}8M%EK`cVQvF|1OyCoXv-ZIS=z!m8x-3Z0HEp12h&y32 z1Ggw!ZnjkB!6b9xv&<5ciM0>5nl zZ*MPUl02YX%(4;feS3?4Y~ntAUz z__R~BXko_3rwDUtfR2cvB#5^$5zSBJLlhWe4J8RauwG(j$ewm}b-j~Nk_DmzAz89S ztP4hz{4$7lBlR%+yy7P&NNjAvywfKdxWK(`KgK|4&wJPnBSNB+Acl&D;%$3bw{R0K z)gd3R=pm7YR!U0|5-A9c5D$|1fjZq2<;L;d$`Ce0JuE~{1#$2hZ*FR(0VF;&0VIRO z2jq>7n-9)YOpuV=;3o4p1v+0zBbM1eSJ?9ImAp5crAVG6=pcf`g{r{mRiJ$oTrK!c z!S~9BEePv2HXh#Iz1i_VNNhHpv#~jM4z$dqNvkIz9^mHS^CTT49v(K{X^!$f6E%Xm zNic+@lORExWIXlQ_>C0@diohaLi~u4Sd=9MNivQE)I%aj66A!;lED(8<W89?Ciu( z2NIu>vIcH#g&;|E=IL0y#?e8-Q z=oL~*6iKOTBB6r)Hcdh>jeVJUI|VP_7eaH|r-p>_#x^R*8Q#Z5D0abfNo;0VbYWmi zNSFa6z!%(kL6TrerOD|iFPw1=Aqj+S0gkYcMwUh(K6twmSp*4|;n7QyzK~c_n?nnjmw71rc|e-9LDKLuxMg+bsj)MjLdyo6dWWc{0tyrMu=XhPz{@6-1y5f zOlHOK2v|5NLc_^iQb3f%4+#>X(S?&!cO=c2ZEY?JpT>!hlnMZ)V+oW}&_t8{r7m_1 zD+_KiXbuL6r?Z>AI~W<>{(OvIbuCV@{AjrPcD(mL=M1Qu+@%H`H`=Il3^ElS4-gCxuKOV|2p)D?M4mdt;fD5((R z@sWDbp|?%+kf2Q>xH*x({Gy#A`!YT&FAK#|o&hBB!-WKg2eCeD_+EepB1k@Yh22tv z3AB1a@`<2d1W0t0G))s@t0+5K>x6B{#$Mr+q9mCNcM87B@I`kElGTm=td>61|w*eZEuJ5SnP;A#W64wz zK=LsN5*8sD*Ry)HV3P!`4svih>~DocZB4 z|6b4H9US(FhTZH_&CNY+K`qRg19)5nFm9eWaqU{R*iL0t5vg0(=^ZSHG}iC#=l_51-Uh76GfVi-V@$5RiCG&26U3BaWc>hB#3KJG zSTiPL{D8%x0%Fy^5DAW0mATpmDBE$dRzN@n6$tAx>Qb3yZ3TwAEy+Nq9C zU3Asxth29HdKK5pT>YPO?)%9H;s@H!$9oI;c=9B~+`pW!``qV@Z*E>fwXne|vBN80 z#}c#DhVc6JhgCYdXGp16I{e@CT4uPu|JmDba{}HcI$*pFKi=`#XL$EBj>%`+-iF8U zIsg9ZzyJHTZQK6$`~Uv-w*P>GpS}I>|Na>qcpFZEt8HJt3m3Y<&QxM_;Pszzge6%l zQVkdp-+c2*>m{trirKWjf!bi!h7GMBee{Z6sRT)akbseEl*Ythqw&LsyUP{@1##yF zyqwW5&YLF%<_3@?mG*^dT%v6pk}v<`F(CO1j<8%XMlGObPMvzC6;PN( zJA7u%`saUTkZjmF>m!gRAWU9y%4Aj*e%SyLuwi3jVgQovki%I)A|xnDihnb2p2q1^ z`L${BgM{@(Yvzq=aA6-A0ZD=;=`gVzR)0v+_zEzqH^2%ac_FF72wDj!98h7`d9mse zyL~V=2@a{0D3M9kTJYgA*vdq3Ko~LbUjGB$xu&3d#_c?qbqjd_!wSc!GLh_*1x(9Xv4uC|a%X#3bk2Jz) z@i+LbRuCP}J%@6G;Mht3NZ)M0V!k6<>c$0gNf|s6Zs2-x@JnG8MvW#Thz(FUL14%h zqJ8Uck|+kACf+;m<<`rYJ9qj+GJ@H#b@6FD3C%~zFx-{}qvcTD<%`=-kN0@4mvBhd zuFVEWK$Beu#e+(1kdj1=!bBlMNWgGKND6S`n*s(+G;&Z5lb-|sI3oZFQdN+FhyWfL z^t>G4q(D3afono=no{w}91@IqPKrwk6|~s8k@QZeA~s17!t(_oQ5GTS;2e`s8!99# zqJ-Nzi%c*@P$}42L5Nhyk_BOa8V9;acpeM2i7jYT1$-%bQlvsrIA8^h!Z@`cm`Jh( zt~=ubA3!qpqgfvTB+t#FzC^SBb=JT7EZ3bor;Ny~s~h*yJ^Ot|0whLh8S(*;fYBN> z`o$OLX{6{X-B;cCD4`n80Lifp1c~1=@36YMG_M^S?K7kReNy8521q$qHjVN|LZ7g#lM~)VFbECRr}SE27H6<6>iJYD|cLx)vcZ$&dkoRUHRemme92OeEtO zim0&LifF#f6XzS4Ap);0s||!C(L`npJ_!h*_U3+1LTLm?X_co|UBp{kdq>W%DdVhu zU&{pe#-?F)fJ~|$!>z^mI-0GzLx=WZ>RNsMuQ9t1v;E$EcjC~nF!(s;jm9LTl@yzQ z@x?5SQ3;=nVn9glZEYoQ{N>4GnNxUWPEmHmGxLM0>9w>RI&|oh%N0k@yz$1ZTa#|x zx|KQ!*J|BvH#*bTak+5qR?szLn#c1ZN1~TKC`qEAU?g9~-$0c`a}AKFeUQka;sgUe z3Hwi5$lTFuy#oac9z{x%757S#%`d$0LRQwa?^f5vPw}0(^NJjV1O}~CPrBvCI#}}So5;agzGS(4yu6t+f*JFJkt9r* za7w6z7lTBNkich%W-SQM;%{P%3Qq~#T&|#*2|Xx5+{JbAkkZ8G8I6g)(|B4 z0w|ai{*dT6B;I5rFC@DayA6t{dWDYiKPW#f$qUJ(3|x_G3L9A6gezj33>k`WKXs!3 z-2_j<1>msSf!Yb<(LAjpBm?VM_p?dLUcmYT)0$fRAW4shpLoIqTuls1)U7^rYaLa# zz=2O7NW#LvjR8oC2@;SazZtzt>U25-SCa1|Nr)Kvq(=AUOwn_}E+uvGT(zuT{qg0? zpMMTy+-hoK`7PyqpmV_>88aRnUl!))as+P=?+9bS`G;3k5&%b?J5SEEV_Iu`?eyomRbGiz>zlUs9P`Z^6ignpVkh8CAh@ zJ8)D8(FTMhOp%<(a$8M4NEAXc;ejXLR@6r($A$VNNs(ZRlSM@8@)h@t2pv36Efgh& zVlO5X8_LLtTCj_SBAqF&zcS$ik6Q2#%7o~Mevo8kbx+G$Htp8xx?$pfI~~hE>f{JDnh8)qVk;`$0m(ean4j z_3C({gi3I(K6L2v<%&+!Eg(1=Cr!FFDK-@l0Wf0A&z(D$nhKN@q~3Ddsk~7;@iCsH z2#xk;4~mk(c{fr~kl7UU{YU{OZ*$@pbWjA~#^r=LMeGu``#x zaXNtyH8W1w3sSy?ib)cng-a3{`&IhhN`QAOlksQw^Ld$?QQxP1fm+6&?DxuQ-+#?m zJJ6H(Q5l^Y__|?POoM!fmdG#?AL;24{r=-HR@Z&k%^*Q3f+}Zo)=-cnPIx&D8wvD- zStLr(Hd5c;co-xvAG+LvMkz?_GcUh0zI?zJ z>e8h?1_?cv@-DdcrK}8+D1W)?(uT-^Dg(*}Jjw=xB&++D7ZRXEH-T&tf`qvob*nSq z;EL*i)~Pk9HsPlu5oG^~!j{L53Ib}d>92@{P`486-#GAlYzq9pkXjHm&3 z{HPzW4~R>WtXs7Cn_QaoY5~6~>G52Wptg-~8F9u7$qNKY*>A~kwPMgf3m=HnNUT`2 zB;}-j3la~6WK!%cj60EH0h^T3fEwl8xx?j*i^EKul&6-XU6PcPl$+n!*mtA7nOEgR z<$`6yu~RU!Tp!*!>rp;UOjyIzDXa74W0%w8eS|#aM~DcD$P0dE!-lO+t2_3~Qz`J- zs4QAd0{R?GK#3;LpP>ot4>v?e-tdFOBrwm036uDA%ob~jCrC)_fE9z6pl)))FxEt| z04Ii7^K)u*4T(ia za@T#G3u7Kq0zZv6{2`&X1LQEF2%+CWL!uPb4PDD*Mx|Pcv9tR^LbuoW9T?|@1hvkw z*7F~nI_0!Vtx}^AV=Dc@iq zp{3sdX8+yA45o#T5HLV#hgZb zmLZ8jQYg#Ns++X3aLR#HD6~-tO^QNHt;c5=qcCY2&MFlOEi!m*c)db}EL?~S#}|!i z0(hgsDG@(EB*eg87rfyn3obos(JdFfn-EUhFl-XaD^jh36jI9O-++--HN498Sd{1K`L@{Lr`jX z2krVm@p3M;e3E;-9mPjG)_`UX&UoJa^#OQ>wjjlGwcb(hQ}L z5h5t!w2D%hE;czInLLw8A z^YKR^@YKenB2z|FeNzN~MwmjE5i2NSlZDuDeWXy45t$zuqKFlWaA$_Wlq7)K$)E+t zd{a~MZbfualc3NFNfA-lyw)p8e({TG-5Xk`@S?pYea(~+nNz5W5v{I)aA`TTI^@%7 z)67>ZDpI*&QdWlQhGIYPj~!}BpWr=VoCpbiZY`~+{2*bzw#*Nb427ap5sR~{4})X7aSyq`)ri3M&?Sar zdNMHpQ(g~H;FD>CRuY4RcIF7UuYz7R={82jl*#-V6?kSiTLG}(li(iw9ZXjd6gnj? z35T*6t09`d`0nsp3%-dsChxfZAV@Mtpw5{h^dBZk_Tg#ftG1)D1t3Y_ zNo8f=-QSbA)%K7khd>A|zm<$`mLNaV<`3)hcn3E-4?%%pB$-i93`THugOC_%DJ4Kr zWT2J(evm{7!fw7Q7Z(+tL(4h01%ZP2>^$}(Q@yD|ISg-6zwgY~@Qz_H zmF%0#`%#bVNBfjy!!Z0JVL`#n%mbHRW=p>xe1Osf6LsM;OAm~n04J+I_&}vWzXVQ5~!Pj^%I=f{pA z8lS{Q@0@ag`b1NJ4J1k3>WfFsW^;pU`C8lOP2EhApy5i81g2;XFdhgA*d*ZMqWB0o z$G0BiV5SMWJ(RCg2II()BV}c?XUAQ;cCF&*Q3p2PldzWd5_SpZYP$q0Ld&ru-yqbD zns2F)sZ>sM%m5Ngj7Iyx2gmmNW}Heb(ULfRHUJ5L(fabsFQdvi)7sj~AeoYxHX(qM z2`$IYpR!tMOOp~UdX|sHH};bxF-FoHHJMPpgh%@zVIFFPK@o*IC^uc!yJ5PbU~y#-jn1j!9<#S%A-IQpDaCD)6<15NSPLM`*!hi3W{TkGXAe z3Rwlcf}#-rJiRVjF!c&`2D~ijps*}T0GP%gIS+6EqEmJfB&@0sK(ck~+N!E5+UZ?& zF^5CaP3lHwR5_nOl1Susw;Rk1f+W_@_Mpf~DpCS?ASo3U1WD2EqCWy8u1+XFEN;4$U-%2>t^tOriuRc^S0L zr8BLUu?Yh_kU1qY-j5SpE^T!>t++Q@rc$bue0}`3|2ud{jXk#DnCQ!Yz0cF4^#OPN zo*_niy$?O`Z}&eGmqm;J(|(ba)nwkDy=Tv{WSM{}ms-uQK6c^au|1o%Z{I^3Y_EeP zx!PI4q9kRMDqwt4NXEGBP2J}XGucs&na6OWsi`S8X@NmM+@1;RwDB0of{vZ`A5dzDQ*7Jc+pz(#EY`lb#W ztRFy7E}^=)OqLv_ZA}^B4XmL3+Vaa^;?7ubaa2~NjIH1fzB6dPAUwE|kxAG88M=o& z;}J*XGNx|eDyO6*d+XNYNebP^A0OMZ=i`q*{^a7tlP6DBHI$UFt&`W6msC}C78GQm z;ff1r%U70#O%79Aa3Us@j>4VdiS-RZL1 z(JXCdkg#U2;~8!J|HdF8Q5)4tOkh=F{9LV2UAeNK2hAo-NawpeMld@K9lv;=v;dt_ z-7=wNbsdTqCV^2951ZhlWcBI~R8px03`niG%%Ab#T@jBn?#-e9VXA=2ge)c(fRxTE zfaD?&ZmOx7GiT2`?|gE+tE;oK)8@it+}yE`opgGpqN zq0Evx3(oO0n$Ec7!%x--MBsc8t@^W%) z2oD$rgJG8eB?(;QR2CKOj*H7l&CSivH8iqSJ<>N~Q%2su)1MH@V@MK=o2x0A%%}iV z^q(IU=Qw@>YaN-%5s9B522P&#i=K&MW&Z>s1zU?vU>u<*9DnQ^t5K#_8}%}-ZWN}0 zatQw#hb$D+Rf!RBff16fT17@>XI$mg-rimtSd2|vl7PM`DQVc0z1C}!ENvS)GAsOO~J=V{Roo{)a&)G3w4qLIqP z6mjY8A7e&;gb|xe^F3`^)_321_wn|dTdUBYw#EJ0cCEJPTJ&ofIZf`9W-3kukWeMe ztF{6bOxxT>aT56UJ?yVM01|8^?YIOe4}X5|;lg zzvopYkD+d;2EI{7Ir2t})M!03j_Vo5fPRNBZf`E20l-FF{wLw(u#Y% zjJ_R7sk#U6`~GVf%COKZ>LrXlrvZ{xuK-1*sqESMoh+!8KBb*L+4FBaD`fl84W>g>~ znA=KuM^6fgj1{ny=2#mh7XYCY$M>gcRcj5<;BnXKSAyH7-POJ45)HdQKiL|uGfrQyJneier)%yVw zX+KC5zF3CUsxq)lFufqlkBr29`4iv$vJD3{iJ;3Y-{{Wj?)K{keVA{GdV%Z*IPhur zG&olO_WQv@M-ELk7!nMp3|GJvh>}VZ*!~7R)*7NXtku6Vl|rUc6%_?fgujceJeZr3 zwfTjfNE1MkxfPxFyge6dR)KT#$?=*>gyd%Sg$q?zui|dolB>@=69$m{13EWLgK6#N z$y{K`82b(Pt)^T;#K5!-T<;PgA*Y87lzAMI=4KD;p$6V>Gu?V(NMu}+U_jntk?NiL zLj*}WOS(#nAB?8)ANwavNE1cL{{1JNPWAoOvs9~Pu@hNDRG1F;T916U#}5(KcooNH z2FbLn7ie<}PbQt#Jxy%)J1vU?bNDb|a(H*xq@?iha6`Dk5Prqb6kAx>UDn+egZqh` zR!kOyuZfmg6UkKg24yO%mP5k11Vnak+xF_vkt0{1pK<|r1J>-hdi;3h@!sCb%2mBp z+p|w!IDc%;o6oEQmD9Us=*Zn5NQf?6yU8(n{r<;=Wc=Aaw>#DlFm@pyefjyj=Ixrt z{2qWODJcY;E!?)pn*ZWHtntl13?#lATCL3b$}3C~h}-lY6A>ms(!}TQzpU5eX7c+O z`WA~Kffn?lOto0ogwur+wF3;y#_CunJD>zAyFF}8^=8@CJj+=#5?C} z9s`o}30#sOByFxEhU5CP~1Zy%7M3PnfV6 z$vi`@2+1`O5-gO2lH}fK>*GO!7x)#z#8#u#xo;oMFW*@5n7T%c!-DmSuK?5?N^x3w z)vbYsI!aoKma72Y#P`4avTZ8Jk&X_rT@}ulIF`}()MuJ7kur@Zr~@AB)~(xB7!wl{ z&IU@6@bJQLpyj8AU1hUp7cW{gdUi~V#-d@BWRz0iLaGEvq-rX-Ar;llGJ<5;jver> zhK7Q=nQ{PiV(7;g7x&hDvT7CRnyRV`7cQLtx1Bp%X3P+)lDxZgDe0TGwxP5NtbP(m zu$fjnN|Jf~AR+4&bxnR34ztS*kUoM|3M&8QqmDy%ZKlhv2p(Vr&v5bJ$+D) z@4y4>680+9-<+~qRL1+*BwCoE)L7i>5Ipql9X)M`2SVN2cS=or=K`Vq~7b>kInkN@F9454%VM>(t5WOUO~0$bIG49$S*A zaj!1sv7`H8F@8R79C@(uJO};>$J0-9vu6JXA0Q<6`BLfiDoa$YLXo>=+qRxB=AscY z1pmS4z`lS}IVMwI7v0jOAkI;wb4J#EJsqV7jD)E0aD57xA}L-_0FnII&d$4cdhZmJ z&0eu^;plhQtpnTD=~T#!RE`DrEUT=fZ;VZ(+C zEHDD*$Z0IM_tAz8b%ze|N=Lz8ZYCY|2L{O#2Gb-G+z)|}?An#jV(=`?ii>-=ev^L% z8DYgFyn~+PJM!d^DEuJN8$YL+-9Le>kpcGA1dfNE@bpvZ9FoQloEF*rB(L77vS4;$ zQ7}N#;}s!uhafB{Nqjvumx++D@f|?Y{pqLc{&D(GV`2(p53olw344yl^yYDz8QtgwZFQUFdNY?ovL0d$Ourf%-2S5VPV&z~x zV?6x86GB3QL`}*DJ}KiTPq8eJdjs+J=$?lX!Ul)r%o$8jGh(qL8I=~0DU@nf_)+VW z8N;Kav0zOxhz-D^0~F5OxgbT_xW1Xntdgk=6A~wFWu#`niHQLm0Ev`Sr%pw&f%+yU zW;z(I|9Rx@-8*;g?1k~+htEHMHzT90xOmj4MZ;rKK#(LPh~-((h=sQWI!8%1Ne_TY zWVY>?IC1FPZ@)V9rI!xuM3Y2aGi%m!|N5{0I_tUTu(;mN=Vtx$EKoO@X={d3E56_! zjx>hlbHYG{S)L3MurL6UTt7&B!;qVQrSB}ICE~iCw{>_s%SPk*tv>)HGRlKC8dccT zMTBI+JvQs(S|~iX;PPcH%!rXyC?S_ht3^?-wpg^<@bLPPBPSYU0zuJ1#_HU;b5ZLI z5ycAYyviI7pyM!nwF(QFjsb}g&hdyr@jje3B!iXDFrQAAy-G zjc4uce24FNF^`pkt}N$ypjUkiNR$MLis~co8+RW_9$~-uz~gBV5~BtSn5twP653bq zg#*v_20ce}p*_S?Oj z5`g5xJ4Xs;FCa*Efw9aWk@+A|pj{#@`aQ-;5ECQ?APFW&UOJG8d(<;7XJ#HdMn%B@ zl9m=;v8ArAnn5zNhik_+f<%p3c~2rq0w7_QYd*$bY3!P3=<7RsmX&u#Nci3wzO@D| z*B=lPENZ6E8jTleS|<#~vw1Xp4z=i|91?E8Ekec)P&32@z%m@H z))gy;h_a*uqiQ&DS%=rHD@5~yhF%{Pm7vF4g?Irb34D^}sAKm23hCI(AOT9AM@e$0 zv;4ibj)g%Bi@R}08vN&_Dkbjo$MU3Da#BW+P@JTVBE3`J9y&5K^xuaLoiX{?SllgK z+EQKp*8Fkf#zp3Z<`vm4@2^hBGJAEyjwQbT{=}IJc5s$oZ~I9wL85vRn?#QO3WMaQ z6oub~0eM3{UjYUm_=?*-UXCV-$HNO>wKq5Oasm>nF>xO^c+l!bEi+oFz1n3q>rWDB z9e7k%pHgGJ6DtO-_+Qpz=|q@X6eFQ;ckB?_+7OQ+bCHaWjv+MQ3gPH!1N-#TufJY5 z9fU>#2n@ZxFd<5R3d~fvmtr6~CLtZ)-a#%te4fS$CPKvVtIp1{w)cvIMvv}^iIHm2 zG*V(o1tlx+YNcJQxmx@QL85v>NrIHv-A%FcnA3|R zcOJ##DNl{`&z1bfvka1Z7#LWJJccA;0at7;r$7D_<*NE1Su?<`dkJ_LBxt|BEYoVK z;E$3)Vgz?nqm{(%TCngg zNap45`bP?)VY(vbwdV3v0fPZt9Iqq^++Fj-K!RJBIV5VMo_jX~&GfjZ_V3?6XU?2- z`Zwpz{SQQ^KP2PEy`iyaRpMT0CC0(6DOQ!Hq9Pbv%pHhG$5a+SgMY(Ud@;4H=exFU zv`=F+nsCrcQ3;xakPx&$$jc=m!lGn%0FUP%Hc$cW?Y&c8RkD(EV4v|Ts7UHY-x6GJ7S=h4WcJ+h_Efc^-p+$_< z07({;BB-c1Bx`l>PDA_!ed9uJMW-|IdOvY%e{lC zn!SOCPIP9J&Bop$9Uap(PAA&ypaQJ`iBzjp%hXnt_L^6c3|TRE0gsWH4jp2$8e6>|>)BRdq7giA8H?yJn?(6TKw`JMQS z!fAB-!e$RqGmim@Ldm@w))?&aQv-y}=4{R0gk$^m?U-`T(T=FNsp+YyrN?S#nk<$wr40%Oyro7s!sdFNq_JUwFuL4tyv7w1rEo!Wdu z=+NNc`W0lZcB}v&<~tN2yJBde4ul6q*Q2N%20)@GNMgYN>AG{`&bPl3F*xzO4-(?# zL#A9l!tW`7mr@FXqQHXwV7p9UzSS}4#~tG^sVO39Wu8#*b50&^2=zU zM4SB+0FpQN10=Qe^{+8V&UAN!SF;SWq}pDeI+ZW*0VEG$pZ6c(oPDEr12-<7ABAs!4;VljH4!SM)YKp6c#p-njv{{f(sF*Z1#%d!{>db$lm8a6a#7O zdhfSKj)b)p7h_-N7>(450TOg;WKy+CsX&{=im3uUJu5Ke3*v3)$dNC>nEw@ zC%C@p@hvTH)zs8fx1e~Lfa->)&%I9KghTRVHVKy`O-)VZxw*Rx`BzAUa7aLofR{rF z1NO7ye_TiusBM&Ljh<{0KS)-8eCYxr0*rvV+4QGBk+Rve>C%nw&k`hOZ+wrCY+AD9 z^yxkKqOnH2G4A7w6qdL8L86U9=XYD;Y)lj?+%-J`S78Vez=4+Sm`Rer!y7PT`RR>g=%DkRjQ&k34cU&(=(SG zt+oY2Um{4J8OIxxvmPcCiw8;4^47k6`{olk1PN*z;$%HRl0%R@i6p_W>6o)O+yxvG zu4f1m)Hb^e~+LJ+|#F!&og4t%#>$xO>-!*gg>?tY9rm^Yt^3y=cpZ@fx z)7fOhe*eoG2njA5e7_uY4?qGJ7f#Q)uK|1Vq!H`X<65iAh!y-)7E4lca&p+bdDEv; zl%3XY!wbO*Nl8I8;C>7vLoY7N#Apf&!|r++AzJ*b5ud#Z4}2IPUDzOOFrKymM9C=3 zV$@QuyiCT#39aQg$tLNU${|^^s@H5bS6!V$l`NFH3A{x`I`7ialHSrn@wE8Wx0=|} z-ZHjg{ex`IlAx_IzMUk=u3fp}9vjp!2F!xqMVZisZ_bh=`LQ5jDgWpPW8v1;r$l|T ze-G%Hl9H|2OwXJ?4Z7w}gh=-3?Z3S7%RYjn?*`BT2f;nw4wlOHJ@33TFeER(EJI0x z*?dN=S_`TrJS9Be5S|boj#da-r>9cFF=Yr|_M20Mcq@ug0>cs&<-`jxUc<`4ukk7v zy5;ZNFnt4vFu8%W_#h$E_0FC0**!g@!NY0OXe<;e!BPr9i%cz3IlR3o|74~r z*s83&0EXmukqV-Gfk$*}1`i20Trsf&n>@X-pE0t3|5|Kvj~&dtV>w=IzjyHNst?&WyxL5b2 zXpN-r$)>6sCE43ie4OTS64%X}=8IJqt6p}WWuoK;K(d`lQS=p?Bx-?3aO3kZVs?}&d(1l8g=^#G4P_58r=o0-Q`Ig%wAAU$C z3x_19Z1!)0K$H{~N&ymu2nqIsBXu)0xPzRVo}NGSpvv94RfHt`P1XsCq({2QNII?Y zwY+i0KN*+VBnrP~LXRy;#>nmN&Q5@27fV^3$JTHRefZPZ*NADZ?c?v8Ui3pr5^U9j zMG{+QFiEoK+3sj~GRKYqNov$OF`PEI3(gh`U+>K5C=I%A{Y43SzoN3?A(K0?Wn~K%E)2rZywgg1<((>{it6!d zY3=6y9?WN%+R@V!2fp1_goG8>N~JK#gmjS+R6WQD-flV5iW`TsxFlifMyY-xNbnew zBuzQx=g$2nuGJW55!lezn2&V09cS&72<;hElw|Odguba*9Pyj#r=G%C+8lrb#YhQ$ zk4}TpaT?^wp5&UQ#?H>;SFd(nX-aKmf&}9v_V;6cfQmq9bvC=}0RHgkRgJd{J zlHG9?%kh7{c5w|eNp`1uAt62{@LpPEleD(_?F-7<%p$H&sBR>f#*F)cbFg?ghD6Y_ z0Xq8n-00ER?Ysh~e2irLj|+*C*(B0$-U6FsKSHv$WGg`e+GZ05Nx&A_ll*N{wYZb@N~gy2S)AGzaAC^K5UOTa96!qp8x5?hwh1Ck`D zr(>Q%W|V0}NQ@j345s1QP0#M#ooKc$Ub|SwUO6(|*LDCSCFx|4FiBE(AL zy>=^?BPAGWU5=9E!q!!>v0=$I`#R4YwOxbvdgYrwe6Q&HqT55HEC-bX&d<%&_ohkj zKZQjYckRkZDlClnv8zt#MDJIOvy#?fcfc2FDl2PSSR6F^%im-mBvK1PV&sshivEa@ zkl~7uY{g<%A|yh59gC8HvPq|gjq%*mnE;Sn#>Q${ynxo`A4c6EB=YfRZ=@n5`F&u3 zxEs&9?RIa?c>k>wgJ5J(kl^YC2IXaH-<_PCckv?mKuFD;{=%f?kTWK0>7pGA%0i~k z8?ejK4>_7PGB!>y;X$nU1?@2(ddH69prD^^i;1yd-!mn+z)~gUlPHVCVA|B4ifdKd z%_UV`UA@dCkqPMtM@tI=($a#NjBky_c-kk&FCQ@xD)xm2niDtV6GOd zdh6oNt5?Uq^;XqU>{5K|1AyfFO;`$WIAtrUJR-Ed&YOl%a8Q@p*U#N&wkU> z18P>O0x!oZr9F&lf@B4Qv-0)}&fP^q95h1zx zR%d6%s+!M_eu9u(JbKIB7~6!9IJU1^jF12{jh$ycSqmo2X#!BdA{ z);*ev{f6aWy3Uh8BIl5dx8s89_-1>vy}j8-iP!gyjMqaI~*$3a3{QSmAfJGxH$Qw5r_KY2SeC*hB zod%<1`}Sjj@sgKssQ{AEJH9Ln$rtB7@isxC-QA>6Bv~?YL!{BU(xO}}6c70921pEG zyrlZGVJO0;NvXRn3R!+?ky5rhDpd$$XJo`7Bw@_8&i$4HL42?UzZ2dZBwFO#43PY6 zVdAzzXA0P4R;N=VJ!87q)-Ag-Dq$DWA>fMy_9Y zeExZ_pF`T`?%ndTvK`>xEZp|@v$am8Ql>>nP~WJfeC=lLT!h3H{rlf{w6*b$e7QTY zXGmFC7+vB|SXc(!3(LsJC@VXRa^zFqWSkqWPaJV2X);EvgT_>he2jm&0D9VZ`QX-o z2f1NfVdPO)jni2@fgs_^CVOj@&DK>>(fPUUCKw|%v9Y-!Sd=)|U`Wu!gojh60EpvH zj$gf6vV8l^&o38E`s5RkJ6pG(#=wdnBySm=7EM-G(3i!V%Xf>uO`=Q(kR&x>H3#?RZjKn(I5OYcaTSH@yHD(ph40M9M!8Mi- zeFx)dJqs~w{>67S7)4V%ol4B#SMwq^+`IYt-JTWT4cGHGkr7um8}P`;q5d*ubTcEP zpn&SW6CxZEZjidhb8gj;GUxal*k`7Bkge@VMSJGujeU*B!13f4oP;&RB8=c%v7RPd=$?Snj%b(U$bdCpXa<0!X$ZBx2#{eMYAi zAQ@F$yfk%pp$Lg0JTk)&7LFZoFh(D#V34Rwb;-AxO_HbBqVPe2t#M=oNmQJymK{@b zNU#N8B(_8e!wFTIo@d4g&wu5v@bgTN{Oa2iK1jA<>s~cNVx{1`^ct5WLx!~V?Cv^< zJJ>~&Bzp6a*`QSlGJbo6Lvkc64BO76rj{2lNV=K25$lsEe-KClxd@!jfhhWcA;DeZ z3f#P{ks41q=S)aXpW~GzTT5)_xY=Q|!@54dbo0%3a#(|}-2D72DKS8arO|!k#?en| zYPvc*kACvjs*;;GKe<(bW%_ZkCwu#Luf7@g)ET4ElF;2f>dWG?@-VNu0nq@Ggc_SA z`#}m$!k|$LN537S((8>%trnxs7*wRNJV}zNJv}`uR;>8K3rQ$8AIcy}0$fl-&3tO7 znVXawav054@^1WGVA_%Y$dC*;{Q65gk7tFL<;o(w?CFSJFla)5GU~}`6uH@v@fWYaxb*uE|O^mI8_w1L2 zbOk;ueRucIiWg>;dz(}MBu2piQ=OC?014QxaU2qvU{Ev}ypZJPDKc)$qEnHUdQrNB z;3Klo5LsxXOo-CbiLwYDT=nT2|IGQlxOKej;KGHYf`a}&Sz}dUrYkNTVodQGdN&;% z!-otX($Uc~wPVE>ZKA0ygdGXX!5(*IW!)hm>*i6bL>%*S=dC-;R1L4Xv~)9N%l`n7 z{6&WU`%_{)0fYo8(d!STr^nCP1Nx?_ilXv1TiopTW`|W)R(-s$H-s3;Ps+#$iw%!b zY6+4qgap1#jh&sVZdTpAm^!KSCiz3)8Ljm>I3LJVYGZfzKNS~e6_m&FKc0cVQHtgYC+$c%}Sre;}<)F-n3#DeSvS?Ej zJi9iT=0qkiEKZ05l0f-Tgd~U{k#b0sEbvS=Ne3<7bab>0>F8+_O%eu489-8y zks1;*Zynh2tOx77b@SF?t+r3SrQ4Rav9SFA1CS`#22X+nB+17U01^-*RV4_?)~Zh1 z&q0#J_4Y2F(OCgDYyPDC{IG4?BBS$@P=R;me#G$-?&& zFiSwKq?XPa4XK+BwiOxoo_2J2wT(gtt}l8vAWf+A47JvzPMe2epaV>0{Wv5;|DSn><&vZz$foXW~3 ztb`B}lApA0-MUGWR$aYzt?TC2Kb@|kFv}jk&+Brl9xKbQTeq;dxUDSd(X#}U!sD*; zL4+-lwHTk-q$$Puh(gOI#krc!BT)b&=y)J^cjj*b<>htqDtwiQ0R6>Ji6Y_M%+ z!Qqf~huP?6za&NI7c04fJ;Nb+=zIN312NDDc!LOuinXqlr645C113mHs*c(!!a6%` zH>5ShTIDg1@RZ8SIg;G75?mP`TK{pK?e(Wl=QV$di&>SFmoL|4%?dyOS_sUY3$V zl7z3^l%OQ3AV`jyZvrI$c`oE!Zh864nTZAG!ooB$7DL5xfaJ=RdFACzxnF;M7$5;( z=gmC;$<3QglCbtC3=%y_lBH$5Limq62$BP6v>Piok|fC)EF^-&)I89nIUF@~ zWgq-}o4_v;B<789)#Wig1|&+ULPe4U%X1iwXR7x#t3*fM~@!;yz29dH*apg z@XRw|u^>r8LXty6>x*K~#e|19c7ATV1(sVzXsE6h#0)%IT2-|c)26d2`7w>{2At9O zfhb8p-IVVVJ1C-|DIM&zJ1s`FLPd~ZW?C>fH?;S3$Pj;RlMx1vFOJxA=dddIv~C_4feUIw&T5%w(PmGC zq;s&4$OU=nfRko-kpJr#kf4V`BJs!*@zuNJ#~%X{kR&RV6{|tXWLBf`n~&%02S_j+ z&(cY5(!l*$SFh&fZ_5VVPOE!x}uv^+sXaS zuDaTrcblg#o06mBn(|N0n+K5elo@!SU189Pkob-Jex|n{`eFOOitdEJx(VFf$F!o<6o2#Q#Pcr#guixe>Isz?+P+4mVlXRxg6%zV}k<#Ne##on;9N%cS&6B z0#e3^Q2+q|07*naR1+%=@*0WI?q~-|(eB^_Uq}+_!81aE7q}ZCVUk3A!r&wc7Uz^| z86+yB{^XoFYxi)IB)bG`i|o_5%X8D|(>J$Yee=yvIw#%AjZMuzg;|!3H_o0p(;J(V zTl=c6{O7gxN%L}ZJ6FxQP*r8C0%?*c#18n8=#u~hLHoWk_$>oP+10>Bq#`U<5tYax zNmN9!dNFWMCZk8=6fEU2e>Yp!QQYUneUJ>~`92?@aBz`t!AgMS-TG*)6&nz;ilJQH z3?V0Y?$oKtq6;n)Sp7q)BD0RrU=|4zCI|_WBuhm|!Uk)&a!BMgf=34e#YSI#xs7ZR zc`sZwgu=tk4Uz`CPK2aXBG?^vFjhSH3Undy)HK(4@C*}!L?_R~2fFwZbc2UPi;_g4 z)<#8H`>GI;wQS3c-=3T7KY=v4d9!L&Z%ysK(xMzp#Krv-4HqkObKygs`C9V6{B`qk z-S50pV*9+JYb*G`YiopS5BzWt5{$9x!0Jei$Y*i~Ac6U>WjBcvcob>6%_d6LbekY~ z$Oo@uf}~$$UNmD_uq204UH>lV#do)9lx(Y~luHtT1R0^Se%?PN6F_X{?xKxR`MG41 zkQAZinr;yiG)dYxBsq^MNkG9!lI`Y(qjqx_O>u<7Q47XJgx&5zYD{vIM}%ZdEeM9Z zc2mF{JIoS+BuS#(%pmbe5_-a*AW;w`8nsa&(^@PlCm5b<#my85$!Xf2m%ZsvxPx!| zrtJ+4=FZN}TLj4s7&ot0R5XQ#PTaD)C@Cp7chWP@9IdcbblPla*L?h@5cz;jjwDHF z2__P(*do>vT&IZ5?*~aFA;EG5ZihwPR$Q|@0wjR~#CPLE@&1V;1sP?F7K|FT@ZEO{ zv8Abs7H?Q)S_f_NL{6sqx)=+*4beO>zs`NS?o-YP>#f7AR=%Nv>Ldj}hIhjUlF(q6 z%Uw)5xLExnm)I#>?(!|;(5>;VelOr~v^(gj4efN2T<#IieWVqjdmvFsHO2uTp;UQP zHP{t78z4EoebXgZgRApQXOj<-#n%9m&j6C$A?wzK+yY3h**dQgBwJTMz5gj)X!yV% zjTaKaAUaB+)-f_fNPrL(mn6xByyJAT8b!)({i8$DuhNm9%X6Z$oIw)w8A5{Ffw4rV zk{0;T|HZ<3Q#*Vn2|)sge2tKV&}tqFu@WO$-P0%yT7=~BTwpeAd55)JOl zQff6CXUf&y#UdpH$!Wef3kAyd?CqN_T$pq9qWR=W_t_6VxN+nA?>B89TT@w3P+vM} zQc_Y#NY3QRHCg;t0Qr7p2e ziA@ngI8!&6GmxKgUr2am8=mO8H(eSb~s{*pb)Fv1O1+>6NDMsky?E2~S>Hj#56wWlC-8%J)CxGP7xZHc65%31B zG8rb@pwXs<(YTm1Qo<~f)07-S0_9J**|X}IXTmZvCgmsPPiky*JFYvHEZ?+g&)By* zC*_9x=ck_*jJ>+&s?8P$l7#x8vP5}j^6ddLS!Mcs9;U)9Tf+nU!Wg)xq>qw?KXjWu zU*Pk3yZ+ZcZ}>#)xw1d>Ed0B_TRA!_!RiF(#;Vd{do@}GrbwESA9Gv^ch(reXrP8@RW&wydBaHrG&?-;{dG?Q&J^Sv3c&*_xWt(yr3V$g$uyA3Zud z&UP2GmgZn#`Ej2+rP5^Kz6sAi%8-fb#!uV$xx|c?Z;u@5E-NbrQ4;hAjnhgti3*F@ z1i#CIJmHieO`E6Nu0k=n*01`z)0vP^0kRP`@(4xh=4u@&r^X~h=10hjR*9aB1kjC1@&Z7*H zwW8IEx&{lAu(AQ$Z$5J^uAsXh1iK*S=H_(mJDwa_R1{rXT2ob3wfN(Ys{o~&-~xBr z?jmP%K#o*bf8ZoBr8Ol!G?DLz8-h=eP#{e-M)=YVyLb0)EapRlBw0rp>oaLlO2K@bN-7wV0iD7<9|J@4mZy=8|54y+QRc-t5+;R8P7CAgKtG_G_9w z&?7)V{jE;#}4p$C|U1E26?AWWse{7Ug$}2I5X0ODj5DW4K zcm;{8LDI}JmDcb|{xhaY6Po;cxWj|7x; zWvKMtpVm5Xc_M|w%r$V+Byj-@o>0lgz$pc1NPZk4 zk$1^$o?eGzCLFAkG`qU&4x5V}mqbWh4)(xfLxPL|Bvoj*uEhx^NphO+@fFLsRy`Be znbFjggpkZLgygWj1;1sGoW_z_;4vRPYO|TmV7Q_rsea`Z-28;y5H&Fg(ZYTG;U9QJ za7b7(^oQu(a3LZV?>xaEDdUi6G#GML8>w?v@QM|ShOm z%yYc7mwrf+NVvM`a@lMG6Bx~|UWp*_2o3nEsEP6#9#fJid0jaSHLAb^zRI#mxZz4} z4T+J{w1#tWY!jw zl_s?!B%0ZyBK{nC0^nV5)hwE5> zNNNC*jS{(yK?0X~?Jl4LAhE+ECdpBW$KkTONPkcxM(Swel_X=j8YFT%V?k~*c?5|> z=aR@bl8kD9Y)GhB7%O(9QuSRG6XmIT&FO5A4yUQ|#GY}JpBX!LY)#ng*z_IJsN_xY%P(80`?QnOY zMq|{!^71REzHw?SQGI96-gvp`4RnE*VP8qiR$38E3w(;fcsFu@MAB;umDs?d@Knl8 zw&RirGcMYiO-D^|vqnC%(k}16_7VxtB%4H1BQbTEISVx)gKA0}?7hbk62Y9;^_Y-Q zM-kk5BUKxnPWM$%Hz)%{NW7!!op)xGmR_4Zdv@9E*++Q1fU<9LIzf<>Rg4|Gor@me z>Sjqv$=0nG&!nWN!oxLKO4#bOXf)FAMg=YW{hxsni%AqDEQ+=_psc44lD&6gWBLA@ zb?e}}VpOw;Yw#j&lML~X>h5Xl)=7=VD6J7bGiOSl+r53$lJPe#U3%jUP&ez> zqv1Mt#X)p|!L=DooJ1~{cqD$CV%Ux=e$zvDx#YNKh|lspqlVw*O$ofW9tRR9ZIcE_ zR8|fNt0zFyeSwG6s@{2Xa%E}Jdjv^Ym>4j?Jt&=Fvn#@`jjh3|;-@!J{Qd&wwQXH% zb~9`<8RzN^WAq@S?kxYryhcj1<4}~`NP-e za8w>0>baO9wo^^fqf_-V39 z;ANcHdmh-pbrF?H%_Pa}g2;hBsUL8dUh_kQ`!as<5nnB}=lA~V?%jgf2N(Vm_&19Z zuwNwzJq8I&gpTlk-P=49fO1C;fBp48{^Qr{nvS9;w|z;oXS`(0n2*kX_j&hJilxn6 zu_%~9@;4uG^@BvoA=&DMWa|ZzC%Tx(7sNHTuZLPyF};lI7bfW>GUH)F*-0bf^wZvm3F9sdN7 z1O+AFt_q`!%3)EQ1nky;VkjmiMVOD%J#XFDyLJI2N6lb>Eg?n#lGe+cm$J^+i&k(* zemHd#kOh68Y}fV%JkNg5=}!g;<;vp#C3|%--*rP>)?##H(B{dQxVfCp$+Nem>)t>N|BFt#@D|N)( z8?JA#K6F`6(85vR2Cvg#!!;|5xY91qAszMpkVIy6GfbxOM6~XvrZX2WUb?w_({(Ij zCXsx<;XvyflyWq8$Uz2)TK2$&%Rxbci9=odw!CY=Q_M&0I>}7-VC4@93GYMa>|-9V zIQFoybq^3iuwd);wHNjvC1kVQyt($`o>eAOEpQT@H}>iUvFPh*+;;;uNs2;&MGG(| z5FybRLjaQZ%64ZI6g1`7Y*%f)y+=D?V1(9ow5hZ6sM%~jnv;`b?mP+)R5Ue-lOIdJ zvHTVeaJ>Kc$3I4wmX_Am*8Vq)+W*F@=c$Z16D3|2yvx5Ia%z10a88^6H?6oBHwCxF z#Ax*3hM~GS*f9jPO?`lkolJXbI3_?y>Pfd_)A{q4F8%VC4UX@>AK%>kr=7rJg?6jb+1Pk>Evq}R zc=6&rdlv6W+vB^$i^co~U_)*)5dj8DO$|^|Id;Z=pUaGpn4L<6OpBfqNfMdV7&7Yb z7WQOh%)>6NZuj-;4KBCa-REW_E~z};PF{^o5+QH5Vd873haNV|O=I%p8(H3}heU`; z9wG0NhgLce9G63)^US0`zPa6Q_8i9-8zdx3aTkNq>273+0-$pib1E1X0LtPty#29P zxS)7pYUkp`nwpxpu*%AscgFRHM5QoljabSQATfd@nM9D3B?b-YFQPTVao z>!7NxJA9A?A6$WkYk*0j2p1utvH{&q1#YZUwsYtC1IGZ8o0o1L+cRa#&JC@zzeDF{ z2-+k$gNH&${6R0={OKoClhnBXjopz7dZiOwvMAC-ifn;RnO1xf)F zhe;BF$%~bh2nhhu3(q=^OMH|DU8xfi2M37?TjI*p7@l`_b}lA9_=sP;cn%D@%`R81 zf{Two{+NrCJs0+@-Fl&_>f+e3Gr=i-X3m_OqPC$zTAfZM*2tl@-Iy6@G!x~Jg!ET-h53azjq80uh z6^Dct`Lfzjl6X90zCV9pL~Cp7#bd{goj-PL!@vFCf4lVEcWszKy@J^!8qJ_w;D$;M zOuB7+C>bA)W{Kcv_H>y&a@=J@lEkBv$SYBjG}|1_a>3CcsgaxWFuaN*6wff>jy<_h z$yNs2;UI@Z4v-u-6D@;)M5zTl6jrNRsdPHcHj$5a5RN(h#yju4L)V-bu6FhyCRJB! zKB>8Q^CnA)Jx$(C)mE2N3Ez4xR{o%l@2GBq5R%65!kBO>ZR}1(b+dfQ_2tVQeeOmV z$T9b%Si@QOb^DDQw@#gMg0>=)#tVs>UQwm8l$Vz?J;MbFGIBz+NBmRenSUet!lLpK zRnLjN$0G>IIOmlP9cmW2 zO_GO_M4qQRDv>7wKsH*?(Ft8(xauUO5e=1+cGN4Ox(10&?vo@E-4@TiR6Gb074~4o zmZt%bpy(hP;NLrh2NCiP-XZw{XQYYd2}06a^T{U+5-v$l-MCcL-ySP}U;{UVB#1#0 zm5@M?+(1aq0wma?t>I5G9@k*4Oir(tSqCTtgO4@yVaS;j$Jr^;lP3Ot(iNY`{&jje;7U&D8X!buu1TH z_~?+xZ4aNnKg$S!#EJzpoKEZ<)7QI-iHyY}5+WIV!12YTbhu<8rNq3SJs20EP>K(d zwQky4>$F-GYOR{e~wK zSSKl34B2WeQXeF0qY8W3OLICyyf(>y1TqrHieG@$OOJolwKsS6>^6+1z4+ofjUwC- z9gQ{9VAS_($P?j(gmt0lF5BF;IV|V$G5C+~Id%celGUrvZ)p9)j-VAiZL??h1P_gi zqn3FONuv2n12NE`G(9jQDWem`ArPX~TAh8XI3ywg;w@3KFgo}xP75yxteDVaECfgvbQh%R^(iTReapd%zTVK#*LZ7^+vRdy>FWdU#_ck@ z`p%xcdFlJ_FPyz`N}7>*8*1oQ>=_TuxiJorwV zev*cra^grvMj6^9L8BuDQ&DtjG#jPSfpe+W0XV;pj!rh+7H;1Le*;b|#gj|fGfGQK z>+xz|z4rz17+e-53Xu;e*YuYLVxU2gs0k9ImF#($LTj{YuhgvaAwoi9j#q9l!_{|l zu}=lfVOj@$9q^60!T|+xb#0>-Egh#4d|w6TBN&aR0FvT@g4Bel6p$p#7jIp=#IYQ_ z8Zb{>uKbj6cSD1_v(pTaT>Ab`f4Xqv`%}gkfW*llv06DKpc<_NNf%c*K1lo+5q+EI znak^Y%wHklZzmchqehLY7Yz3=Y5>F1l#!a0AI>7Ek5DbZe?*1$FQ4!Tkobi&28yqG zD*Yew+&B2~a9?IXNQ_3UOs3UZ(B;r#2W5rK>U4WG4Nm_4IijNBa%HioX81J<5U!Nw zc>Ns|yjxktw6$v+jqvJPf&^0ojS6EpcsIpm2uT#Glm>^x-rx?O1SW{x?#4bpZuiM& z#(vxPLEq`~2+5687Jx)c6^Jxg)?21VNbr`_U?@Lg?)8tM^_LR?E53gD(EbCS{q5b< z)Uuw13lo3T)oEEl=%69-TYL!(c%Zr2?{O1{D@QmB=3-Q9 zoB+4gXf;j`KXSxOjXk~Ah-jFIF?l~0ybF5+1YPgO#?Icn@ZBG~N>`HUJ`ea$PN_+d zH0we`C8k7^JVFwYDEJ_8nDQifi7tt4iz!hO5o!bf*H#lM4>c1Y9s$m6(CO@nAUn)? zm~rI6lMoWKDMB6!PH^u`d4%ba1dBqiH{!Z4riw{rp!5@P22z}zKC@M{Q+=`p0f~=K z7e$L#;CO>5>?)0$CRo97?KiZO0vjRXDlj(SwO|fdSy@3iND`78ZimaApKHIK4Q8&Z zug~?)J8MQxjsUmDm3{j3O}G100zqO0NU+%`h$f9iD@~BeoJNi2NbICLdr$B}B>mi* zKt%kbXM5Qe96$5+M0t7H(j7m3!dy}6z{maOMvj$7LM8H0i9@ncu9FC20W5?>khtUx z@KBz_-t54_G=ij5a$Ihb*ifT*wn!Y!ASrAO?MFQ|63jSqu=rc0$0TVtv#eS3czNhO zL<}rRXcL77Au&o5Fl7uOF$ai^Iqw9B5sa9m)zt+sa!{q=NKWj1o=Fa$2w@lf#E4jX(I-p%OWXh?Z9j6yHyo<_{0+ak@#OU$ZI8g( z5`qnvV+64PRw(_cJwtm93>!0+4NH}hGjZd0&5KoHWE|~4U&h~!je#&M4ONx)ffy#p{AFD zgNMQh4$a$GIhHIEQOSsU1}u&Ew9FASGSkwArKN#RVUI5M*)Q+-J39o))wL;L8>54* zz-TFM*_T;|4_{cEm6Z{mf-bPDWb4-D;PhT;XuwG8$-cg`4u{Ki(%pFFioxJ?!bwpC zNmP_Yqt|QU2fzkY5>#4jF`PPyLE>e>&wF9=!cVC9GegpZZM4Ag?VUU2^?#PV$^(<= zH#cBpcs7pjHE)!ZRyLSz@}rXGcHDKtJd_%<#Ff{MNdy}u8_kvNHcx}clJ|a}VlP7X+9yaAE+t>x>Xb>fQY%2B=8&jV!-xOV!mO-< zD1yYzA^E1^Izr+)OOTw*>BL5%r&6N&5E2k~77IXY5tdGOz0dHLPF{u;&4bD~1`i!*y!y;LtN6lR{Ng=8#*`6L zrc4 zgCqe_(wE}4FE6nJ7T>th8E$L@CJf;*2~jaohzCLv4z5>1j0G=2o}>UH0104%vLzv* z@W_$7{>5p~5)qg5p69ZHD;~zn2{CiPo3VzH1RfM2!NNEdNwI=Lrb`km)c!!hE0>!> zL`YJ@6viS&lE5AibZ}$0CA>+e)9XM4g$n}KPtgj(ZAF+6VN@iC3tq405h3|27_!>r zi9_!ZBce2UX~sJ&fI4Ez2oNF2$CRBrH*DCsbHp$lX>gS`Z1w63NC`Gpe&-&I12lhBnfdeCkF-$cZ0Zk*Z^?M^I{- z3M{X<*XOyM@NV1NyO$MmB_OCaH1~x3P!S<9B?)R>M7|XuoDphNTv`SV8a3|BjV$aUAVBFgvsK?_X?85i&rf+6C?_iO3jL& zPy*aifTXRh%#eVqH;wKqSf4K?W_ma}F$sDLs-ct=eN+sJ5++NS03lhT1u%?onm&Os zk`Q+{_YMn`h%PPDCF1;lC>pXSp7$;X@8uQK{6)!s@4cgA^A)x`Pk}}U+N(OIZgfoD zh;?ISSQAoOWM~q76@(;?AgNGT;$-zrO-&q<3^YHF&`{g4wGQPglE{m8p>n@YB#N?~*4{UMflzhh5U(7-(L9a7gYa zMEF><`p|({vt|J#v*-sQ8OCME2#lwJwE~wHPTxdGO4br4ED$?KjGj!o<H9X-Fz#gJ7B95{ZpUQg|VGoVEWS1d`yPBZGq}w1&SCrqvrn zZ8Hlf**OIjOj;U1l7@y!UD~kB5%Foqj$LTL{Szhr<||(rY;3e@F>6^%Z6JXX%)`i< zwlJt;#cz|M!hK@Hl8{0%5i~;(5++Ir5&oce^q=|_&-*~`lW_&LLH z`_A2OzYWM95f=gR_P5`Dd*|-m&eYsV`3A%En5gN~!y^Wqz8`u#T#}ewo;*pOT`oAN z>quoogCGYDwrY!a7gS85*Jn=!8ocMjIMM$=6@g5ilPA{sN10+vClEj0l${-=TB%UA{cI?9TY%omxAYto1t9nyXlu|V% z3X!_OI0-<~jgWLBBq%X}3#T(G9B_!CzzA6;vvQuD$DpL|mZ(Jcts6B$h*h`PcwS6hQJ zOB1)~bfG#>Ho;_`ymXm~5k9y{B3iC+5g(t1>%y6+ZnC%HQlBVE@ZYMVPN#}81+2Ik znC(iJ$+{002OV7WLTotZ3gBdiqcuVfZw#Y@Y?YVH)0?cLmOPl&eD@Xbf%eC@m3Qvua5~^`gUZ5?F3K-_d7W?0WcNw?=s%(|_>Bzq zgr-_-L958G#h86ql)@N>&a*7T?9Vh|=qw=oXV0VbK#rh0K#9`MuwI6P~@x zcWWJvvoP-P47EFV?sk@!=jP{vjZ9A`D>(|;qd%($g~K6116Jl&N{)kjZ`ZY)oY?$aLrNcV;dFv}p@1D2!Fp{94a2&1hYyztzKNIBtEgjwApjDC_reRw zZGT7%Lb$@B3sDPUz(u4&D2x+i{ULd*i0fZw^n+yN$YA_^b<5i`6JJYy?X|aqnTIpK z^#GS7sBKVw#HW!x0*nAE07+f-nwP49oYh+|1V92euU=Iul`{WI!jvsw{rYPW5 zeKf>yBt-dv5Rv<%_lD`g8X@x(ZcR9S!7XBq9QIaOwb#43(>oYmBb7%&9w;E!rfcY*sZk;vQoaXM|c(QJKeG^Khr! z3pprBVwf`Vi46Z6A{Xq6dqVsQxY3hYVzC&G962I-xO^F}_s-ge=Ii58-?-hhH7W*7 zRB(ojpk^=^57k;YSUrV>U+11HD=2H*QCwW?l_WBSOs7ypDB~2^!b{C12^>yTM29Q% z$>FK_MLZxcCXD2v5fXvNqJ@mxBx7WPAOi9Kin<9NIq_AUZf4|byUW7D>O;AE(~33; z*{%n6W-`YYqa<}BL}$3gl#x+7E9__DgN@+Hml5fX))eUBt zP+KOQEP1zqTO(pp2}zPj9bTAX@u3hwCPbQ8LW#^TujFqO5|9}qF@Z67i|&1}NH`=U zNyZ@`Ox^4}FoG}IumwI$Pa9S@tR=LdpmbbIdVGA{>OBFFm;n+cYemH%p)KE9kR-cM zl5{tPpAsP<*B2@AlPMe>7E4Qr5+OlMEKX7zDFlg8A0Ag;&LP?R9{|a>-*(-(V|D-} zXBi|+&u|aPqCp251j;-^NJvxncO4yz5E7&$5E9TRLbwc@0s2FN(+v*@vbb70D8^F> zk|qIdjyMGtMmGT@2DOe^F#dMT-z+5H*#rkq+!FeBWPN>DK}K0LlO!X@u~;ib)CiI^ z5+7nfEk3huTxofEfoa_B{gmLC=F6|Qh2ySWQIcT&Pl80F(V!#=3VNXl<0Q-`5y^-V z!y@dsSB@}0gh>;UB~ei6sI0t zDHw(;N#|0#+y2nAptyM9%29yFs8K6d1_ix%I}j4=%B4sKNuu+Eq$xuY8>XmDltm!MMsAfl!evmMDJz; zMdoL1*g0hiVZm77k&^h9mfIQS<>lA5Y*|xXorbZtIc)Xj>eWW4k_}2)lqtL#M^ji> zJZfQaSxz|SoKZl{Yn3EK`K*uxZ!AQ#Li7}r$GCh9g%JDZ1$w*qQ z!7GZ9%uK9}j*bf}Dw@e%;6nt-teqQX?HoaidSH5RPSC@tYiXIEnhKO`OWd+%&5XKX zBhupI7r(P=RaGM}V$pa@iXbG+8I-D}(_=bXjoto5bRkCl=9GwfOVG z5{{xMj31>>jg1Y-&84)ZsHo}S4kT=LpzxWdOeduoo5~C?xF9HKVOhp012;xkMl1UbkR*gg3d6$(iIW9Nyc{7U|Cyg_ zm`;$yAS7=4bx<}WM_{Cc7tUL^t~;x3^T7qh^)`fLH$k%Ue}49}|MQ#Qyi1V8Xmo=` z;c>FMYT&pFz8 zO6%0hv|6m_D5IkCGNl3=m>aQ>O$-I0FtPL@TdTD)oYXZ2@*d`Ho@Y%r)Mk1 zQQ=XBoUjKkL3Vdq)SVm!G}(VzdhmOq%rFi=$r* zdiL4jp9Kd8XJjNujYgIA&#-~-QG#h4lB0Hy#4MqHCi0^mN0$qW1{^)^sFd)7g5#*I zvQ}afx+IQ`aJ05P&s9@-Twc>9k#yx%O3Z?-p;pq~+uJUwanuZ4^7RoQ89H$y*dh~O z-LhrN`#KOL+ah0s5vkJ!d+kSQ(2}jJqS^egl6aw^4+OG*|jp^KQ91prA~n8831@&t5Dk(F>CE<}i!&`PU(WZ&Y#FHg<9|qHDM7 z?8ieTx=^!OunVCM!JZsC-h|tTL6QhAmmn8v9KwC7M?VyjkwC~x2+6BDgygf01j)9y zx!D>#j;-$PiP2l5*Vqm$q32h8Q>PDaY!tr%4KR!iBHkT#2m!p zWB>`*DGUv-OhGufI$^lzMT?d!RvyB~6Jl^jPE?BChLDi^6B9EXAaMW(<2fWtu7e~2 zNWL5$2uVR37RQ@9ap+JJK%&=MRZeD;$ON4b`hW_~;R9D5hur8ipwc%D>bX3+zYL80F;v(xxuqp7{@Ae(tX3?@i`B2xYU~xtM2U<;(n00ruUuhnjdvB#KlVzVjlbfF zq9tPzJ;aip@4CR{o6gQ~@Op4PcY2Ja&wT^jU$R;mB&2y}$NgsI&ql4>(c{J%7k2wu zLsEWO+vaWXzid*$J5*RzDjl0eolIfS4Lrjca6CNY&jE=E_xturYUJ2pks#^ikjQN{ ztm`63k{U_rae%|DlQ;yBC=$4lh>++i$be_Wn|>U%d^OA-7xFG0R~B0Cg3rQnXnj>pFFt&#QG!$8*MVOo%%pS5B z4D(_`Qr%#PaQ7FK4VH9VPRb{2M^8sj&KozbZ}K!Z(~-uaqM<{RUyG3`2okPtXcm*B zWV;g$irt7rhN37bloI8Ol7-!|;TiRjT7@#XUZDunm!@hXiv|VBqpBP1jI~kHY>Hq< zs0gd1p$jERvx(|+f+VR0Nis&)E(e#}F-9OrNRo63LJjb-1=J1P>;gz6y1_$YoX8~z zj`!ilmRG@g#kg9qSB{J`wa(f(YXeI=B7+1Bkvf)jgyw7fu(}!Z!%|ZVV#`B9nu>~Q zW8a&t+p^_$bzR-C)vI52TCFgzQndyfB4LF#Y_EnXj2aD=uv( z#o1E$ZQDUZSA+_C7YVtNsu@|ju0fvmpj~N`zD2j zf&1G$W=u1R7j%uUT^qWksX&T#A+dUjsBYjQHK{075voX3gkeZcNa9mlprbXt@JN}U zHAE_s6LXD%B9=lSVNE|2Bs4sd@vMv{Pb!fIq@u|sV!=+i*b+@n9v4S z;|I+MKr(U*Q1a^guj+IpN5FQSI5K#sKP2-JlARn9LSz_&gxwy2kj%)51xN~FLz<44 zCYSplNvk`fw`vIz6eKb%&ZbmJwFF5*4?>cWpTyD?83YMDK0@NcCqP6(#48JK%hF>Q z4z8S(@2ZK(D4JK7(mWn45;s9|og~R}v_dB3a7c&}JBSin*U&Ag_(0#*p{53uw?LQkG+4=$>Tus*Dz$SlD&$4 z4dMYp#E%X>-g-;SINHF%tq2K^x293rQQC|d73Js7m6w;5)klOz#-2Mj6U>~+)qqLe z>N6=RR;^Qyb+)h`8(-_gVvi_E7WQN$C9(7&&>DWbD8z`oPxFYoJb{m>6h0`&1QSyY z`MCwxA|n$MBez9vOiVN-);K_y+yFu1MuP+aS)N@|QnGxx+t8Tb>2Nm#C1lM4Htxon z%BUz%ieO(Wl}bN#6Nd42{cdfBu0j^p50VT#CDddx;ZBKsx&fo`QJbg#?Lea1GLh2( zUU2Zp0rudGTyyL)1xRL*+3HJv=2zqhS63fDckWz9oXG?)H4{8xaG!M(x7?n;A2_*m z>6Fvy#J0-VT#dy`a1}VgvYFJ)B!VP`(uh)gScsN~Hzv>Z5N;AqiSkC)3g;Q}o5GI7 z)z`lUghWQZ8;P9cVWGcpo)@BV##eSOWi$#t3W!&<-jz-gt@L~0Tx zN{X$;BxGT2y@J?Sk|eZfmm+#H7N0O-R*6Uo+iC&7)93B_`rL23%ZiFhzumZT=C*A! zXKs8g5rqldtf^^WRx5cnSc;sCl7%TT z3~HUY1r$#3$opW@50V2TeCf}$iEji^Gor2dayB zM?d%gJMc+08qzncM>QC(2+5AJ*boZK>-D0~%bZ?ILclT&j&K&PM|=R1UGwIZcW0GF z7eyy;j6^aL;R+#vQ8Tu|Znt}5ButcSZy-n--EK@C06H8<3%JG{67hS-ap_6iJyuY=G|}u=4(sKl@TY~l)^&G(_lH0H zq4+m1{^qm4-6tyi(UJkBBfa zNX&vw(nTG}+l2^+#3eYu>8%vefNjr;^G(K_h+M5zWDCD?M& z+?FR7JmcXGF2Bfa9#{Kuxuh#u&T9>rU7k`n3qvPnxddC-C&FDb_0KX%YCM9xp*c_T zXhk{uL2`dYI3(|~J>s->lgS~87abcWNz&?810)d<)vH58U(yL%gozV%vuDS~mZwhY zB}mfZ<1zTEm7?LQP;2}kK}pihyc@J!Q&Ri_WeEYfBp6anxiSeLnLYdWUltdC`QnQ& z{%q9f(SQHf5}fY_hoA$oAfQ<3%998YAQS{LRJu%+?Y$B?DkL`Vpl)1t8?|M$M^q+LH=8Y< z+Qb?-!E69t4FFZ4n5cpJ4(Bj8UWD=E~pvX6DRo8@C}IAXL8m&4L9LyK`{aw+|ul3X<*1 zx4Te|pdi^=k`2EN4lY9am@G+AS=jD=5hQN8o>fCTV6Gp%F9zzCskCuiRxxpW_(@irBfCPsL7~Qxk{zg zuY)Ns?rv%d4-e<^A|}R}LXlK7Q^UzVowo}EFz@yBpoUqvaug_Q z%1oOFd+s&3;B3~Su|cp!NE~Bql3Gb(XhTg+Z>^&XU!YwcTKNdwI|l{H$dQM5(jt!Y z8>R%1!Pfb_TgEBHB-BJvmsht;d|#N2Jy|x!{* zcv#LURylwfB`HXW1*C_;0Oo0TTU%R4@ry5xUI<*gNLi>W86b;b{O;LjhYuN2T)bdM z+ZR(;z!*Mv$dIWnv&%uz4~n&-|62l#EC*e4!|igF;7(L*=Y>s3*Mbde=T?ami$kI$ zQU5uN5@Fz+wFgbs{kD6`<=(>1%{KAO0Z%S%w?9S|f(Jn|5+NZW!ZpqmZiw77MvNdx zhK-nP+VT>qn~7Vt%s$th8k<9q#Di5**K+6sBPJVpB?&+>dQ{ND-{$0mb4X~7CdFy7 zIHL%Xq>ye*RPHDq{o+C#D@Tj@sH1}x1_30`GDtv#bO0e=tiUGE0Ex?GClSFRA%kT3 z@)FnC4}J-dY+YVLkgP>aN|uu!Op-(;B}mlDii{tf5yO32s}Ft(CH_D>#M6~GI38nT z@dF?kIkdWZ!vViCSO>htjYMg}WyuJZh?EvTV)A5EH4|x-Fd5f{b8?s@p|sdmY#U%i zNkY0`Yh1Sw^A~e6qL>7s$|O-S(|7Hf7gAm@yQgOdD3})kil9+JL8CEMc@*lGpl6>A zdUp8m;m`gK1PM?we9;hsqhsojxkH8z?`ga4aM0-MDeX4F(Ax zsBgAzWxcVtmY5qGQ+SY1rj+U)HMah^OsZCAu>sZ7M{N&Y``UN(LMk>X4gi}jO?Xj!ODJiG}(fb1bODg=hlo;>(`hRI41{x25B)GbjN*nDI zU0|=>n&yLq%M$Tm#AGl?UY&^U&8wkJAt6moO*0rIBZk$*uXgH<3baY2C`ka4dBtG4 zmX(#Uq{S3~WL_>n^4?~UAz+8R$S5ICW+m>30V|bZvd9a`vx`lLb&W2+9`0bTl@$oIx^- zXE}cJjSJl%>ozO2NhdfPP{21_JQx5Jt%&Mhn66?C;=FCPz@Xd^Mz} zr_(W}c|4`ai!qYz%S)(htlMQKKC(;vl?@Gdic&@0p;%KwY|A4v?5;IMgbIQw)bzlg znFIXZ^CJkMm`q?YB^Ny~;lyulJf<#N`^*}%q{h=_Gs$(w8*Gw>ygZ#GqSWQ+ven8% zYwYGq#*BHRqqeJ79?`W$9_o_YD#6LIyCi}n)Y02jD+#T%HQP3}=b;cXx69!bj(17S zl0-@EBh~l3pCp-a?3ieY?A$15|GI3c|A3R0 zE#161cxX-zP&k;rz~HKwYfy63!i1XacDdQ+5#WAT#x<3RIN*ikf>DJYXHfLo~i5CzyA6%ns7ev>-kN>_4W#8kKk!| z9)lz-Og%VA#y3dhdAPNz25^~)4NYvgOrtY{i|=Tb3pnF5&1OjU>FnKW^qr%$*r zn*{Tis$1%2R8*WRIzFRL+zdJbA(8Q%4P56lCV+Q?+Z$dS4U%N#=+VGO#~;31x2v%1 zZ7`hQ4(-{zlzn&G+Avf`#wkIu=-J`K#qXYFzVM>o;q~w4PVK1(YiPEk(Mrii%a?3g zf{;+C)zwfUnyt(rsq!itH@RK7cTA~LIdPw%68peurCgHCT~BXg>N0pc>z6W7v3?nV zkj21Qwv1#6U1c$P@FYNl!L)fZb{L2Mw{)Oro z8bCs4ceR^MAUcjRNz#rxbmWN$Nhk$g&A4X=56h3sBkV4@x!FOag~}afPlTk@v*qz2 z8F~AV2#08p;8kWkIl#P}zt_DeiP2Mh%H^^OPx!mTU;_`A#Pil~u&Fy9&!Na!c+2L93JAKS z;0UiEahVI;BPvPM9CGp?>>Sb9y( zEe1(EZM@)+P()2Zki<|g?_##@-}Z+rfFwo=lmH}&i6Bef|8i*?P6T{sMMzkLglQfS zDg7X6>pA(xrZHk731G6x50VC4+5>we+Z#_KM1YpQKJ37wvT6Ym+KkH74Toe!4+jLL z8q**?vx7k*>KVGXj9Vs5h>+>>lQvX0vOz-fh+}XYH=9j^{sZ?yGJpPMu^9!46KZb* zmzlWFMie6tkR*bD+6F5N)J>jzeB6xH1PSfG=m&|@nXu!_-@I77qi6Hs?s>SKAGelk zz)RL@wMn_jDAl%Y>ml(?h9Y=5&+-^6c)w)0qJM+7?6VXq=~xkW^5hZ^E$cQf@g@m0 zxZI760LgZ*F(SrVucAeA^;SxX44aHbl9Axk02%-6E41hxQ>Kg%JsLkB*z4oK zWxQyUy!z^^Yu2=2n6;$^x8C3r;~6ApPFj6yp9qOjufdu}ShNU+N(~2$YNOVOb?9X& zDYkc>d1ma`vBzyTTPKW)-Eq5j^z|ZT{^$d)?uK zWIM&tN*d7lU7o$1Tdiw(Kpw1CC+;e=ShOlyoR%_5&=n!W_5HRslpu3akbyK|kTBgs zdWXyp@^LsM%g7$d@|ms6mT`3>Q#>@4{x1#0K*JxBkuS|(jjBe3WG4^FW8ihl6t9vA z6eipn;Rm02W(`JM*SwUDo5}0uRHxPPlCSYzb)&#NP#7pl(Ho5kBt=pP5hw1&)ymk$ zVZBAkAbDq1O{Eu-irqbakbL#*aBj+?Xqh{F$d31Nu3wjf`+LLTgQS79jf;XL%e~f! zFOY_iSTzh1R;&w)AP^*06{?#aQa5vv5Dp1fB3Xn4>J||a#KY_0OeIH|&TQk7MEMw! zBrwE!?=r7{Jk0;xh|q|3mN+1JH2d`7kc=F88w}P12M#R?s?nv_Eh^AMM1^>$O_IMXS{-jLwvt zoK>r+7bx16Xh@i=s*c(||NPqS-M`U*;@gUWG>2)sn5bBemC3Q+{_kj94sJ@ zTWuOJBh7)4*5zJGyy|AH`Bb0NqSZ*FEGn`{6lyRpDddWq`Isb`N|2B&@nZxn5M+YM zlch|s@JE=*>NRf}Br^3NA;Fk>JIflLtEy;BPx64Ycz>yp09) z!7U0fZ65;|5t5hIRG)9%;42=mQ#4wcFT9h5)&oYoXq3eJpCD<(y7yX*Mr&2F zZORHMx;Z$cEaD1~pfNIJsuvOxBjoh5NSZIoO2!K6oAvx2vs*SV#W;!DsM0=cImmx< z1jlhnm)RTvo~yanktfl?{XFna%#yqsdjtkdFwT+K)sQHub#!@-J9P30kIBwB8q?*l zx7+M_u26@$lI_W<1fbw)64N02pKwSfA3AiN%E!+VmwcJ=>g|;^j23A6sT&@0^&LrT zsU~&vRyF3Buvk3Vw4x+AV^yPxD3y{lF{-sVD`0-8WLP5FD3xk0N|gl*NL!sLwysr+ zy@ar=kFA(@Sc1PaZvMQdr)}=s^&FD6iVC+JAdxp;$3zkU1@qAw91aKE%SPXKIgh20 zwxJg!2pR-HYiBs5_?Uv4wL51W=W#U)htLH%^T%7#Q=w`p|`yhcYlMrndxe1z#Mu( z5+Tpy1js8L4v)=lmYBSfL?=Jq+#qqaKPDvO4jp1f$Se$?ou?FmS$@$pZ1I}uZ;W^= zxr!I;NOcQ9vPB?B(ikLcPkB5=ToDqGBedpa_tAaMgF4uB+^8?B-T zOfSA1AwfEov@)%7VkKe@iPWoZU~o#N&ZU4FQz#@tFfu}rh(-uLzFq{08@8lwK!I5Y z1BuDg(2lidBs#$}6SN7YGDnge$dky;s9LaA$uppFT%cGuBsC%=pl&?2W|zd{=;e?c zb+xxYE+pWK_IQl&!4tRh@iVs#?1 z;*Qa()gmMZL6l6LJD0^s+PLw`rr)b-e9<*A>NZu3qyZyY@4W|*h(!JB8kL4WV{3=C&ptH`k2WXtsH3TspaqAi~yUP>N zP}ya-p(%pvc{+z67wm&;?x@1Gyw&IXMMXqJd}#t=xK&)M;gH0q1;*C^5{jfzog3a1 zmIm1;b)UD=Zcp$s0TQW|CIu&loK9xE!sOrv9ko^EyxO}s01`?S02Hrr0{3?b#ah|Q-f|ai_r&2DbA34%BW&>(C5g+`r@^KfN~M+;BUTbG zV3YtP;2H1U4eF++1J#W;H1B7;E(;jz#lXmVF?`SOwe|F%B+;@?KaUKFq}{`lL_BDz zqUgXXDlImG#Xu*UCi()S$nOJ4 zxYbHueNr|hB}~3Pg{)`0N-WixBaBomvgrvGf*fQ~@{mfXUhB$R(jSM3vC#|(r zZ-q}DApsQ78URa#8jdSqW)KrBzz6fC(KuBpt9pH|4VNU@ln;_!lFe?Gm^(Xj3Ni`` zx(mu)09n#~B&V_Q#uC0md^-*_Te0Ntb?j&2a8N|;!p%K2)>bvTQ>0|Es#KK1&#JkB z9gQjx(AA)K({XSGS*$#q=8Kgq3(zutnug3=b`Fcsf(slxI}F{p9}yDIkJVwzc=97z#F~_uCT4BD;X;SPMkP&>@y8iYhu&# zhLRFsq=6*Kb;or(WvhLkoxS+Y>iy~IbL!HL9lO+b%Bhs8jT{p4%;AkNNZ@U%DJ)+f zy#Pl?&w_&;J30>TIJl!@$H9XKd)R3Eg5SU+xN3kW(E0SN1$gF;-|q+x4x5c@Q$Hdk zKiZJ7zG>nnJ#U~SP?lthR%$#Ci}+v>i~iCkzF~EB07=AZwnuoz{Q3L#C6Aro(!xC9 zw7S-dr;IYC)MCLER;LnW2g?|gc`*T*f^|$ZDyMsu=-h}l34ww(3CWS=XkC+eoGwu=urL`KgjL{;Dcqxo)i-5MemEs%L4-RU6RMB7VxM;!DR(SNcx#0qUnkq zZYY!%?{j|Byi&xwc!TkfmO10LPy>Py!|JNXCfC-#_FD4TH|N)({7K79Z<(_%g~B9g z=R1)I{9!h$j3*HoDO3Swq^oz;VqY-LJJ4<=7kD{9ve+9wT{Uy&#^mVw(zvij_j1~_ zN07K0-1cTqb9?*ur%z|50UIzTJUwB;g!mC7rcBxJ(MPZ7*@iKo1ph3kJ0sSGL}1i1 zm8GcY0i`(xHAYs1(LT~aKw_&oE@?KoB;W~4%qHwN-&G^&N<<^nVe*(IlA5mLaz`Qt zJrZr9U6|bZ7)8M!4U&77d^ss%umo3t#gY>u7lAfxnwZOol4MOaKoXx`H@~L7{4>mfT zsHKcjrN+>3o#zNpvQhJrC1bw-{`C3tlnw)ofGC-O(LI1k)vD&Z8 z<-oNZPlVizna$%v<;N+T*(QmQdt4i_zx0m)$$<^rvGE!tew%;UIN z0Z7K(zKz8u;#=yf5t5A?>ucuc)zziNkI2LXla~MzEG4eBYNJSuz;{@UUNCnKG5^&n z16$H*wXNzeNwS&giorDUZL$}OkCap)BncQ81K-)L1SQO!ZC+pK=3w7&k=KmU0_bnU+Vt5?$#TdIc+t&a}J8Bl30 z;CdQqAxEl}lB~ytKfpwV)}zyDqt!isyS0P@C1{Y+`VB}D@p#GBK9!Y{$*@ptU!RL7 z2@oXTdpxI4AInV31VRv!bksIL$&@Kmo_p@OmrtECV(}#{_M%0j#AsAVHEO9*A=7Gc zTBX#kM=iy^wT$cg3^i#|jOUBh1F0DlhUJV}BW{+LJ-lI#-`r5}G!JVP$#D(lC_!Rw z_e5a33P~Pv0YCnbgnF8P6iIS#5?Vi z&zF#r(9n#Sgcu;h5R#D*S05QUbK*qNKAeda!7Wm)Go?2$ChzlsSvgklaG2c+cg<$A zQz2(5cV0m;rS=V8uow(%sXr1b-;lA+9Q+Zq$gSYg4FVE2SoLpy?MILV zOI&$ul6w#T;KR6Kr#Jnqe<+Qs9kz9kL2#e?Bwq2-l0Gh-LsDG>g5=k`uf-PBChx0$ zlU9M>B1nb?KynQrF}<`!gd{O4N@}qvt$j{fxmg?_N!TK8HXB>L<}6TBlAqZtNm?dK zlGayVIb}2gB(xbw&D9Nx5-IKpX0r@302dJ0JSx=)k&3z~;P9V!nGY73ulO}tD6AXu z4++ViYZy25kCEI9iAcdP+CCHCUzYfC<#Dm*DXx*`wA9oCB(=4(fBsr>{rs_{ZVnyl z3Kqjn_lqa!ZX3X2k@oeiTD*#{-E8&OHv~xuOL||sm2#W6R^4(taqB3Fb(RvMaylDn zUuX9JJ-zcIG_DvV{W8(~WC}f8mzK_@PIYzZYp=al ziygSY$r+oM&TNw74-Gm6kK8SlTAXh8s(aN9+g8O>)3Qa!7;ZE+I!QyYxj`);)i_g9 zF#Y+$l$|@DBMTfL$;4#^4oP}i8d|O&UAly2x->>Li4qYJHHir(GnBOQsNnhtxnYy7 zBvur>Tim@DehX70RXo(C`(+f?HA7Pob}O18>URzDXJSJg!E0_h$%ZcBnk~E8Y7QlsF@(q zYRM^A0&!e!pr3n>yill_ajNioK>V(Z`j-+U#(^E6hd?5j&4OR>-N7snze93C(%#Q3 zvE`W)kNe%<=nL0($vw$W21)DvB*_7Pql5H~4-CJIl6bCpSkCjXVd?4nz$PgwivIPl zL6Ribq@$!yZ<%~w2{JPD-#11?yfk#=$jO+ScG9)VmvR&klxLX&Y>yR-t!=GhWs1~H zm>8*4tVRm2(%0v{uoGiu8>Vo51OJ8e31GS+B=N&2GJok6y&f!Asjp`-*`~NIOyYtQ zqLy-J#oy_b$-FC+3cs78$E&jXG!7O%8C22{cFx*pwr`2ZleFsuli8({2ts0mPLSxj z675?Ap`lmMHR~j1L8y`IDs@{3l2VE7xTHo9%ye9m7b?+l`B5pCZ`>$I%y~7Q-pIk^ zmKYzbZdgO{5nf2*{lMUbu+l^emUhhK~~E|NEAxZCZ%806fDP4Cc3rWd8Oq9A2VFq zFf6QmotqV{w+=2dO%MbVmLU-w5jMESmYjC893+Y0keJPKlS!_V+qZbI60lt`v;M#~ zcv7=nkhkBa3c>c8P;U^n5^IK=JvEY}@=*C;{33CIZ(u>PfoMB8!(&uswOb82+Eay9DI4B$vkR?(p?hzzN zFhcKi0wiFUx3+>P$>f%6I(fkubR7o%&2!H^cj?qAf`lSx3=##kZt|ur%Y2Zi{3Hl} zFwpQ&h!1l}xL-{cigj?1;E#~Juh%6sNK6O`2#4|5f&gLY$}@R%5<8p$GN%E~V35>G zBsv%C%7{H2Hwq?E;eaHe7;aakXXBt!p%wRoV*|5M4tRHEiTTfI_wa!#C|-1LXaP7L zUEs)HzxG;mZ0v7;|Lb4>$MNI)@xj$~14Dwo&d61((A3B_o2xK5R<-qBLBfKqd{0HT zA2?WXY(Xh+7{C< zPQs&TRJxafX}l)QRx{`o1zE1-KS@$6)odx-s4_aOlz69R(nu}F)W~L{yehDH za7jn2^CW! zG;x8?S2=>J(5w}=(YSFJ2Fx*T*Tl>oE$-(rYS4B~xpeFR{jUxjn8He%10nIuzX49_ zhT)?aPqSEPTQWYAcJEQRERY8=(yE0Y7MRC7)_^m-(OBH(rLwXmKNhFO7L_WD2^&=w z4R)*5L}AlEpi?^_Bz~hN)GV~i`^DV*-+$22CmN(~(E9f>a``eqasbDM%To?qu3OD{ zz@Cf!uKSJE2u&Rr9&p`)kVM!2zP!9(H%OG48i1s3HCwy6KO|LE%+8<<4-`yWdzE&_ zR8^I%r462xM^aUVRTSY7%yGqZ=$sVnr2{ie-%y~1b_T*tgyj7B4Pcypbl^Z{=ITuR z&!ofHzaR6{;GJe3fdB5x011^hu;5-~VuQ^#n_iU~e(;|N38nL^h!&~J8=@Dh&X0>QyVq&zG6x!WmH0mD)iCo_NV`Vu%!Z6|o2)_)G1J%{l^YPa=#*LdS z4!S>i99++sKZB3S_&XWy&W8){li=~mrihs{XC@{mCnv(S$rOQSn)vf zLs$4G>Bd+%H1?f$;1@5S*$5}#Dfl2(9l%3>EG;dKj;^oA9~kwe(Qp9nMb{VARKE%T zqp`_(@V~-03vX@mxEc83Gw{EG|J~~9ef!|)r8uJDMl{{2uZMf}_*(Rfmo)0@`3*Xw zo;|5Px|IGVI}z{KvxiFS#UDBn&E8@?zEyZoOS?&p(uYCvmmP{$#s|B++&{B7m>ZTu zy|J%g?>FCPc2c&l|H*iFBtI*7=>6knelIbU^T!Qjvgsq(O(MYugBjx{SQZq zO@zE3$H)`~=C2slf9;TXav?tg-KaAN=GdS79p?}_4>@ZN$a@*DgVe$($g&=L0d`xD=P z|9#)te(%cf<^BG|lZ=T0FVyeNPZU4giL?T)l7YFSG(HFt`9mS`mF)Gly^)OZhXiX; zc&m#0AAH22Xyu*^shrD0hfe&b1z&v8)`t6QUwDBw*>-n#Ps2;NySZ)i=FLC(N!u4~ zUwrY!iZ5{dbPVshITE3oYhj*gxlxJjFrdcIgOcg2c>2M^*trH&r>={UFo z55UD#IHm2q_uhk-g}*nA{v!Oz7qZ|cT*2Rc0gk);V zS<%)u^^3L@J#F+q>FHtr54!B=`Qi(>;JdQC|NQQ;|2{k){@-nFo3r45_5xmP-rV*R ztdP;u#?JntZ3jT2)*7Xl)H`sTL}#u?1xNjUJ3CNOA!-oucR@{HTlfjBoRD72_a8-+OjfQ4+=WeyEG0|`h=0ghIxWi!%RfwG0&N;mGHn`Tq#JkrA|#6z z6*EYJu<6?9mB7VHVu70U(ZGf%NXBUFwKbaeWgGn>0>p4xNJN1kK}e?3ynlsX0m1^N z9)MW!#oVcQYY4l?_XE#m-vuhmIG5;vZ@>y9=?mN=4iGG36UuTt2r~Lv5fWJHqYe|p@d4a+4FVjB#ltBVFKJDI7T#O=wLo#}l zud@aIu4MQ82C{*NkPg5J&S1yrHj%~V{j0C|^oyco?z7(i^bmGAWbWJ{{wD>D^?WRY zugL4`y#pVBUqWy_ev)wWOR!umTCGB>)j9`;BvF!w>P9DzFiRYm{#@hHc_qo1T2LjG zc1#PvX24|M9tU2!B$aZZz4AEOD#`Ltc@5RaqVnPJe2F=aRTrp{gtk}qH&pH;NiHEA ztprLdshckV5}1Zh{{=5Z3BL^IlYLC2P?*FW&c9W|zu3I_AJ={T>DT{Q2xIzm?AEHM zx{5Kh%_%_>1BceF!&jn-$7@zv`}No9n?_YFm;Hhs5YM>J_!oFX-B}<NUiOP$uv4;j02+&e(B=S07OouSqvU5C3Z_}SysRYQfxTkIexO`8 zal>TzTt46Zk${6=;jJNGd5<6*10ms)Bpjpx!1>Ax4M8IF_D=b0j+0!v^wFhOKAr;? zc;vwzP!uHK86`BU(-+4L{;n((SwzW^yh9~l_HtaA*fBa3MqR;-=Xn_^0yK~g+=QBY7&$0&j% zh-R87;L7D^c$ZArl}vz$oUHsAV@HI9>!Ot_pY?}>tCO!_Mga@d5MOa+!vzS;Qv=J(0bLzdZSZ^btXVnNs(&N&aevk?6R@Ibo87m#f|U0?Gb=c)=^_VTS$z zO)zw1=B^md)X%eEu=cE57c+0tq}bS4{N*DgDQQyDq)ACh`ALl_;abhSd50M#pRz%B ze!=WIGE7T;862{Hd-{eMwu-DUrkmG#|@4uE7)2TG5ipiwJDm9laa zvq?DFd-W;upX81^;&c3s({Bd;VYlg&)U? zxum%}b`=)JrlvNf!bNKNy(1(lN-HfaTt{ZkGV)x%g`fY779ag?%W}~ z#U42jC~%enD$@Xx;zj?9w}A~B?PsX2GiWNOZ&~99DN(PNhb*Wq>VP# zY~1{VmMc-5xpanf4apOfB>%KPwBD!|srVtFV@hVkr%Y*3Lzk)W1;;L{n`2_;VXJ5u z-R0%%2L@nLR#28vb|fSwMk9@hSw}|er(BXu%i@$U?E`nk?-_p8_$&>9DSGzVuUG|D zl=w@Ry`I&b)x8fO30hRlWy4BtwDL*Epc+5Ea_S6q7N8(Qr^VUaOT^ z9Hd{q^2rrW1jB@1@S=0GhnAy?;FX!Hj>c=L}PUP|6`GFt&=k zf-fUfpw!q{D4+$ZjM_S5Q$Pwuv0#uoR4g?lL%)&V}rOTU5f(kFNUN-{kqh5zR$E%Xd)cFf-G zlt1Y>%DWWc;8s+ix3GH7Bk`fA9Z57olkDR#98;?^u*w61V1nW7TfBW?mW5+w{c1eI zy;WafVuJ6_4I4(;UvqrJE8J;`LP&5wCEmAS4u%7jiMM!2Fgm8JEa##;&v`4Dg!@mx z(PVc%cr={kfaHUSSjFFTZqDiOW^Ng1iNGMOXM=C%$sAWSH^Fy?L?jocyR;}=S}Y>C zQ>8!v1dVc`i%=rKoQE8f?^Lzu@&L7tRvHy}S11=s(raprr*JGZ@g@Ij!9USl?;5at=Ed~WG3Ujq7sz*RDGUJefi+WNLthK+x+>Jn}&|+s^ zp;YMtkQfEyY>rnU7mZ_caE)Lb8?)LW5xNMnj4V@zJ#BJbB}=pdVM|s^4R)-M z80GT2+j-9!l22ax4f}v`aXO~uxffz}R7XX0M~4$6OLp(Rgpka6WaAue?B0#1Z}Z08 zvpv)ZNhm@RI(s(4LXd>=kW6!TKguX!VzPQQyshBX8SFi3NNU&`BPP4!=kxQ1)#k4|;TnzHI~~j3m2#Tv6?%i?>LT!Vkw~y-nhQ?t%4-mk79-vsmozJdF48O`Qxbu) zO>wI2Rub+8l9y0Q%0NjP8t6Yge!OGOl1odLWMlvVAR$X`8W|b6{^$K%=ge2fe(?q9 zj7KPOkrX-`Zp72b_4m)s$cT^6i1%IWyJ(@id%+qLdT*;JGxtn|)0-7uSI!G~g0)kA z!jS+)&%ng?;icCXUf`(Jn{e)C)001VFkBE72HAh2t>LM_i6y&Ota7*;bRYb8ZjdgZ zQQ`@qI2g5KJ%xb0144iE=mvTw{Y>VaP@ZJbqDj={;tnA&>)$&r6bh-pnH4z;@qkmm z5`0iW4aM1`0`7`^Vp2ZR(YNG>l*&%~&2O&%hJB&Afxml43cVnvUvZ67P|OB7*rd93BA45@aMJe&?*6JAJ_?SwkV>Di-h3 zDd(&Vx~P=uq>u_F#SRH_VNndXR89E~3|rvhaMIz! z>Vm^`0Q?Pq-}&H;Uh3%R*d6Z?Iy)mbHy%L2L6Cs&GH2rwe?)4Lm)F#V?yj3nCWPP_ zG$2v%MM?HoHvGydugT5hpo8#)!}P4O$D6NUr~uy54scu_V_NX!{XalRoUX|v{fhjB z)ponG>Xn-V7Q_Q56KJvmWdzy4Kj#&K1aC8u;5`riD1OjG^zd6W;enSuOi94vIF-2m zIFo5Fym00E_4pHPyyQtr^1&+~JaPQ^C4aCU1&32p3kp)X;loC3SXfwWY^p!4b$g^> z^XARyJL07j$i!ZXS`2x|MSdn+|LUIZ%dqzuz#YCJpa7?Q7+1P{+S68D({Q% z_vsviong;l%yRkx=bsrGN;^9L4038-8D0MhdMDhEk6O?FXNloK2nntE`msY2%;9kb zK2DqfC2?yYbF-o1nMZRmZHkOwR*WD~`KSmIz$9}x)o=1NbZd`-u}MnGnB(p>ep4g!-3gLY3I!`)=Asej zpyZYS<)7F!To8PP26A%!#EFZZyyI#*e*97Y(4>x3+yep-0Z3G!Bq}B*u|A+B93=BS zHgAp(4b7P4>gs#mAG{R?3HY^3I7l|~kZe4D9F59xGA2*_Y7JJ&KEVnCDLn!H>#Frf zk1|2WTuQ`-RS_`Y68kT{+7=kI@hf-Sk<4$1vbPT=GDo17A? z6krYo*^E~xHS^Yb&Nn3!gufa8kel4t_4GZAktp6(B|F4{;RMeFj!;|BadlnvElSd; z(AHpq5#Is8sf=v=md+8De<~y=u5g^dCzzY*rU?9xR#mKi)FX*=NC*?OI>-r#No*`= zNo#Lu4X?=@vwu0dD@qktBQG`TW~C z;V$t2j}zktb85e^TNq9$MkxTN8{|`rI--(Qqm&+@pk|Z;U1w9sIU{sz)RAQ2^kY3| z!tnXL<2q^T9nFnJpismpurD-nViZVY1ei|smI_7V5bd_aw9u1U6atL}9vjzM1X6{u zkq%c0#^u7SHmtY*d)w~?e@^4dmCq5BG@Rh;$NwVg?9oREO>wG?9sR0;wp|N`i68K@csJ^ zA7sA8dnbvjqfxHe{9+i&Yfyu>32_n~jo8u<;6U!eU$sW7yyWWah*;35fHP*7q<-z9j?}mf}2(i=b30 z#HLnSp+$%}cd1Y*a7o9ME6wJ~1u@!F(zXYMa-&cnHMWdLQjSe7P^3$Qr{r>h;O}iX zAIu@bt`2(=B=8S`6Tdr@%a=kR!*NoOs#mEPBr2cyS(7JCb3lT zHX*~6I6J9`Gb@kTzlDbco`2zg@d+_x0^Y14uMGfMd zQ~I;tii)zkG&G2g8%_sOI7mQA?gU92*0YL)RYDO?w`c_#86Gxzd*haj#&m^%TFFb5 zBDtVVAT-KcT#QDc5L0W|G&)iM;u0wrJn#>JgdbNhx-m7N*B15SrQK+5xY-vT5@vZ+ zBq&SV5erxMjS$TE`_G?-eHSJ>H78`(lQ6(@oj=PD*JE$qe3tZq-e-xJmbV9-udpO0 zdv&?GHL@^V;=*LYiJNDRW2$8JGhh7m&sZbRi33j2@x(lTAC;X=ln(ytG5SQ+dD4!} zW6xs|w0&mAX}%_kPBI*4=a@;2!|XT%z+xLt1?@rdM2EzoA^6x^c1YlTb*DUuh3c0D zRW0O?Xay~JzH8D2SwfLQSR-r}$gvA>R*TUao+>l~C^bgGxRUIPP=r%}!Zx`;`1e9G zdE>^<&m$lkKi{~Klmw!i(G9CAE?wG;a9}-1FII@4sL*T-xv>SQhg1DsgM+=Mxi0j} z$nXG2TxZRiKg-v5{z4d(y8 zPVSA&t}#+x&#C=0@V@=qhG$m)`PaW@#Uh+~Q28o%*BO%M?_3!<_3%0 zEsc^af+SFceyoecD0LBvVuTiN4JJ^t1dVOzxXQ;x5;QGR31!`l=>mm|NRTek{@qG) z-uL`Q_&5(=pKnZ}=w=kc!RSkuFv+ei2vvsyAfYrB6Ur+Kz!Dm|5wHL!#N9uG!WkMF z8B4h9Tz)L^&qX(O4o>}Cx5vPLk&20^X*D<%V1f0$4;HMeVohK$Kd_(+dS#} zLxOzx5+t90e*U_fn`eUwlocV_jMM#8Sr*z0kl@sv+Cd4#GwuM1s~125@ow%Cj*cZf zEg9?}Mmm@~AxL&#!hmu$&UmdxNTR41|HZR>tu?D3KuYi(&DFx9f`{WHc!vIl2BD%t z1xmsyhzJw@jNiwqMecJHs!bFSERg1cA^ux1QvP2635f?>yoi{*!Y}H?n$9_@v#g0G!nXfYA z7h^roJPf8M_dWL5{oHCT`>Klj?zb0A+pE>?gC{=r1jbL{>l4Ef75IyyI7fp~!rfZ` zH@N&8T>Q;hFzkr1V>i|_F+x3hhXe$uU?1ym&?UlhgT6I|t4zb*H$U=>DiT0}QsL_u=Y40x-yLB>+|O>_?4kDX$nbCg z5}%Q=(SIY(1mnbRZm#S6jT;vR2hUISVK{^_R>FMv86HH$hkg3Q764N2k3Jf`YV^kF zDlP|shKB{Y>$!6LsJ9$1F@eJT0r-2~L9=uAZ2ZMz$FM!#;HFJXEgs|8;EGo1>ML+w0h`0j4cTT^A;Lp~0s>B{ zpTGZ-cxGAvl7#@tv}yAZh_G17)RTHJRY7WE@d%ADp8|J(KlhD~Mz8l(U4>d17hG^{du9PU6|nFAfdPy_Z4q*kfPw0PtQ2gT(HfvWS?LeLjZAc}VVK zi}~)q@5v{>{`!Mg?9S#pZ&75v-a*O@2F4AB2583(-l%YP;|4*(UA#q>#mQeKDPel@ z&drcCP;`TdgF8Wz71`o)D(kyqle?{0#iGSVuBu-6y*3-4*)7%epN&-;ugEpgMO2R=B>oX@e*L}_-QMbH9?e9}! zlU_fBWEFXWj@$yAyBmP+OV~vbl;n%Q{uv;7o|BIWCgrB3;(Vk7Y&`ZDzvh$d5z5Vd zPpqPMIXmfZ+5Zq;D!7wOgMS_e2A%15*y(@k#trWHTQ}J8cO1`n=banx+_=HtwGWDJ zsN?6IAQ6oVTNHs75w`Ai5v8+c;4Uta0*%OpH4$jh2t?Ahm=>WV1_cLO%}Zmjv%t6! zE9&7uj36d5Mj(lF5nw_tCQ{%cQcxHTS0d5P?T>Chf_>fHgM-~UPU0PqfCCzui_+nr zL4e@!e}qlOEb(8G>$iBJzn>rOUY8q7ZU^s&gmDf^EH@R%Ssow1*|UMMvu`m-Zt$mn zl=DAE9ib%e*{$c^vUFw=Z>;~@TS*;*uO508Td|Uo@EXGBOD4D|wDgx*9%g>Hv`VM#QZ``63Xn)v^8@D{duE^X>`!-1E z?VeRCbZIeWjZ0my893KD9B&{6S{E=!;{v7hK_M=*F$y%}F#rlnpb4vL+TgGPG{l8# zK+)J(N|S@**e+Nq5Z>LiAmbx=0wnkXYz9a?{QVJ z5G0$JCo+K#HlF8I4@n<9zeQ)4vVWfPnE?zGt?c0}eN z8NG4i=+O*}Y5X?M_w(Nf<|QMZl4Jh4AR)O+NJ|#ZpXE=GOy20jyCY#fcKhO^qRHYi zI9A5Y(UQYy?g$Cz`r+B&Z2o#O_I8(*P80V|=8O>c20!}J#Y3+iT8^6?4DR1#4`1vt ztrH(89ejTQxbr+}i36qk`OZgQ-xp;U4^BbsI`9^|?{ubbkaF0cbsH?~UX zmk4Cz@R0X7-^wOEUEWBV^OZmlS(AR3Q-4SZHp`~Le3H={Z@qXq1Krj+b6jzvj=T_J z!+$p@$!;<^UaqtJXU%f;@^S^wHCE3w#3!~4nef5gaDALi4nmUA+Pcsk%nf_(*Ap6c zP3KMe1idFsf02L1Z~X1X(XPR{bMKjleW=0QeEk@;ySk5Ce#L9ZWB2i{Eb~z9;_}#p zyc(N8{`%|nx1Q=7cUFKq5rKo~I(9IlKv zFB`qXV6D)-yu9c--qX#^fad0MFGMuC3l~oHTDWlWVn0Wf+3wws>?TfJUHz^ABrxVD zCE=dQPR^@62zI^!k+Pqw>+Z8mYtfZ+_=8R-isaq#7#G&C$7bi`%w>C#%===~{UinklG>#`hE*h+s6`f6ZSsq!o{akT(|;!@-l0$XaK3Fnb{mH5 z_h3+|06MP!xIV5mciAcLdyZ+r?nDT~#0e6hB-eK#X25(GFFw!ttGjpmKkD!Q=*Hdt z8(rP~ui!FpS9kZMB%g_pP~^)C2^SLcko0o?-%Z1b5+{1z;fZ?Z9gKTsA6gDdvXnvc zBy&sI1m9y$9;#h2aD5(|{pBFJ?|x(iC;?73{rS)L-~a0;zZH@fZ@$N$ZUzYl%Zv7B zUcT(W=babf9v-@Ung9OFFLIAxrYANqCE@o^`A0xd=?&xj9N5}lK@yCk)=Pf+J zmw6oMByup^{LXhAdyyyP9YO)WF4Kv3!ss&HAQ~7P?DmV7e@D-St4up2-_pnRM=<~r z*J)Gn3*0Ay#GuFj0Tb`Da7%YrciJHy+w;$#GiT1MM;>{ERh%vM&xPX)7rMIo=O%?F zskuBFrqz77fH;;*yE0rd^%?H&bH0bszG=L8wrly)d+(ixJ9*7pe&puy26w&x;Qk}~ zX)t=g!q^KLpJbXt6T**ysrniu>^6o1$M2jjo$taq{@w350$%(b4LAtL@QXX(JZ^L7 zQFcX;OvWv#|6xkbUOax;L@dRi>7<$DSlym?%9f{4!l zW#Zs6QUhO?*+Ha-Gy?^OgT#J=-N8#8=aXQ7bNdi@;$qAgmN$`oOTJXYKlA4Cy%Maq zLNeKTppvM=K}arn#K-&3CpxCGDk54Q?l))7Ba9IWd4MagV83ZZ(8g3wKEj;b)mUbQ z$T`txhJ}J2?Ix+c_4U8)Nty8AW&bl^Zg7(>+_C1!cA#S3_J>gLsMZ!U@fv{`3q0ahXmvowm!4(`Y~Dbm*o7PNHzz@#v$Ea!+`a z-LwycRS3oeUG%8|*F5})(X^b#NAQ@M-cnh>r znG}-Wg69JV*w8{F<_v_l$}M;V?ALO zh>4UY<^YCtIMs?qp(0Ww5J-fP0<4*Dq#5FI<0+{?sB9C`Q^6d$2)%^@0q`Xkv?##R zz<1)_d*dy4*(UruAaO%T9`&bL-VAP9FMf7Bzrq(GK}2u~76=Lm147~&%t7Kv$Mb-& z8(fM$)@R{DFFy|te~^VobNz4oCiJ&o`Ewua0?wcxgXE26m`q#7K$tg=6BG`MiL^Yl zYyvs+xQ*4=tv7N25`RDc+n!bb+n(G<9_23KEOXNE=uPlA{{&jR$S!Vukb?w!FWwOn ztzcX$kmI`_XL@5;yBe{e6d+;!Noe;9iK3C841O1xW>mlh|6V)Wf0k-N9*1^AGm& z+PE<{N#(;wy*{xH9dVMASRb4v%E;heZccl-&qwTH{HXm=URCh=cYc27a+tNDUEJoq z!LhOIp=HbFIRwOk$vnH*JT!0KLlbrgycZ5EySjMsoZLH}iGYKaiS#)BaQ6I1 zA9a3s!o{P^C!qxucbvNsH5${24B;ucqD2OJP}*pW6toE?Y+KG#2>{6hS%R!|Dd40q zHe!<-sZ`;D1@j8HClW*|;5$)CS_Cq%Q=&U@@U6pn@z|8943bAZ)aru6sVW%ySUsHG zR=Z!}IO%XNbduZM?SHh#x_PO$sGV~1|` z1%CI4-^HAJao<=@6W*A&j2HnzmOW&rW7#q%^{^u|@1coOgN($1t+~zb`4WZ ztXh8ZZ6Of|aaj$y5klI8f@>shZ$Z*>3Y+Mq*9ciR@pJ`UDX5#CuqHjdQP|QlE~q)B z__8#Ae|LZX`1sV+SQVdQ zbxhoF*DCt{+}z+CyceE>myYp{T0O87lw>LIxITn?Ks&L3in453TuvO0 zGi*CXdIDS?SvCmYWpSpUcI`P{}bSrUJp0vv$t2Rcl?d^|Dm^+ z|D)CTC)208SKWKla5_Lsn0hbw_Hd8{-^tw2nQgoC9GuoD`Hr(2V~i2BSd@H|Pm%G5 zIj%P;3H;reVFne7f<4u)kF|RiPQ|Mj>4qkulB8|i=!%f|03=+sK&+F1#A59L-h}VS zU4oFP*-MPC8@<}SH@)rzM>u=b{>rWo4IRX-g(pG+iZGA&PKl8fD^|c)+#7Gi#Vtdn zS%$~qcH9x9gm$2R2pk$fXnSjDFZa6$4xUN=mqMtnzAeLe!U+cZUyH44d)Y&3we#Pt zz8Me>61WJrL$c_ON%p@;fjy5o7Dc<L9L zU%vFf_Iccs>6@1=yU3J;`}vnIhvTiwPJhs4{G`K|4eXjbY=06Z*qxs4^u7G?%YYmE zaH5K?01{8yTsZjKAo(#2=f7`?7b;0Ze_};N1-B?X%*Uw=F^p6KP*CxCR8>a7VO%mX z$KOBHLw%S*k*e}Zg$r5>$}J4#x`!wE`v?1eQD(q)5{Ze4;qYMqT5co~GFYKFk)5|3 zxHa_BWpQsTU7E9Z?=sMj(|eJa)8NM}UwV2O z3wV~zBRzVkOP$31>{|w$(6@ToU*JFkhz-9?*urCPIYV*Tj+7H!P6sac;upZh;g7)d zhVv`9A#>BvkeFC;T*nZ>aw1MrP$GB_l$-HQRV_(MD)S*oJTj8hDwT@Y z4){uC3qlL1e|Qr0bVW#f%G97FHwcnMY&-&=;fZuXm8^&hy|mPlB%FPQCyo{r4Bm@{ z0;na+7$nTi0D}{^_sqwqKSBXniiTzd-r5^SH$G-Z=j~nb1~WIy9=eD02q01OEI3O< zFY>_N@$7s%o^iRCF=Btz0W*gRj|o1{p&W<{LBf9@eQ{j{&~^RJxtrUR89Eoq^LhFh z`w=BMyzDtKl)B9t$9nbr1aiwh!{779f%P@;y#s}k~=8LDGepdYK($5 zg+?Hdx1AEU$OY22ba^U*CfI^h6 zh2zbF7OGj33!Cpg(zy*JJ);p3$76LmJ@2+MKlYY*7W*Bs#z$dl4-eKZT+KDApnIYA z9V?Ow*x~s2VBfAi)eQ|1i4kldErbhQgmdzO_J?c`yNQ(iP1ONPG8Y+HmXot|sZ;u6 z8G5SB8(p^ajiqrp71NpOUeI$2hh&IIDPt~^V$HMB^?(qd+8-r#GUKz)zF?Fi6mGO&Pd1sw2Q*&Ief*YNMt?1d_Nu;c9lx85-u3Q2$1?IwK?4Hy~kVUS6Nh zP!ZuYh?R)M#6$-r`SR0C<1oUZ z7&va($MYOv@4R{U%>C$9g5;ig%i0T6HzFboj-l5Z01zBNiW4aM+reW;%3z?-*l^p2 zdvChc>o7OrDZIJ4qfesHU>AWJh;XoHfKZy{f<{ED6=4RpW!y!pZDBDjL6Rj9#z+Oi zW}y-ju?!M=4ne}YNCPC^s3hr)kxttQe=kU;VxFX7%rqLYfd~OkbjSPcVXqH2r^^Wm zGehKsq_R#Xz4m^;5rG=;${;wbk0$Ub+o3}t8eM<2aPklgb|Q-|ut4T2<* zv609KF|bq5FyWbTe5xIAFoN`SL+=EXBRqBrl%2$60wi8{ghW^>#I5zx(*+ufKqzk$ z;yj%|dTN|@V{8Fk5vDsJ!Miav@LbBqa*)t-n7N_vh5L=;EeMH4c=z=KH$lQHiAe|N z48HnJy5q62q$bSJPy-tke)_QZ1@p43Lu1lmuEneKpr>HNH5EoYp&r4$30n9iTT?1@ zCPoM#$;J)lquhQN{-#ppfI~v(8w=EyE@kPlWy_kH2D=6anoua-08*C4L6C#gfG^UN zlk)~C2uq~gGk5NruYU9@dcP1OHK|k)5u-o|L|ci-LIk=+@QJ7*GW>;s2~0RAGq)Y# z4wRe_V|Q*cXK;@Mg)=vcTwU)F0t-bNBN+;<0+mFnjTDV51?gGJNQKtYR-;h_qO!;p z93;{#?--$^s+2(@@WvgZjS5g78JQbzg%$(|j8PG}2C1P7Mi4d7($n$Kq~M+V_k&z{Zr#xnLB9YH z8D+GL(r3i&5CL{Z0TMXV|3#48dk;dwvg`;6jDa%)IS~5pT{>^sUNAYQPaivW5y#+m zF4;Qoo}5E(zBv~lS&k0yz4P{~^rNGr`UvJ9aViE^NbAJEf<1@~!4rui2fWNu8VD=9 zZ^a(E?a-@%8Z}(95O@(lGWCubSFSnu#7^Ka#`*r?6Q4akPA$Y){tO?a`vUfCYCGbB81A6dZ2jFyrYXXpBWHqJS6iFl0&b)dWx6nuN5^U8?{I42+@oRFm9 zS=aL&qEk8Dpk~oHAIPUkxLhmWLYgLTz*eQDEdof~aBSV$V{-fwoypF~s#WkxS5)9B z00CLWNy&}BrK*lR^k2xxLtrfKy?6O(%CjFhkPIUxCdS)4h7GtA5&{=^JYf5Fszq9M z;K265!HU5{%jW_lbLZZR>$~Rpl$lH)7%{SOu1ua+K*;Tgd~?i!kxJW`1)YYn*NFk6^mqiRQ9IOdKTIM z7b*&IsIP#%qk!|&4O>3W0;Dt_UtbQAnKQdN8)LHjuK>fUL~>CoDk2hjU14v;zon+W z!9fBZ#y$5eU%rey(Kn8La`B~?F1~c}3$iXCA6=j;__crk{+uI6*u>6}rb75D2M-;Z zd+61_%w0~994P}xP)TkXH#5T6;D`REgXq)f0S(dGg?S0Fb2nqTm^|wNz<00W<;V^q)JSE%MS}dX@tc<(H2gC3|_La${ zTGE^#5iw)KD8UPO17mOQiIA*bT@j6x+(k^m(4+_QAq+ix_F|{Dk zWUA;obm+}PhmIYZI~P}F9NAGgI%;B65UVC9Omy509vYpU5M9LWQPNHLW_F25Ns|*L zOl>O2v8hP;P9>4L;QC$fahEJXmQf1PZ;b+Owqc4*XGdn7$l&o_mACF=n9P6_&cz+uYNo60gG0HGWrG#ov%cQ5AB;+mTF?*~=s z>Pnk^^eD*GhCv8#Aie=eFn4>Tu+;RoQH~G0nsCrKc}jT96l-Y;$wog8tu3UZi$30lxH*I%W_*lQR0PzTKwFcj~*e~^b{>sAV~M@{xT2@5R=lT}XfFF1OJ zQSdt%Bt*$ln&{oTZr!@qh!cLi{`%`%UZ-2vF7CP>KYRA|!|}6ou( zNFLh1KVoz=;?9FV<0hV(+djv1v*_IV1RcB3*{!RNhXix2lkNyfWLB0yA{U61ftY@; zY0SdrBN_{w;h3x}vMfT005|7*z}Sc&pt-RKBLguF8zT^CrCC{7@Bcqy!*Yv&PiWAI4P+aHfRsg+@+mSZu5Vp;%r_d~P0P zWohuhY==+c_I9T!f+b^!kx`bHTJM}CS;a*+5fOg_NVao62?xoF6$nZBI!4KsEr`Z* zufKk63xnj`u3ZSpbzBhA+uNbjjTRy#Zyv**YxmxJ&k=&eNjWB1oe5l+xC;j;IK4$r zxS0>T(r}OHBA9!Q4jA_!)0BvAf@IR2m1JCl?c_y*NI^QL--TKQy!+EzEWm_@70Ofc zy$YLOk&8b8}KLql65QC;M8QxYg@KF_Z*-?ceZS4Zr!yDo2;l=8`_M5f)Dmk zzqMC!9Uy~5N7>#xsl?rm2@+zu85!ouFizO}p`WFN$lOeuhD(9(SR$pxq~#?uLOB<>K+R9i=FE6_?O!T{v-c&;J>KKXdWub(2DHr z>=oGv360mt@X+OJTclFy?Af!EJoq-ncw@BeBZTCm(>Xb`bf>AQ;*Q~rJ-Ievvig>1 zv-=ehHy<|L-nC_l($AAXl{5V zSz}s5K1such7XDxii;aEdBup0RryRDVc1o|$A{0srlt9CkQ{c@EwXbpJEK<(kl2+3 z{2%-L4Zdm+->h22L%~iFpG}L1c(bokWByU5L0fvsS?&aU4EwA%xx09ltF>I*t?0 zLUpsXz`?i?{oO#)@(<|~|3fk;6CepjNV@Bhjt?3xTwnoC!v`OHKyH^xg)RuCSBZwh zhYuI9ZRc@Man{JwBR+#$?w7%}kmg4(o~K@q_|Ln#9FWvkfZm$`4!)pd74J#vC`XAk z0^qbp8+1BzRf0ASWaPlIhnC#~N^)i|h)8xFd@z$!j%*MhNK3g?dNmh*VMd0>Z2O-v zns$2m+~v#no~A(PbX-7*s={E0fhB2fg9R9O<-|3eH|YW zn|PlD1K_(6%B_rdw3k>>`AXj zsE5;tpUqYh14Oj${QBo*xX~Z8Hg5IY>{DMJjF}+^Fub9e z|9h7XoGxcdQdd{!FgZ+7%FCrKEwk~jp}%1^+wMH{t+Je)k3RlCzkjXE(~K`T!+{Nt&3JK?DMcu&TvR6=W+RP_m(pH(>7|PorOnM3 zj|~ob+LffT0d-^p+M9;@%7X{H>qqLbwsF;}_0I3)o~?O#Zh0$1mMuebLy)}j@v(D5 z2uR(EI$lidzKK-YvTN7uP>)_GT6;r7&!)9E{r;QZfBGqe$pA@tp;5)1#Ka073I{Ko zv9r%i<9Uv7V3EkHLxr6kXO!$e&Or>5$^GN`aJ36j*?_ok1a@!WrH#ZOG8-w3D z6@tsm1%kU-9_-A>6jG9Ua$ErsP!Kdb4R{lk>IM@<{xC2QzDcrd>nAff7kQIh@*iHSM{ zCG&lRBo822#w*Di$3B)?vO^dobqo@Fpui7oEdU5L5ci9mQ4FLC2_Gkn|!Ad^e2S3J*_u;8bU`A z3LE%cLZ@eOKl5(3)wS~aP}87C8i4vYaj?-Q;g=O!(-R=*}Hb_3O#)N`r*S# zNp_*Y(F&ui`C@ZfYjYQj!7j}p&BQh}HIDV~hmz23kemq4_S|A= z5*^P=#OLvz4o`;xXSNe7R#9#ce+>F0uH?Ah!6$*}Rbz}9R~of+Lfb4cr?emp4`}5s zf-Iv*Akm1jl&2IHTI^XWj}drlwYGvFNXwYOIC&o*9YJbT&!KoruRf5H@A~xV-PwKDHUgT z?AQU2^hJ!?A~1-AUu_%fe7mzVFAu&>b^;`I2M(}2$-H@QT)VdG`Yy{1CL`I_Y)iJq zGGu|Tq4F)@O~-R&*rf#QWUsm`?A&uOo~0P5T;A%V(>e5kE@-(&#e}LS-s~Vc6FifO zMDFPo4gukR7)b{ivI;|@fipDt9OmbuU*qserrsVBp$otv6-tE~YVVycP_&SeXatxs zQ`BG&`BMrPfe=lNR1hOj2qGcA)sof-tE99mQmN2IklyIRDMpKYTo{Sl3JVp&wsCo+ zpmE&z-D%eeknlbUIwET*z5&1FLc^~cE`0E_;s$`k=VDnIU;V6&yv zcjCzFWTb=?9r!t$yqPyI?%K5vuU~INr=$+NS40HF1g#E0qE1408NBJ)p|g2N;%9>~ z^zmsWNS?z4EhtGWlM51uM84iAF|oo~8TisgnjhfwhFKftrP!tArXUB!gUXT;d8MLn zH1P%~k@ra^-3gL$7l8$^Ft)Uil0?eW2@=Y^H{(`&XhLdSq*5#pXc5GuOQq7r7D1L& ziqupIr6@6_*bO>e&?aY)XoR3G0)aP{S&z%H$X@x~6F8G5LV{`eViS6-#c;tSq~SvG z2gN`8pg1KZ-Zq`^GT1F`0C~ z+qiq<<|X;E%D!U2#588MTCL{1JR+o%u4~KV;(q>L>=*96di5&!9U2zhWNWj*+!&2R zm@~1ZF>fh;wlgFkC851~eJc|Z@=2u9*08WxCl@5~Hp5O17v_)~0{7V5G$LSd0?6Ty z(4h)^w1Rt>fr3}M2!0m$+w&wY0*NqdJd0aM<1LW$khBRTg0=^}K{3V^r8KFFO=^T~ zLP>gyP}+zKwm?b9X)OhF)0XZn)RIwYQAo!T9i^ZR&5it&RA~I}8Jr1_Fmr?1vto2t znWX_m!TW4xxO&sU?c0+q@uP3>al0d{VZfq1Zf{8$_P#A@BoNW<;-2v;N zfQQos4>pcBQ-|<$yel6UG-4YY{AR^C*3knbjYi?AbR)IS5*mdya&l$m3NSe7!sZtG zY2O2qDKrZVkTmcCFu;Ks6QTu}xd3Vcp2OO;3w};#ot^&!+p*l|OcS;}WFWA~TE}ow znggDmPLOP^PZ@)7X2UBDrj$p&Q0?Endv{9rrj6CrG9&{m63|iGc`^^LYEN$Y@b%aC zu6QGE@5dj%z9l{V>eZIR9`W(lrP6iaxYotRWv?igw$9##(JqHYFPAByfL%S?LsgKZ zP@p@4h@fpM-y*Nzw1G(jd)r6fPE*(*C@MH|eX~=RZHd z)B^?N!1iTv=(sMsEhN0eaCiU9nGrYd`jL@hfW(B5q!J_zo9vKuiku(;B>_mD-MeDh zypPL2{yz+ow9WDHSEbVO71_8DID4;DnwGl@V;b~R86>@-&XDNU3dNS!%F8h?i;!&D z(wtb~2w*Cl>n5E>xc%HmJIo9TM+Kkv&@sOze0>x{EP~IzFhuYokyY+i=$PZ0;>Pus zzoU};BgPM4;+8SN+)!Hnsi%tnrn6j#evtXr|}wP#;{`m<9tt*u72n({NaIuPdvX3x&> z$bi^4bT${+pptO9g4l%VTd&q|riKFN*IwH)?BiotzkYpmba-^)>cnUR`WWk1ajPcy zc}A>Urn5{&gcl!PcsPMcbQl#pz#cTPq#OHb@FOsc)?tB6Vi1F5^0aAFf8-h0sS_YU zbJN{@fhPBgi{In4KZ^eYF8QYZ}&cQzC5obkCJ*XMm5eeZheR7|#@e z-8p@Fu<6Y9WU*LWRJ6V6%$b3Ky(`WvKmGCPy-Tr?^BePSf`nLL@ykeleqYayp8P#~ z3T!qsFX)P#JbCgxfTVNZKDb%)VS4%&lz?^Xo_+eW^sB9{npm}Z3HYS(EXPM6uyB{R zH;$AmKGxdW3QDqtAwo)mNtIT^Dt>iLbOoNsRh+HhZAKy!1^di27@TN|R+uNtjx#S6 zLtaA#2U9dV%;CX)R(N!{fjxzl3Lqrk-Fo8RJ8pu+6DRmS_yEjH@dqCOAV2&1Xa95I ze;~H`;AdZd{j;wxeBgk@%@ZN{`2v)W0}BqsZHEXKAc3H`h!`m=CmW^t=Gv5$AnTrCwZ65M>tma^}W%Y;&7r8;V3EKjzt()uuO&BxLhlGhbNhvDd3ab2@(bFP2v=O z;El$AJtWRP$)tq{Nqygi3v1RCBP0zC{pgYOz(s#gKhP0W9aLRkUtf*cQu{z%5ih9u z=9|WEo}&_EeDR;%^6ay(Kl>U@xIOzUD9JrkdwgU<1nky{Hbsn})P;ng+i|kg3?8>;XIq9WHE?S8uAuxG{*o;%Eg{}6UnLwqjBbcWJkIuV^ELLkmt!Q9 z4qo5&;nfd6ZKS{k3sIo2fIz7cK2771|&CX{uKS(~ON^1)9*)vAcDXFkcaNz93sX&%>Vg{zQ|kOg9b zq_)mzlMdmqU@-vA%ajicfq1|VT!FSMBt#64yw=iE6eE$u6c#3Vcx+}>455z9$ZRer z&x8bnoU2zKd{Fr5r?0)n*&0Ckx#vE8ZA-b2W63VF4x|u?(YGI*cLG);5uX-a!6nb4 zkfU(&Y9lza6U{=L3O*#FTnchm;jAQga$JRibnPi4madM=l>%W)vrwqC2n5rXc#B){ML#}#xP***8py?5>#O(heQ#Ix3lVxa}00KEvQt3wk55ZG+38jXb;*~H7h zKzTVr(iE@&A*qW)NTfv}2uV-@u#gcS51uKrD-(x3U9t-xdEjY+1Q;7)kTgO->;u+= zN+#jl(QFJsLP@gdaCUx4Ny4L<)5@n?qgj_7-tQn;;cX2m3iDhmDx&STA}RnJfFznh zG8G_!2>1?d!(+y401|8uF4qc#QtS=>?}ua|rz9U>@!|(2AS57bcsPD`yx;lHKR>s> z9g`6ON^lzBYvu$^Sh=$0)2APJ`sv2TXW{haEM2~wwac7~fGnLy4#~YskCc>5NRxP4 z!HB>|+rZ#Jzyi<`bU#AG%GTDGE;ctecXi=}GWfoO?PqWjaovjYa(xe(%%1&W`U4L<09wa_8+1sXd-}NtUMt_?10F|I zI3+_^aV;Z)GcpGHVs?kfhz<|8%L-N!v0w(B(r~g!Ts6GiND*}Q1PiA|(a|Zq<9bJ* zBnB)EKoVJ_9M>qcEx2uGqqZex{D(FF{^4Vhv$@%c$+TkfNg7gi1SJGyB`2h%sYE)bIK3l@|V6)h-Qut1xY<$S)y;;U$Go<4Qz8#FECqb}!e-MgGIa%5iI(2z4) zo}OAVD(x5qwFkgY1=}MRi?f=W&kaEId}d(q%$YOWi;|O*7c78Zx_56)O&tggdNLC5 zDJ&~$ON}<0*=!yLEM~LHB63K29WDtT?443@xv_*R_dINzRY%jF7Wq_MH_)3~^$bLY|;xqFr)9&9NT=txe^-m40+6C`Wb zwx2ph6C)(qVlhjttgx)JtO$`=t!D6~ zt1>ekQ#7IWQln5Ole25rt_M#&{lIh2Zdo_PbYu%SB#jSzy3SbcgGK{F4s=7pnWxI} z5KgDnKyQ6RB0JB9L9MT21n5h9d72B7ZIKw1D|mPpJdvPyg$iANVrmg z;|NJYa`Ir;xnYgQIyPoAY6>rwAtc+I;B>;tgtNBI(+LtOS(~RneVT^^n}FPVFNX`N z$#o)~LlUwUHKZIM8EkJa0Vd$*F3=z(0T)p^iWVeq$9xNR8WD$x#Va80g`kHR z30W})r#eK|XExUdnX86}L+y<4kT^N9m~Wj8kbDYC;tYubpe9J7F@J{r`=ZH~pnrm9 z#Sl)qVqn4lhan2_8B}c)YM%sV ze(Yv2HW2;_8?j6PATb(^>()K{+^3&@*f{>&y4GPsR8-V@nxH`-$p0Xxlw~xWVqng4 zggYD-76EgaHO`<=a|!lCoMIx(veGw%cOXLs!wybKrrt3G{;`Y+khp?R;t8?L_U%Wu z$CZ=>1QdzKY&I}AW7%ayRnuApd0W;TxmRo4fpVmHTAl#|4*#-hnR zt~BlX?5iJs*!cA8uRr_jYwOCTtx{?EvtS$_Odo&EI6TaCy5d|-@Iu!kXZq|NO`#LBPV0+cW@t0S|+=SjYI#`Rx6oFSQlJ7-NNNJ_TH z!TAda5L;}v_uhMN2p|D+j{Su}f~#HXYAqHz-vG(FEuW&0Jl&X{p1vYGyQJw2+%0c8 z0>ZA}IDPue>5t3PPc^0^B;c~HRn`F{u5f6TLZ`akUjZbgERiNvPwlJF%BAdof(;FLKGqw)v z*ec)(1_7OEbQ&Cr!Mu}br@I^z1PPZ@31@gkGYvsGVg5;U1uI|F5hN@m#^+F4{wHB> zmN+Ykdj|a7F)`#p9w{k;pmeQ72B+lVeb(%3un0N8$g%eJqB?LRv7A&Y-BMn@cQ3s1 z&pn4;>!;~guL3^WlBP3n#8Ka7P?6Kvdg%1PVAr*B#rSyRYb#b*hOiJ-3h!-cJFwB! z+>A}|nva#2mk$iJ8RdGtzBde9<$-}?0~GlT4b`E7fQ{Q%%Sj35V!2y=))8AzPtVAR zUdKmvSR~ z5FE}S5>1H{-gJ<=!ETd{GDLH6F@M8Ahw%FlBJ@jifC%|7^o`)w1UYPmcv?=7!+`qNK8 zz4#Ky!hV1xuBquv&Kc@Abo$u90LyoL2GQGt&pn5;uq_J3haZ0U89a0h!lsMO%~DE? zz_T>QVZB~m5LSlYQ9gkBQa+SzIr-juwU{SGE@)1e#=d<(Nv%0kkHeOBnN|tf7u@vP zE7WF(UcK7#99NJw4E|_Xm;xbr?zwfDd{Yr!MfB?E=ngU+PLg3Ta49rW2__cgywcM! zqe{UtBf=2QlVxBRq({-=d~Pl=I)Vuam>V9FsXuxp`LnZs~S#Uc4)%6FZ5UpI$edq`FY$$xE-eOa86tj zqwS9*a{SP*31WE?faJ#>0#AelGp;cq$(SuWP_#W@MhFLqID|AstPB810)UbxoI=S4 z33=|>#`Kn!FVoVDE=9Jtg1{2P#^fRccr73rtOA9!vZE!jm-6pGJ| zp8zK+0>D7l1x1zLMlr|wGV^&a-_fWT1aF9HVjMUZ=C4Dx% z&IXVe0TK_#I@4Z$c~&n63D&l*TUQa;X9LH;AHBm;oI z2<)8We69hkQ-#C6gga+p4a}*HwnLK0en1reIJ@X^`;NJrAI;d|#K@$bSWf~~$2~vZc)GZJPAS9Sh+g^gjKMypXsu{9;`Q`c6@^yQkYuvbTNp5bM1(n2N z3BYG)6F}xCZnh8J>Z1&9GdrR;yFx za*gI9x-C+RCA)TP%sOOQu_C+HQC?8XjZTQtvErn!)EuT(+w<}sEdQF3vDtvuC~OOZ zvpg0d2~#}%K%+t`Povs^M8-%oD@-$RSrPtJhx44+L7;e+)B?NnybxA6vA<26z@j=z4a6SBmvM>%a@?x^}Jn zwRNwf)d8m!+*Y`N%kqJ)L3nz3n?|G88`NsO&#J(I2>2)6+g%h=eyS_dSxc1ZB1 z*<6{K8RkQcE*yC^@=VllN_D!-EmTM{BsYwXM(FhjNsB(rV2@2WN)i*fl@oU7#BM{P zovx#Z5c>{ zLw^vC36N066?Fq#k~o6I8z6xLIA-8v{(_JI^j@>ui;57Ey#z_y(5}y~TyF&u%J=Wr zDy>#4R(~)^uk+K!a1M9OLGo!! zSQwXbH!%OSf+qObLMjS|4F*my$gUV1ps<4!+7dIw2v_l3!Aj5QsZ`ad>+eZP(e)p% zNQ`C?FnYY0aa}Z(W`XYjiMQYf?9ob#u$-p=Td;KLZaZJycDUc-lY}ILkSrkQb>-R+ zZisOLMU0fdnLpFM0`nV1aoKek*MR*ANKOt25aWEy_U+<2a1{2{S}Y|c9|H|tL*R3? zwY4_`8ZDq7*C2#xKGrp~w_E|@5AG`1m}})IC&!L;9lKUOaBQ&2V(|g<5FT#uY3`z> zg6#nT;02c`Fa1h$fr|iYq6N!@#-_P>@3CVSuRZ(hv+MSL43=g9 zAOT_d{p+v41{7VpcIB!$a%VNn3sN zcoNly7DZYb+ZTf@Lq|tAmV;Crr`|MlK517b&NX#-Cs7>?lnQh;bcw)51r;D6ROtWG z!cRnlEpaCCpqvT*S{*+>4Bjm3DllbQ@U%PacO#Lc3(^(iG4LgmHVc#j+929xTttlp z@Mul?xYQ`bCVS(NLTRImAf1+fk9!MT#uYV2S~}dKkP2LcF6lRSkG}hnaFg!dCYc!UC0FAuWM+GO)WHv{H!CwRL zMboyB>J~k<-lb}xDB7b2PVI3WP30OIOeR`rg#`k95KOyEM0bF?bWk)?!SGs5^(SD8 zSdO(Kni;BauG*0kpm3Hpp?j=imh0n+HjORQ9~1>77=PLRk!Hp-;~UB-a{4c@u7Wy=t_CLAPk7{kM16ozQE zRhgNYj1ix*vNE4mJx~JvhL4YJWP~8ucd~XL1TicwInjyJf$L$@ecR)f;Xa}B1L&R}fpcT=eBOzhClCZ#rFoILuQ30}p zPezl%m8-Ele4?R(*7w14P=Z!hR2=6WVAQH`9yS9m0pvCyn0#kQupwu&qH)})XcQQw zEmS7oj63r&NNV5_fwu$<3APmwTEHT?2wFHL0WCQtWmIsGC~oOfj3CcCvl3&{w5GXVx%+RhCuo?gd3A zJsm7o#`*zV3+zddObWi^9(>-ov0jWQ zeH^}|atT7x=ps_qFi7wb0kAVJA~#j;9VlpyY-yC@(;oP1Lm}~< z;J6|r=znZSBeR`H1OR~%GJ~@%Av3;`up&Z(m1<3%DSQ3D9#Mzj8gRi#X zu(YzUu=>hMED@L~5=n4tny*||PIp-=HV(I9n@>FT=++@3nRw-cs*$PB93Ga-S@Hx% z`OuISoKt*iz0TIFRvYv-ie+%7rx%#A*)m6nvq)?qTTl?{k(6}(;>AI1praj@+d4ZN zDq{PAf(Y995uzu9Vf4m&1GnTM+`#2r$%UoV30D{5lqEAHCUSOzg~kL+Ma44}R2_?6 zt38Xt4Wz>m?by+TN(DMPFo&{(Q<6JFLW3(qb2t6S#51vah4e50V13tE`yItB5KWW zR&8e4N>9(cyvU$}0{>aF7P`B;FZA`jlBQH{%bTejLFq}8aQSwNbv0YMofpF5{ z)YMdUQdqtj`;4k_FIEHYg4c^4?Rs3gOLH+SJ0Hc8rv?Mp>WC#nm~;>^>$%zhKFmQ| z5)~EA#l&nvhrAJPf)CUKpJU*-G4QGbk5IMzj;9gtw% z-~uu<$r8y73BzN?SHK6z2%4F-U}nU1AuCr#0wntZ4{=cuL6S`QdvTo|67T75Zh12S z61D%VIrA6JXOL*Kw#}SbIW|_0K1PGh#+~%ERDEhHK(c2~*q*SmGGo`^wTn^?k|B$Q zAPLh94h^SrjPQ_nASCKun*|`T){emsRI}CMp{a)v61~-$srMmB)G9P9YD0tpA*o;m z$_x=&MuR>mw|JZ&NpyxJJTZ!&kxAs1W<^KY?F}VN!l~-0g1Cw5z*U_NZ9xa80@MY5 z2vw%tH6;Jeaa%}cpj}xI0yxZ=0Z@n}A{UpnYh7GOQpm=LBsA$)2M5~r$G}Z+cEv@Q zhhGcVxG)AGIa%8|GtW&FsPxIroj=JHH^KGta&`4u^$+wic>Y#kZX9=*ClosqF*${Tf8D~xPvPl zKvpVfc_?PsqQieWka#&m;)Re%Bzy)5 zfB*9vmn>P*YY3;_s`bTv_0%x|`+Dmj{M``6t*pTlkJ$~dhs-RY7t5-g85ΛW2 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 B31|QS literal 0 HcmV?d00001 diff --git a/packaging/vita/sce_sys/manual/006.png b/packaging/vita/sce_sys/manual/006.png new file mode 100644 index 0000000000000000000000000000000000000000..77c537f3ced557157e1d30e1c41b499700cd5bd2 GIT binary patch literal 151558 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